@avi770/testteam 3.0.0 → 3.2.0

package/core/__tests__/integration.test.ts

@@ -1,204 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateConfig } from '../config';
-import { Orchestrator } from '../orchestrator';
-import type { TestTeamConfig } from '../config';
-
-/**
- * Inline sample config that mirrors testteam.config.ts.
- * Using an inline copy keeps the integration test self-contained and avoids
- * a top-level await / dynamic-import requirement in the test runner.
- */
-const sampleConfig: TestTeamConfig = {
-  schemaVersion: 1,
-  name: 'my-app',
-
-  auth: {
-    loginUrl: '/login',
-    credentials: {
-      alpha: { email: 'admin@example.com', password: 'test-placeholder' },
-      uat: { email: '', password: '' },
-    },
-    roles: [
-      { name: 'owner', email: 'admin@example.com' },
-      { name: 'senior_accountant', email: 'sarah@example.com' },
-      { name: 'accountant', email: 'mike@example.com' },
-    ],
-  },
-
-  modules: [
-    { id: 'overview', route: '/', sidebarIcon: true },
-    { id: 'tasks', route: '/tasks', sidebarIcon: true },
-    { id: 'kanban', route: '/kanban', sidebarIcon: true },
-    { id: 'triage', route: '/triage', sidebarIcon: true },
-    { id: 'calendar', route: '/calendar', sidebarIcon: true },
-    { id: 'compliance', route: '/compliance', sidebarIcon: true },
-    { id: 'client-portal', route: '/client-portal', sidebarIcon: true },
-    { id: 'client-health', route: '/client-health', sidebarIcon: true },
-    { id: 'communications', route: '/communications', sidebarIcon: true },
-    { id: 'documents', route: '/documents', sidebarIcon: true },
-    { id: 'workflows', route: '/workflows', sidebarIcon: true },
-    { id: 'recurring', route: '/recurring', sidebarIcon: true },
-    { id: 'task-dependencies', route: '/task-dependencies', sidebarIcon: true },
-    { id: 'time-tracking', route: '/time-tracking', sidebarIcon: true },
-    { id: 'staff-workload', route: '/staff-workload', sidebarIcon: true },
-    { id: 'staff-onboarding', route: '/staff-onboarding', sidebarIcon: true },
-    { id: 'quick-notes', route: '/quick-notes', sidebarIcon: true },
-    { id: 'announcements', route: '/announcements', sidebarIcon: true },
-    { id: 'activity', route: '/activity', sidebarIcon: true },
-    { id: 'analytics', route: '/analytics', sidebarIcon: true },
-    { id: 'reports', route: '/reports', sidebarIcon: true },
-    { id: 'xero', route: '/xero', sidebarIcon: true },
-    { id: 'integrations', route: '/integrations', sidebarIcon: true },
-    { id: 'settings', route: '/settings', sidebarIcon: true },
-  ],
-
-  environments: {
-    alpha: { baseUrl: 'http://localhost:3000', seed: true },
-    beta: { baseUrl: 'http://staging.example.com', seed: false },
-    uat: { baseUrl: 'https://app.example.com', seed: false },
-  },
-
-  portals: [
-    { name: 'bookkeeper', queryParam: null },
-    { name: 'client', queryParam: '?portal=client' },
-  ],
-
-  breakpoints: [1920, 1366, 768, 375],
-
-  integrations: [
-    { name: 'xero', type: 'oauth', sandboxAvailable: true },
-    { name: 'stripe', type: 'webhook', sandboxAvailable: true },
-    { name: 'email-ingest', type: 'imap', sandboxAvailable: false },
-    { name: 'ocr-textract', type: 'aws', sandboxAvailable: true },
-  ],
-
-  workers: [
-    { name: 'email-ingest' },
-    { name: 'ocr-textract' },
-    { name: 'subscription-renewer' },
-    { name: 'xero-fullsync' },
-    { name: 'xero-incremental' },
-  ],
-
-  workflows: [
-    {
-      name: 'Order Fulfillment',
-      steps: [
-        { action: 'navigate', target: '/triage', verify: 'section-loaded' },
-        { action: 'click', target: '[data-testid="unreconciled-item"]:first-child', verify: 'item-selected' },
-        { action: 'click', target: '[data-testid="reconcile-btn"]', verify: 'toast-success' },
-        { action: 'navigate', target: '/workflows', verify: 'section-loaded' },
-        { action: 'click', target: '[data-testid="trigger-bas"]', verify: 'workflow-started' },
-        { action: 'wait', target: '[data-testid="bas-report"]', timeout: 10000 },
-        { action: 'click', target: '[data-testid="send-for-approval"]', verify: 'toast-success' },
-        { action: 'navigate', target: '/?portal=client', verify: 'portal-switched' },
-        { action: 'click', target: '[data-testid="approve-bas"]', verify: 'toast-success' },
-        { action: 'navigate', target: '/workflows', verify: 'status-approved' },
-      ],
-    },
-    {
-      name: 'New Client Onboarding',
-      steps: [
-        { action: 'navigate', target: '/client-portal', verify: 'section-loaded' },
-        { action: 'click', target: '[data-testid="create-client-btn"]', verify: 'modal-open' },
-        { action: 'fill-form', target: '[data-testid="client-form"]', data: 'seed:new-client' },
-        { action: 'click', target: '[data-testid="submit-client"]', verify: 'toast-success' },
-        { action: 'verify', target: '[data-testid="client-list"]', contains: 'seed:new-client.name' },
-        { action: 'navigate', target: '/integrations', verify: 'section-loaded' },
-        { action: 'click', target: '[data-testid="connect-xero"]', verify: 'xero-oauth-started' },
-        { action: 'verify', target: '[data-testid="sync-status"]', contains: 'syncing' },
-      ],
-    },
-  ],
-
-  accuracy: {
-    enabled: true,
-    decimalPrecision: 2,
-    currencySymbol: 'USD',
-    timezone: 'America/New_York',
-  },
-
-  tenancy: {
-    enabled: true,
-    isolationField: 'firmId',
-    testFirms: ['firm-demo-001'],
-  },
-
-  costBudget: {
-    maxPerRun: 50,
-    maxPerAgent: 10,
-    alertThreshold: 0.8,
-    onExceeded: 'abort',
-  },
-
-  agentClassification: {
-    blocking: [1, 2, 3, 4, 5, 6, 7, 8, 11, 14, 19, 23],
-    advisory: [12, 13, 15, 16, 17, 20, 21, 22],
-  },
-
-  thresholds: {
-    unitCoverage: { lines: 80, functions: 80, branches: 70, statements: 80 },
-    lighthouse: { accessibility: 90, performance: 85, bestPractices: 85, seo: 80 },
-    apiResponseTime: 500,
-    bundleSizeLimit: 500,
-    maxConsoleErrors: 0,
-  },
-
-  disabledAgents: [],
-};
-
-describe('Sample Platform — TestTeam Integration', () => {
-  it('validates the sample config without throwing', () => {
-    expect(() => validateConfig(sampleConfig)).not.toThrow();
-  });
-
-  it('validateConfig returns a ValidatedConfig with disabledAgentSet', () => {
-    const validated = validateConfig(sampleConfig);
-    expect(validated.disabledAgentSet).toBeInstanceOf(Set);
-    expect(validated.disabledAgentSet.size).toBe(0);
-  });
-
-  it('validated config preserves all 24 modules', () => {
-    const validated = validateConfig(sampleConfig);
-    expect(validated.modules).toHaveLength(24);
-  });
-
-  it('validated config preserves three environments', () => {
-    const validated = validateConfig(sampleConfig);
-    expect(Object.keys(validated.environments)).toEqual(['alpha', 'beta', 'uat']);
-  });
-
-  describe('Orchestrator.dryRun with sample config', () => {
-    it('returns agent IDs [1, 2, 23, 24, 3, 4, 5, 37, 38, 62, 68, 69, 70] for alpha phase', () => {
-      const validated = validateConfig(sampleConfig);
-      const orchestrator = new Orchestrator(validated);
-      const plan = orchestrator.dryRun('alpha');
-
-      expect(plan.map(e => e.agentId)).toEqual([1, 2, 23, 24, 3, 4, 5, 37, 38, 62, 68, 69, 70]);
-    });
-
-    it('returns all 59 agent IDs for beta phase', () => {
-      const validated = validateConfig(sampleConfig);
-      const orchestrator = new Orchestrator(validated);
-      const plan = orchestrator.dryRun('beta');
-
-      expect(plan.map(e => e.agentId)).toEqual([5, 6, 7, 8, 12, 13, 14, 15, 16, 18, 19, 21, 22, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]);
-    });
-
-    it('marks all alpha agents as unregistered when no agents are registered', () => {
-      const validated = validateConfig(sampleConfig);
-      const orchestrator = new Orchestrator(validated);
-      const plan = orchestrator.dryRun('alpha');
-
-      expect(plan.every(e => e.status === 'unregistered')).toBe(true);
-    });
-
-    it('marks all beta agents as unregistered when no agents are registered', () => {
-      const validated = validateConfig(sampleConfig);
-      const orchestrator = new Orchestrator(validated);
-      const plan = orchestrator.dryRun('beta');
-
-      expect(plan.every(e => e.status === 'unregistered')).toBe(true);
-    });
-  });
-});

