fischerX/services/api/src/modules/file/image-processor.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { ImageProcessorService } from './image-processor.service';

jest.mock('sharp', () => {
  return jest.fn().mockImplementation(() => {
    const chain: any = {};
    chain.resize = jest.fn().mockReturnValue(chain);
    chain.toFormat = jest.fn().mockReturnValue(chain);
    chain.jpeg = jest.fn().mockReturnValue(chain);
    chain.png = jest.fn().mockReturnValue(chain);
    chain.webp = jest.fn().mockReturnValue(chain);
    chain.toBuffer = jest.fn().mockResolvedValue(Buffer.from('mock-image'));
    chain.toFile = jest.fn().mockResolvedValue({ size: 1024 });
    chain.metadata = jest.fn().mockResolvedValue({ width: 800, height: 600, format: 'jpeg' });
    chain.clone = jest.fn().mockReturnValue(chain);
    chain.composite = jest.fn().mockReturnValue(chain);
    chain.raw = jest.fn().mockReturnValue(chain);
    chain.ensureAlpha = jest.fn().mockReturnValue(chain);
    return chain;
  });
});

import sharp from 'sharp';

describe('ImageProcessorService', () => {
  let service: ImageProcessorService;

  beforeEach(async () => {
    (sharp as any).mockClear();

    const module: TestingModule = await Test.createTestingModule({
      providers: [ImageProcessorService],
    }).compile();

    service = module.get<ImageProcessorService>(ImageProcessorService);
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  describe('processImage', () => {
    it('should process image with resize options', async () => {
      const mockBuffer = Buffer.from('test');
      const mockResultBuffer = Buffer.from('result');

      const mockResize = jest.fn().mockReturnThis();
      const mockToFormat = jest.fn().mockReturnThis();
      const mockToBuffer = jest.fn().mockResolvedValue(mockResultBuffer);
      const mockMetadata = jest.fn().mockResolvedValue({ width: 800, height: 600, format: 'jpeg' });

      (sharp as any).mockReturnValue({
        resize: mockResize,
        toFormat: mockToFormat,
        toBuffer: mockToBuffer,
        metadata: mockMetadata,
      });

      const result = await service.processImage(mockBuffer, {
        width: 800,
        height: 600,
        quality: 80,
      });

      expect(sharp).toHaveBeenCalledWith(mockBuffer);
      expect(mockResize).toHaveBeenCalledWith(800, 600, {
        fit: 'inside',
        withoutEnlargement: true,
      });
      expect(result).toBe(mockResultBuffer);
    });

    it('should process image with format conversion', async () => {
      const mockBuffer = Buffer.from('test');
      const mockResultBuffer = Buffer.from('result');

      const mockResize = jest.fn().mockReturnThis();
      const mockToFormat = jest.fn().mockReturnThis();
      const mockToBuffer = jest.fn().mockResolvedValue(mockResultBuffer);

      (sharp as any).mockReturnValue({
        resize: mockResize,
        toFormat: mockToFormat,
        toBuffer: mockToBuffer,
      });

      const result = await service.processImage(mockBuffer, {
        format: 'webp',
        quality: 85,
      });

      expect(mockToFormat).toHaveBeenCalledWith('webp', { quality: 85 });
      expect(result).toBe(mockResultBuffer);
    });
  });

  describe('generateThumbnail', () => {
    it('should generate thumbnail', async () => {
      const mockBuffer = Buffer.from('test');
      const mockResultBuffer = Buffer.from('thumbnail');

      const mockResize = jest.fn().mockReturnThis();
      const mockJpeg = jest.fn().mockReturnThis();
      const mockToBuffer = jest.fn().mockResolvedValue(mockResultBuffer);

      (sharp as any).mockReturnValue({
        resize: mockResize,
        jpeg: mockJpeg,
        toBuffer: mockToBuffer,
      });

      const result = await service.generateThumbnail(mockBuffer, 200);

      expect(mockResize).toHaveBeenCalledWith(200, 200, {
        fit: 'cover',
        withoutEnlargement: true,
      });
      expect(mockJpeg).toHaveBeenCalledWith({ quality: 80 });
      expect(result).toBe(mockResultBuffer);
    });
  });

  describe('optimizeImage', () => {
    it('should optimize image', async () => {
      const mockBuffer = Buffer.from('test');
      const mockResultBuffer = Buffer.from('optimized');

      const mockResize = jest.fn().mockReturnThis();
      const mockJpeg = jest.fn().mockReturnThis();
      const mockToBuffer = jest.fn().mockResolvedValue(mockResultBuffer);

      (sharp as any).mockReturnValue({
        resize: mockResize,
        jpeg: mockJpeg,
        toBuffer: mockToBuffer,
      });

      const result = await service.optimizeImage(mockBuffer, 1920, 85);

      expect(mockResize).toHaveBeenCalledWith(1920, null, {
        withoutEnlargement: true,
      });
      expect(mockJpeg).toHaveBeenCalledWith({ quality: 85 });
      expect(result).toBe(mockResultBuffer);
    });
  });
});