@avi770/testteam 1.2.0 → 3.0.0

package/agents/__tests__/49-i18n-tester.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1,
+    name: 'test',
+    auth: {
+      loginUrl: 'http://localhost/login',
+      credentials: { admin: { email: 'admin@test.com', password: 'secret' } },
+    },
+    modules: [
+      { id: 'dashboard', route: '/dashboard', sidebarIcon: true },
+      { id: 'tasks', route: '/tasks', sidebarIcon: true },
+    ],
+    environments: { alpha: { 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: [49] },
+    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>(),
+    ...overrides,
+  };
+}
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+function makeMockLocator(countVal = 0) {
+  const locator: Record<string, ReturnType<typeof vi.fn>> = {
+    count: vi.fn().mockResolvedValue(countVal),
+    first: vi.fn(),
+    nth: vi.fn(),
+    click: vi.fn().mockResolvedValue(undefined),
+    fill: vi.fn().mockResolvedValue(undefined),
+  };
+  locator.first.mockReturnValue(locator);
+  locator.nth.mockReturnValue(locator);
+  return locator;
+}
+
+function makeMockPage() {
+  const defaultLocator = makeMockLocator(0);
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    locator: vi.fn().mockReturnValue(defaultLocator),
+    evaluate: vi.fn().mockResolvedValue(''),
+    on: vi.fn(),
+    route: vi.fn().mockResolvedValue(undefined),
+    unroute: vi.fn().mockResolvedValue(undefined),
+    keyboard: { press: vi.fn().mockResolvedValue(undefined) },
+    waitForSelector: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+let currentMockPage: ReturnType<typeof makeMockPage>;
+let mockBrowser: { newPage: ReturnType<typeof vi.fn>; newContext: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: {
+    launch: vi.fn().mockImplementation(async () => mockBrowser),
+  },
+}));
+
+const { I18nTesterAgent } = await import('../49-i18n-tester');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new I18nTesterAgent(config, phase, '/tmp/test-run');
+}
+
+describe('I18nTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      newContext: vi.fn().mockResolvedValue({ newPage: vi.fn().mockResolvedValue(currentMockPage), close: vi.fn() }),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('has agentId 49 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(49);
+    expect(agent.agentName).toBe('i18n Tester');
+  });
+
+  it('throws when modules array is empty', async () => {
+    const agent = createAgent(makeConfig({ modules: [] }));
+    const result = await agent.run();
+    expect(result.status).toBe('failed');
+  });
+
+  it('reports no language switcher when none found', async () => {
+    currentMockPage.evaluate.mockResolvedValue('Hello world');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-lang-switcher'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('low');
+  });
+
+  it('detects untranslated i18n keys', async () => {
+    currentMockPage.evaluate.mockResolvedValueOnce('') // findLanguageSwitcher
+      .mockResolvedValueOnce('home.title.subtitle') // body text with i18n key
+      .mockResolvedValue('');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('untranslated'));
+    expect(finding).toBeDefined();
+  });
+
+  it('handles login failure gracefully', async () => {
+    loginMock.mockRejectedValue(new Error('Login failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('login-failed'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('medium');
+  });
+
+  it('handles playwright crash gracefully', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Browser crashed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('playwright-failure'));
+    expect(finding).toBeDefined();
+  });
+
+  it('handles navigation failure for module', async () => {
+    currentMockPage.goto.mockRejectedValue(new Error('Nav failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('nav-failed'));
+    expect(finding).toBeDefined();
+  });
+
+  it('checks RTL layout when language switcher found', async () => {
+    currentMockPage.locator.mockReturnValue(makeMockLocator(1)); // lang switcher found
+    currentMockPage.evaluate
+      .mockResolvedValueOnce('Normal text') // body text
+      .mockResolvedValueOnce('Normal text') // body text
+      .mockResolvedValueOnce('ltr') // document.dir
+      .mockResolvedValueOnce('ar'); // document.lang
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('rtl-missing'));
+    expect(finding).toBeDefined();
+  });
+
+  it('does not report RTL issue when locale is LTR', async () => {
+    currentMockPage.locator.mockReturnValue(makeMockLocator(1));
+    currentMockPage.evaluate
+      .mockResolvedValueOnce('Normal text')
+      .mockResolvedValueOnce('Normal text')
+      .mockResolvedValueOnce('ltr')
+      .mockResolvedValueOnce('en');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('rtl-missing'));
+    expect(finding).toBeUndefined();
+  });
+
+  it('closes browser in finally block', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  it('continues without credentials when none configured', async () => {
+    const config = makeConfig({ auth: { loginUrl: '/login', credentials: {} } });
+    const agent = createAgent(config);
+    const result = await agent.run();
+    expect(result.status).not.toBe('failed');
+  });
+});