package/core/__tests__/license-gen.test.ts

@@ -1,227 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import { generateKeyPair, generateLicenseKey } from '../license-gen';
-import { validateLicense } from '../license';
-import type { LicensePayload, LicenseTier } from '../license';
-
-// ---------------------------------------------------------------------------
-// Shared keypair
-// ---------------------------------------------------------------------------
-
-let publicKey: string;
-let privateKey: string;
-
-beforeAll(() => {
-  const keys = generateKeyPair();
-  publicKey = keys.publicKey;
-  privateKey = keys.privateKey;
-});
-
-function buildPayload(
-  overrides: Partial<Omit<LicensePayload, 'iat'>> = {},
-): Omit<LicensePayload, 'iat'> {
-  return {
-    tier: 'pro',
-    exp: Math.floor(Date.now() / 1000) + 3600,
-    sub: 'test@example.com',
-    maxProjects: 3,
-    maxRunsPerMonth: 100,
-    features: [],
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// generateKeyPair extended tests
-// ---------------------------------------------------------------------------
-
-describe('generateKeyPair — extended', () => {
-  it('returns an object with publicKey and privateKey strings', () => {
-    const keys = generateKeyPair();
-    expect(typeof keys.publicKey).toBe('string');
-    expect(typeof keys.privateKey).toBe('string');
-  });
-
-  it('generates EC P-256 keys (SPKI/PKCS8 PEM format)', () => {
-    const keys = generateKeyPair();
-    expect(keys.publicKey).toContain('BEGIN PUBLIC KEY');
-    expect(keys.publicKey).toContain('END PUBLIC KEY');
-    expect(keys.privateKey).toContain('BEGIN PRIVATE KEY');
-    expect(keys.privateKey).toContain('END PRIVATE KEY');
-  });
-
-  it('generates different keys on each call', () => {
-    const keys1 = generateKeyPair();
-    const keys2 = generateKeyPair();
-    expect(keys1.publicKey).not.toBe(keys2.publicKey);
-    expect(keys1.privateKey).not.toBe(keys2.privateKey);
-  });
-
-  it('keypair can sign and verify a license', () => {
-    const keys = generateKeyPair();
-    const payload = buildPayload();
-    const key = generateLicenseKey(payload, keys.privateKey);
-    const result = validateLicense(key, keys.publicKey);
-    expect(result).not.toBeNull();
-    expect(result!.tier).toBe('pro');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// generateLicenseKey extended tests
-// ---------------------------------------------------------------------------
-
-describe('generateLicenseKey — extended', () => {
-  it('produces a valid JWT with three base64url-encoded parts', () => {
-    const key = generateLicenseKey(buildPayload(), privateKey);
-    const parts = key.split('.');
-    expect(parts).toHaveLength(3);
-
-    // Each part should be valid base64url
-    for (const part of parts) {
-      expect(() => Buffer.from(part, 'base64url')).not.toThrow();
-    }
-  });
-
-  it('header declares alg=ES256 and typ=JWT', () => {
-    const key = generateLicenseKey(buildPayload(), privateKey);
-    const headerJson = Buffer.from(key.split('.')[0], 'base64url').toString('utf8');
-    const header = JSON.parse(headerJson) as Record<string, string>;
-    expect(header.alg).toBe('ES256');
-    expect(header.typ).toBe('JWT');
-  });
-
-  it('payload includes all fields from input', () => {
-    const payload = buildPayload({
-      tier: 'enterprise',
-      sub: 'enterprise@corp.com',
-      maxProjects: 999,
-      maxRunsPerMonth: 999999,
-      features: ['sso', 'audit-trail'],
-    });
-
-    const key = generateLicenseKey(payload, privateKey);
-    const result = validateLicense(key, publicKey);
-
-    expect(result).not.toBeNull();
-    expect(result!.tier).toBe('enterprise');
-    expect(result!.sub).toBe('enterprise@corp.com');
-    expect(result!.maxProjects).toBe(999);
-    expect(result!.maxRunsPerMonth).toBe(999999);
-    expect(result!.features).toEqual(['sso', 'audit-trail']);
-  });
-
-  it('sets iat to approximately current timestamp', () => {
-    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('generates different signatures for different payloads', () => {
-    const key1 = generateLicenseKey(buildPayload({ sub: 'user1@test.com' }), privateKey);
-    const key2 = generateLicenseKey(buildPayload({ sub: 'user2@test.com' }), privateKey);
-
-    const sig1 = key1.split('.')[2];
-    const sig2 = key2.split('.')[2];
-    expect(sig1).not.toBe(sig2);
-  });
-
-  it('works with all license tiers', () => {
-    const tiers: LicenseTier[] = ['free', 'pro', 'enterprise'];
-
-    for (const tier of tiers) {
-      const payload = buildPayload({ tier });
-      const key = generateLicenseKey(payload, privateKey);
-      const result = validateLicense(key, publicKey);
-      expect(result).not.toBeNull();
-      expect(result!.tier).toBe(tier);
-    }
-  });
-
-  it('works with empty features array', () => {
-    const payload = buildPayload({ features: [] });
-    const key = generateLicenseKey(payload, privateKey);
-    const result = validateLicense(key, publicKey);
-    expect(result).not.toBeNull();
-    expect(result!.features).toEqual([]);
-  });
-
-  it('works with multiple features', () => {
-    const features = ['ci-mode', 'sso', 'parallel-agents', 'custom-agents', 'audit-trail'];
-    const payload = buildPayload({ features });
-    const key = generateLicenseKey(payload, privateKey);
-    const result = validateLicense(key, publicKey);
-    expect(result).not.toBeNull();
-    expect(result!.features).toEqual(features);
-  });
-
-  it('handles maxProjects and maxRunsPerMonth of 0', () => {
-    const payload = buildPayload({ maxProjects: 0, maxRunsPerMonth: 0 });
-    const key = generateLicenseKey(payload, privateKey);
-    const result = validateLicense(key, publicKey);
-    expect(result).not.toBeNull();
-    expect(result!.maxProjects).toBe(0);
-    expect(result!.maxRunsPerMonth).toBe(0);
-  });
-
-  it('handles very large expiry timestamps', () => {
-    const farFuture = Math.floor(Date.now() / 1000) + 10 * 365 * 86400; // 10 years
-    const payload = buildPayload({ exp: farFuture });
-    const key = generateLicenseKey(payload, privateKey);
-    const result = validateLicense(key, publicKey);
-    expect(result).not.toBeNull();
-    expect(result!.exp).toBe(farFuture);
-  });
-
-  it('produces expired license that validateLicense rejects', () => {
-    const payload = buildPayload({ exp: Math.floor(Date.now() / 1000) - 3600 });
-    const key = generateLicenseKey(payload, privateKey);
-    const result = validateLicense(key, publicKey);
-    expect(result).toBeNull();
-  });
-
-  it('signed with wrong key is rejected by validateLicense', () => {
-    const otherKeys = generateKeyPair();
-    const payload = buildPayload();
-    const key = generateLicenseKey(payload, otherKeys.privateKey);
-    const result = validateLicense(key, publicKey);
-    expect(result).toBeNull();
-  });
-
-  it('handles unicode characters in sub field', () => {
-    const payload = buildPayload({ sub: 'ユーザー@test.com' });
-    const key = generateLicenseKey(payload, privateKey);
-    const result = validateLicense(key, publicKey);
-    expect(result).not.toBeNull();
-    expect(result!.sub).toBe('ユーザー@test.com');
-  });
-
-  it('handles very long sub field', () => {
-    const longSub = 'a'.repeat(500) + '@test.com';
-    const payload = buildPayload({ sub: longSub });
-    const key = generateLicenseKey(payload, privateKey);
-    const result = validateLicense(key, publicKey);
-    expect(result).not.toBeNull();
-    expect(result!.sub).toBe(longSub);
-  });
-
-  it('handles enterprise-scale maxProjects and maxRunsPerMonth', () => {
-    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!.maxProjects).toBe(999);
-    expect(result!.maxRunsPerMonth).toBe(999999);
-  });
-
-  it('signature is 64 bytes raw (r||s) for P-256', () => {
-    const key = generateLicenseKey(buildPayload(), privateKey);
-    const sigB64 = key.split('.')[2];
-    const sigBuf = Buffer.from(sigB64, 'base64url');
-    expect(sigBuf.length).toBe(64);
-  });
-});