@hed-hog/core 0.0.373 → 0.0.375

package/hedhog/frontend/app/menu/page.tsx.ejs

@@ -992,7 +992,7 @@ function MenuTreeWorkspace({
                 'group relative mr-1 flex cursor-pointer items-center gap-2 rounded-xl border px-2 py-1.5 transition-all duration-150 select-none active:scale-[0.99]',
                 isDraggingThis ? 'opacity-40' : 'opacity-100',
                 selectedId === node.id
-                  ? 'border-primary/70 bg-linear-to-r from-primary/10 via-primary/5 to-background shadow-[0_10px_24px_-18px_hsl(var(--primary))] ring-1 ring-primary/15'
+                  ? 'border-primary/70 bg-linear-to-r from-primary/10 via-primary/5 to-background shadow-[0_10px_24px_-18px_var(--primary)] ring-1 ring-primary/15'
                   : 'border-transparent hover:border-primary/30 hover:bg-muted/60 hover:shadow-sm',
                 isInside ? 'ring-2 ring-primary bg-primary/10' : ''
               )}

package/hedhog/frontend/app/users/user-sheet.tsx.ejs

@@ -147,6 +147,14 @@ const OAUTH_PROVIDER_TOGGLE_MAP: Array<{
       name: 'Microsoft Entra ID',
     },
   },
