@hed-hog/core 0.0.399 → 0.0.401

package/src/file/file.service.spec.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, jest } from '@jest/globals';
-import { NotFoundException } from '@nestjs/common';
+import { NotFoundException, ServiceUnavailableException } from '@nestjs/common';
 import { FileService } from './file.service';
 import { ProviderFactory } from './provider/provider.factory';
 
@@ -273,3 +273,264 @@ describe('FileService — arquivo privado nas rotas por id', () => {
     expect(String(erro?.message ?? '')).not.toMatch(/Not found/);
   });
 });
+
+/**
+ * Um 503 do Spaces com corpo que não é XML estourava no parse do SDK
+ * (`char 'u' is not expected`) e virava 500 na rota de segmento HLS. O SDK ainda
+ * carimba o status em `$metadata`, e é por ele que a falha vira 503 passageiro.
+ */
+describe('FileService — falha do storage na leitura', () => {
+  const buildService = (readError: unknown, size: number | null = 1024) => {
+    const prisma = {
+      file: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: 9,
+          filename: 'seg037.ts',
+          location: 'lms/lessons/hls/2274/stream_0',
+          path: 'lms/lessons/hls/2274/stream_0/abc.ts',
+          size,
+          file_mimetype: { name: 'video/MP2T' },
+        } as never),
+      },
+    };
+    const service = new FileService(prisma as any, {} as any, {} as any, {} as any, {} as any);
+    const provider = {
+      metaData: jest.fn().mockResolvedValue({ ContentLength: 1024 } as never),
+      readStream: jest.fn().mockRejectedValue(readError as never),
+    };
+    jest.spyOn(service, 'getProvider').mockResolvedValue(provider as never);
+    return { service, provider };
+  };
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it('503 do storage com corpo ilegível vira ServiceUnavailable com code STORAGE_UNAVAILABLE', async () => {
+    const sdkError = Object.assign(new Error("char 'u' is not expected.:1:1"), {
+      $metadata: { httpStatusCode: 503 },
+    });
+    const { service } = buildService(sdkError);
+
+    const erro: any = await service.openReadStreamById(9).catch((e) => e);
+
+    expect(erro).toBeInstanceOf(ServiceUnavailableException);
+    expect(erro.getResponse()).toMatchObject({ code: 'STORAGE_UNAVAILABLE' });
+    expect(erro.cause).toBe(sdkError);
+  });
+
+  it('throttle (SlowDown) também é indisponibilidade, inclusive na leitura por faixa', async () => {
+    const { service } = buildService(Object.assign(new Error('Slow down'), { name: 'SlowDown' }));
+
+    await expect(service.openReadStreamWithRange(9, 0, 99)).rejects.toBeInstanceOf(
+      ServiceUnavailableException,
+    );
+  });
+
+  it('NoSuchKey continua 404', async () => {
+    const { service } = buildService(Object.assign(new Error('missing'), { name: 'NoSuchKey' }));
+
+    await expect(service.openReadStreamById(9)).rejects.toBeInstanceOf(NotFoundException);
+  });
+
+  it('erro sem status de storage é repassado como veio', async () => {
+    const original = new Error('boom');
+    const { service } = buildService(original);
+
+    await expect(service.openReadStreamById(9)).rejects.toBe(original);
+  });
+
+  it('não faz HEAD no storage quando o tamanho já está na tabela', async () => {
+    const { service, provider } = buildService(null);
+    provider.readStream.mockResolvedValue({} as never);
+
+    await service.openReadStreamById(9);
+
+    expect(provider.metaData).not.toHaveBeenCalled();
+  });
+});
+
+/**
+ * A varredura de reotimização do acervo passa em todo arquivo, e recomprimir WebP sobre
+ * WebP sempre devolve alguns bytes a menos. Sem um ganho mínimo, cada passada trocaria o
+ * arquivo por uma economia irrisória e mais uma geração de perda de qualidade — medido
+ * em três passadas seguidas: 10926 → 10664 → 10662 bytes.
+ */
+describe('FileService.reoptimizeFile — ganho mínimo', () => {
+  const makeService = (optimizedSize: number, optimizedMimetype = 'image/webp') => {
+    const oldSize = 10000;
+    const deps: any = {
+      prisma: { file: { update: jest.fn() } },
+      pagination: {},
+      setting: {},
+      jwt: {},
+      imageOptimization: {
+        optimizeBuffer: jest.fn().mockResolvedValue({
+          buffer: Buffer.alloc(optimizedSize),
+          mimetype: optimizedMimetype,
+          originalname: 'a.webp',
+        } as never),
+      },
+    };
+
+    const service = new FileService(
+      deps.prisma,
+      deps.pagination,
+      deps.setting,
+      deps.jwt,
+      deps.imageOptimization,
+    );
+
+    jest.spyOn(service as any, 'getBuffer').mockResolvedValue({
+      file: {
+        id: 1,
+        filename: 'a.webp',
+        size: oldSize,
+        location: 'lms/xp/skills',
+        path: 'x.webp',
+        file_mimetype: { name: 'image/webp' },
+      },
+      buffer: Buffer.alloc(oldSize),
+    } as never);
+
+    return { service, deps, oldSize };
+  };
+
+  it('não regrava quando a economia fica abaixo do limiar', async () => {
+    // 2 bytes de ganho: exatamente o caso que fazia a varredura nunca convergir.
+    const { service, deps } = makeService(9998);
+
+    const result = await service.reoptimizeFile(1);
+
+    expect(result.changed).toBe(false);
+    expect(deps.prisma.file.update).not.toHaveBeenCalled();
+  });
+
+  it('regrava quando a economia passa do limiar', async () => {
+    const { service } = makeService(5000);
+    const getProvider = jest
+      .spyOn(service as any, 'getProvider')
+      .mockResolvedValue({ upload: jest.fn().mockResolvedValue('novo.webp' as never), delete: jest.fn() } as never);
+    jest.spyOn(service as any, 'getMimeType').mockResolvedValue(5 as never);
+
+    const result = await service.reoptimizeFile(1);
+
+    expect(result.changed).toBe(true);
+    expect(getProvider).toHaveBeenCalled();
+  });
+
+  it('regrava mesmo com ganho pequeno quando o formato muda (PNG → WebP)', async () => {
+    const { service } = makeService(9998, 'image/webp');
+    jest.spyOn(service as any, 'getBuffer').mockResolvedValue({
+      file: {
+        id: 1,
+        filename: 'a.png',
+        size: 10000,
+        location: 'lms/xp/skills',
+        path: 'x.png',
+        file_mimetype: { name: 'image/png' },
+      },
+      buffer: Buffer.alloc(10000),
+    } as never);
+    jest
+      .spyOn(service as any, 'getProvider')
+      .mockResolvedValue({ upload: jest.fn().mockResolvedValue('novo.webp' as never), delete: jest.fn() } as never);
+    jest.spyOn(service as any, 'getMimeType').mockResolvedValue(5 as never);
+
+    const result = await service.reoptimizeFile(1);
+
+    expect(result.changed).toBe(true);
+    expect(result.mimetypeChanged).toBe(true);
+  });
+});
+
+/**
+ * O Instagram recusa WebP, e toda image/* que passa pela otimizacao vira WebP. Quem
+ * entrega o arquivo a um consumidor externo pede os bytes intactos.
+ */
+describe('FileService — skipImageOptimization', () => {
+  const makeService = () => {
+    const deps: any = {
+      prisma: { file: { create: jest.fn().mockImplementation((args: any) => Promise.resolve(args.data)) } },
+      pagination: {},
+      setting: {},
+      jwt: {},
+      imageOptimization: {
+        optimizeBuffer: jest.fn().mockResolvedValue({
+          buffer: Buffer.from('webp'),
+          mimetype: 'image/webp',
+          originalname: 'foto.webp',
+        } as never),
+      },
+    };
+    const service = new FileService(
+      deps.prisma,
+      deps.pagination,
+      deps.setting,
+      deps.jwt,
+      deps.imageOptimization,
+    );
+    const provider = {
+      upload: jest.fn().mockResolvedValue('social/foto.jpg' as never),
+      uploadFromPath: jest.fn().mockResolvedValue('social/foto.jpg' as never),
+    };
+    jest.spyOn(service as any, 'getProvider').mockResolvedValue(provider as never);
+    jest.spyOn(service as any, 'getMimeType').mockResolvedValue(7 as never);
+    return { service, deps, provider };
+  };
+
+  it('upload grava a imagem sem otimizar quando o chamador pede', async () => {
+    const { service, deps, provider } = makeService();
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 1, 2, 3]);
+
+    const file: any = await service.upload(
+      'social/brands/1',
+      { buffer: jpeg, mimetype: 'image/jpeg', originalname: 'foto.jpg', size: jpeg.length } as any,
+      undefined,
+      { skipMimeValidation: true, skipSizeValidation: true, skipImageOptimization: true },
+    );
+
+    expect(deps.imageOptimization.optimizeBuffer).not.toHaveBeenCalled();
+    const sent = (provider.upload.mock.calls[0] as any[])[1];
+    expect(sent.mimetype).toBe('image/jpeg');
+    expect(Buffer.compare(sent.buffer, jpeg)).toBe(0);
+    expect(file.size).toBe(jpeg.length);
+  });
+
+  it('upload sem a opcao continua otimizando', async () => {
+    const { service, deps } = makeService();
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 1, 2, 3]);
+
+    await service.upload(
+      'social/brands/1',
+      { buffer: jpeg, mimetype: 'image/jpeg', originalname: 'foto.jpg', size: jpeg.length } as any,
+      undefined,
+      { skipMimeValidation: true, skipSizeValidation: true },
+    );
+
+    expect(deps.imageOptimization.optimizeBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it('uploadFromPath manda a imagem pelo caminho de streaming, intacta', async () => {
+    const { service, deps, provider } = makeService();
+    const os = await import('node:os');
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    const tmp = path.join(os.tmpdir(), `skip-opt-${process.pid}.jpg`);
+    await fs.writeFile(tmp, Buffer.from([0xff, 0xd8, 0xff, 0xe0, 1, 2, 3]));
+
+    try {
+      await service.uploadFromPath('social/brands/1', tmp, {
+        mimetype: 'image/jpeg',
+        originalname: 'foto.jpg',
+        skipMimeValidation: true,
+        skipSizeValidation: true,
+        skipImageOptimization: true,
+      });
+    } finally {
+      await fs.rm(tmp, { force: true });
+    }
+
+    expect(deps.imageOptimization.optimizeBuffer).not.toHaveBeenCalled();
+    expect(provider.uploadFromPath).toHaveBeenCalledTimes(1);
+    expect(provider.upload).not.toHaveBeenCalled();
+  });
+});