@hed-hog/core 0.0.371 → 0.0.374

package/src/utils/webauthn-origin.spec.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { resolveWebAuthnOrigin } from './webauthn-origin';
+
+describe('resolveWebAuthnOrigin', () => {
+  const originalEnv = process.env.CORS_ALLOWED_ORIGINS;
+
+  afterEach(() => {
+    if (originalEnv === undefined) {
+      delete process.env.CORS_ALLOWED_ORIGINS;
+    } else {
+      process.env.CORS_ALLOWED_ORIGINS = originalEnv;
+    }
+  });
+
+  it('usa fallback padrão quando não há origins configuradas', () => {
+    delete process.env.CORS_ALLOWED_ORIGINS;
+    const result = resolveWebAuthnOrigin();
+    expect(result).toEqual({
+      rpID: 'localhost',
+      expectedOrigin: 'http://localhost:3200',
+    });
+  });
+
+  it('retorna o request origin quando está na allowlist', () => {
+    process.env.CORS_ALLOWED_ORIGINS =
+      'https://admin.example.com,https://training.example.com';
+    const result = resolveWebAuthnOrigin('https://training.example.com');
+    expect(result).toEqual({
+      rpID: 'training.example.com',
+      expectedOrigin: 'https://training.example.com',
+    });
+  });
+
+  it('normaliza trailing slash do request origin antes de comparar', () => {
+    process.env.CORS_ALLOWED_ORIGINS = 'https://admin.example.com';
+    const result = resolveWebAuthnOrigin('https://admin.example.com/');
+    expect(result.expectedOrigin).toBe('https://admin.example.com');
+  });
+
+  it('cai para o primeiro origin permitido quando request origin não está na lista', () => {
+    process.env.CORS_ALLOWED_ORIGINS =
+      'https://first.example.com;https://second.example.com';
+    const result = resolveWebAuthnOrigin('https://unknown.example.com');
+    expect(result.expectedOrigin).toBe('https://first.example.com');
+    expect(result.rpID).toBe('first.example.com');
+  });
+
+  it('cai para o primeiro origin permitido quando request origin é inválido', () => {
+    process.env.CORS_ALLOWED_ORIGINS = 'https://first.example.com';
+    const result = resolveWebAuthnOrigin('not-a-url');
+    expect(result.expectedOrigin).toBe('https://first.example.com');
+  });
+
+  it('ignora entradas vazias/inválidas ao construir a allowlist', () => {
+    process.env.CORS_ALLOWED_ORIGINS =
+      '\n , ; not-a-url ; https://valid.example.com';
+    const result = resolveWebAuthnOrigin('https://valid.example.com');
+    expect(result.expectedOrigin).toBe('https://valid.example.com');
+  });
+
+  it('usa fallback quando request origin é null e allowlist vazia', () => {
+    process.env.CORS_ALLOWED_ORIGINS = '';
+    const result = resolveWebAuthnOrigin(null);
+    expect(result.expectedOrigin).toBe('http://localhost:3200');
+  });
+
+  it('extrai o origin de uma URL com path e porta', () => {
+    process.env.CORS_ALLOWED_ORIGINS = 'http://localhost:3001/app/login';
+    const result = resolveWebAuthnOrigin('http://localhost:3001');
+    expect(result.expectedOrigin).toBe('http://localhost:3001');
+    expect(result.rpID).toBe('localhost');
+  });
+});

