@avi770/testteam 3.0.0 → 3.2.0

package/helpers/__tests__/api-client.test.ts

@@ -1,199 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { ApiClient } from '../api-client';
-import type { ApiResponse } from '../api-client';
-
-// ---------------------------------------------------------------------------
-// fetch mock helpers
-// ---------------------------------------------------------------------------
-
-function makeFetchResponse(
-  status: number,
-  body: unknown,
-  headers: Record<string, string> = {},
-): Response {
-  const responseHeaders = new Headers({
-    'content-type': 'application/json',
-    ...headers,
-  });
-
-  return {
-    status,
-    headers: responseHeaders,
-    json: async () => body,
-    text: async () => JSON.stringify(body),
-  } as unknown as Response;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('ApiClient', () => {
-  beforeEach(() => {
-    vi.stubGlobal('fetch', vi.fn());
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  describe('Authorization header', () => {
-    it('includes Bearer token in GET requests when token is provided', async () => {
-      const mockFetch = vi.mocked(fetch);
-      mockFetch.mockResolvedValueOnce(makeFetchResponse(200, { ok: true }));
-
-      const client = new ApiClient('https://api.example.com', 'my-jwt-token');
-      await client.get('/api/data');
-
-      expect(mockFetch).toHaveBeenCalledOnce();
-      const [, init] = mockFetch.mock.calls[0];
-      const headers = init?.headers as Record<string, string>;
-      expect(headers['Authorization']).toBe('Bearer my-jwt-token');
-    });
-
-    it('omits Authorization header when no token is provided', async () => {
-      const mockFetch = vi.mocked(fetch);
-      mockFetch.mockResolvedValueOnce(makeFetchResponse(200, {}));
-
-      const client = new ApiClient('https://api.example.com');
-      await client.get('/api/public');
-
-      const [, init] = mockFetch.mock.calls[0];
-      const headers = init?.headers as Record<string, string>;
-      expect(headers['Authorization']).toBeUndefined();
-    });
-
-    it('includes Bearer token in POST requests', async () => {
-      const mockFetch = vi.mocked(fetch);
-      mockFetch.mockResolvedValueOnce(makeFetchResponse(201, { id: 1 }));
-
-      const client = new ApiClient('https://api.example.com', 'post-token');
-      await client.post('/api/items', { name: 'test' });
-
-      const [, init] = mockFetch.mock.calls[0];
-      const headers = init?.headers as Record<string, string>;
-      expect(headers['Authorization']).toBe('Bearer post-token');
-    });
-
-    it('includes Bearer token in PUT requests', async () => {
-      const mockFetch = vi.mocked(fetch);
-      mockFetch.mockResolvedValueOnce(makeFetchResponse(200, { updated: true }));
-
-      const client = new ApiClient('https://api.example.com', 'put-token');
-      await client.put('/api/items/1', { name: 'updated' });
-
-      const [, init] = mockFetch.mock.calls[0];
-      const headers = init?.headers as Record<string, string>;
-      expect(headers['Authorization']).toBe('Bearer put-token');
-    });
-
-    it('includes Bearer token in DELETE requests', async () => {
-      const mockFetch = vi.mocked(fetch);
-      mockFetch.mockResolvedValueOnce(makeFetchResponse(204, null));
-
-      const client = new ApiClient('https://api.example.com', 'delete-token');
-      await client.delete('/api/items/1');
-
-      const [, init] = mockFetch.mock.calls[0];
-      const headers = init?.headers as Record<string, string>;
-      expect(headers['Authorization']).toBe('Bearer delete-token');
-    });
-  });
-
-  describe('response timing', () => {
-    it('records a non-negative durationMs', async () => {
-      const mockFetch = vi.mocked(fetch);
-      mockFetch.mockResolvedValueOnce(makeFetchResponse(200, {}));
-
-      const client = new ApiClient('https://api.example.com');
-      const response: ApiResponse = await client.get('/api/ping');
-
-      expect(response.durationMs).toBeGreaterThanOrEqual(0);
-      expect(typeof response.durationMs).toBe('number');
-    });
-  });
-
-  describe('response shape', () => {
-    it('returns status, body, headers, and durationMs', async () => {
-      const mockFetch = vi.mocked(fetch);
-      mockFetch.mockResolvedValueOnce(
-        makeFetchResponse(200, { message: 'hello' }, { 'x-request-id': 'abc123' }),
-      );
-
-      const client = new ApiClient('https://api.example.com');
-      const response = await client.get('/api/hello');
-
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual({ message: 'hello' });
-      expect(response.headers).toHaveProperty('content-type');
-      expect(typeof response.durationMs).toBe('number');
-    });
-  });
-
-  describe('HTTP methods', () => {
-    it('uses GET method for get()', async () => {
-      vi.mocked(fetch).mockResolvedValueOnce(makeFetchResponse(200, {}));
-      const client = new ApiClient('https://api.example.com');
-      await client.get('/api/test');
-      const [, init] = vi.mocked(fetch).mock.calls[0];
-      expect(init?.method).toBe('GET');
-    });
-
-    it('uses POST method and sends JSON body for post()', async () => {
-      vi.mocked(fetch).mockResolvedValueOnce(makeFetchResponse(201, {}));
-      const client = new ApiClient('https://api.example.com');
-      await client.post('/api/test', { key: 'value' });
-      const [, init] = vi.mocked(fetch).mock.calls[0];
-      expect(init?.method).toBe('POST');
-      expect(init?.body).toBe(JSON.stringify({ key: 'value' }));
-    });
-
-    it('uses PUT method for put()', async () => {
-      vi.mocked(fetch).mockResolvedValueOnce(makeFetchResponse(200, {}));
-      const client = new ApiClient('https://api.example.com');
-      await client.put('/api/test/1', { updated: true });
-      const [, init] = vi.mocked(fetch).mock.calls[0];
-      expect(init?.method).toBe('PUT');
-    });
-
-    it('uses DELETE method for delete()', async () => {
-      vi.mocked(fetch).mockResolvedValueOnce(makeFetchResponse(204, null));
-      const client = new ApiClient('https://api.example.com');
-      await client.delete('/api/test/1');
-      const [, init] = vi.mocked(fetch).mock.calls[0];
-      expect(init?.method).toBe('DELETE');
-    });
-  });
-
-  describe('createAuthenticated()', () => {
-    it('returns an authenticated client when login succeeds with access_token', async () => {
-      const mockFetch = vi.mocked(fetch);
-      mockFetch.mockResolvedValueOnce(
-        makeFetchResponse(200, { access_token: 'jwt-abc' }),
-      );
-
-      const client = await ApiClient.createAuthenticated('https://api.example.com', {
-        email: 'user@example.com',
-        password: 'secret',
-      });
-
-      // Verify the token is used on the next request
-      mockFetch.mockResolvedValueOnce(makeFetchResponse(200, {}));
-      await client.get('/api/me');
-      const [, init] = mockFetch.mock.calls[1];
-      const headers = init?.headers as Record<string, string>;
-      expect(headers['Authorization']).toBe('Bearer jwt-abc');
-    });
-
-    it('throws when the login response contains no token', async () => {
-      vi.mocked(fetch).mockResolvedValueOnce(makeFetchResponse(401, { error: 'Unauthorized' }));
-
-      await expect(
-        ApiClient.createAuthenticated('https://api.example.com', {
-          email: 'bad@example.com',
-          password: 'wrong',
-        }),
-      ).rejects.toThrow(/Authentication failed/);
-    });
-  });
-});

package/helpers/__tests__/element-discovery.test.ts

@@ -1,202 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import {
-  classifyAsDestructive,
-  discoverInteractiveElements,
-} from '../element-discovery';
-import type { DiscoveredElement } from '../element-discovery';
-import type { Page } from 'playwright';
-
-// ---------------------------------------------------------------------------
-// classifyAsDestructive
-// ---------------------------------------------------------------------------
-
-describe('classifyAsDestructive(text)', () => {
-  it('returns true for "Delete client"', () => {
-    expect(classifyAsDestructive('Delete client')).toBe(true);
-  });
-
-  it('returns false for "Save changes"', () => {
-    expect(classifyAsDestructive('Save changes')).toBe(false);
-  });
-
-  it('returns true for "Remove item"', () => {
-    expect(classifyAsDestructive('Remove item')).toBe(true);
-  });
-
-  it('returns true for "Archive"', () => {
-    expect(classifyAsDestructive('Archive')).toBe(true);
-  });
-
-  it('returns true for "Clear all"', () => {
-    expect(classifyAsDestructive('Clear all')).toBe(true);
-  });
-
-  it('returns true for "destroy"', () => {
-    expect(classifyAsDestructive('destroy')).toBe(true);
-  });
-
-  it('returns true for "Reset password" (case-insensitive)', () => {
-    expect(classifyAsDestructive('Reset password')).toBe(true);
-  });
-
-  it('returns false for "Submit"', () => {
-    expect(classifyAsDestructive('Submit')).toBe(false);
-  });
-
-  it('returns false for an empty string', () => {
-    expect(classifyAsDestructive('')).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// discoverInteractiveElements — mock page
-// ---------------------------------------------------------------------------
-
-type EvaluateFn = (selector: string) => Array<{
-  tag: string;
-  role: string;
-  text: string;
-  ariaLabel: string | null;
-  testId: string | null;
-}>;
-
-function makeMockPage(evaluateResult: ReturnType<EvaluateFn>): Page {
-  return {
-    evaluate: vi.fn().mockResolvedValue(evaluateResult),
-  } as unknown as Page;
-}
-
-describe('discoverInteractiveElements(page)', () => {
-  it('returns a button element with correct type and selector', async () => {
-    const page = makeMockPage([
-      { tag: 'button', role: '', text: 'Save changes', ariaLabel: null, testId: null },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results).toHaveLength(1);
-    expect(results[0]?.type).toBe('button');
-    expect(results[0]?.isDestructive).toBe(false);
-    expect(results[0]?.selector).toContain('button');
-  });
-
-  it('returns a link element with type "link"', async () => {
-    const page = makeMockPage([
-      { tag: 'a', role: '', text: 'Go to dashboard', ariaLabel: null, testId: null },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results[0]?.type).toBe('link');
-  });
-
-  it('classifies a delete button as destructive', async () => {
-    const page = makeMockPage([
-      { tag: 'button', role: '', text: 'Delete client', ariaLabel: null, testId: null },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results[0]?.isDestructive).toBe(true);
-  });
-
-  it('prefers data-testid selector when present', async () => {
-    const page = makeMockPage([
-      { tag: 'button', role: '', text: 'Submit', ariaLabel: null, testId: 'submit-btn' },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results[0]?.selector).toBe('[data-testid="submit-btn"]');
-  });
-
-  it('falls back to aria-label selector when no data-testid', async () => {
-    const page = makeMockPage([
-      { tag: 'button', role: '', text: '', ariaLabel: 'Close dialog', testId: null },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results[0]?.selector).toBe('[aria-label="Close dialog"]');
-    expect(results[0]?.ariaLabel).toBe('Close dialog');
-  });
-
-  it('classifies role="tab" elements with type "tab"', async () => {
-    const page = makeMockPage([
-      { tag: 'div', role: 'tab', text: 'Overview', ariaLabel: null, testId: null },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results[0]?.type).toBe('tab');
-  });
-
-  it('classifies role="menuitem" elements with type "menuitem"', async () => {
-    const page = makeMockPage([
-      { tag: 'li', role: 'menuitem', text: 'Profile', ariaLabel: null, testId: null },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results[0]?.type).toBe('menuitem');
-  });
-
-  it('classifies input elements with type "input"', async () => {
-    const page = makeMockPage([
-      { tag: 'input', role: '', text: '', ariaLabel: 'Email', testId: null },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results[0]?.type).toBe('input');
-  });
-
-  it('deduplicates elements that resolve to the same selector', async () => {
-    const page = makeMockPage([
-      { tag: 'button', role: '', text: 'Save', ariaLabel: null, testId: 'save-btn' },
-      { tag: 'button', role: '', text: 'Save', ariaLabel: null, testId: 'save-btn' },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results).toHaveLength(1);
-  });
-
-  it('returns multiple distinct elements', async () => {
-    const page = makeMockPage([
-      { tag: 'button', role: '', text: 'Add client', ariaLabel: null, testId: 'add-client' },
-      { tag: 'button', role: '', text: 'Delete client', ariaLabel: null, testId: 'delete-client' },
-      { tag: 'a', role: '', text: 'Home', ariaLabel: null, testId: null },
-    ]);
-
-    const results: DiscoveredElement[] = await discoverInteractiveElements(page);
-
-    expect(results).toHaveLength(3);
-
-    const deleteEl = results.find((r) => r.selector === '[data-testid="delete-client"]');
-    expect(deleteEl?.isDestructive).toBe(true);
-
-    const addEl = results.find((r) => r.selector === '[data-testid="add-client"]');
-    expect(addEl?.isDestructive).toBe(false);
-  });
-
-  it('uses tag:text() selector as last resort', async () => {
-    const page = makeMockPage([
-      { tag: 'button', role: '', text: 'Confirm', ariaLabel: null, testId: null },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results[0]?.selector).toBe('button:text("Confirm")');
-  });
-
-  it('uses bare tag selector when there is no text, aria-label, or testId', async () => {
-    const page = makeMockPage([
-      { tag: 'button', role: '', text: '', ariaLabel: null, testId: null },
-    ]);
-
-    const results = await discoverInteractiveElements(page);
-
-    expect(results[0]?.selector).toBe('button');
-  });
-});

package/helpers/__tests__/form-filler-extended.test.ts

@@ -1,212 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { fillForm, generateTestValue } from '../form-filler';
-
-// ---------------------------------------------------------------------------
-// Mock Playwright Page
-// ---------------------------------------------------------------------------
-
-interface MockElement {
-  getAttribute: ReturnType<typeof vi.fn>;
-  fill: ReturnType<typeof vi.fn>;
-  isChecked: ReturnType<typeof vi.fn>;
-  check: ReturnType<typeof vi.fn>;
-}
-
-function makeElement(overrides: Partial<Record<string, unknown>> = {}): MockElement {
-  return {
-    getAttribute: vi.fn().mockImplementation((attr: string) => {
-      if (attr === 'name') return overrides.name ?? '';
-      if (attr === 'type') return overrides.type ?? 'text';
-      return null;
-    }),
-    fill: vi.fn().mockResolvedValue(undefined),
-    isChecked: vi.fn().mockResolvedValue(overrides.checked ?? false),
-    check: vi.fn().mockResolvedValue(undefined),
-  };
-}
-
-function makeMockPage(inputs: MockElement[] = [], textareas: MockElement[] = []) {
-  return {
-    $$: vi.fn().mockImplementation((selector: string) => {
-      if (selector.includes('textarea')) return Promise.resolve(textareas);
-      return Promise.resolve(inputs);
-    }),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// fillForm tests — uncovered branches
-// ---------------------------------------------------------------------------
-
-describe('fillForm()', () => {
-  it('fills nothing when no inputs or textareas exist (empty form)', async () => {
-    const page = makeMockPage([], []);
-    await fillForm(page as never, 'form');
-
-    expect(page.$$).toHaveBeenCalledTimes(2);
-  });
-
-  it('uses testData values when field name matches a key', async () => {
-    const input = makeElement({ name: 'companyName', type: 'text' });
-    const page = makeMockPage([input]);
-
-    await fillForm(page as never, 'form', { companyName: 'Acme Inc' });
-
-    expect(input.fill).toHaveBeenCalledWith('Acme Inc');
-  });
-
-  it('auto-generates value when testData is provided but field name does not match', async () => {
-    const input = makeElement({ name: 'otherField', type: 'text' });
-    const page = makeMockPage([input]);
-
-    await fillForm(page as never, 'form', { differentKey: 'value' });
-
-    // Should have called fill with an auto-generated value, not the testData value
-    expect(input.fill).toHaveBeenCalledTimes(1);
-    const filledValue = input.fill.mock.calls[0][0] as string;
-    expect(filledValue).toMatch(/^Test Value /);
-  });
-
-  it('checks unchecked checkboxes', async () => {
-    const checkbox = makeElement({ name: 'agree', type: 'checkbox', checked: false });
-    const page = makeMockPage([checkbox]);
-
-    await fillForm(page as never, 'form');
-
-    expect(checkbox.isChecked).toHaveBeenCalled();
-    expect(checkbox.check).toHaveBeenCalled();
-  });
-
-  it('does not check already-checked checkboxes', async () => {
-    const checkbox = makeElement({ name: 'agree', type: 'checkbox', checked: true });
-    const page = makeMockPage([checkbox]);
-
-    await fillForm(page as never, 'form');
-
-    expect(checkbox.isChecked).toHaveBeenCalled();
-    expect(checkbox.check).not.toHaveBeenCalled();
-  });
-
-  it('checks unchecked radio buttons', async () => {
-    const radio = makeElement({ name: 'size', type: 'radio', checked: false });
-    const page = makeMockPage([radio]);
-
-    await fillForm(page as never, 'form');
-
-    expect(radio.check).toHaveBeenCalled();
-  });
-
-  it('skips already-checked radio buttons', async () => {
-    const radio = makeElement({ name: 'size', type: 'radio', checked: true });
-    const page = makeMockPage([radio]);
-
-    await fillForm(page as never, 'form');
-
-    expect(radio.check).not.toHaveBeenCalled();
-  });
-
-  it('fills textareas with testData when name matches', async () => {
-    const textarea = makeElement({ name: 'notes' });
-    const page = makeMockPage([], [textarea]);
-
-    await fillForm(page as never, 'form', { notes: 'Some important notes' });
-
-    expect(textarea.fill).toHaveBeenCalledWith('Some important notes');
-  });
-
-  it('fills textareas with auto-generated value when no testData matches', async () => {
-    const textarea = makeElement({ name: 'description' });
-    const page = makeMockPage([], [textarea]);
-
-    await fillForm(page as never, 'form');
-
-    expect(textarea.fill).toHaveBeenCalledTimes(1);
-    const filledValue = textarea.fill.mock.calls[0][0] as string;
-    expect(filledValue).toMatch(/^Test textarea value /);
-  });
-
-  it('fills textareas with auto-generated value when testData is provided but key does not match', async () => {
-    const textarea = makeElement({ name: 'bio' });
-    const page = makeMockPage([], [textarea]);
-
-    await fillForm(page as never, 'form', { differentKey: 'x' });
-
-    const filledValue = textarea.fill.mock.calls[0][0] as string;
-    expect(filledValue).toMatch(/^Test textarea value /);
-  });
-
-  it('handles inputs with empty name attribute', async () => {
-    const input = makeElement({ name: '', type: 'text' });
-    const page = makeMockPage([input]);
-
-    // testData provided but name is empty — should not match any key, falls through to generateTestValue
-    await fillForm(page as never, 'form', { someKey: 'val' });
-
-    expect(input.fill).toHaveBeenCalledTimes(1);
-    const filledValue = input.fill.mock.calls[0][0] as string;
-    expect(filledValue).toMatch(/^Test Value /);
-  });
-
-  it('handles inputs with null name and type attributes', async () => {
-    const input: MockElement = {
-      getAttribute: vi.fn().mockReturnValue(null),
-      fill: vi.fn().mockResolvedValue(undefined),
-      isChecked: vi.fn().mockResolvedValue(false),
-      check: vi.fn().mockResolvedValue(undefined),
-    };
-    const page = makeMockPage([input]);
-
-    await fillForm(page as never, 'form');
-
-    // Should use default type 'text' and empty name, producing a generic value
-    expect(input.fill).toHaveBeenCalledTimes(1);
-  });
-
-  it('handles multiple inputs in a single form', async () => {
-    const emailInput = makeElement({ name: 'email', type: 'email' });
-    const phoneInput = makeElement({ name: 'phone', type: 'tel' });
-    const numberInput = makeElement({ name: 'quantity', type: 'number' });
-    const page = makeMockPage([emailInput, phoneInput, numberInput]);
-
-    await fillForm(page as never, 'form');
-
-    expect(emailInput.fill).toHaveBeenCalledTimes(1);
-    expect(phoneInput.fill).toHaveBeenCalledTimes(1);
-    expect(numberInput.fill).toHaveBeenCalledWith('100');
-  });
-
-  it('uses testData for textarea when provided and name matches', async () => {
-    const textarea = makeElement({ name: 'comment' });
-    const page = makeMockPage([], [textarea]);
-
-    await fillForm(page as never, '#my-form', { comment: 'Great product!' });
-
-    expect(textarea.fill).toHaveBeenCalledWith('Great product!');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Edge cases for generateTestValue
-// ---------------------------------------------------------------------------
-
-describe('generateTestValue() edge cases', () => {
-  it('handles uppercase field names (EMAIL)', () => {
-    const value = generateTestValue('text', 'EMAIL');
-    expect(value).toMatch(/^test-[a-z0-9]+@example\.com$/);
-  });
-
-  it('handles mixed case (PhoneNumber)', () => {
-    const value = generateTestValue('text', 'PhoneNumber');
-    expect(value).toMatch(/^\+61 400 \d{6}$/);
-  });
-
-  it('handles ABN in camelCase (clientAbn)', () => {
-    const value = generateTestValue('text', 'clientAbn');
-    expect(value).toMatch(/^\d{11}$/);
-  });
-
-  it('handles date in various positions (startDate, dateOfBirth)', () => {
-    expect(generateTestValue('text', 'startDate')).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-    expect(generateTestValue('text', 'dateOfBirth')).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-  });
-});