package/agents/__tests__/50-timezone-tester.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1, name: 'test',
+    auth: { loginUrl: 'http://localhost/login', credentials: { admin: { email: 'a@t.com', password: 's' } } },
+    modules: [
+      { id: 'dashboard', route: '/dashboard', sidebarIcon: true },
+      { id: 'tasks', route: '/tasks', sidebarIcon: true },
+    ],
+    environments: { alpha: { 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>(),
+    ...overrides,
+  };
+}
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+function makeMockPage() {
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue([]),
+    locator: vi.fn().mockReturnValue({ count: vi.fn().mockResolvedValue(0), first: vi.fn() }),
+    on: vi.fn(),
+  };
+}
+
+let currentMockPage: ReturnType<typeof makeMockPage>;
+let mockContext: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+let mockBrowser: { newPage: ReturnType<typeof vi.fn>; newContext: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: {
+    launch: vi.fn().mockImplementation(async () => mockBrowser),
+  },
+}));
+
+const { TimezoneTesterAgent } = await import('../50-timezone-tester');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new TimezoneTesterAgent(config, phase, '/tmp/test-run');
+}
+
+describe('TimezoneTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+    currentMockPage = makeMockPage();
+    mockContext = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      newContext: vi.fn().mockResolvedValue(mockContext),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('has agentId 50 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(50);
+    expect(agent.agentName).toBe('Timezone Tester');
+  });
+
+  it('throws when modules array is empty', async () => {
+    const agent = createAgent(makeConfig({ modules: [] }));
+    const result = await agent.run();
+    expect(result.status).toBe('failed');
+  });
+
+  it('reports no dates found when page has none', async () => {
+    currentMockPage.evaluate.mockResolvedValue([]);
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-dates-found'));
+    expect(finding).toBeDefined();
+  });
+
+  it('detects off-by-one date differences', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) return ['Jan 15, 2025'];
+      if (callCount === 2) return ['Jan 16, 2025'];
+      if (callCount === 3) return ['Jan 16, 2025'];
+      return [];
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('off-by-one'));
+    expect(finding).toBeDefined();
+  });
+
+  it('handles navigation failure', async () => {
+    currentMockPage.goto.mockRejectedValue(new Error('Nav failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('nav-failed'));
+    expect(finding).toBeDefined();
+  });
+
+  it('handles playwright crash gracefully', async () => {
+    mockBrowser.newContext.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('playwright-failure'));
+    expect(finding).toBeDefined();
+  });
+
+  it('reports date count mismatch across timezones', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) return ['Jan 15', 'Feb 20'];
+      if (callCount === 2) return ['Jan 15'];
+      return ['Jan 15'];
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('date-count-mismatch'));
+    expect(finding).toBeDefined();
+  });
+
+  it('closes browser in finally block', async () => {
+    mockBrowser.newContext.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  it('handles login failure gracefully', async () => {
+    loginMock.mockRejectedValue(new Error('Login failed'));
+    currentMockPage.evaluate.mockResolvedValue([]);
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.findings).toBeDefined();
+  });
+
+  it('reports same dates as no issue', async () => {
+    currentMockPage.evaluate.mockResolvedValue(['Jan 15, 2025']);
+    const agent = createAgent();
+    const result = await agent.run();
+    const offByOne = result.findings.find(f => f.id.includes('off-by-one'));
+    expect(offByOne).toBeUndefined();
+  });
+
+  it('handles evaluate failure', async () => {
+    currentMockPage.evaluate.mockRejectedValue(new Error('Eval failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+});

package/agents/__tests__/51-error-recovery-tester.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1, name: 'test',
+    auth: { loginUrl: 'http://localhost/login', credentials: { admin: { email: 'a@t.com', password: 's' } } },
+    modules: [{ id: 'dashboard', route: '/dashboard', sidebarIcon: true }],
+    environments: { alpha: { 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>(),
+    ...overrides,
+  };
+}
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+function makeMockLocator(countVal = 0) {
+  const loc: Record<string, ReturnType<typeof vi.fn>> = {
+    count: vi.fn().mockResolvedValue(countVal),
+    first: vi.fn(),
+  };
+  loc.first.mockReturnValue(loc);
+  return loc;
+}
+
+function makeMockPage() {
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue('Some content'),
+    locator: vi.fn().mockReturnValue(makeMockLocator(0)),
+    route: vi.fn().mockResolvedValue(undefined),
+    unroute: vi.fn().mockResolvedValue(undefined),
+    on: vi.fn(),
+  };
+}
+
+let currentMockPage: ReturnType<typeof makeMockPage>;
+let mockBrowser: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: { launch: vi.fn().mockImplementation(async () => mockBrowser) },
+}));
+
+const { ErrorRecoveryTesterAgent } = await import('../51-error-recovery-tester');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new ErrorRecoveryTesterAgent(config, phase, '/tmp/test-run');
+}
+
+describe('ErrorRecoveryTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('has agentId 51 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(51);
+    expect(agent.agentName).toBe('Error Recovery Tester');
+  });
+
+  it('throws when modules empty', async () => {
+    const agent = createAgent(makeConfig({ modules: [] }));
+    const result = await agent.run();
+    expect(result.status).toBe('failed');
+  });
+
+  it('reports blank screen after recovery as high', async () => {
+    currentMockPage.evaluate.mockResolvedValue('');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('blank-screen'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('high');
+  });
+
+  it('reports recovery UI as low', async () => {
+    currentMockPage.evaluate.mockResolvedValue('Some content after recovery');
+    currentMockPage.locator.mockReturnValue(makeMockLocator(1)); // retry button found
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('recovery-ui'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('low');
+  });
+
+  it('handles nav failure', async () => {
+    currentMockPage.goto.mockRejectedValue(new Error('Nav failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('nav-failed'));
+    expect(finding).toBeDefined();
+  });
+
+  it('handles login failure', async () => {
+    loginMock.mockRejectedValue(new Error('Login failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('login-failed'));
+    expect(finding).toBeDefined();
+  });
+
+  it('handles playwright crash', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('playwright-failure'));
+    expect(finding).toBeDefined();
+  });
+
+  it('calls route and unroute for offline simulation', async () => {
+    currentMockPage.evaluate.mockResolvedValue('Content');
+    const agent = createAgent();
+    await agent.run();
+    expect(currentMockPage.route).toHaveBeenCalledWith('**/*', expect.any(Function));
+    expect(currentMockPage.unroute).toHaveBeenCalledWith('**/*', expect.any(Function));
+  });
+
+  it('closes browser in finally', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  it('handles evaluate failure in recovery check', async () => {
+    currentMockPage.evaluate.mockRejectedValue(new Error('Eval failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('recovery-check-failed'));
+    expect(finding).toBeDefined();
+  });
+
+  it('no credentials continues without error', async () => {
+    const config = makeConfig({ auth: { loginUrl: '/login', credentials: {} } });
+    const agent = createAgent(config);
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+});