@avi770/testteam 1.2.0

package/core/__tests__/integration.test.ts

@@ -0,0 +1,204 @@
+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, 3, 4, 5] 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, 3, 4, 5]);
+    });
+
+    it('returns agent IDs [5, 6, 7, 8, 12, 13, 14, 15, 16, 18, 19, 21, 22] 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]);
+    });
+
+    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

@@ -0,0 +1,227 @@
+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);
+  });
+});