@hed-hog/core 0.0.387 → 0.0.393

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

@@ -0,0 +1,275 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from '@jest/globals';
+import { NotFoundException } from '@nestjs/common';
+import { FileService } from './file.service';
+import { ProviderFactory } from './provider/provider.factory';
+
+/**
+ * Resolver o provider custava 3 queries + a reconstrução do client de storage por arquivo.
+ * Em upload em massa (segmentos HLS em lotes paralelos, frames, pacotes SCORM) isso virava
+ * milhares de round-trips simultâneos e estourava o pool de conexões no meio da conversão.
+ */
+describe('FileService.getProvider', () => {
+  let deps: any;
+  let service: FileService;
+  let createSpy: jest.SpiedFunction<typeof ProviderFactory.create>;
+
+  beforeEach(() => {
+    deps = {
+      prisma: {
+        integration_profile: {
+          findUnique: jest.fn().mockResolvedValue({
+            slug: 'spaces',
+            config: {},
+            integration_type: { slug: 'storage' },
+            integration_provider: { slug: 's3-compatible' },
+          } as never),
+        },
+        file_provider: {
+          findFirst: jest.fn().mockResolvedValue({ id: 7 } as never),
+        },
+      },
+      pagination: {},
+      setting: {
+        getSettingValues: jest
+          .fn()
+          .mockResolvedValue({ 'file-storage-profile-id': 'spaces' } as never),
+      },
+      jwt: {},
+      imageOptimization: {},
+    };
+
+    createSpy = jest
+      .spyOn(ProviderFactory, 'create')
+      .mockResolvedValue({ name: 'spaces-provider' } as never);
+
+    service = new FileService(
+      deps.prisma,
+      deps.pagination,
+      deps.setting,
+      deps.jwt,
+      deps.imageOptimization,
+    );
+  });
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it('resolve uma vez e reaproveita dentro da janela de cache', async () => {
+    const first = await service.getProvider();
+    const second = await service.getProvider();
+
+    expect(second).toBe(first);
+    expect(createSpy).toHaveBeenCalledTimes(1);
+    expect(deps.prisma.integration_profile.findUnique).toHaveBeenCalledTimes(1);
+    expect(deps.prisma.file_provider.findFirst).toHaveBeenCalledTimes(1);
+  });
+
+  it('mantém o providerId ao servir do cache (usado no registro do arquivo)', async () => {
+    await service.getProvider();
+    (service as any).providerId = undefined;
+
+    await service.getProvider();
+
+    expect((service as any).providerId).toBe(7);
+  });
+
+  it('deduplica resoluções simultâneas (lote de uploads paralelos)', async () => {
+    const results = await Promise.all(
+      Array.from({ length: 20 }, () => service.getProvider()),
+    );
+
+    expect(createSpy).toHaveBeenCalledTimes(1);
+    expect(new Set(results).size).toBe(1);
+  });
+
+  it('não guarda resolução com erro e volta a tentar na chamada seguinte', async () => {
+    deps.setting.getSettingValues.mockResolvedValueOnce({
+      'file-storage-profile-id': '',
+    } as never);
+
+    await expect(service.getProvider()).rejects.toThrow(
+      'No file storage profile configured',
+    );
+
+    await expect(service.getProvider()).resolves.toEqual({
+      name: 'spaces-provider',
+    });
+  });
+
+  it('reresolve depois que a janela de cache expira', async () => {
+    await service.getProvider();
+    (service as any).cachedProvider.expiresAt = Date.now() - 1;
+
+    await service.getProvider();
+
+    expect(createSpy).toHaveBeenCalledTimes(2);
+  });
+});
+
+/**
+ * As URLs temporárias de `/file/open` e `/file/download` saíam do `Host` da requisição.
+ * Para o class, que fala com a API pelo proxy interno do Next, esse `Host` é o Service do
+ * cluster (`hub-api:3100`) — a URL voltava inútil para o navegador e a imagem não carregava.
+ */
+describe('FileService.resolvePublicBaseUrl', () => {
+  const req = {
+    protocol: 'https',
+    get: (header: string) => (header === 'host' ? 'hub-api:3100' : undefined),
+  } as any;
+
+  function createService(settingValues: unknown) {
+    const setting = {
+      getSettingValues: jest.fn().mockResolvedValue(settingValues as never),
+    };
+    return new FileService({} as any, {} as any, setting as any, {} as any, {} as any);
+  }
+
+  it('prefere a URL pública do setting api-url ao Host da requisição', async () => {
+    const service = createService({ 'api-url': 'https://hub-api.hcode.com.br' });
+
+    await expect(service.resolvePublicBaseUrl(req)).resolves.toBe(
+      'https://hub-api.hcode.com.br',
+    );
+  });
+
+  it('remove a barra final do setting', async () => {
+    const service = createService({ 'api-url': 'https://hub-api.hcode.com.br/' });
+
+    await expect(service.resolvePublicBaseUrl(req)).resolves.toBe(
+      'https://hub-api.hcode.com.br',
+    );
+  });
+
+  it('cai para o setting url quando api-url está vazio', async () => {
+    const service = createService({ 'api-url': '', url: 'https://hub.hcode.com.br' });
+
+    await expect(service.resolvePublicBaseUrl(req)).resolves.toBe(
+      'https://hub.hcode.com.br',
+    );
+  });
+
+  it('usa o Host quando não há setting configurado', async () => {
+    const service = createService({});
+
+    await expect(service.resolvePublicBaseUrl(req)).resolves.toBe(
+      'https://hub-api:3100',
+    );
+  });
+
+  it('ignora valor que não é uma URL absoluta', async () => {
+    const service = createService({ 'api-url': 'hub-api.hcode.com.br' });
+
+    await expect(service.resolvePublicBaseUrl(req)).resolves.toBe(
+      'https://hub-api:3100',
+    );
+  });
+
+  it('não deixa falha na leitura do setting derrubar a requisição', async () => {
+    const setting = {
+      getSettingValues: jest
+        .fn()
+        .mockRejectedValue(new Error('setting indisponível') as never),
+    };
+    const service = new FileService(
+      {} as any,
+      {} as any,
+      setting as any,
+      {} as any,
+      {} as any,
+    );
+
+    await expect(service.resolvePublicBaseUrl(req)).resolves.toBe(
+      'https://hub-api:3100',
+    );
+  });
+});
+
+/**
+ * `GET /file/open/:id` e `GET /file/image/:id` são anônimos e recebem um id
+ * sequencial, então servem de porta enumerável para o acervo inteiro. `is_private`
+ * é o que fecha essa porta para anexo de formulário sem afetar a imagem de um post.
+ */
+describe('FileService — arquivo privado nas rotas por id', () => {
+  const buildService = (file: any) => {
+    const prisma = {
+      file: { findFirst: jest.fn().mockResolvedValue(file as never) },
+    };
+    const service = new FileService(
+      prisma as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+    );
+    // getProvider faria 3 queries e montaria o client de storage; o teste para
+    // antes disso, na checagem de privacidade.
+    jest
+      .spyOn(service, 'getProvider')
+      .mockResolvedValue({ metaData: jest.fn() } as never);
+    return { service, prisma };
+  };
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it('recusa servir por id um arquivo privado', async () => {
+    const { service } = buildService({
+      id: 42,
+      filename: 'curriculo.pdf',
+      is_private: true,
+      file_mimetype: { name: 'application/pdf' },
+    });
+
+    await expect(
+      service.serveFileById('pt', 42, undefined, {} as any),
+    ).rejects.toBeInstanceOf(NotFoundException);
+  });
+
+  it('recusa também na rota de imagem', async () => {
+    const { service } = buildService({
+      id: 42,
+      filename: 'rg.png',
+      is_private: true,
+      file_mimetype: { name: 'image/png' },
+    });
+
+    await expect(
+      service.serveImageById('pt', 42, undefined, {} as any),
+    ).rejects.toBeInstanceOf(NotFoundException);
+  });
+
+  it('responde igual a inexistente, sem revelar que o id existe', async () => {
+    const privado = buildService({
+      id: 42,
+      filename: 'curriculo.pdf',
+      is_private: true,
+      file_mimetype: { name: 'application/pdf' },
+    });
+    const ausente = buildService(null);
+
+    const erroPrivado = await privado.service
+      .serveFileById('pt', 42, undefined, {} as any)
+      .catch((e) => e);
+    const erroAusente = await ausente.service
+      .serveFileById('pt', 42, undefined, {} as any)
+      .catch((e) => e);
+
+    expect(erroPrivado.constructor).toBe(erroAusente.constructor);
+    expect(erroPrivado.message).toBe(erroAusente.message);
+  });
+
+  it('não afeta arquivo comum: segue para a resolução do provider', async () => {
+    const { service } = buildService({
+      id: 7,
+      filename: 'post.png',
+      is_private: false,
+      file_mimetype: { name: 'image/png' },
+    });
+
+    // Passa da checagem e falha adiante, no provider mockado sem metaData útil —
+    // o que importa é NÃO ter parado no 404.
+    const erro = await service
+      .serveFileById('pt', 7, undefined, {} as any)
+      .catch((e) => e);
+
+    expect(String(erro?.message ?? '')).not.toMatch(/Not found/);
+  });
+});