+  {
+    settingSlug: 'oauth-apple-enabled',
+    provider: { id: 'apple', slug: 'apple-oauth', name: 'Apple' },
+  },
+  {
+    settingSlug: 'oauth-linkedin-enabled',
+    provider: { id: 'linkedin', slug: 'linkedin-oauth', name: 'LinkedIn' },
+  },
 ];
 
 function generateRandomPassword(length = 16) {

package/hedhog/frontend/e2e/core.spec.ts.ejs

@@ -0,0 +1,28 @@
+import { test } from '@playwright/test';
+import { expectPageLoads } from './support';
+
+test.describe('Módulo core', () => {
+  const urls = [
+    '/core/menu',
+    '/core/dashboard/management',
+    '/core/roles',
+    '/core/routes',
+    '/core/configurations',
+    '/core/mail',
+    '/core/mail/template',
+    '/core/mail/log',
+    '/core/integration/profiles',
+    '/core/ai_agent',
+    '/core/integrations-webhooks',
+    '/core/setting-list',
+    '/core/access-log',
+    '/core/users',
+    '/core/mcp_chat',
+  ];
+
+  for (const url of urls) {
+    test(`${url} carrega sem crash`, async ({ page }) => {
+      await expectPageLoads(page, url);
+    });
+  }
+});

package/hedhog/frontend/messages/en.json

@@ -870,6 +870,38 @@
       "loading": "Loading...",
       "errorOccurred": "An error occurred.",
       "alreadyProcessed": "This authentication callback has already been processed. Start the flow again."
+    },
+    "apple": {
+      "loginTitle": "Completing login...",
+      "loginDescription": "Please wait while we process your Apple authentication",
+      "loginSuccess": "Login successful!",
+      "registerTitle": "Completing registration...",
+      "registerDescription": "Please wait while we process your Apple authentication",
+      "registerSuccess": "Account created successfully!",
+      "connectTitle": "Completing account connection...",
+      "connectDescription": "Please wait while we process your Apple authentication",
+      "connectSuccess": "Account connected successfully!",
+      "errorTitle": "Unable to authenticate",
+      "buttonRetry": "Try again",
+      "loading": "Loading...",
+      "errorOccurred": "An error occurred.",
+      "alreadyProcessed": "This authentication callback has already been processed. Start the flow again."
+    },
+    "linkedin": {
+      "loginTitle": "Completing login...",
+      "loginDescription": "Please wait while we process your LinkedIn authentication",
+      "loginSuccess": "Login successful!",
+      "registerTitle": "Completing registration...",
+      "registerDescription": "Please wait while we process your LinkedIn authentication",
+      "registerSuccess": "Account created successfully!",
+      "connectTitle": "Completing account connection...",
+      "connectDescription": "Please wait while we process your LinkedIn authentication",
+      "connectSuccess": "Account connected successfully!",
+      "errorTitle": "Unable to authenticate",
+      "buttonRetry": "Try again",
+      "loading": "Loading...",
+      "errorOccurred": "An error occurred.",
+      "alreadyProcessed": "This authentication callback has already been processed. Start the flow again."
     }
   },
   "ConnectedAccounts": {
@@ -2408,6 +2440,9 @@
     "fieldOrganization": "Organization ID",
     "fieldRedirectUri": "Redirect URI",
     "fieldTenantId": "Tenant ID",
+    "fieldTeamId": "Team ID",
+    "fieldKeyId": "Key ID",
+    "fieldPrivateKey": "Private Key (.p8)",
     "fieldPublishableKey": "Publishable Key",
     "fieldSecretKey": "Secret Key",
     "fieldWebhookSecret": "Webhook Secret",

package/hedhog/frontend/messages/pt.json

@@ -870,6 +870,38 @@
       "loading": "Carregando...",
       "errorOccurred": "Ocorreu um erro.",
       "alreadyProcessed": "Esta autenticacao ja foi processada. Inicie o fluxo novamente."
+    },
+    "apple": {
+      "loginTitle": "Finalizando login...",
+      "loginDescription": "Aguarde enquanto processamos sua autenticação com a Apple",
+      "loginSuccess": "Login realizado com sucesso!",
+      "registerTitle": "Finalizando cadastro...",
+      "registerDescription": "Aguarde enquanto processamos sua autenticação com a Apple",
+      "registerSuccess": "Conta criada com sucesso!",
+      "connectTitle": "Finalizando conexão da conta...",
+      "connectDescription": "Aguarde enquanto processamos sua autenticação com a Apple",
+      "connectSuccess": "Conta conectada com sucesso!",
+      "errorTitle": "Não foi possível autenticar",
+      "buttonRetry": "Tentar novamente",
+      "loading": "Carregando...",
+      "errorOccurred": "Ocorreu um erro.",
+      "alreadyProcessed": "Esta autenticacao ja foi processada. Inicie o fluxo novamente."
+    },
+    "linkedin": {
+      "loginTitle": "Finalizando login...",
+      "loginDescription": "Aguarde enquanto processamos sua autenticação com o LinkedIn",
+      "loginSuccess": "Login realizado com sucesso!",
+      "registerTitle": "Finalizando cadastro...",
+      "registerDescription": "Aguarde enquanto processamos sua autenticação com o LinkedIn",
+      "registerSuccess": "Conta criada com sucesso!",
+      "connectTitle": "Finalizando conexão da conta...",
+      "connectDescription": "Aguarde enquanto processamos sua autenticação com o LinkedIn",
+      "connectSuccess": "Conta conectada com sucesso!",
+      "errorTitle": "Não foi possível autenticar",
+      "buttonRetry": "Tentar novamente",
+      "loading": "Carregando...",
+      "errorOccurred": "Ocorreu um erro.",
+      "alreadyProcessed": "Esta autenticacao ja foi processada. Inicie o fluxo novamente."
     }
   },
   "ConnectedAccounts": {
@@ -2463,6 +2495,9 @@
     "fieldOrganization": "ID da Organização",
     "fieldRedirectUri": "URI de Redirecionamento",
     "fieldTenantId": "Tenant ID",
+    "fieldTeamId": "Team ID",
+    "fieldKeyId": "Key ID",
+    "fieldPrivateKey": "Chave Privada (.p8)",
     "fieldPublishableKey": "Chave Publicável",
     "fieldSecretKey": "Chave Secreta",
     "fieldWebhookSecret": "Segredo do Webhook",

package/hedhog/table/user_account.yaml

@@ -15,6 +15,7 @@ columns:
       - apple
       - microsoft
       - microsoft-entra-id
+      - linkedin
   - name: provider_user_id
   - name: email
     isNullable: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/core",
-  "version": "0.0.373",
+  "version": "0.0.375",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -45,8 +45,8 @@
     "@hed-hog/api-locale": "0.0.14",
     "@hed-hog/api-mail": "0.0.9",
     "@hed-hog/api-pagination": "0.0.7",
-    "@hed-hog/api-types": "0.0.1",
-    "@hed-hog/api-prisma": "0.0.6"
+    "@hed-hog/api-prisma": "0.0.6",
+    "@hed-hog/api-types": "0.0.1"
   },
   "exports": {
     ".": {

package/src/access-log/access-log.service.spec.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+
+jest.mock('@hed-hog/api-prisma', () => ({
+  __esModule: true,
+  PrismaService: class {},
+  Prisma: {
+    sql: (...args: any[]) => ({ __sql: args }),
+    raw: (v: string) => ({ __raw: v }),
+  },
+}));
+
+jest.mock('@hed-hog/api-pagination', () => ({
+  __esModule: true,
+  PaginationService: class {},
+}));
+
+jest.mock('geoip-lite', () => ({
+  __esModule: true,
+  lookup: jest.fn(),
+}));
+
+jest.mock('ua-parser-js', () => ({
+  __esModule: true,
+  UAParser: jest.fn(),
+}));
+
+import * as geoip from 'geoip-lite';
+import { UAParser } from 'ua-parser-js';
+import { AccessLogService } from './access-log.service';
+
+const mockLookup = geoip.lookup as unknown as jest.Mock;
+const mockUAParser = UAParser as unknown as jest.Mock;
+
+const makeService = () => {
+  const prisma = {
+    access_log: { create: jest.fn() },
+    $executeRaw: jest.fn(),
+  };
+  const pagination = {
+    paginate: jest.fn(),
+  };
+  const service = new AccessLogService(prisma as any, pagination as any);
+  return { service, prisma, pagination };
+};
+
+describe('AccessLogService', () => {
+  beforeEach(() => {
+    mockUAParser.mockImplementation(() => ({
+      getResult: () => ({
+        browser: { name: 'Chrome', version: '120' },
+        os: { name: 'Windows', version: '11' },
+      }),
+    }));
+    mockLookup.mockReturnValue({ country: 'BR', city: 'Sao Paulo' });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('recordHttp', () => {
+    it('persiste o log HTTP com os campos mapeados', () => {
+      const { service, prisma } = makeService();
+      prisma.access_log.create.mockResolvedValue({});
+
+      service.recordHttp({
+        userId: 3,
+        ip: '1.2.3.4',
+        userAgent: 'UA',
+        method: 'GET',
+        path: '/api/x',
+      });
+
+      expect(prisma.access_log.create).toHaveBeenCalledWith({
+        data: {
+          user_id: 3,
+          ip: '1.2.3.4',
+          user_agent: 'UA',
+          method: 'GET',
+          path: '/api/x',
+        },
+      });
+    });
+
+    it('usa null para campos opcionais ausentes', () => {
+      const { service, prisma } = makeService();
+      prisma.access_log.create.mockResolvedValue({});
+
+      service.recordHttp({ method: 'POST', path: '/x' });
+
+      expect(prisma.access_log.create).toHaveBeenCalledWith({
+        data: { user_id: null, ip: null, user_agent: null, method: 'POST', path: '/x' },
+      });
+    });
+
+    it('não propaga erro de persistência (loga warn)', async () => {
+      const { service, prisma } = makeService();
+      prisma.access_log.create.mockRejectedValue(new Error('db down'));
+      const warnSpy = jest
+        .spyOn((service as any).logger, 'warn')
+        .mockImplementation(() => undefined);
+
+      expect(() => service.recordHttp({ method: 'GET', path: '/x' })).not.toThrow();
+      await new Promise((r) => process.nextTick(r));
+
+      expect(warnSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('recordMcp', () => {
+    it('persiste o log MCP com tool e prompt', () => {
+      const { service, prisma } = makeService();
+      prisma.access_log.create.mockResolvedValue({});
+
+      service.recordMcp({ userId: 9, mcpTool: 'search', mcpPrompt: 'q' });
+
+      expect(prisma.access_log.create).toHaveBeenCalledWith({
+        data: { user_id: 9, mcp_tool: 'search', mcp_prompt: 'q' },
+      });
+    });
+  });
+
+  describe('list', () => {
+    const paginateResult = (data: any[]) => ({ data, total: data.length, page: 1 });
+
+    it('sem filtros usa where vazio e mantém orderBy/include', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({});
+
+      const [, , opts] = pagination.paginate.mock.calls[0];
+      expect(opts.where).toEqual({});
+      expect(opts.orderBy).toEqual({ created_at: 'desc' });
+      expect(opts.include.user.select).toMatchObject({ id: true, name: true });
+    });
+
+    it('filtra por userId', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({ userId: 5 });
+
+      expect(pagination.paginate.mock.calls[0][2].where).toMatchObject({ user_id: 5 });
+    });
+
+    it('filtra por userSearch com contains insensitive', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({ userSearch: 'ana' });
+
+      expect(pagination.paginate.mock.calls[0][2].where.user).toEqual({
+        OR: [{ name: { contains: 'ana', mode: 'insensitive' } }],
+      });
+    });
+
+    it('monta o range de datas com fim de dia em createdAtTo', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({ createdAtFrom: '2026-01-01', createdAtTo: '2026-01-31' });
+
+      const where = pagination.paginate.mock.calls[0][2].where;
+      expect(where.created_at.gte).toEqual(new Date('2026-01-01'));
+      const lte: Date = where.created_at.lte;
+      expect(lte.getHours()).toBe(23);
+      expect(lte.getMinutes()).toBe(59);
+      expect(lte.getSeconds()).toBe(59);
+      expect(lte.getMilliseconds()).toBe(999);
+    });
+
+    it('type=http filtra method not null; type=mcp filtra mcp_tool not null', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({ type: 'http' });
+      expect(pagination.paginate.mock.calls[0][2].where).toMatchObject({
+        method: { not: null },
+      });
+
+      await service.list({ type: 'mcp' });
+      expect(pagination.paginate.mock.calls[1][2].where).toMatchObject({
+        mcp_tool: { not: null },
+      });
+    });
+
+    it('enriquece cada log com dados de user-agent e geoip', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(
+        paginateResult([{ id: 1, user_agent: 'UA', ip: '8.8.8.8' }]),
+      );
+
+      const result = await service.list({});
+
+      expect(result.data[0]).toMatchObject({
+        browser_name: 'Chrome',
+        browser_version: '120',
+        os_name: 'Windows',
+        os_version: '11',
+        country: 'BR',
+        city: 'Sao Paulo',
+      });
+    });
+
+    it('usa null quando não há user_agent nem ip', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(
+        paginateResult([{ id: 2, user_agent: null, ip: null }]),
+      );
+
+      const result = await service.list({});
+
+      expect(result.data[0]).toMatchObject({
+        browser_name: null,
+        os_name: null,
+        country: null,
+        city: null,
+      });
+      expect(mockUAParser).not.toHaveBeenCalled();
+      expect(mockLookup).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('clearOld', () => {
+    it('executa o DELETE em lote via $executeRaw', async () => {
+      const { service, prisma } = makeService();
+      prisma.$executeRaw.mockResolvedValue(1);
+
+      await service.clearOld(30, 500);
+
+      expect(prisma.$executeRaw).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/ai-instruction/ai-prompt-builder.service.spec.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { AiPromptBuilderService } from './ai-prompt-builder.service';
+
+const makeService = () => {
+  const instructionService = {
+    getLayer: jest.fn(),
+    getAgentInstruction: jest.fn(),
+  };
+  const service = new AiPromptBuilderService(instructionService as any);
+  return { service, instructionService };
+};
+
+describe('AiPromptBuilderService', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('build', () => {
+    it('inclui apenas a camada system quando é a única disponível', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(async (layer: string) =>
+        layer === 'system' ? 'SYS' : null,
+      );
+
+      const result = await service.build({});
+
+      expect(result.layers).toEqual(['SYS']);
+      expect(result.layerNames).toEqual(['system']);
+      expect(result.systemPrompt).toBe('SYS');
+    });
+
+    it('junta system + product com o separador', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(async (layer: string) => {
+        if (layer === 'system') return 'SYS';
+        if (layer === 'product') return 'PROD';
+        return null;
+      });
+
+      const result = await service.build({});
+
+      expect(result.layers).toEqual(['SYS', 'PROD']);
+      expect(result.layerNames).toEqual(['system', 'product']);
+      expect(result.systemPrompt).toBe('SYS\n\n---\n\nPROD');
+    });
+
+    it('inclui a camada module quando moduleSlug é fornecido e existe', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(
+        async (layer: string, slug?: string) => {
+          if (layer === 'system') return 'SYS';
+          if (layer === 'module' && slug === 'crm') return 'MOD';
+          return null;
+        },
+      );
+
+      const result = await service.build({ moduleSlug: 'crm' });
+
+      expect(result.layerNames).toEqual(['system', 'module:crm']);
+      expect(instructionService.getLayer).toHaveBeenCalledWith('module', 'crm');
+    });
+
+    it('não inclui module quando moduleSlug é fornecido mas não há conteúdo', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(async (layer: string) =>
+        layer === 'system' ? 'SYS' : null,
+      );
+
+      const result = await service.build({ moduleSlug: 'crm' });
+
+      expect(result.layerNames).toEqual(['system']);
+    });
+
+    it('inclui a camada agent quando agentSlug é fornecido e existe', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(async (layer: string) =>
+        layer === 'system' ? 'SYS' : null,
+      );
+      instructionService.getAgentInstruction.mockResolvedValue('AGENT');
+
+      const result = await service.build({ agentSlug: 'support' });
+
+      expect(result.layerNames).toEqual(['system', 'agent:support']);
+      expect(result.layers).toEqual(['SYS', 'AGENT']);
+      expect(instructionService.getAgentInstruction).toHaveBeenCalledWith('support');
+    });
+
+    it('compõe as quatro camadas na ordem de prioridade', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(
+        async (layer: string, slug?: string) => {
+          if (layer === 'system') return 'L1';
+          if (layer === 'product') return 'L2';
+          if (layer === 'module' && slug === 'm') return 'L3';
+          return null;
+        },
+      );
+      instructionService.getAgentInstruction.mockResolvedValue('L4');
+
+      const result = await service.build({ moduleSlug: 'm', agentSlug: 'a' });
+
+      expect(result.layers).toEqual(['L1', 'L2', 'L3', 'L4']);
+      expect(result.systemPrompt).toBe('L1\n\n---\n\nL2\n\n---\n\nL3\n\n---\n\nL4');
+    });
+
+    it('retorna prompt vazio quando nenhuma camada tem conteúdo', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockResolvedValue(null);
+
+      const result = await service.build({});
+
+      expect(result.layers).toEqual([]);
+      expect(result.layerNames).toEqual([]);
+      expect(result.systemPrompt).toBe('');
+    });
+  });
+
+  describe('buildRuntimeContext', () => {
+    it('inclui apenas o cabeçalho quando não há parâmetros', () => {
+      const { service } = makeService();
+      expect(service.buildRuntimeContext({})).toBe('[Runtime context]');
+    });
+
+    it('inclui campos presentes na ordem esperada', () => {
+      const { service } = makeService();
+      const out = service.buildRuntimeContext({
+        userId: 7,
+        locale: 'pt',
+        userRoles: ['admin', 'user'],
+        currentDate: '2026-07-04',
+      });
+      expect(out).toBe(
+        [
+          '[Runtime context]',
+          'user_id: 7',
+          'locale: pt',
+          'roles: admin, user',
+          'date: 2026-07-04',
+        ].join('\n'),
+      );
+    });
+
+    it('ignora userRoles vazio', () => {
+      const { service } = makeService();
+      const out = service.buildRuntimeContext({ userId: 1, userRoles: [] });
+      expect(out).toBe('[Runtime context]\nuser_id: 1');
+    });
+
+    it('anexa extraContext como pares chave: valor', () => {
+      const { service } = makeService();
+      const out = service.buildRuntimeContext({
+        userId: 1,
+        extraContext: { plan: 'pro', tz: 'UTC' },
+      });
+      expect(out).toContain('plan: pro');
+      expect(out).toContain('tz: UTC');
+    });
+  });
+
+  describe('summarizeHistory', () => {
+    it('retorna as mensagens intactas quando o total <= keepLast', () => {
+      const { service } = makeService();
+      const messages = [
+        { role: 'user', content: 'a' },
+        { role: 'assistant', content: 'b' },
+      ];
+      expect(service.summarizeHistory(messages, 6)).toBe(messages);
+    });
+
+    it('resume as mensagens antigas e mantém as recentes verbatim', () => {
+      const { service } = makeService();
+      const messages = Array.from({ length: 10 }, (_, i) => ({
+        role: i % 2 === 0 ? 'user' : 'assistant',
+        content: `msg-${i}`,
+      }));
+
+      const result = service.summarizeHistory(messages, 6);
+
+      // 1 mensagem de resumo + 6 recentes
+      expect(result).toHaveLength(7);
+      expect(result[0].role).toBe('user');
+      expect(result[0].content).toContain('[Earlier conversation summary: 4 messages]');
+      expect(result[0].content).toContain('First question: "msg-0"');
+      // As 6 últimas verbatim.
+      expect(result.slice(1)).toEqual(messages.slice(4));
+    });
+
+    it('inclui a contagem de tool_call quando há chamadas de ferramenta', () => {
+      const { service } = makeService();
+      const messages = [
+        { role: 'user', content: 'q' },
+        { role: 'tool_call', content: 't1' },
+        { role: 'tool_call', content: 't2' },
+        { role: 'assistant', content: 'r' },
+        { role: 'user', content: 'q2' },
+        { role: 'assistant', content: 'r2' },
+        { role: 'user', content: 'q3' },
+        { role: 'assistant', content: 'r3' },
+      ];
+
+      const result = service.summarizeHistory(messages, 2);
+
+      expect(result[0].content).toContain('Tools called: 2');
+    });
+
+    it('trunca a primeira pergunta em 120 caracteres', () => {
+      const { service } = makeService();
+      const longQuestion = 'x'.repeat(200);
+      const messages = [
+        { role: 'user', content: longQuestion },
+        ...Array.from({ length: 6 }, (_, i) => ({
+          role: 'assistant',
+          content: `r-${i}`,
+        })),
+      ];
+
+      const result = service.summarizeHistory(messages, 1);
+
+      expect(result[0].content).toContain(`"${'x'.repeat(120)}"`);
+      expect(result[0].content).not.toContain('x'.repeat(121));
+    });
+  });
+
+  describe('interpolate', () => {
+    it('substitui os placeholders {{var}} pelos valores', () => {
+      const { service } = makeService();
+      expect(
+        service.interpolate('Olá {{name}}, seu plano é {{plan}}', {
+          name: 'Ana',
+          plan: 'pro',
+        }),
+      ).toBe('Olá Ana, seu plano é pro');
+    });
+
+    it('mantém o placeholder quando a variável não existe', () => {
+      const { service } = makeService();
+      expect(service.interpolate('valor {{missing}}', {})).toBe('valor {{missing}}');
+    });
+
+    it('substitui múltiplas ocorrências da mesma variável', () => {
+      const { service } = makeService();
+      expect(service.interpolate('{{x}}-{{x}}', { x: 'a' })).toBe('a-a');
+    });
+
+    it('não altera texto sem placeholders', () => {
+      const { service } = makeService();
+      expect(service.interpolate('sem variaveis', { a: '1' })).toBe('sem variaveis');
+    });
+  });
+});