first commit

test/integracoes.e2e-spec.ts

@@ -0,0 +1,486 @@
+import { randomUUID } from 'node:crypto';
+import { IncomingMessage, Server, ServerResponse, createServer } from 'node:http';
+import { AddressInfo } from 'node:net';
+import { INestApplication, ValidationPipe } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import request from 'supertest';
+import { AppModule } from '../src/app.module';
+import { EncryptionService } from '../src/common/encryption.service';
+import { PrismaService } from '../src/config/prisma.service';
+import { hashPassword } from '../src/modules/auth/password.util';
+
+// Nome com prefixo "mock" para escapar da restrição do Jest contra
+// variáveis fora de escopo dentro da factory de `jest.mock`.
+const mockSendMail = jest.fn().mockResolvedValue({ messageId: 'fake-message-id' });
+jest.mock('nodemailer', () => ({
+  createTransport: jest.fn(() => ({ sendMail: mockSendMail })),
+}));
+
+interface TokenPair {
+  access_token: string;
+  refresh_token: string;
+}
+
+/**
+ * Substituto local da Evolution API real (indisponível neste ambiente de
+ * teste/CI — sem internet nem instância dedicada). Implementa o subset da
+ * API v2 usado por `EvolutionApiClient`, o suficiente para exercitar o
+ * fluxo ponta a ponta desta etapa contra um servidor HTTP real.
+ */
+class FakeEvolutionServer {
+  server: Server;
+  baseUrl = '';
+  connectionState: 'open' | 'connecting' | 'close' = 'close';
+  requests: Array<{ method: string; url: string; apikey?: string; body: unknown }> = [];
+
+  async start(): Promise<void> {
+    this.server = createServer((req, res) => this.handle(req, res));
+    await new Promise<void>((resolve) => this.server.listen(0, '127.0.0.1', resolve));
+    const { port } = this.server.address() as AddressInfo;
+    this.baseUrl = `http://127.0.0.1:${port}`;
+  }
+
+  async stop(): Promise<void> {
+    await new Promise<void>((resolve) => this.server.close(() => resolve()));
+  }
+
+  private handle(req: IncomingMessage, res: ServerResponse): void {
+    const chunks: Buffer[] = [];
+    req.on('data', (chunk: Buffer) => chunks.push(chunk));
+    req.on('end', () => {
+      const raw = Buffer.concat(chunks).toString('utf8');
+      const body: unknown = raw ? JSON.parse(raw) : undefined;
+      const url = req.url ?? '';
+      const method = req.method ?? 'GET';
+      this.requests.push({ method, url, apikey: req.headers.apikey as string | undefined, body });
+
+      const json = (status: number, payload: unknown) => {
+        res.writeHead(status, { 'content-type': 'application/json' });
+        res.end(JSON.stringify(payload));
+      };
+
+      if (method === 'GET' && url === '/') {
+        return json(200, { version: '2.3.0', message: 'Welcome to the Evolution API' });
+      }
+      if (method === 'POST' && url === '/instance/create') {
+        return json(201, { instance: body });
+      }
+      if (method === 'GET' && url.startsWith('/instance/connect/')) {
+        return json(200, { base64: 'data:image/png;base64,ZmFrZQ==', pairingCode: '12-34' });
+      }
+      if (method === 'GET' && url.startsWith('/instance/connectionState/')) {
+        return json(200, { instance: { state: this.connectionState } });
+      }
+      if (method === 'DELETE' && url.startsWith('/instance/logout/')) {
+        return json(200, {});
+      }
+      if (method === 'DELETE' && url.startsWith('/instance/delete/')) {
+        return json(200, {});
+      }
+      if (method === 'POST' && url.startsWith('/message/sendText/')) {
+        const numero = (body as { number?: string } | undefined)?.number;
+        if (numero === '0000000000') {
+          return json(500, { message: 'falha simulada de envio' });
+        }
+        return json(201, { status: 'PENDING' });
+      }
+
+      json(404, { message: 'rota não simulada' });
+    });
+  }
+}
+
+describe('Integrações — Evolution API (WhatsApp) e E-mail (e2e)', () => {
+  let app: INestApplication;
+  let prisma: PrismaService;
+  let encryptionService: EncryptionService;
+  let httpServer: Parameters<typeof request>[0];
+  let evolution: FakeEvolutionServer;
+
+  const senha = 'SenhaForteDemo#26';
+  const suffix = randomUUID().slice(0, 8);
+  const masterEmail = `master-etapa4-${suffix}@teste.com`;
+
+  let masterId: string;
+  let masterToken: string;
+
+  const tenantIds: string[] = [];
+  const planoIds: string[] = [];
+  const tenantUserIds: string[] = [];
+  const evolutionConfigIds: string[] = [];
+  const masterEmailConfigIds: string[] = [];
+
+  async function authMaster(): Promise<string> {
+    const res = await request(httpServer)
+      .post('/auth/master/login')
+      .send({ email: masterEmail, senha })
+      .expect(200);
+    return (res.body as TokenPair).access_token;
+  }
+
+  function asMaster() {
+    return {
+      get: (url: string) =>
+        request(httpServer).get(url).set('Authorization', `Bearer ${masterToken}`),
+      post: (url: string) =>
+        request(httpServer).post(url).set('Authorization', `Bearer ${masterToken}`),
+      put: (url: string) =>
+        request(httpServer).put(url).set('Authorization', `Bearer ${masterToken}`),
+      delete: (url: string) =>
+        request(httpServer).delete(url).set('Authorization', `Bearer ${masterToken}`),
+    };
+  }
+
+  function asTenant(token: string) {
+    return {
+      get: (url: string) => request(httpServer).get(url).set('Authorization', `Bearer ${token}`),
+      post: (url: string) => request(httpServer).post(url).set('Authorization', `Bearer ${token}`),
+      put: (url: string) => request(httpServer).put(url).set('Authorization', `Bearer ${token}`),
+      delete: (url: string) =>
+        request(httpServer).delete(url).set('Authorization', `Bearer ${token}`),
+    };
+  }
+
+  async function criarPlano(overrides: Partial<Record<string, unknown>> = {}) {
+    const res = await asMaster()
+      .post('/master/planos')
+      .send({
+        nome: `Plano ${suffix} ${randomUUID().slice(0, 4)}`,
+        valor_mensal: 199.9,
+        limite_instancias_whatsapp: 1,
+        ...overrides,
+      })
+      .expect(201);
+    planoIds.push((res.body as { id: string }).id);
+    return res.body as { id: string };
+  }
+
+  async function criarTenantComAdmin(planoId: string) {
+    const emailAdmin = `admin-${randomUUID().slice(0, 8)}-${suffix}@teste.com`;
+    const res = await asMaster()
+      .post('/master/tenants')
+      .send({
+        razao_social: `Tenant Integração ${suffix} ${randomUUID().slice(0, 6)}`,
+        email_contato: `contato-${randomUUID().slice(0, 6)}@teste.com`,
+        plano_id: planoId,
+        admin: { nome: 'Admin de Teste', email: emailAdmin },
+      })
+      .expect(201);
+    const body = res.body as {
+      tenant: { id: string };
+      admin: { id: string; email: string; senha_provisoria: string };
+    };
+    tenantIds.push(body.tenant.id);
+    tenantUserIds.push(body.admin.id);
+
+    await prisma.tenants.update({ where: { id: body.tenant.id }, data: { status: 'ativo' } });
+
+    const login = await request(httpServer)
+      .post('/auth/tenant/login')
+      .send({ email: body.admin.email, senha: body.admin.senha_provisoria })
+      .expect(200);
+
+    return {
+      tenant: body.tenant,
+      admin: body.admin,
+      token: (login.body as TokenPair).access_token,
+    };
+  }
+
+  async function criarEvolutionConfigAtiva() {
+    const res = await asMaster()
+      .post('/master/evolution-config')
+      .send({
+        nome: `Evolution ${suffix}`,
+        base_url: evolution.baseUrl,
+        api_key: 'chave-evolution-secreta-1234',
+      })
+      .expect(201);
+    const body = res.body as { id: string };
+    evolutionConfigIds.push(body.id);
+    return body;
+  }
+
+  beforeAll(async () => {
+    evolution = new FakeEvolutionServer();
+    await evolution.start();
+
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    app.useGlobalPipes(
+      new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }),
+    );
+    await app.init();
+    httpServer = app.getHttpServer() as Parameters<typeof request>[0];
+
+    prisma = app.get(PrismaService);
+    encryptionService = app.get(EncryptionService);
+
+    const senha_hash = await hashPassword(senha);
+    const master = await prisma.master_admins.create({
+      data: { nome: 'Master Etapa 4', email: masterEmail, senha_hash },
+    });
+    masterId = master.id;
+
+    masterToken = await authMaster();
+  });
+
+  afterAll(async () => {
+    await prisma.tenant_whatsapp_instances.deleteMany({ where: { tenant_id: { in: tenantIds } } });
+    await prisma.tenant_email_config.deleteMany({ where: { tenant_id: { in: tenantIds } } });
+    await prisma.tenants.deleteMany({ where: { id: { in: tenantIds } } });
+    await prisma.planos.deleteMany({ where: { id: { in: planoIds } } });
+    await prisma.evolution_api_config.deleteMany({ where: { id: { in: evolutionConfigIds } } });
+    await prisma.master_email_config.deleteMany({ where: { id: { in: masterEmailConfigIds } } });
+    await prisma.auth_refresh_tokens.deleteMany({
+      where: { usuario_id: { in: [masterId, ...tenantUserIds] } },
+    });
+    await prisma.login_attempts.deleteMany({
+      where: { usuario_tipo: 'master', email: masterEmail },
+    });
+    await prisma.audit_logs.deleteMany({ where: { usuario_id: masterId } });
+    await prisma.master_admins.deleteMany({ where: { id: masterId } });
+
+    await app.close();
+    await evolution.stop();
+  });
+
+  describe('Evolution API — config master', () => {
+    it('cadastra config, nunca retorna api_key em texto puro e testa conexão', async () => {
+      const config = await criarEvolutionConfigAtiva();
+      const body = config as unknown as Record<string, unknown>;
+
+      expect(body.api_key_cripto).toBeUndefined();
+      expect(body.api_key).toMatch(/^\*+1234$/);
+
+      const raw = await prisma.evolution_api_config.findUniqueOrThrow({ where: { id: config.id } });
+      expect(raw.api_key_cripto).not.toBe('chave-evolution-secreta-1234');
+      expect(encryptionService.decrypt(raw.api_key_cripto)).toBe('chave-evolution-secreta-1234');
+
+      const lista = await asMaster().get('/master/evolution-config').expect(200);
+      expect(
+        (lista.body as Array<Record<string, unknown>>).every((c) => c.api_key_cripto === undefined),
+      ).toBe(true);
+
+      const teste = await asMaster()
+        .post(`/master/evolution-config/${config.id}/testar-conexao`)
+        .expect(201);
+      expect((teste.body as { status_http: number; versao: string }).status_http).toBe(200);
+      expect((teste.body as { versao: string }).versao).toBe('2.3.0');
+    });
+
+    it('bloqueia endpoints de evolution-config com token de tenant_user', async () => {
+      const plano = await criarPlano();
+      const { token } = await criarTenantComAdmin(plano.id);
+
+      await asTenant(token).get('/master/evolution-config').expect(403);
+    });
+  });
+
+  describe('WhatsApp — instâncias do tenant', () => {
+    it('cria instância, obtém QR code e reflete status conectado após consultar', async () => {
+      await criarEvolutionConfigAtiva();
+      const plano = await criarPlano({ limite_instancias_whatsapp: 1 });
+      const { token } = await criarTenantComAdmin(plano.id);
+
+      const criada = await asTenant(token).post('/tenant/whatsapp/instancias').send({}).expect(201);
+      const instancia = criada.body as { id: string; status: string; instance_name: string };
+      expect(instancia.status).toBe('desconectado');
+      expect(instancia.instance_name).toMatch(/^tenant-/);
+
+      const qrcode = await asTenant(token)
+        .get(`/tenant/whatsapp/instancias/${instancia.id}/qrcode`)
+        .expect(200);
+      expect((qrcode.body as { base64: string }).base64).toContain('base64');
+
+      evolution.connectionState = 'open';
+      const status = await asTenant(token)
+        .get(`/tenant/whatsapp/instancias/${instancia.id}/status`)
+        .expect(200);
+      expect((status.body as { status: string }).status).toBe('conectado');
+    });
+
+    it('criar instância além do limite do plano retorna erro claro', async () => {
+      await criarEvolutionConfigAtiva();
+      const plano = await criarPlano({ limite_instancias_whatsapp: 1 });
+      const { token } = await criarTenantComAdmin(plano.id);
+
+      await asTenant(token).post('/tenant/whatsapp/instancias').send({}).expect(201);
+      const segunda = await asTenant(token)
+        .post('/tenant/whatsapp/instancias')
+        .send({})
+        .expect(400);
+      expect((segunda.body as { message: string }).message).toMatch(/limite/i);
+    });
+
+    it('teste de envio funciona (sucesso) e reporta falha claramente quando a Evolution API recusa', async () => {
+      await criarEvolutionConfigAtiva();
+      const plano = await criarPlano({ limite_instancias_whatsapp: 1 });
+      const { token } = await criarTenantComAdmin(plano.id);
+
+      const criada = await asTenant(token).post('/tenant/whatsapp/instancias').send({}).expect(201);
+      const instanceId = (criada.body as { id: string }).id;
+
+      const sucesso = await asTenant(token)
+        .post(`/tenant/whatsapp/instancias/${instanceId}/testar-envio`)
+        .send({ numero: '5511999998888' })
+        .expect(201);
+      expect(sucesso.body).toMatchObject({ sucesso: true });
+
+      const falha = await asTenant(token)
+        .post(`/tenant/whatsapp/instancias/${instanceId}/testar-envio`)
+        .send({ numero: '0000000000' })
+        .expect(201);
+      expect((falha.body as { sucesso: boolean; erro: string }).sucesso).toBe(false);
+      expect((falha.body as { erro: string }).erro).toEqual(expect.any(String));
+    });
+
+    it('desconecta e remove a instância', async () => {
+      await criarEvolutionConfigAtiva();
+      const plano = await criarPlano({ limite_instancias_whatsapp: 1 });
+      const { token } = await criarTenantComAdmin(plano.id);
+
+      const criada = await asTenant(token).post('/tenant/whatsapp/instancias').send({}).expect(201);
+      const instanceId = (criada.body as { id: string }).id;
+
+      await asTenant(token).delete(`/tenant/whatsapp/instancias/${instanceId}`).expect(204);
+      await asTenant(token).get(`/tenant/whatsapp/instancias/${instanceId}/status`).expect(404);
+    });
+
+    it('bloqueia acesso a instância de outro tenant (RLS) com 404', async () => {
+      await criarEvolutionConfigAtiva();
+      const planoA = await criarPlano({ limite_instancias_whatsapp: 1 });
+      const { token: tokenA } = await criarTenantComAdmin(planoA.id);
+      const planoB = await criarPlano({ limite_instancias_whatsapp: 1 });
+      const { token: tokenB } = await criarTenantComAdmin(planoB.id);
+
+      const criada = await asTenant(tokenA)
+        .post('/tenant/whatsapp/instancias')
+        .send({})
+        .expect(201);
+      const instanceId = (criada.body as { id: string }).id;
+
+      await asTenant(tokenB).get(`/tenant/whatsapp/instancias/${instanceId}/status`).expect(404);
+    });
+  });
+
+  describe('E-mail — config master e tenant', () => {
+    async function criarMasterEmailConfig(overrides: Partial<Record<string, unknown>> = {}) {
+      const res = await asMaster()
+        .post('/master/email-config')
+        .send({
+          smtp_host: 'smtp.padrao.teste',
+          smtp_porta: 587,
+          smtp_usuario: 'padrao@teste.com',
+          smtp_senha: 'senha-smtp-padrao-9876',
+          email_remetente: 'padrao@seconectai.teste',
+          ...overrides,
+        })
+        .expect(201);
+      const body = res.body as { id: string };
+      masterEmailConfigIds.push(body.id);
+      return body;
+    }
+
+    it('cadastra config padrão da plataforma sem nunca retornar a senha em texto puro', async () => {
+      const config = await criarMasterEmailConfig();
+      const body = config as unknown as Record<string, unknown>;
+
+      expect(body.smtp_senha_cripto).toBeUndefined();
+      expect(body.smtp_senha).toMatch(/^\*+9876$/);
+
+      const raw = await prisma.master_email_config.findUniqueOrThrow({ where: { id: config.id } });
+      expect(encryptionService.decrypt(raw.smtp_senha_cripto)).toBe('senha-smtp-padrao-9876');
+    });
+
+    it('tenant usa o padrão por default e consegue trocar para SMTP próprio (PUT exige campos)', async () => {
+      await criarMasterEmailConfig();
+      const plano = await criarPlano();
+      const { token } = await criarTenantComAdmin(plano.id);
+
+      const inicial = await asTenant(token).get('/tenant/email-config').expect(200);
+      expect(inicial.body).toEqual({ usar_config_padrao: true });
+
+      await asTenant(token)
+        .put('/tenant/email-config')
+        .send({ usar_config_padrao: false })
+        .expect(400);
+
+      const proprio = await asTenant(token)
+        .put('/tenant/email-config')
+        .send({
+          usar_config_padrao: false,
+          smtp_host: 'smtp.proprio.teste',
+          smtp_porta: 465,
+          smtp_usuario: 'tenant@proprio.teste',
+          smtp_senha: 'senha-smtp-propria-4321',
+          email_remetente: 'contato@tenantproprio.teste',
+        })
+        .expect(200);
+      expect(proprio.body).toMatchObject({
+        usar_config_padrao: false,
+        smtp_host: 'smtp.proprio.teste',
+        email_remetente: 'contato@tenantproprio.teste',
+      });
+      expect((proprio.body as { smtp_senha: string }).smtp_senha).toMatch(/^\*+4321$/);
+
+      const voltaPadrao = await asTenant(token)
+        .put('/tenant/email-config')
+        .send({ usar_config_padrao: true })
+        .expect(200);
+      expect(voltaPadrao.body).toEqual({ usar_config_padrao: true });
+    });
+
+    it('teste de envio funciona usando o padrão e usando o SMTP próprio do tenant', async () => {
+      await criarMasterEmailConfig({ email_remetente: `padrao-${suffix}@seconectai.teste` });
+      const plano = await criarPlano();
+      const { token } = await criarTenantComAdmin(plano.id);
+
+      mockSendMail.mockClear();
+      await asTenant(token)
+        .post('/tenant/email-config/testar-envio')
+        .send({ destinatario: 'destino@teste.com' })
+        .expect(201)
+        .expect((res) => {
+          if (!(res.body as { sucesso: boolean }).sucesso) {
+            throw new Error(`envio via padrão falhou: ${JSON.stringify(res.body)}`);
+          }
+        });
+      expect(mockSendMail).toHaveBeenCalledWith(
+        expect.objectContaining({ from: `padrao-${suffix}@seconectai.teste` }),
+      );
+
+      await asTenant(token)
+        .put('/tenant/email-config')
+        .send({
+          usar_config_padrao: false,
+          smtp_host: 'smtp.proprio.teste',
+          smtp_porta: 465,
+          smtp_usuario: 'tenant@proprio.teste',
+          smtp_senha: 'senha-smtp-propria-4321',
+          email_remetente: `proprio-${suffix}@tenantproprio.teste`,
+        })
+        .expect(200);
+
+      mockSendMail.mockClear();
+      await asTenant(token)
+        .post('/tenant/email-config/testar-envio')
+        .send({ destinatario: 'destino@teste.com' })
+        .expect(201);
+      expect(mockSendMail).toHaveBeenCalledWith(
+        expect.objectContaining({ from: `proprio-${suffix}@tenantproprio.teste` }),
+      );
+    });
+
+    it('bloqueia endpoints de email-config do tenant com token de master e vice-versa', async () => {
+      const plano = await criarPlano();
+      const { token } = await criarTenantComAdmin(plano.id);
+
+      await asTenant(token).get('/master/email-config').expect(403);
+      await asMaster().get('/tenant/email-config').expect(403);
+    });
+  });
+});