@hed-hog/core 0.0.390 → 0.0.393

package/src/mail/mail.service.spec.ts

@@ -23,14 +23,32 @@ const makeDeps = () => {
       createMany: jest.fn(),
       findMany: jest.fn(),
     },
-    locale: { findMany: jest.fn() },
+    locale: { findMany: jest.fn(), findUnique: jest.fn() },
+    user_identifier: { findFirst: jest.fn(async () => null) },
+  };
+  const mailMainService = {
+    send: jest.fn(),
+    setConfig: jest.fn(),
+    getBrandName: jest.fn(async () => 'HedHog'),
+    invalidateLayoutCache: jest.fn(),
   };
-  const mailMainService = { send: jest.fn(), setConfig: jest.fn() };
   const localeService = {};
-  const setting = { getSettingValues: jest.fn(), setValue: jest.fn() };
+  const setting = {
+    getSettingValues: jest.fn(),
+    setValue: jest.fn(),
+    getUserSettingValue: jest.fn(async () => null),
+    getSettingListValues: jest.fn(async () => ['en', 'pt']),
+    // A cadeia de precedencia em si é testada em setting.service.spec.ts.
+    resolveUserLocale: jest.fn(async () => 'en'),
+  };
   const integrationApi = { subscribe: jest.fn() };
   const incident = { record: jest.fn(), persist: jest.fn() };
