@avi770/testteam 1.2.0

package/agents/__tests__/22-email-notification-verifier.test.ts

@@ -0,0 +1,441 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config
+// ---------------------------------------------------------------------------
+
+const stubConfig: ValidatedConfig = {
+  schemaVersion: 1,
+  name: 'test',
+  auth: {
+    loginUrl: 'http://localhost/login',
+    credentials: { admin: { email: 'admin@test.com', password: 'secret' } },
+  },
+  modules: [{ id: 'dashboard', route: '/dashboard', sidebarIcon: true }],
+  environments: {
+    beta: { baseUrl: 'http://localhost:3000', seed: false },
+  },
+  portals: [],
+  breakpoints: [],
+  integrations: [],
+  workers: [],
+  workflows: [],
+  accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+  tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+  costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' },
+  agentClassification: { blocking: [], advisory: [] },
+  thresholds: {
+    unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+    lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+    apiResponseTime: 2000,
+    bundleSizeLimit: 500000,
+    maxConsoleErrors: 0,
+  },
+  disabledAgents: [],
+  disabledAgentSet: new Set<number>(),
+};
+
+// ---------------------------------------------------------------------------
+// Mock global fetch (Mailhog health, Mailhog API, link resolution)
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock ApiClient (password reset)
+// ---------------------------------------------------------------------------
+
+const apiClientPostMock = vi.fn();
+
+vi.mock('../../helpers/api-client', () => ({
+  ApiClient: class MockApiClient {
+    post(...args: unknown[]) {
+      return apiClientPostMock(...args);
+    }
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers for building Mailhog message objects
+// ---------------------------------------------------------------------------
+
+interface MailhogMessage {
+  ID: string;
+  Content: { Headers: Record<string, string[]>; Body: string };
+  Created: string;
+}
+
+function makeMailhogMessage(body: string, id = 'msg-001'): MailhogMessage {
+  return {
+    ID: id,
+    Content: {
+      Headers: {
+        Subject: ['Password Reset'],
+        To: ['admin@test.com'],
+      },
+      Body: body,
+    },
+    Created: new Date().toISOString(),
+  };
+}
+
+function mailhogApiResponse(messages: MailhogMessage[]) {
+  return {
+    ok: true,
+    status: 200,
+    json: async () => ({
+      items: messages,
+      total: messages.length,
+      count: messages.length,
+      start: 0,
+    }),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+const { EmailNotificationVerifierAgent } = await import('../22-email-notification-verifier');
+
+function createAgent(phase: Phase = 'beta'): InstanceType<typeof EmailNotificationVerifierAgent> {
+  return new EmailNotificationVerifierAgent(stubConfig, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('EmailNotificationVerifierAgent', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    // Default: password reset API returns success
+    apiClientPostMock.mockResolvedValue({ status: 200, body: {} });
+  });
+
+  it('has agentId 22 and agentName "Email & Notification Verifier"', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(22);
+    expect(agent.agentName).toBe('Email & Notification Verifier');
+  });
+
+  // -------------------------------------------------------------------------
+  // preFlight() — Mailhog availability (advisory, never throws)
+  // -------------------------------------------------------------------------
+
+  describe('preFlight() — Mailhog advisory', () => {
+    it('does not throw when Mailhog is unreachable (advisory only)', async () => {
+      fetchMock.mockRejectedValue(new Error('ECONNREFUSED'));
+
+      const agent = createAgent();
+      // run() must not throw even when Mailhog is down
+      const result = await agent.run();
+
+      // Should complete with a low advisory finding
+      expect(result.status).toBe('passed'); // low severity does not fail
+      const advisoryFinding = result.findings.find((f) => f.id.includes('mailhog-unavailable'));
+      expect(advisoryFinding).toBeDefined();
+      expect(advisoryFinding!.severity).toBe('low');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — Mailhog unavailable: returns advisory and stops
+  // -------------------------------------------------------------------------
+
+  describe('execute() when Mailhog is unavailable', () => {
+    it('returns advisory finding and does not call password reset endpoint', async () => {
+      fetchMock.mockRejectedValue(new Error('ECONNREFUSED'));
+
+      const agent = createAgent();
+      await agent.run();
+
+      expect(apiClientPostMock).not.toHaveBeenCalled();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — password reset triggering
+  // -------------------------------------------------------------------------
+
+  describe('execute() — password reset', () => {
+    it('creates a medium finding when password reset returns non-2xx', async () => {
+      // Mailhog reachable
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // HEAD to Mailhog health
+        .mockResolvedValue(mailhogApiResponse([])); // subsequent calls
+
+      apiClientPostMock.mockResolvedValue({ status: 500, body: { error: 'Internal error' } });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const resetFinding = result.findings.find((f) => f.id.includes('password-reset'));
+      expect(resetFinding).toBeDefined();
+      expect(resetFinding!.severity).toBe('medium');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — email delivery
+  // -------------------------------------------------------------------------
+
+  describe('execute() — email delivery', () => {
+    it('creates a high finding when no email arrives in Mailhog within timeout', async () => {
+      // Mailhog reachable but no messages
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // HEAD to Mailhog health
+        .mockResolvedValue(mailhogApiResponse([])); // always empty
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const deliveryFinding = result.findings.find((f) => f.id.includes('email-not-delivered'));
+      expect(deliveryFinding).toBeDefined();
+      expect(deliveryFinding!.severity).toBe('high');
+    });
+
+    it('creates no delivery finding when email arrives in Mailhog', async () => {
+      const msg = makeMailhogMessage(
+        'Click here to reset: http://localhost:3000/reset?token=abc123',
+      );
+
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // HEAD to Mailhog health
+        .mockResolvedValueOnce(mailhogApiResponse([msg])) // first poll — has messages
+        .mockResolvedValue({ ok: true, status: 200 }); // link HEAD check
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const deliveryFinding = result.findings.find((f) => f.id.includes('email-not-delivered'));
+      expect(deliveryFinding).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — template variable detection
+  // -------------------------------------------------------------------------
+
+  describe('execute() — template variable detection', () => {
+    it('creates a high finding when email body contains raw template variables', async () => {
+      const msg = makeMailhogMessage(
+        'Hello {{firstName}}, reset your password: http://localhost:3000/reset?token={{resetToken}}',
+      );
+
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // Mailhog health
+        .mockResolvedValueOnce(mailhogApiResponse([msg])) // poll returns message
+        .mockResolvedValue({ ok: true, status: 200 }); // link resolution
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const templateFinding = result.findings.find((f) => f.id.includes('template-vars'));
+      expect(templateFinding).toBeDefined();
+      expect(templateFinding!.severity).toBe('high');
+      expect(templateFinding!.description).toContain('{{firstName}}');
+    });
+
+    it('creates no finding for an email body with no template variables', async () => {
+      const msg = makeMailhogMessage(
+        'Hello Admin, click http://localhost:3000/reset?token=abc to reset your password.',
+      );
+
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // Mailhog health
+        .mockResolvedValueOnce(mailhogApiResponse([msg])) // poll
+        .mockResolvedValue({ ok: true, status: 200 }); // link resolution
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const templateFindings = result.findings.filter((f) => f.id.includes('template-vars'));
+      expect(templateFindings).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — broken link detection
+  // -------------------------------------------------------------------------
+
+  describe('execute() — broken link detection', () => {
+    it('creates a medium finding when a link in the email body returns 404', async () => {
+      const msg = makeMailhogMessage(
+        'Reset here: http://localhost:3000/reset?token=abc123',
+      );
+
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // Mailhog health
+        .mockResolvedValueOnce(mailhogApiResponse([msg])) // poll
+        .mockResolvedValue({ ok: false, status: 404 }); // HEAD link check → 404
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const brokenLinkFinding = result.findings.find((f) => f.id.includes('broken-link'));
+      expect(brokenLinkFinding).toBeDefined();
+      expect(brokenLinkFinding!.severity).toBe('medium');
+    });
+
+    it('creates no broken-link finding when all links in the email body resolve to 200', async () => {
+      const msg = makeMailhogMessage(
+        'Reset here: http://localhost:3000/reset?token=abc123',
+      );
+
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // Mailhog health
+        .mockResolvedValueOnce(mailhogApiResponse([msg])) // poll
+        .mockResolvedValue({ ok: true, status: 200 }); // HEAD link check → 200
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const brokenLinkFindings = result.findings.filter((f) => f.id.includes('broken-link'));
+      expect(brokenLinkFindings).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Missing environment
+  // -------------------------------------------------------------------------
+
+  describe('execute() — no environment', () => {
+    it('creates a critical finding when no environment is configured', async () => {
+      const noEnvConfig: ValidatedConfig = {
+        ...stubConfig,
+        environments: {},
+      };
+      // Mailhog unavailable
+      fetchMock.mockRejectedValue(new Error('ECONNREFUSED'));
+
+      const agent = new EmailNotificationVerifierAgent(noEnvConfig, 'beta', '/tmp/test-run');
+      const result = await agent.run();
+
+      const finding = result.findings.find(f => f.id.includes('no-env'));
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('critical');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Password reset trigger error (fetch throws)
+  // -------------------------------------------------------------------------
+
+  describe('execute() — password reset error', () => {
+    it('creates a medium finding when password reset API throws', async () => {
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // Mailhog health
+        .mockResolvedValue(mailhogApiResponse([]));
+
+      apiClientPostMock.mockRejectedValue(new Error('Network error'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const errorFinding = result.findings.find(f => f.id.includes('password-reset-error'));
+      expect(errorFinding).toBeDefined();
+      expect(errorFinding!.severity).toBe('medium');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Link resolution error (fetch throws for link)
+  // -------------------------------------------------------------------------
+
+  describe('execute() — link resolution error', () => {
+    it('creates a low finding when link verification fetch throws', async () => {
+      const msg = makeMailhogMessage(
+        'Visit http://localhost:3000/reset?token=xyz to reset.',
+      );
+
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // Mailhog health
+        .mockResolvedValueOnce(mailhogApiResponse([msg])) // poll
+        .mockRejectedValue(new Error('DNS resolution failed')); // link check
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const linkErrorFinding = result.findings.find(f => f.id.includes('link-error'));
+      expect(linkErrorFinding).toBeDefined();
+      expect(linkErrorFinding!.severity).toBe('low');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Email body with no URLs
+  // -------------------------------------------------------------------------
+
+  describe('execute() — email with no URLs', () => {
+    it('creates no broken-link findings when email body has no URLs', async () => {
+      const msg = makeMailhogMessage('Your password has been reset. No links here.');
+
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // Mailhog health
+        .mockResolvedValueOnce(mailhogApiResponse([msg])); // poll
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const linkFindings = result.findings.filter(f =>
+        f.id.includes('broken-link') || f.id.includes('link-error'),
+      );
+      expect(linkFindings).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Password reset returns 202/204
+  // -------------------------------------------------------------------------
+
+  describe('execute() — accepted status codes', () => {
+    it('proceeds when password reset returns 202', async () => {
+      const msg = makeMailhogMessage('Reset here: http://localhost:3000/reset');
+
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // Mailhog health
+        .mockResolvedValueOnce(mailhogApiResponse([msg])) // poll
+        .mockResolvedValue({ ok: true, status: 200 }); // link check
+
+      apiClientPostMock.mockResolvedValue({ status: 202, body: {} });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const resetFinding = result.findings.find(f => f.id.includes('password-reset-failed'));
+      expect(resetFinding).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Mailhog poll retry
+  // -------------------------------------------------------------------------
+
+  describe('execute() — Mailhog poll retry', () => {
+    it('retries polling when first attempts return empty and eventually succeeds', async () => {
+      const msg = makeMailhogMessage('Reset at http://localhost:3000/reset');
+
+      let pollCount = 0;
+      fetchMock
+        .mockResolvedValueOnce({ ok: true, status: 200 }) // Mailhog health
+        .mockImplementation(async (url: string) => {
+          if (url.includes('messages')) {
+            pollCount++;
+            if (pollCount < 3) return mailhogApiResponse([]);
+            return mailhogApiResponse([msg]);
+          }
+          return { ok: true, status: 200 };
+        });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const deliveryFinding = result.findings.find(f => f.id.includes('email-not-delivered'));
+      expect(deliveryFinding).toBeUndefined();
+    });
+  });
+});

package/agents/__tests__/23-migration-tester.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+
+vi.mock('node:child_process', () => ({
+  execFile: vi.fn(),
+}));
+
+import { execFile } from 'node:child_process';
+import { MigrationTesterAgent } from '../23-migration-tester';
+
+const mockedExecFile = vi.mocked(execFile);
+
+type ExecFileCallback = (err: Error | null, stdout: string, stderr: string) => void;
+
+function makeExecFileSuccess(stdout = '') {
+  return (...args: unknown[]) => {
+    // execFile may be called with or without an options object:
+    //   execFile(file, args, cb)  OR  execFile(file, args, options, cb)
+    const cb = args[args.length - 1] as ExecFileCallback;
+    cb(null, stdout, '');
+  };
+}
+
+function makeExecFileFailure(stderr: string) {
+  const error = Object.assign(new Error('Command failed'), { stderr });
+  return (...args: unknown[]) => {
+    const cb = args[args.length - 1] as ExecFileCallback;
+    cb(error, '', stderr);
+  };
+}
+
+const stubConfig: ValidatedConfig = {
+  schemaVersion: 1,
+  name: 'test',
+  auth: { loginUrl: 'http://localhost' },
+  modules: [{ id: 'mod', route: '/mod', sidebarIcon: true }],
+  environments: {},
+  portals: [],
+  breakpoints: [],
+  integrations: [],
+  workers: [],
+  workflows: [],
+  accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+  tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+  costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' },
+  agentClassification: { blocking: [], advisory: [] },
+  thresholds: {
+    unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+    lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+    apiResponseTime: 2000,
+    bundleSizeLimit: 500000,
+    maxConsoleErrors: 0,
+  },
+  disabledAgents: [],
+  disabledAgentSet: new Set<number>(),
+};
+
+function createAgent(): MigrationTesterAgent {
+  return new MigrationTesterAgent(stubConfig, 'alpha', '/tmp/test-run');
+}
+
+describe('MigrationTesterAgent', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('has agentId 23 and agentName Migration Tester', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(23);
+    expect(agent.agentName).toBe('Migration Tester');
+  });
+
+  it('returns no findings when all migration steps succeed', async () => {
+    // preFlight: prisma --version, then 3 execute steps
+    mockedExecFile
+      .mockImplementationOnce(makeExecFileSuccess('prisma: 5.0.0') as never)
+      .mockImplementationOnce(makeExecFileSuccess('All migrations have been applied.') as never)
+      .mockImplementationOnce(makeExecFileSuccess('Migrations applied successfully.') as never)
+      .mockImplementationOnce(makeExecFileSuccess('Seeded database successfully.') as never);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.status).toBe('passed');
+    expect(result.findings).toHaveLength(0);
+  });
+
+  it('returns medium infra-issue finding when migrate status fails in alpha', async () => {
+    mockedExecFile
+      .mockImplementationOnce(makeExecFileSuccess('prisma: 5.0.0') as never)
+      .mockImplementationOnce(makeExecFileFailure('Error: P1001: Can\'t reach database server') as never);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.status).toBe('passed'); // medium severity doesn't trigger failure
+    expect(result.findings).toHaveLength(1);
+    expect(result.findings[0].type).toBe('infra-issue');
+    expect(result.findings[0].severity).toBe('medium'); // alpha phase → medium
+    expect(result.findings[0].description).toContain('migrate status failed');
+  });
+
+  it('returns critical infra-issue finding when migrate deploy fails', async () => {
+    mockedExecFile
+      .mockImplementationOnce(makeExecFileSuccess('prisma: 5.0.0') as never)
+      .mockImplementationOnce(makeExecFileSuccess('') as never)
+      .mockImplementationOnce(makeExecFileFailure('Error: Migration failed to apply') as never);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings).toHaveLength(1);
+    expect(result.findings[0].type).toBe('infra-issue');
+    expect(result.findings[0].severity).toBe('critical');
+    expect(result.findings[0].description).toContain('migrate deploy failed');
+  });
+
+  it('returns critical infra-issue finding when db seed fails', async () => {
+    mockedExecFile
+      .mockImplementationOnce(makeExecFileSuccess('prisma: 5.0.0') as never)
+      .mockImplementationOnce(makeExecFileSuccess('') as never)
+      .mockImplementationOnce(makeExecFileSuccess('') as never)
+      .mockImplementationOnce(makeExecFileFailure('Error: Seed script exited with code 1') as never);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings).toHaveLength(1);
+    expect(result.findings[0].type).toBe('infra-issue');
+    expect(result.findings[0].severity).toBe('critical');
+    expect(result.findings[0].description).toContain('db seed failed');
+  });
+
+  it('returns infra-issue finding when preFlight (prisma --version) fails', async () => {
+    mockedExecFile.mockImplementationOnce(makeExecFileFailure('npx: command not found') as never);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings[0].type).toBe('infra-issue');
+  });
+});