package/src/webhook-integration/integration-event-catalog.service.spec.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { BadRequestException, NotFoundException } from '@nestjs/common';
+import { IntegrationEventCatalogService } from './integration-event-catalog.service';
+
+const makeDeps = () => {
+  const catalog = {
+    findMany: jest.fn(),
+    findUnique: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+    deleteMany: jest.fn(),
+  };
+  const prisma = {
+    integration_event_catalog: catalog,
+    createInsensitiveSearch: jest.fn().mockReturnValue([]),
+  };
+  const pagination = { paginate: jest.fn().mockResolvedValue({ data: [] }) };
+  return { prisma, pagination, catalog };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new IntegrationEventCatalogService(deps.prisma as any, deps.pagination as any),
+  deps,
+});
+
+describe('IntegrationEventCatalogService', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  describe('normalize', () => {
+    let service: IntegrationEventCatalogService;
+    beforeEach(() => {
+      service = makeService().service;
+    });
+    const call = (data: any, partial?: boolean) =>
+      (service as any).normalize(data, partial);
+
+    it('faz trim e default status active', () => {
+      const result = call({ slug: '  s  ', name: ' N ', module: ' m ' });
+      expect(result).toEqual({
+        slug: 's',
+        name: 'N',
+        module: 'm',
+        description: null,
+        status: 'active',
+      });
+    });
+
+    it('status inactive é preservado', () => {
+      expect(call({ status: 'inactive' }).status).toBe('inactive');
+    });
+
+    it('description string vira trim ou null', () => {
+      expect(call({ description: '  hi  ' }).description).toBe('hi');
+      expect(call({ description: '   ' }).description).toBeNull();
+    });
+
+    it('partial pula description undefined mas mantém slug/name/module vazios', () => {
+      const result = call({ slug: 'x' }, true);
+      expect(result).toEqual({ slug: 'x', name: '', module: '', status: 'active' });
+      expect(result).not.toHaveProperty('description');
+    });
+  });
+
+  describe('get', () => {
+    it('lança NotFound quando não existe', async () => {
+      const { service, deps } = makeService();
+      deps.catalog.findUnique.mockResolvedValue(null);
+      await expect(service.get(1)).rejects.toThrow(NotFoundException);
+    });
+
+    it('retorna registro existente', async () => {
+      const { service, deps } = makeService();
+      deps.catalog.findUnique.mockResolvedValue({ id: 1, slug: 's' });
+      await expect(service.get(1)).resolves.toMatchObject({ id: 1 });
+    });
+  });
+
+  describe('create', () => {
+    it('lança BadRequest quando slug já existe', async () => {
+      const { service, deps } = makeService();
+      deps.catalog.findUnique.mockResolvedValue({ id: 1 });
+      await expect(service.create({ slug: 'dup' })).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+
+    it('cria com dados normalizados quando slug livre', async () => {
+      const { service, deps } = makeService();
+      deps.catalog.findUnique.mockResolvedValue(null);
+      deps.catalog.create.mockResolvedValue({ id: 2 });
+      await service.create({ slug: ' new ', name: 'N', module: 'm' });
+      expect(deps.catalog.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ slug: 'new', status: 'active' }),
+      });
+    });
+  });
+
+  describe('update', () => {
+    it('checa disponibilidade só quando slug muda', async () => {
+      const { service, deps } = makeService();
+      deps.catalog.findUnique
+        .mockResolvedValueOnce({ id: 1, slug: 'old' }) // get()
+        .mockResolvedValueOnce(null); // ensureSlugAvailable
+      deps.catalog.update.mockResolvedValue({ id: 1 });
+      await service.update(1, { slug: 'new' });
+      expect(deps.catalog.update).toHaveBeenCalledWith({
+        where: { id: 1 },
+        data: expect.objectContaining({ slug: 'new' }),
+      });
+    });
+
+    it('não checa disponibilidade quando slug igual', async () => {
+      const { service, deps } = makeService();
+      deps.catalog.findUnique.mockResolvedValue({ id: 1, slug: 'same' });
+      deps.catalog.update.mockResolvedValue({ id: 1 });
+      await service.update(1, { slug: 'same', name: 'X' });
+      expect(deps.catalog.findUnique).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('delete', () => {
+    it('lança BadRequest sem ids', async () => {
+      const { service } = makeService();
+      await expect(service.delete({ ids: [] } as any)).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+
+    it('remove por ids', async () => {
+      const { service, deps } = makeService();
+      deps.catalog.deleteMany.mockResolvedValue({ count: 2 });
+      await service.delete({ ids: [1, 2] } as any);
+      expect(deps.catalog.deleteMany).toHaveBeenCalledWith({
+        where: { id: { in: [1, 2] } },
+      });
+    });
+  });
+
+  describe('options', () => {
+    it('lista apenas ativos', async () => {
+      const { service, deps } = makeService();
+      deps.catalog.findMany.mockResolvedValue([{ id: 1 }]);
+      await service.options();
+      expect(deps.catalog.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { status: 'active' } }),
+      );
+    });
+  });
+});