-  return { prismaService, mailMainService, localeService, setting, integrationApi, incident };
+  const brandAsset = {
+    resolveAssetUrl: jest.fn(async (value: string) =>
+      value?.startsWith('/') ? `https://hub.hcode.com.br${value}` : value,
+    ),
+  };
+  return { prismaService, mailMainService, localeService, setting, integrationApi, incident, brandAsset };
 };
 
 const makeService = (deps = makeDeps()) => ({
@@ -41,6 +59,7 @@ const makeService = (deps = makeDeps()) => ({
     deps.setting as any,
     deps.integrationApi as any,
     deps.incident as any,
+    deps.brandAsset as any,
   ),
   deps,
 });
@@ -242,7 +261,10 @@ describe('MailService', () => {
   });
 
   describe('sendTemplatedMail', () => {
-    it('aborta silenciosamente quando mail não configurado', async () => {
+    // Continua sem lançar (há call sites sem await que quebrariam), mas o
+    // retorno agora diz que nada saiu: era isso que faltava para a fila do SAC
+    // distinguir enviado de engolido.
+    it('não lança quando mail não configurado, e devolve sent=false', async () => {
       const { service, deps } = makeService();
       deps.setting.getSettingValues.mockResolvedValue({
         'configured-mail': 'false',
@@ -253,9 +275,268 @@ describe('MailService', () => {
           slug: 's',
           variables: {},
         } as any),
-      ).resolves.toBeUndefined();
+      ).resolves.toEqual({ sent: false, reason: 'mail-not-configured' });
+      expect(deps.mailMainService.send).not.toHaveBeenCalled();
+    });
+
+    it('devolve sent=false quando o provedor falha, sem propagar a exceção', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'true',
+      });
+      jest
+        .spyOn(service, 'reloadConfig')
+        .mockRejectedValue(new Error('SES unreachable'));
+
+      await expect(
+        service.sendTemplatedMail('en', {
+          email: 'a@b.com',
+          slug: 's',
+          variables: {},
+        } as any),
+      ).resolves.toEqual({
+        sent: false,
+        reason: 'send-failed',
+        error: 'SES unreachable',
+      });
       expect(deps.mailMainService.send).not.toHaveBeenCalled();
     });
+
+    it('devolve o id do provedor quando o envio funciona', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'true',
+      } as any);
+      jest
+        .spyOn(service, 'reloadConfig')
+        .mockResolvedValue({ success: true, provider: 'ses', from: 'a@b.com', config: {} });
+      deps.prismaService.locale.findUnique.mockResolvedValue({ id: 1, code: 'en' });
+      deps.prismaService.mail.findUnique.mockResolvedValue({
+        id: 7,
+        mail_locale: [
+          { subject: 'Oi {{name}}', body: 'Corpo', locale: { code: 'en' } },
+        ],
+        mail_var: [],
+      });
+      deps.mailMainService.send.mockResolvedValue({
+        result: { MessageId: 'ses-abc' },
+      });
+
+      await expect(
+        service.sendTemplatedMail('en', {
+          email: 'a@b.com',
+          slug: 's',
+          variables: { name: 'João' },
+        } as any),
+      ).resolves.toEqual({ sent: true, providerMessageId: 'ses-abc' });
+    });
+
+    // O bug que originou esta mudanca: o e-mail saia no idioma do header (ou no
+    // `en` de quem nao manda header), ignorando a preferencia do destinatario.
+    describe('idioma do destinatario', () => {
+      const arrange = (deps: any) => {
+        deps.setting.getSettingValues.mockResolvedValue({
+          'configured-mail': 'true',
+          language: 'en',
+        } as any);
+        deps.prismaService.mail.findUnique.mockResolvedValue({
+          id: 7,
+          mail_locale: [
+            { subject: 'Hello', body: 'Body', locale: { code: 'en' } },
+            { subject: 'Olá', body: 'Corpo', locale: { code: 'pt' } },
+          ],
+          mail_var: [],
+        });
+        deps.mailMainService.send.mockResolvedValue({ result: { MessageId: 'x' } });
+      };
+
+      const send = (service: any, locale: string) =>
+        service.sendTemplatedMail(locale, {
+          email: 'a@b.com',
+          slug: 's',
+          variables: {},
+        } as any);
+
+      it('resolve o idioma pelo destinatario, nao pelo locale do chamador', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue({ user_id: 42 });
+        deps.setting.resolveUserLocale.mockResolvedValue('pt');
+
+        await send(service, 'en');
+
+        expect(deps.setting.resolveUserLocale).toHaveBeenCalledWith(42);
+        expect(deps.mailMainService.send).toHaveBeenCalledWith(
+          expect.objectContaining({ subject: 'Olá', body: 'Corpo', locale: 'pt' }),
+        );
+      });
+
+      // Envio de fila/cron nao tem requisicao, entao a cadeia do SettingService
+      // nao tem contexto de onde tirar idioma: sobra o que o chamador informou.
+      it('usa o locale do chamador quando nao ha nada melhor', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue(null);
+        deps.setting.resolveUserLocale.mockResolvedValue('en');
+
+        await send(service, 'pt');
+
+        expect(deps.mailMainService.send).toHaveBeenCalledWith(
+          expect.objectContaining({ subject: 'Olá', locale: 'pt' }),
+        );
+      });
+
+      // Regressao do commerce: 8 call sites passavam 'pt-BR', a tabela `locale`
+      // so tem code de 2 letras e o envio morria silenciosamente.
+      it('aceita tag regional do chamador e envia', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue(null);
+        deps.setting.getSettingValues.mockResolvedValue({
+          'configured-mail': 'true',
+        } as any);
+
+        await expect(send(service, 'pt-BR')).resolves.toEqual({
+          sent: true,
+          providerMessageId: 'x',
+        });
+        expect(deps.mailMainService.send).toHaveBeenCalledWith(
+          expect.objectContaining({ locale: 'pt' }),
+        );
+      });
+
+      it('usa a traducao disponivel quando o idioma pedido nao existe', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue({ user_id: 42 });
+        deps.setting.resolveUserLocale.mockResolvedValue('es');
+
+        await send(service, 'es');
+
+        expect(deps.mailMainService.send).toHaveBeenCalledWith(
+          expect.objectContaining({ subject: 'Olá', locale: 'pt' }),
+        );
+      });
+
+      // Antes virava TypeError engolido pelo catch e reportado como falha do
+      // provedor - o e-mail sumia sem ninguem saber por que.
+      it('reporta incidente proprio quando o template nao tem traducao alguma', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue(null);
+        deps.prismaService.mail.findUnique.mockResolvedValue({
+          id: 7,
+          mail_locale: [],
+          mail_var: [],
+        });
+
+        await expect(send(service, 'pt')).resolves.toEqual({
+          sent: false,
+          reason: 'template-locale-missing',
+        });
+        expect(deps.mailMainService.send).not.toHaveBeenCalled();
+        expect(deps.incident.record).toHaveBeenCalledWith(
+          expect.objectContaining({ code: 'mail_template_no_locale' }),
+        );
+      });
+
+      // Convite, formulario do site: destinatario que ainda nao tem conta.
+      it('nao quebra quando o destinatario nao e usuario', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue(null);
+
+        await expect(send(service, 'pt')).resolves.toEqual({
+          sent: true,
+          providerMessageId: 'x',
+        });
+        // Sem usuario encontrado, a cadeia e consultada sem id — nao explode.
+        expect(deps.setting.resolveUserLocale).toHaveBeenCalledWith(null);
+      });
+    });
+
+    // Sem isto os transacionais saem sem Reply-To e a resposta de quem trata o
+    // e-mail como conversa cai na caixa do remetente.
+    it('usa o reply-to do perfil de integração quando o chamador não informa', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'true',
+      } as any);
+      jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+        success: true,
+        provider: 'ses',
+        from: 'a@b.com',
+        replyTo: 'Suporte <suporte@b.com>',
+        config: {},
+      });
+      deps.prismaService.locale.findUnique.mockResolvedValue({ id: 1, code: 'en' });
+      deps.prismaService.mail.findUnique.mockResolvedValue({
+        id: 7,
+        mail_locale: [{ subject: 'Oi', body: 'Corpo', locale: { code: 'en' } }],
+        mail_var: [],
+      });
+      deps.mailMainService.send.mockResolvedValue({ result: {} });
+
+      await service.sendTemplatedMail('en', {
+        email: 'a@b.com',
+        slug: 's',
+        variables: {},
+      } as any);
+
+      expect(deps.mailMainService.send).toHaveBeenCalledWith(
+        expect.objectContaining({ replyTo: 'Suporte <suporte@b.com>' }),
+      );
+    });
+
+    it('o reply-to explícito do chamador tem precedência sobre o do perfil', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'true',
+      } as any);
+      jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+        success: true,
+        provider: 'ses',
+        from: 'a@b.com',
+        replyTo: 'suporte@b.com',
+        config: {},
+      });
+      deps.prismaService.locale.findUnique.mockResolvedValue({ id: 1, code: 'en' });
+      deps.prismaService.mail.findUnique.mockResolvedValue({
+        id: 7,
+        mail_locale: [{ subject: 'Oi', body: 'Corpo', locale: { code: 'en' } }],
+        mail_var: [],
+      });
+      deps.mailMainService.send.mockResolvedValue({ result: {} });
+
+      await service.sendTemplatedMail('en', {
+        email: 'a@b.com',
+        slug: 's',
+        variables: {},
+        replyTo: ' atendimento@b.com ',
+      } as any);
+
+      expect(deps.mailMainService.send).toHaveBeenCalledWith(
+        expect.objectContaining({ replyTo: 'atendimento@b.com' }),
+      );
+    });
   });
 
   describe('preview', () => {
@@ -359,6 +640,26 @@ describe('MailService', () => {
       expect(html).toBe('<p>cru</p>');
     });
 
+    it('resolve o logo pelo BrandAssetService, não pela env API_URL', async () => {
+      const { service, deps } = makePreviewService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'system-name': 'Acme',
+        'image-url': '/logo.svg',
+      } as any);
+
+      const { html } = await service.preview('pt', {
+        body: '<p>corpo</p>',
+        layout: {
+          wrapper: '<html>{{{header}}}{{{content}}}</html>',
+          header: '{{{brandMark}}}',
+          footer: '',
+        },
+      });
+
+      expect(deps.brandAsset.resolveAssetUrl).toHaveBeenCalledWith('/logo.svg');
+      expect(html).toContain('<img src="https://hub.hcode.com.br/logo.svg"');
+    });
+
     it('cai no layout embutido quando não há layout no banco', async () => {
       const { service, deps } = makePreviewService();
       (deps.prismaService as any).mail_layout.findFirst.mockResolvedValue(null);