uploads.createFromBuffer.unit.tests.js

/**
 * Module dependencies.
 */
import { jest, beforeEach, afterEach } from '@jest/globals';

/**
 * Unit tests for uploads createFromBuffer service
 */
describe('Uploads createFromBuffer unit tests:', () => {
  let UploadsService;
  let mockGridfs;
  let mockConfig;

  const fakeFile = {
    _id: '507f1f77bcf86cd799439011',
    filename: 'abc123.jpeg',
    contentType: 'image/jpeg',
    metadata: { kind: 'snapshot', contentType: 'image/jpeg' },
    length: 1024,
  };

  beforeEach(async () => {
    jest.resetModules();

    mockGridfs = {
      createFromBuffer: jest.fn().mockResolvedValue(fakeFile),
      getStorage: jest.fn(),
    };

    mockConfig = {
      uploads: {
        snapshot: {
          kind: 'snapshot',
          formats: ['image/jpeg', 'image/png'],
          limits: { fileSize: 5 * 1024 * 1024 },
        },
        avatar: {
          kind: 'avatar',
          formats: ['image/png', 'image/jpeg', 'image/jpg', 'image/gif'],
          limits: { fileSize: 1 * 1024 * 1024 },
        },
      },
    };

    jest.unstable_mockModule('../../../lib/services/gridfs.js', () => ({
      default: mockGridfs,
    }));

    jest.unstable_mockModule('../../../config/index.js', () => ({
      default: mockConfig,
    }));

    jest.unstable_mockModule('../../../lib/services/multer.js', () => ({
      default: { generateFileName: jest.fn() },
    }));

    jest.unstable_mockModule('../repositories/uploads.repository.js', () => ({
      default: {
        get: jest.fn(),
        getStream: jest.fn(),
        update: jest.fn(),
        remove: jest.fn(),
      },
    }));

    UploadsService = (await import('../services/uploads.service.js')).default;
  });

  afterEach(() => {
    jest.restoreAllMocks();
  });

  test('should store a valid JPEG buffer and return upload document', async () => {
    const buffer = Buffer.alloc(1024);
    const result = await UploadsService.createFromBuffer(buffer, 'image/jpeg', 'snapshot', { user: '507f1f77bcf86cd799439011' });

    expect(result).toBeDefined();
    expect(result.contentType).toBe('image/jpeg');
    expect(result.metadata.kind).toBe('snapshot');
    expect(mockGridfs.createFromBuffer).toHaveBeenCalledTimes(1);

    const [buf, filename, contentType, metadata] = mockGridfs.createFromBuffer.mock.calls[0];
    expect(buf).toBe(buffer);
    expect(filename).toMatch(/^[a-f0-9]{64}\.jpeg$/);
    expect(contentType).toBe('image/jpeg');
    expect(metadata.kind).toBe('snapshot');
    expect(metadata.user).toBe('507f1f77bcf86cd799439011');
  });

  test('should store a valid PNG buffer and return upload document', async () => {
    const buffer = Buffer.alloc(512);
    mockGridfs.createFromBuffer.mockResolvedValue({ ...fakeFile, contentType: 'image/png' });

    const result = await UploadsService.createFromBuffer(buffer, 'image/png', 'snapshot');
    expect(result).toBeDefined();
    expect(result.contentType).toBe('image/png');

    const [, filename] = mockGridfs.createFromBuffer.mock.calls[0];
    expect(filename).toMatch(/^[a-f0-9]{64}\.png$/);
  });

  test('should throw error when buffer exceeds size limit', async () => {
    const oversizedBuffer = Buffer.alloc(6 * 1024 * 1024); // 6 MB > 5 MB limit

    await expect(
      UploadsService.createFromBuffer(oversizedBuffer, 'image/jpeg', 'snapshot'),
    ).rejects.toThrow(/buffer size .* exceeds limit/);

    expect(mockGridfs.createFromBuffer).not.toHaveBeenCalled();
  });

  test('should throw error when content type is not allowed for kind', async () => {
    const buffer = Buffer.alloc(1024);

    await expect(
      UploadsService.createFromBuffer(buffer, 'application/pdf', 'snapshot'),
    ).rejects.toThrow(/content type .* not allowed/);

    expect(mockGridfs.createFromBuffer).not.toHaveBeenCalled();
  });

  test('should throw error when kind is unknown', async () => {
    const buffer = Buffer.alloc(1024);

    await expect(
      UploadsService.createFromBuffer(buffer, 'image/jpeg', 'unknown'),
    ).rejects.toThrow(/unknown kind/);

    expect(mockGridfs.createFromBuffer).not.toHaveBeenCalled();
  });

  test('should throw error when buffer is null or undefined', async () => {
    await expect(
      UploadsService.createFromBuffer(null, 'image/jpeg', 'snapshot'),
    ).rejects.toThrow(/buffer is required/);

    await expect(
      UploadsService.createFromBuffer(undefined, 'image/jpeg', 'snapshot'),
    ).rejects.toThrow(/buffer is required/);

    expect(mockGridfs.createFromBuffer).not.toHaveBeenCalled();
  });

  test('should throw error when buffer is not a Buffer', async () => {
    await expect(
      UploadsService.createFromBuffer('not a buffer', 'image/jpeg', 'snapshot'),
    ).rejects.toThrow(/buffer is required/);

    expect(mockGridfs.createFromBuffer).not.toHaveBeenCalled();
  });

  test('should accept empty buffer (0-byte file)', async () => {
    const emptyBuffer = Buffer.alloc(0);
    mockGridfs.createFromBuffer.mockResolvedValue({ ...fakeFile, length: 0 });

    const result = await UploadsService.createFromBuffer(emptyBuffer, 'image/jpeg', 'snapshot');
    expect(result).toBeDefined();
    expect(result.length).toBe(0);
    expect(mockGridfs.createFromBuffer).toHaveBeenCalledTimes(1);
  });

  test('should use custom mimeType extension from config.uploads.mimeTypes', async () => {
    mockConfig.uploads.mimeTypes = { 'text/html': 'html' };
    mockConfig.uploads.report = {
      kind: 'report',
      formats: ['text/html'],
      limits: { fileSize: 1 * 1024 * 1024 },
    };
    mockGridfs.createFromBuffer.mockResolvedValue({ ...fakeFile, contentType: 'text/html' });

    const buffer = Buffer.alloc(512);
    await UploadsService.createFromBuffer(buffer, 'text/html', 'report', { user: '507f1f77bcf86cd799439011' });

    const [, filename] = mockGridfs.createFromBuffer.mock.calls[0];
    expect(filename).toMatch(/^[a-f0-9]{64}\.html$/);
  });

  test('should resolve text/html to .html extension via built-in MIME_TO_EXT (no config.uploads.mimeTypes needed)', async () => {
    // text/html is in the built-in MIME_TO_EXT map so downstream features that
    // store rendered HTML snapshots in GridFS get a correct .html filename
    // without requiring per-deployment mimeTypes config.
    mockConfig.uploads.snapshot = {
      kind: 'snapshot',
      formats: ['text/html'],
      limits: { fileSize: 1 * 1024 * 1024 },
    };
    mockGridfs.createFromBuffer.mockResolvedValue({ ...fakeFile, contentType: 'text/html' });

    const buffer = Buffer.alloc(512);
    await UploadsService.createFromBuffer(buffer, 'text/html', 'snapshot');

    const [, filename] = mockGridfs.createFromBuffer.mock.calls[0];
    expect(filename).toMatch(/^[a-f0-9]{64}\.html$/);
  });

  test('should throw error when kind has no formats configured', async () => {
    // Adding 'broken' kind at runtime — service reads config dynamically via module reference
    mockConfig.uploads.broken = { kind: 'broken', limits: { fileSize: 1024 } };

    await expect(
      UploadsService.createFromBuffer(Buffer.alloc(10), 'image/jpeg', 'broken'),
    ).rejects.toThrow(/no formats configured/);

    expect(mockGridfs.createFromBuffer).not.toHaveBeenCalled();
  });

  test('should fallback to bin extension for unmapped MIME types', async () => {
    mockConfig.uploads.generic = {
      kind: 'generic',
      formats: ['application/octet-stream'],
      limits: { fileSize: 1 * 1024 * 1024 },
    };
    mockGridfs.createFromBuffer.mockResolvedValue({ ...fakeFile, contentType: 'application/octet-stream' });

    const buffer = Buffer.alloc(512);
    await UploadsService.createFromBuffer(buffer, 'application/octet-stream', 'generic');

    const [, filename] = mockGridfs.createFromBuffer.mock.calls[0];
    expect(filename).toMatch(/^[a-f0-9]{64}\.bin$/);
  });

  test('should fallback to bin extension when config extension contains invalid characters', async () => {
    mockConfig.uploads.mimeTypes = { 'application/x-tar': 'tar.gz' };
    mockConfig.uploads.archive = {
      kind: 'archive',
      formats: ['application/x-tar'],
      limits: { fileSize: 10 * 1024 * 1024 },
    };
    mockGridfs.createFromBuffer.mockResolvedValue({ ...fakeFile, contentType: 'application/x-tar' });

    const buffer = Buffer.alloc(512);
    await UploadsService.createFromBuffer(buffer, 'application/x-tar', 'archive');

    const [, filename] = mockGridfs.createFromBuffer.mock.calls[0];
    expect(filename).toMatch(/^[a-f0-9]{64}\.bin$/);
  });
});