@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/email-cli.test.ts

@@ -1,8 +1,7 @@
-import { mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach,beforeEach, describe, expect, test } from 'bun:test';
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Test isolation: override BASE_DATA_DIR so guardrails state uses a temp dir
@@ -31,26 +30,27 @@ afterEach(() => {
 // ---------------------------------------------------------------------------
 // Provider factory tests
 // ---------------------------------------------------------------------------
-describe('email provider factory', () => {
-  test('getActiveProviderName defaults to agentmail', async () => {
-    const { getActiveProviderName } = await import('../email/providers/index.js');
-    expect(getActiveProviderName()).toBe('agentmail');
+describe("email provider factory", () => {
+  test("getActiveProviderName defaults to agentmail", async () => {
+    const { getActiveProviderName } =
+      await import("../email/providers/index.js");
+    expect(getActiveProviderName()).toBe("agentmail");
   });
 
-  test('SUPPORTED_PROVIDERS includes agentmail', async () => {
-    const { SUPPORTED_PROVIDERS } = await import('../email/providers/index.js');
-    expect(SUPPORTED_PROVIDERS).toContain('agentmail');
+  test("SUPPORTED_PROVIDERS includes agentmail", async () => {
+    const { SUPPORTED_PROVIDERS } = await import("../email/providers/index.js");
+    expect(SUPPORTED_PROVIDERS).toContain("agentmail");
   });
 
-  test('createProvider throws without API key', async () => {
-    const { createProvider } = await import('../email/providers/index.js');
+  test("createProvider throws without API key", async () => {
+    const { createProvider } = await import("../email/providers/index.js");
     try {
-      await createProvider('agentmail');
+      await createProvider("agentmail");
       // If we get here, the API key might be set in the env
       // The important thing is it doesn't throw for wrong reasons
     } catch (err) {
       expect(err instanceof Error).toBe(true);
-      expect((err as Error).message).toContain('API key');
+      expect((err as Error).message).toContain("API key");
     }
   });
 });
@@ -58,141 +58,143 @@ describe('email provider factory', () => {
 // ---------------------------------------------------------------------------
 // Service guardrail tests (via guardrails module directly)
 // ---------------------------------------------------------------------------
-describe('email guardrails', () => {
-  test('pause blocks sends (returns outbound_paused)', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+describe("email guardrails", () => {
+  test("pause blocks sends (returns outbound_paused)", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
 
     guardrails.setOutboundPaused(true);
     expect(guardrails.isOutboundPaused()).toBe(true);
 
-    const result = guardrails.checkSendGuardrails(['user@example.com']);
+    const result = guardrails.checkSendGuardrails(["user@example.com"]);
     expect(result).not.toBeNull();
-    expect(result!.error).toBe('outbound_paused');
+    expect(result!.error).toBe("outbound_paused");
   });
 
-  test('resume allows sends', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+  test("resume allows sends", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
 
     guardrails.setOutboundPaused(true);
     guardrails.setOutboundPaused(false);
 
-    const result = guardrails.checkSendGuardrails(['user@example.com']);
+    const result = guardrails.checkSendGuardrails(["user@example.com"]);
     expect(result).toBeNull();
   });
 
-  test('daily cap enforced', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+  test("daily cap enforced", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
 
     guardrails.setDailySendCap(2);
     guardrails.incrementDailySendCount();
     guardrails.incrementDailySendCount();
 
-    const result = guardrails.checkSendGuardrails(['user@example.com']);
+    const result = guardrails.checkSendGuardrails(["user@example.com"]);
     expect(result).not.toBeNull();
-    expect(result!.error).toBe('daily_cap_reached');
+    expect(result!.error).toBe("daily_cap_reached");
     expect(result!.count).toBe(2);
     expect(result!.cap).toBe(2);
   });
 
-  test('blocklist checked', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+  test("blocklist checked", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
 
-    guardrails.addAddressRule('block', '*@spam.com');
+    guardrails.addAddressRule("block", "*@spam.com");
 
-    const result = guardrails.checkSendGuardrails(['user@spam.com']);
+    const result = guardrails.checkSendGuardrails(["user@spam.com"]);
     expect(result).not.toBeNull();
-    expect(result!.error).toBe('address_blocked');
-    expect(result!.address).toBe('user@spam.com');
+    expect(result!.error).toBe("address_blocked");
+    expect(result!.address).toBe("user@spam.com");
   });
 
-  test('allowlist enforcement', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+  test("allowlist enforcement", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
 
-    guardrails.addAddressRule('allow', '*@trusted.com');
+    guardrails.addAddressRule("allow", "*@trusted.com");
 
-    expect(guardrails.checkSendGuardrails(['bob@trusted.com'])).toBeNull();
+    expect(guardrails.checkSendGuardrails(["bob@trusted.com"])).toBeNull();
 
-    const result = guardrails.checkSendGuardrails(['bob@untrusted.com']);
+    const result = guardrails.checkSendGuardrails(["bob@untrusted.com"]);
     expect(result).not.toBeNull();
-    expect(result!.error).toBe('address_blocked');
-    expect(result!.reason).toBe('not in allowlist');
+    expect(result!.error).toBe("address_blocked");
+    expect(result!.reason).toBe("not in allowlist");
   });
 
-  test('rule lifecycle: add, list, remove', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+  test("rule lifecycle: add, list, remove", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
 
-    const rule = guardrails.addAddressRule('block', '*@evil.com');
+    const rule = guardrails.addAddressRule("block", "*@evil.com");
     expect(rule.id).toBeTruthy();
-    expect(rule.type).toBe('block');
+    expect(rule.type).toBe("block");
 
     const rules = guardrails.listRules();
     expect(rules.length).toBe(1);
-    expect(rules[0].pattern).toBe('*@evil.com');
+    expect(rules[0].pattern).toBe("*@evil.com");
 
     expect(guardrails.removeAddressRule(rule.id)).toBe(true);
     expect(guardrails.listRules().length).toBe(0);
   });
 
-  test('remove non-existent rule returns false', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
-    expect(guardrails.removeAddressRule('non-existent')).toBe(false);
+  test("remove non-existent rule returns false", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
+    expect(guardrails.removeAddressRule("non-existent")).toBe(false);
   });
 
-  test('default cap is 25', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+  test("default cap is 25", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
     expect(guardrails.getDailySendCap()).toBe(25);
   });
 
-  test('incrementDailySendCount returns new count', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+  test("incrementDailySendCount returns new count", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
 
     expect(guardrails.incrementDailySendCount()).toBe(1);
     expect(guardrails.incrementDailySendCount()).toBe(2);
     expect(guardrails.getDailySendCount()).toBe(2);
   });
 
-  test('guardrails check priority: pause > cap > blocklist', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+  test("guardrails check priority: pause > cap > blocklist", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
 
     guardrails.setOutboundPaused(true);
     guardrails.setDailySendCap(0);
-    guardrails.addAddressRule('block', '*@blocked.com');
+    guardrails.addAddressRule("block", "*@blocked.com");
 
-    const result = guardrails.checkSendGuardrails(['user@blocked.com']);
-    expect(result!.error).toBe('outbound_paused');
+    const result = guardrails.checkSendGuardrails(["user@blocked.com"]);
+    expect(result!.error).toBe("outbound_paused");
   });
 });
 
 // ---------------------------------------------------------------------------
 // Service layer tests (with mocked provider)
 // ---------------------------------------------------------------------------
-describe('email service guardrails integration', () => {
-  test('GuardrailError has correct structure', async () => {
-    const { GuardrailError } = await import('../email/service.js');
-
-    const err = new GuardrailError('outbound_paused', 'Send blocked', { extra: true });
-    expect(err.code).toBe('outbound_paused');
-    expect(err.message).toBe('Send blocked');
+describe("email service guardrails integration", () => {
+  test("GuardrailError has correct structure", async () => {
+    const { GuardrailError } = await import("../email/service.js");
+
+    const err = new GuardrailError("outbound_paused", "Send blocked", {
+      extra: true,
+    });
+    expect(err.code).toBe("outbound_paused");
+    expect(err.message).toBe("Send blocked");
     expect(err.details).toEqual({ extra: true });
-    expect(err.name).toBe('GuardrailError');
+    expect(err.name).toBe("GuardrailError");
     expect(err instanceof Error).toBe(true);
   });
 
-  test('getEmailService returns singleton', async () => {
-    const { getEmailService } = await import('../email/service.js');
+  test("getEmailService returns singleton", async () => {
+    const { getEmailService } = await import("../email/service.js");
     const a = getEmailService();
     const b = getEmailService();
     expect(a).toBe(b);
   });
 
-  test('service getProviderName returns default', async () => {
-    const { getEmailService } = await import('../email/service.js');
+  test("service getProviderName returns default", async () => {
+    const { getEmailService } = await import("../email/service.js");
     const svc = getEmailService();
-    expect(svc.getProviderName()).toBe('agentmail');
+    expect(svc.getProviderName()).toBe("agentmail");
   });
 
-  test('service guardrails methods work', async () => {
-    const { getEmailService } = await import('../email/service.js');
+  test("service guardrails methods work", async () => {
+    const { getEmailService } = await import("../email/service.js");
     const svc = getEmailService();
 
     const initial = svc.getGuardrails();
@@ -205,12 +207,12 @@ describe('email service guardrails integration', () => {
     expect(updated.dailyCap).toBe(10);
   });
 
-  test('service address rule methods work', async () => {
-    const { getEmailService } = await import('../email/service.js');
+  test("service address rule methods work", async () => {
+    const { getEmailService } = await import("../email/service.js");
     const svc = getEmailService();
 
-    const rule = svc.addRule('block', '*@test.com');
-    expect(rule.type).toBe('block');
+    const rule = svc.addRule("block", "*@test.com");
+    expect(rule.type).toBe("block");
 
     const rules = svc.listAddressRules();
     expect(rules.length).toBe(1);
@@ -223,62 +225,73 @@ describe('email service guardrails integration', () => {
 // ---------------------------------------------------------------------------
 // JSON output format / contract tests
 // ---------------------------------------------------------------------------
-describe('email JSON contract', () => {
-  test('guardrails status has expected shape', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
+describe("email JSON contract", () => {
+  test("guardrails status has expected shape", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
     const status = guardrails.getGuardrailsStatus();
     const json = JSON.stringify(status);
     const parsed = JSON.parse(json);
 
-    expect(parsed).toHaveProperty('paused');
-    expect(parsed).toHaveProperty('dailyCap');
-    expect(parsed).toHaveProperty('dailyCount');
-    expect(parsed).toHaveProperty('rules');
-    expect(typeof parsed.paused).toBe('boolean');
-    expect(typeof parsed.dailyCap).toBe('number');
-    expect(typeof parsed.dailyCount).toBe('number');
+    expect(parsed).toHaveProperty("paused");
+    expect(parsed).toHaveProperty("dailyCap");
+    expect(parsed).toHaveProperty("dailyCount");
+    expect(parsed).toHaveProperty("rules");
+    expect(typeof parsed.paused).toBe("boolean");
+    expect(typeof parsed.dailyCap).toBe("number");
+    expect(typeof parsed.dailyCount).toBe("number");
     expect(Array.isArray(parsed.rules)).toBe(true);
   });
 
-  test('address rule has expected JSON fields', async () => {
-    const guardrails = await import('../cli/email-guardrails.js');
-    const rule = guardrails.addAddressRule('block', '*@test.com');
+  test("address rule has expected JSON fields", async () => {
+    const guardrails = await import("../cli/email-guardrails.js");
+    const rule = guardrails.addAddressRule("block", "*@test.com");
     const parsed = JSON.parse(JSON.stringify(rule));
 
-    expect(parsed).toHaveProperty('id');
-    expect(parsed).toHaveProperty('type');
-    expect(parsed).toHaveProperty('pattern');
-    expect(parsed).toHaveProperty('createdAt');
-    expect(parsed.type).toBe('block');
-    expect(parsed.pattern).toBe('*@test.com');
+    expect(parsed).toHaveProperty("id");
+    expect(parsed).toHaveProperty("type");
+    expect(parsed).toHaveProperty("pattern");
+    expect(parsed).toHaveProperty("createdAt");
+    expect(parsed.type).toBe("block");
+    expect(parsed.pattern).toBe("*@test.com");
   });
 });
 
 // ---------------------------------------------------------------------------
 // Provider interface conformance
 // ---------------------------------------------------------------------------
-describe('AgentMailProvider interface', () => {
-  test('AgentMailProvider implements all required methods', async () => {
-    const { AgentMailProvider } = await import('../email/providers/agentmail.js');
+describe("AgentMailProvider interface", () => {
+  test("AgentMailProvider implements all required methods", async () => {
+    const { AgentMailProvider } =
+      await import("../email/providers/agentmail.js");
 
     // Create with a dummy client — we won't call any methods
     const provider = new AgentMailProvider({} as never);
 
     // Verify all interface methods exist
     const requiredMethods = [
-      'health',
-      'setupDomain', 'getDomainDnsRecords', 'verifyDomain',
-      'ensureInboxes',
-      'setupWebhook',
-      'createDraft', 'listDrafts', 'getDraft', 'deleteDraft', 'sendDraft',
-      'listMessages', 'getMessage',
-      'listThreads', 'getThread',
+      "health",
+      "setupDomain",
+      "getDomainDnsRecords",
+      "verifyDomain",
+      "ensureInboxes",
+      "setupWebhook",
+      "createDraft",
+      "listDrafts",
+      "getDraft",
+      "deleteDraft",
+      "sendDraft",
+      "listMessages",
+      "getMessage",
+      "listThreads",
+      "getThread",
     ];
 
     for (const method of requiredMethods) {
-      expect(typeof (provider as unknown as Record<string, unknown>)[method]).toBe('function');
+      expect(
+        typeof (provider as unknown as Record<string, unknown>)[method],
+      ).toBe("function");
     }
 
-    expect(provider.name).toBe('agentmail');
+    expect(provider.name).toBe("agentmail");
   });
 });