@avi770/testteam 1.2.0 → 2.0.0

package/agents/__tests__/52-offline-mode-tester.test.ts

@@ -0,0 +1,164 @@
+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(false),
+    locator: vi.fn().mockReturnValue({ count: vi.fn().mockResolvedValue(0), first: vi.fn() }),
+    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 { OfflineModeTesterAgent } = await import('../52-offline-mode-tester');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new OfflineModeTesterAgent(config, phase, '/tmp/test-run');
+}
+
+describe('OfflineModeTesterAgent', () => {
+  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 52 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(52);
+    expect(agent.agentName).toBe('Offline Mode Tester');
+  });
+
+  it('throws when modules empty', async () => {
+    const agent = createAgent(makeConfig({ modules: [] }));
+    const result = await agent.run();
+    expect(result.status).toBe('failed');
+  });
+
+  it('reports no service worker when not detected', async () => {
+    currentMockPage.evaluate.mockResolvedValue(false);
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-service-worker'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('low');
+  });
+
+  it('reports blank page when offline', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) return false; // no service worker
+      return ''; // blank page offline
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('blank-offline'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('medium');
+  });
+
+  it('reports offline message when detected', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) return true; // has service worker
+      return 'You are offline'; // offline message
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('offline-message'));
+    expect(finding).toBeDefined();
+  });
+
+  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('closes browser in finally', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  it('calls route to simulate offline', async () => {
+    currentMockPage.evaluate.mockResolvedValue(false);
+    const agent = createAgent();
+    await agent.run();
+    expect(currentMockPage.route).toHaveBeenCalledWith('**/*', expect.any(Function));
+  });
+
+  it('handles evaluate failure for service worker check', async () => {
+    currentMockPage.evaluate.mockRejectedValue(new Error('Eval failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+});

package/agents/__tests__/53-graceful-degradation-tester.test.ts

@@ -0,0 +1,168 @@
+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);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: vi.fn().mockResolvedValue(undefined),
+  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) }),
+    route: vi.fn().mockResolvedValue(undefined),
+    on: vi.fn(),
+  };
+}
+
+let mockPage1: ReturnType<typeof makeMockPage>;
+let mockPage2: ReturnType<typeof makeMockPage>;
+let mockContext1: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+let mockContext2: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+let contextCallCount: number;
+let mockBrowser: { newContext: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: { launch: vi.fn().mockImplementation(async () => mockBrowser) },
+}));
+
+const { GracefulDegradationTesterAgent } = await import('../53-graceful-degradation-tester');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new GracefulDegradationTesterAgent(config, phase, '/tmp/test-run');
+}
+
+describe('GracefulDegradationTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    mockPage1 = makeMockPage();
+    mockPage2 = makeMockPage();
+    contextCallCount = 0;
+    mockContext1 = { newPage: vi.fn().mockResolvedValue(mockPage1), close: vi.fn().mockResolvedValue(undefined) };
+    mockContext2 = { newPage: vi.fn().mockResolvedValue(mockPage2), close: vi.fn().mockResolvedValue(undefined) };
+    mockBrowser = {
+      newContext: vi.fn().mockImplementation(async () => {
+        contextCallCount++;
+        return contextCallCount === 1 ? mockContext1 : mockContext2;
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('has agentId 53 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(53);
+    expect(agent.agentName).toBe('Graceful Degradation Tester');
+  });
+
+  it('throws when modules empty', async () => {
+    const agent = createAgent(makeConfig({ modules: [] }));
+    const result = await agent.run();
+    expect(result.status).toBe('failed');
+  });
+
+  it('reports no SSR when blank without JS', async () => {
+    mockPage1.evaluate.mockResolvedValue('');
+    mockPage2.evaluate.mockResolvedValue(0);
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-ssr'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('medium');
+  });
+
+  it('reports missing alt text', async () => {
+    mockPage1.evaluate.mockResolvedValue('Some SSR content');
+    mockPage2.evaluate.mockResolvedValue(3); // 3 images missing alt
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('missing-alt'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('medium');
+  });
+
+  it('no finding when SSR works and alt text present', async () => {
+    mockPage1.evaluate.mockResolvedValue('Server rendered content');
+    mockPage2.evaluate.mockResolvedValue(0); // no missing alt
+    const agent = createAgent();
+    const result = await agent.run();
+    const ssrFinding = result.findings.find(f => f.id.includes('no-ssr'));
+    const altFinding = result.findings.find(f => f.id.includes('missing-alt'));
+    expect(ssrFinding).toBeUndefined();
+    expect(altFinding).toBeUndefined();
+  });
+
+  it('handles playwright crash', 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('closes browser in finally', async () => {
+    mockBrowser.newContext.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  it('handles no-JS navigation failure', async () => {
+    mockPage1.goto.mockRejectedValue(new Error('Page failed'));
+    mockPage2.evaluate.mockResolvedValue(0);
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-js-nav-failed'));
+    expect(finding).toBeDefined();
+  });
+
+  it('handles image test failure', async () => {
+    mockPage1.evaluate.mockResolvedValue('Content');
+    mockPage2.goto.mockRejectedValue(new Error('Nav failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('img-test-failed'));
+    expect(finding).toBeDefined();
+  });
+
+  it('blocks image routes in test 2', async () => {
+    mockPage1.evaluate.mockResolvedValue('Content');
+    mockPage2.evaluate.mockResolvedValue(0);
+    const agent = createAgent();
+    await agent.run();
+    expect(mockPage2.route).toHaveBeenCalledWith('**/*.{png,jpg,jpeg,gif,webp,svg,ico}', expect.any(Function));
+  });
+
+  it('creates context with javaScriptEnabled false for test 1', async () => {
+    mockPage1.evaluate.mockResolvedValue('Content');
+    mockPage2.evaluate.mockResolvedValue(0);
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.newContext).toHaveBeenCalledWith({ javaScriptEnabled: false });
+  });
+});

package/agents/__tests__/54-websocket-tester.test.ts

@@ -0,0 +1,157 @@
+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 makeMockPage() {
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    on: vi.fn(),
+    locator: vi.fn().mockReturnValue({ count: vi.fn().mockResolvedValue(0) }),
+  };
+}
+
+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 { WebSocketTesterAgent } = await import('../54-websocket-tester');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new WebSocketTesterAgent(config, phase, '/tmp/test-run');
+}
+
+describe('WebSocketTesterAgent', () => {
+  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 54 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(54);
+    expect(agent.agentName).toBe('WebSocket Tester');
+  });
+
+  it('throws when modules empty', async () => {
+    const agent = createAgent(makeConfig({ modules: [] }));
+    const result = await agent.run();
+    expect(result.status).toBe('failed');
+  });
+
+  it('reports no WS connections when none detected', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-ws-connections'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('low');
+  });
+
+  it('reports WS configured but no connection', async () => {
+    const config = makeConfig({ integrations: [{ name: 'websocket' }] });
+    const agent = createAgent(config);
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('ws-configured-no-connection'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('medium');
+  });
+
+  it('registers websocket event listener', async () => {
+    const agent = createAgent();
+    await agent.run();
+    expect(currentMockPage.on).toHaveBeenCalledWith('websocket', expect.any(Function));
+  });
+
+  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('closes browser in finally', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  it('detects WS errors from event handler', async () => {
+    currentMockPage.on.mockImplementation((event: string, handler: Function) => {
+      if (event === 'websocket') {
+        const mockWs = {
+          url: () => 'ws://localhost:3000/ws',
+          on: (evt: string, cb: Function) => {
+            if (evt === 'socketerror') cb('Error');
+          },
+        };
+        handler(mockWs);
+      }
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('ws-error'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('medium');
+  });
+
+  it('no credentials continues', async () => {
+    const config = makeConfig({ auth: { loginUrl: '/login', credentials: {} } });
+    const agent = createAgent(config);
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+
+  it('handles nav failure for module', async () => {
+    currentMockPage.goto.mockRejectedValue(new Error('Nav failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    // Should not crash, just skip module
+    expect(result.status).toBeDefined();
+  });
+});

package/agents/__tests__/55-realtime-sync-tester.test.ts

@@ -0,0 +1,181 @@
+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 makeMockLocator(countVal = 0) {
+  const loc: Record<string, ReturnType<typeof vi.fn>> = {
+    count: vi.fn().mockResolvedValue(countVal),
+    first: vi.fn(),
+    nth: vi.fn(),
+    fill: vi.fn().mockResolvedValue(undefined),
+    click: vi.fn().mockResolvedValue(undefined),
+  };
+  loc.first.mockReturnValue(loc);
+  loc.nth.mockReturnValue(loc);
+  return loc;
+}
+
+function makeMockPage() {
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue(5),
+    locator: vi.fn().mockReturnValue(makeMockLocator(0)),
+    on: vi.fn(),
+  };
+}
+
+let mockPage1: ReturnType<typeof makeMockPage>;
+let mockPage2: ReturnType<typeof makeMockPage>;
+let mockContext1: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+let mockContext2: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+let contextCallCount: number;
+let mockBrowser: { newContext: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: { launch: vi.fn().mockImplementation(async () => mockBrowser) },
+}));
+
+const { RealtimeSyncTesterAgent } = await import('../55-realtime-sync-tester');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new RealtimeSyncTesterAgent(config, phase, '/tmp/test-run');
+}
+
+describe('RealtimeSyncTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+    mockPage1 = makeMockPage();
+    mockPage2 = makeMockPage();
+    contextCallCount = 0;
+    mockContext1 = { newPage: vi.fn().mockResolvedValue(mockPage1), close: vi.fn().mockResolvedValue(undefined) };
+    mockContext2 = { newPage: vi.fn().mockResolvedValue(mockPage2), close: vi.fn().mockResolvedValue(undefined) };
+    mockBrowser = {
+      newContext: vi.fn().mockImplementation(async () => {
+        contextCallCount++;
+        return contextCallCount === 1 ? mockContext1 : mockContext2;
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('has agentId 55 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(55);
+    expect(agent.agentName).toBe('Realtime Sync Tester');
+  });
+
+  it('throws when modules empty', async () => {
+    const agent = createAgent(makeConfig({ modules: [] }));
+    const result = await agent.run();
+    expect(result.status).toBe('failed');
+  });
+
+  it('reports no credentials when none configured', async () => {
+    const config = makeConfig({ auth: { loginUrl: '/login', credentials: {} } });
+    const agent = createAgent(config);
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-credentials'));
+    expect(finding).toBeDefined();
+  });
+
+  it('reports no create button when none found', async () => {
+    mockPage1.locator.mockReturnValue(makeMockLocator(0));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-create-button'));
+    expect(finding).toBeDefined();
+  });
+
+  it('reports no realtime sync when item not visible', async () => {
+    mockPage1.locator.mockReturnValue(makeMockLocator(1));
+    mockPage1.evaluate.mockResolvedValue(5);
+    mockPage2.evaluate.mockResolvedValue(5); // same count — no sync
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-realtime-sync'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('low');
+  });
+
+  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 nav failure', async () => {
+    mockPage1.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', 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('closes browser in finally', async () => {
+    mockBrowser.newContext.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  it('handles create action failure', async () => {
+    const createLocator = makeMockLocator(1);
+    createLocator.first.mockReturnValue({
+      click: vi.fn().mockRejectedValue(new Error('Click failed')),
+    });
+    mockPage1.locator.mockReturnValue(createLocator);
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('create-failed'));
+    expect(finding).toBeDefined();
+  });
+
+  it('creates two browser contexts', async () => {
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.newContext).toHaveBeenCalledTimes(2);
+  });
+});