@avi770/testteam 1.2.0

package/core/__tests__/license.test.ts

@@ -0,0 +1,326 @@
+import { describe, it, expect, beforeEach, beforeAll, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  validateLicense,
+  loadLicense,
+  getLicenseTier,
+  resetLicenseCache,
+} from '../license';
+import type { LicensePayload } from '../license';
+import { generateKeyPair, generateLicenseKey } from '../license-gen';
+
+// ── Shared test keypair ──────────────────────────────────────────────
+
+let publicKey: string;
+let privateKey: string;
+
+beforeAll(() => {
+  const keys = generateKeyPair();
+  publicKey = keys.publicKey;
+  privateKey = keys.privateKey;
+});
+
+beforeEach(() => {
+  resetLicenseCache();
+});
+
+// ── Helper to build a valid payload ──────────────────────────────────
+
+function buildPayload(
+  overrides: Partial<Omit<LicensePayload, 'iat'>> = {},
+): Omit<LicensePayload, 'iat'> {
+  return {
+    tier: 'pro',
+    exp: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
+    sub: 'test@example.com',
+    maxProjects: 3,
+    maxRunsPerMonth: 100,
+    features: ['ci-mode'],
+    ...overrides,
+  };
+}
+
+// ── validateLicense ──────────────────────────────────────────────────
+
+describe('validateLicense', () => {
+  it('decodes and returns a valid license payload', () => {
+    const payload = buildPayload();
+    const key = generateLicenseKey(payload, privateKey);
+
+    const result = validateLicense(key, publicKey);
+
+    expect(result).not.toBeNull();
+    expect(result!.tier).toBe('pro');
+    expect(result!.sub).toBe('test@example.com');
+    expect(result!.maxProjects).toBe(3);
+    expect(result!.maxRunsPerMonth).toBe(100);
+    expect(result!.features).toEqual(['ci-mode']);
+    expect(typeof result!.iat).toBe('number');
+  });
+
+  it('returns null for an expired license', () => {
+    const payload = buildPayload({
+      exp: Math.floor(Date.now() / 1000) - 3600, // 1 hour ago
+    });
+    const key = generateLicenseKey(payload, privateKey);
+
+    const result = validateLicense(key, publicKey);
+    expect(result).toBeNull();
+  });
+
+  it('returns null for a tampered payload (signature mismatch)', () => {
+    const payload = buildPayload();
+    const key = generateLicenseKey(payload, privateKey);
+
+    // Tamper with the payload section
+    const parts = key.split('.');
+    const tamperedPayload = Buffer.from(
+      JSON.stringify({ ...payload, tier: 'enterprise', iat: Math.floor(Date.now() / 1000) }),
+    ).toString('base64url');
+    const tamperedKey = `${parts[0]}.${tamperedPayload}.${parts[2]}`;
+
+    const result = validateLicense(tamperedKey, publicKey);
+    expect(result).toBeNull();
+  });
+
+  it('returns null for a completely invalid string', () => {
+    expect(validateLicense('not-a-jwt', publicKey)).toBeNull();
+  });
+
+  it('returns null for an empty string', () => {
+    expect(validateLicense('', publicKey)).toBeNull();
+  });
+
+  it('returns null when signed with a different key', () => {
+    const otherKeys = generateKeyPair();
+    const payload = buildPayload();
+    const key = generateLicenseKey(payload, otherKeys.privateKey);
+
+    // Verify with the original public key — should fail
+    const result = validateLicense(key, publicKey);
+    expect(result).toBeNull();
+  });
+
+  it('returns null for a malformed header (not ES256)', () => {
+    // Manually build a JWT with RS256 header
+    const header = Buffer.from(JSON.stringify({ alg: 'RS256', typ: 'JWT' })).toString('base64url');
+    const payload = Buffer.from(JSON.stringify(buildPayload())).toString('base64url');
+    const fakeKey = `${header}.${payload}.fakesignature`;
+
+    const result = validateLicense(fakeKey, publicKey);
+    expect(result).toBeNull();
+  });
+
+  it('returns null when payload is missing required fields', () => {
+    // Generate a valid key, then manually re-sign with incomplete payload
+    // Simplest approach: use a payload missing 'tier'
+    const incompletePayload = { sub: 'x@y.com', exp: Date.now() / 1000 + 3600 };
+    const header = Buffer.from(JSON.stringify({ alg: 'ES256', typ: 'JWT' })).toString('base64url');
+    const payloadB64 = Buffer.from(JSON.stringify(incompletePayload)).toString('base64url');
+
+    // We can't properly sign this without internal access, so it will fail on signature
+    const result = validateLicense(`${header}.${payloadB64}.invalidsig`, publicKey);
+    expect(result).toBeNull();
+  });
+});
+
+// ── Tier-specific validation ─────────────────────────────────────────
+
+describe('tier-specific payloads', () => {
+  it('free tier returns correct limits', () => {
+    const payload = buildPayload({
+      tier: 'free',
+      maxProjects: 1,
+      maxRunsPerMonth: 10,
+    });
+    const key = generateLicenseKey(payload, privateKey);
+    const result = validateLicense(key, publicKey);
+
+    expect(result).not.toBeNull();
+    expect(result!.tier).toBe('free');
+    expect(result!.maxProjects).toBe(1);
+    expect(result!.maxRunsPerMonth).toBe(10);
+  });
+
+  it('pro tier returns correct limits', () => {
+    const payload = buildPayload({
+      tier: 'pro',
+      maxProjects: 3,
+      maxRunsPerMonth: 100,
+    });
+    const key = generateLicenseKey(payload, privateKey);
+    const result = validateLicense(key, publicKey);
+
+    expect(result).not.toBeNull();
+    expect(result!.tier).toBe('pro');
+    expect(result!.maxProjects).toBe(3);
+    expect(result!.maxRunsPerMonth).toBe(100);
+  });
+
+  it('enterprise tier returns correct limits', () => {
+    const payload = buildPayload({
+      tier: 'enterprise',
+      maxProjects: 999,
+      maxRunsPerMonth: 999999,
+    });
+    const key = generateLicenseKey(payload, privateKey);
+    const result = validateLicense(key, publicKey);
+
+    expect(result).not.toBeNull();
+    expect(result!.tier).toBe('enterprise');
+    expect(result!.maxProjects).toBe(999);
+    expect(result!.maxRunsPerMonth).toBe(999999);
+  });
+});
+
+// ── loadLicense ──────────────────────────────────────────────────────
+
+describe('loadLicense', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    resetLicenseCache();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tf-license-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('loads a valid license from .testteam-license file', () => {
+    const payload = buildPayload();
+    const key = generateLicenseKey(payload, privateKey);
+    const fileContent = `${key}\n\n${publicKey}`;
+    fs.writeFileSync(path.join(tmpDir, '.testteam-license'), fileContent);
+
+    const result = loadLicense(tmpDir);
+    expect(result).not.toBeNull();
+    expect(result!.tier).toBe('pro');
+    expect(result!.sub).toBe('test@example.com');
+  });
+
+  it('returns null when license file does not exist', () => {
+    const result = loadLicense(tmpDir);
+    expect(result).toBeNull();
+  });
+
+  it('returns null when license file is empty', () => {
+    fs.writeFileSync(path.join(tmpDir, '.testteam-license'), '');
+
+    const result = loadLicense(tmpDir);
+    expect(result).toBeNull();
+  });
+
+  it('returns null when license file has invalid JWT', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.testteam-license'),
+      `not-a-valid-jwt\n\n${publicKey}`,
+    );
+
+    const result = loadLicense(tmpDir);
+    expect(result).toBeNull();
+  });
+
+  it('caches the result across multiple calls', () => {
+    const payload = buildPayload();
+    const key = generateLicenseKey(payload, privateKey);
+    fs.writeFileSync(
+      path.join(tmpDir, '.testteam-license'),
+      `${key}\n\n${publicKey}`,
+    );
+
+    const result1 = loadLicense(tmpDir);
+    // Delete the file — cached result should still work
+    fs.unlinkSync(path.join(tmpDir, '.testteam-license'));
+    const result2 = loadLicense(tmpDir);
+
+    expect(result1).not.toBeNull();
+    expect(result2).toEqual(result1);
+  });
+});
+
+// ── getLicenseTier ───────────────────────────────────────────────────
+
+describe('getLicenseTier', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    resetLicenseCache();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tf-tier-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns "free" when no license file exists', () => {
+    expect(getLicenseTier(tmpDir)).toBe('free');
+  });
+
+  it('returns "free" when license is invalid', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.testteam-license'),
+      `garbage\n\n${publicKey}`,
+    );
+    expect(getLicenseTier(tmpDir)).toBe('free');
+  });
+
+  it('returns the tier from a valid license', () => {
+    const payload = buildPayload({ tier: 'enterprise', maxProjects: 999, maxRunsPerMonth: 999999 });
+    const key = generateLicenseKey(payload, privateKey);
+    fs.writeFileSync(
+      path.join(tmpDir, '.testteam-license'),
+      `${key}\n\n${publicKey}`,
+    );
+    expect(getLicenseTier(tmpDir)).toBe('enterprise');
+  });
+});
+
+// ── generateKeyPair ──────────────────────────────────────────────────
+
+describe('generateKeyPair', () => {
+  it('produces PEM-encoded public and private keys', () => {
+    const keys = generateKeyPair();
+    expect(keys.publicKey).toContain('BEGIN PUBLIC KEY');
+    expect(keys.privateKey).toContain('BEGIN PRIVATE KEY');
+  });
+
+  it('generates unique keypairs on each call', () => {
+    const keys1 = generateKeyPair();
+    const keys2 = generateKeyPair();
+    expect(keys1.publicKey).not.toBe(keys2.publicKey);
+    expect(keys1.privateKey).not.toBe(keys2.privateKey);
+  });
+});
+
+// ── generateLicenseKey ───────────────────────────────────────────────
+
+describe('generateLicenseKey', () => {
+  it('produces a three-part dot-separated JWT string', () => {
+    const key = generateLicenseKey(buildPayload(), privateKey);
+    const parts = key.split('.');
+    expect(parts).toHaveLength(3);
+  });
+
+  it('sets iat automatically', () => {
+    const before = Math.floor(Date.now() / 1000);
+    const key = generateLicenseKey(buildPayload(), privateKey);
+    const after = Math.floor(Date.now() / 1000);
+
+    const result = validateLicense(key, publicKey);
+    expect(result).not.toBeNull();
+    expect(result!.iat).toBeGreaterThanOrEqual(before);
+    expect(result!.iat).toBeLessThanOrEqual(after);
+  });
+
+  it('round-trips through validateLicense', () => {
+    const payload = buildPayload({ features: ['sso', 'parallel-agents'] });
+    const key = generateLicenseKey(payload, privateKey);
+    const result = validateLicense(key, publicKey);
+
+    expect(result).not.toBeNull();
+    expect(result!.features).toEqual(['sso', 'parallel-agents']);
+  });
+});

package/core/__tests__/multi-browser.test.ts

@@ -0,0 +1,278 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  runMultiBrowser,
+  compareBrowserResults,
+  DEFAULT_MULTI_BROWSER_CONFIG,
+} from '../multi-browser';
+import type { MultiBrowserConfig, MultiBrowserResult, BrowserEngine } from '../multi-browser';
+import type { AgentResult, Finding } from '../types';
+import type { TestTeamConfig } from '../config';
+import type { BaseAgent } from '../../agents/base-agent';
+
+/** Build a minimal AgentResult with optional overrides. */
+function makeAgentResult(overrides: Partial<AgentResult> = {}): AgentResult {
+  return {
+    agentId: 5,
+    agentName: 'Browser Crawler',
+    phase: 'alpha',
+    status: 'passed',
+    startedAt: '2026-01-01T00:00:00Z',
+    completedAt: '2026-01-01T00:01:00Z',
+    durationMs: 60_000,
+    findings: [],
+    evidence: [],
+    summary: 'All checks passed',
+    ...overrides,
+  };
+}
+
+/** Build a minimal Finding. */
+function makeFinding(description: string, overrides: Partial<Finding> = {}): Finding {
+  return {
+    id: `finding-${description.slice(0, 20).replace(/\s+/g, '-')}`,
+    type: 'code-bug-logic',
+    severity: 'medium',
+    agentId: 5,
+    module: 'test-module',
+    description,
+    ...overrides,
+  };
+}
+
+/** Create a mock BaseAgent that returns the given result. */
+function createMockAgent(result: AgentResult): BaseAgent {
+  return {
+    agentId: 5,
+    agentName: 'Browser Crawler',
+    run: vi.fn().mockResolvedValue(result),
+  } as unknown as BaseAgent;
+}
+
+const STUB_CONFIG = {} as TestTeamConfig;
+
+describe('runMultiBrowser', () => {
+  it('runs all engines concurrently when parallel is true', async () => {
+    const callOrder: string[] = [];
+
+    const mockAgent = {
+      agentId: 5,
+      agentName: 'Browser Crawler',
+      run: vi.fn().mockImplementation(async () => {
+        const engine = `call-${callOrder.length}`;
+        callOrder.push(engine);
+        return makeAgentResult();
+      }),
+    } as unknown as BaseAgent;
+
+    const config: MultiBrowserConfig = {
+      engines: ['chromium', 'firefox', 'webkit'],
+      parallel: true,
+      compareResults: false,
+    };
+
+    const { results } = await runMultiBrowser(mockAgent, STUB_CONFIG, 'alpha', config);
+
+    expect(results).toHaveLength(3);
+    expect(results[0].engine).toBe('chromium');
+    expect(results[1].engine).toBe('firefox');
+    expect(results[2].engine).toBe('webkit');
+    // All three calls were initiated (Promise.all)
+    expect(mockAgent.run).toHaveBeenCalledTimes(3);
+  });
+
+  it('runs engines sequentially when parallel is false', async () => {
+    const callTimestamps: number[] = [];
+
+    const mockAgent = {
+      agentId: 5,
+      agentName: 'Browser Crawler',
+      run: vi.fn().mockImplementation(async () => {
+        callTimestamps.push(Date.now());
+        // Small delay to distinguish sequential from parallel
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return makeAgentResult();
+      }),
+    } as unknown as BaseAgent;
+
+    const config: MultiBrowserConfig = {
+      engines: ['chromium', 'firefox', 'webkit'],
+      parallel: false,
+      compareResults: false,
+    };
+
+    const { results } = await runMultiBrowser(mockAgent, STUB_CONFIG, 'alpha', config);
+
+    expect(results).toHaveLength(3);
+    expect(mockAgent.run).toHaveBeenCalledTimes(3);
+
+    // Sequential: each call starts after the previous one finishes
+    for (let i = 1; i < callTimestamps.length; i++) {
+      expect(callTimestamps[i]).toBeGreaterThanOrEqual(callTimestamps[i - 1]);
+    }
+  });
+
+  it('detects cross-browser diffs when compareResults is true', async () => {
+    let callCount = 0;
+    const mockAgent = {
+      agentId: 5,
+      agentName: 'Browser Crawler',
+      run: vi.fn().mockImplementation(async () => {
+        callCount++;
+        if (callCount === 2) {
+          // Firefox finds an extra issue
+          return makeAgentResult({
+            findings: [makeFinding('Button misaligned on mobile viewport')],
+          });
+        }
+        return makeAgentResult();
+      }),
+    } as unknown as BaseAgent;
+
+    const config: MultiBrowserConfig = {
+      engines: ['chromium', 'firefox'],
+      parallel: true,
+      compareResults: true,
+    };
+
+    const { results, diffs } = await runMultiBrowser(mockAgent, STUB_CONFIG, 'alpha', config);
+
+    expect(results).toHaveLength(2);
+    expect(diffs).toHaveLength(1);
+    expect(diffs[0].engine1).toBe('chromium');
+    expect(diffs[0].engine2).toBe('firefox');
+    expect(diffs[0].differences.length).toBeGreaterThan(0);
+  });
+
+  it('returns no diffs when compareResults is false', async () => {
+    let callCount = 0;
+    const mockAgent = {
+      agentId: 5,
+      agentName: 'Browser Crawler',
+      run: vi.fn().mockImplementation(async () => {
+        callCount++;
+        if (callCount === 2) {
+          return makeAgentResult({
+            findings: [makeFinding('Only in firefox')],
+          });
+        }
+        return makeAgentResult();
+      }),
+    } as unknown as BaseAgent;
+
+    const config: MultiBrowserConfig = {
+      engines: ['chromium', 'firefox'],
+      parallel: true,
+      compareResults: false,
+    };
+
+    const { diffs } = await runMultiBrowser(mockAgent, STUB_CONFIG, 'alpha', config);
+    expect(diffs).toHaveLength(0);
+  });
+
+  it('tags findings with engine name', async () => {
+    const mockAgent = createMockAgent(
+      makeAgentResult({ findings: [makeFinding('Console error in dashboard')] }),
+    );
+
+    const config: MultiBrowserConfig = {
+      engines: ['webkit'],
+      parallel: true,
+      compareResults: false,
+    };
+
+    const { results } = await runMultiBrowser(mockAgent, STUB_CONFIG, 'alpha', config);
+    expect(results[0].result.findings[0].description).toContain('[webkit]');
+  });
+});
+
+describe('compareBrowserResults', () => {
+  it('returns empty array for single engine result', () => {
+    const results: MultiBrowserResult[] = [
+      { engine: 'chromium', result: makeAgentResult(), duration: 100 },
+    ];
+    expect(compareBrowserResults(results)).toEqual([]);
+  });
+
+  it('returns empty array when findings match across browsers', () => {
+    const sharedFinding = makeFinding('Shared issue');
+    const results: MultiBrowserResult[] = [
+      {
+        engine: 'chromium',
+        result: makeAgentResult({ findings: [{ ...sharedFinding, description: '[chromium] Shared issue' }] }),
+        duration: 100,
+      },
+      {
+        engine: 'firefox',
+        result: makeAgentResult({ findings: [{ ...sharedFinding, description: '[firefox] Shared issue' }] }),
+        duration: 120,
+      },
+    ];
+    expect(compareBrowserResults(results)).toEqual([]);
+  });
+
+  it('detects findings present in one browser but not another', () => {
+    const results: MultiBrowserResult[] = [
+      {
+        engine: 'chromium',
+        result: makeAgentResult({ findings: [] }),
+        duration: 100,
+      },
+      {
+        engine: 'firefox',
+        result: makeAgentResult({
+          findings: [{ ...makeFinding('Firefox-only bug'), description: '[firefox] Firefox-only bug' }],
+        }),
+        duration: 120,
+      },
+    ];
+
+    const diffs = compareBrowserResults(results);
+    expect(diffs).toHaveLength(1);
+    expect(diffs[0].engine1).toBe('chromium');
+    expect(diffs[0].engine2).toBe('firefox');
+    expect(diffs[0].differences).toHaveLength(1);
+  });
+
+  it('compares all pairs for three engines', () => {
+    const results: MultiBrowserResult[] = [
+      {
+        engine: 'chromium',
+        result: makeAgentResult({ findings: [{ ...makeFinding('A'), description: '[chromium] A' }] }),
+        duration: 100,
+      },
+      {
+        engine: 'firefox',
+        result: makeAgentResult({ findings: [{ ...makeFinding('B'), description: '[firefox] B' }] }),
+        duration: 110,
+      },
+      {
+        engine: 'webkit',
+        result: makeAgentResult({ findings: [{ ...makeFinding('A'), description: '[webkit] A' }] }),
+        duration: 120,
+      },
+    ];
+
+    const diffs = compareBrowserResults(results);
+    // chromium vs firefox: A differs from B => diff
+    // chromium vs webkit: both have A => no diff
+    // firefox vs webkit: B differs from A => diff
+    expect(diffs).toHaveLength(2);
+
+    const chromiumFirefox = diffs.find(d => d.engine1 === 'chromium' && d.engine2 === 'firefox');
+    expect(chromiumFirefox).toBeDefined();
+
+    const firefoxWebkit = diffs.find(d => d.engine1 === 'firefox' && d.engine2 === 'webkit');
+    expect(firefoxWebkit).toBeDefined();
+
+    const chromiumWebkit = diffs.find(d => d.engine1 === 'chromium' && d.engine2 === 'webkit');
+    expect(chromiumWebkit).toBeUndefined();
+  });
+});
+
+describe('DEFAULT_MULTI_BROWSER_CONFIG', () => {
+  it('has correct default values', () => {
+    expect(DEFAULT_MULTI_BROWSER_CONFIG.engines).toEqual(['chromium']);
+    expect(DEFAULT_MULTI_BROWSER_CONFIG.parallel).toBe(true);
+    expect(DEFAULT_MULTI_BROWSER_CONFIG.compareResults).toBe(true);
+  });
+});