@avi770/testteam 1.2.0

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

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

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

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { generateTestValue } from '../form-filler';
+
+describe('generateTestValue(inputType, inputName)', () => {
+  describe('email pattern', () => {
+    it('generates a valid email when name contains "email"', () => {
+      const value = generateTestValue('text', 'email');
+      expect(value).toMatch(/^test-[a-z0-9]+@example\.com$/);
+    });
+
+    it('generates a valid email for "userEmail" field name', () => {
+      const value = generateTestValue('email', 'userEmail');
+      expect(value).toMatch(/^test-[a-z0-9]+@example\.com$/);
+    });
+
+    it('generates unique emails on successive calls', () => {
+      const a = generateTestValue('text', 'email');
+      const b = generateTestValue('text', 'email');
+      // Very unlikely to collide with 36^6 space
+      expect(a).not.toBe(b);
+    });
+  });
+
+  describe('phone pattern', () => {
+    it('generates an Australian mobile number when name contains "phone"', () => {
+      const value = generateTestValue('text', 'phone');
+      expect(value).toMatch(/^\+61 400 \d{6}$/);
+    });
+
+    it('matches "phoneNumber" field name', () => {
+      const value = generateTestValue('tel', 'phoneNumber');
+      expect(value).toMatch(/^\+61 400 \d{6}$/);
+    });
+  });
+
+  describe('ABN pattern', () => {
+    it('generates an 11-digit string when name contains "abn"', () => {
+      const value = generateTestValue('text', 'abn');
+      expect(value).toMatch(/^\d{11}$/);
+    });
+
+    it('generates a valid ABN (checksum passes)', () => {
+      const value = generateTestValue('text', 'abn');
+      const weights = [10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+      const digits = value.split('').map(Number);
+      digits[0] -= 1;
+      const sum = digits.reduce((acc, d, i) => acc + d * weights[i], 0);
+      expect(sum % 89).toBe(0);
+    });
+
+    it('matches "companyAbn" field name', () => {
+      const value = generateTestValue('text', 'companyAbn');
+      expect(value).toMatch(/^\d{11}$/);
+    });
+  });
+
+  describe('date pattern', () => {
+    it('generates an ISO date string when name contains "date"', () => {
+      const value = generateTestValue('text', 'date');
+      expect(value).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    });
+
+    it('generates a date approximately 30 days in the future', () => {
+      const value = generateTestValue('date', 'dueDate');
+      const generated = new Date(value).getTime();
+      const now = Date.now();
+      const days28 = 28 * 24 * 60 * 60 * 1000;
+      const days32 = 32 * 24 * 60 * 60 * 1000;
+      expect(generated).toBeGreaterThan(now + days28);
+      expect(generated).toBeLessThan(now + days32);
+    });
+  });
+
+  describe('number type', () => {
+    it('returns "100" when input type is "number"', () => {
+      const value = generateTestValue('number', 'quantity');
+      expect(value).toBe('100');
+    });
+
+    it('does not use number path when name contains email despite type=number', () => {
+      // email name takes priority over type=number
+      const value = generateTestValue('number', 'email');
+      expect(value).toMatch(/^test-[a-z0-9]+@example\.com$/);
+    });
+  });
+
+  describe('default fallback', () => {
+    it('returns "Test Value {random}" for an unrecognised field', () => {
+      const value = generateTestValue('text', 'description');
+      expect(value).toMatch(/^Test Value [a-z0-9]+$/);
+    });
+
+    it('generates unique values on successive calls', () => {
+      const a = generateTestValue('text', 'notes');
+      const b = generateTestValue('text', 'notes');
+      expect(a).not.toBe(b);
+    });
+  });
+});

package/helpers/__tests__/modal-handler.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, vi } from 'vitest';
+import { openModal, closeModal, isModalOpen } from '../modal-handler';
+import type { Page, Locator } from 'playwright';
+
+// ---------------------------------------------------------------------------
+// Mock builder helpers
+// ---------------------------------------------------------------------------
+
+/** Creates a mock Locator that reports visible or not. */
+function makeLocator(visible: boolean): Locator {
+  return {
+    isVisible: vi.fn().mockResolvedValue(visible),
+    click: vi.fn().mockResolvedValue(undefined),
+  } as unknown as Locator;
+}
+
+/** Creates a minimal mock Page. */
+function makePage(options: {
+  selectorVisible?: boolean;
+  clickError?: boolean;
+  waitForSelectorError?: boolean;
+}): Page {
+  const { selectorVisible = true, clickError = false, waitForSelectorError = false } = options;
+
+  const locator = makeLocator(selectorVisible);
+
+  return {
+    click: clickError
+      ? vi.fn().mockRejectedValue(new Error('Element not found'))
+      : vi.fn().mockResolvedValue(undefined),
+    waitForSelector: waitForSelectorError
+      ? vi.fn().mockRejectedValue(new Error('Timeout'))
+      : vi.fn().mockResolvedValue(undefined),
+    locator: vi.fn().mockReturnValue(locator),
+    keyboard: {
+      press: vi.fn().mockResolvedValue(undefined),
+    },
+    waitForTimeout: vi.fn().mockResolvedValue(undefined),
+  } as unknown as Page;
+}
+
+// ---------------------------------------------------------------------------
+// isModalOpen()
+// ---------------------------------------------------------------------------
+
+describe('isModalOpen(page)', () => {
+  it('returns true when a modal selector is visible', async () => {
+    const page = makePage({ selectorVisible: true });
+    const result = await isModalOpen(page);
+    expect(result).toBe(true);
+  });
+
+  it('returns false when no modal selector is visible', async () => {
+    const invisibleLocator = makeLocator(false);
+    const page = {
+      locator: vi.fn().mockReturnValue(invisibleLocator),
+    } as unknown as Page;
+
+    const result = await isModalOpen(page);
+    expect(result).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// openModal()
+// ---------------------------------------------------------------------------
+
+describe('openModal(page, triggerSelector)', () => {
+  it('returns true when modal becomes visible after click', async () => {
+    const page = makePage({ selectorVisible: true, waitForSelectorError: false });
+    const result = await openModal(page, '#open-modal-btn');
+
+    expect(result).toBe(true);
+    expect(page.click).toHaveBeenCalledWith('#open-modal-btn');
+  });
+
+  it('returns false when no modal selector becomes visible', async () => {
+    const page = makePage({ selectorVisible: false, waitForSelectorError: true });
+    const result = await openModal(page, '#open-modal-btn');
+
+    expect(result).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// closeModal()
+// ---------------------------------------------------------------------------
+
+describe('closeModal(page, method)', () => {
+  describe('x-button method', () => {
+    it('clicks the close button and returns true when modal is gone', async () => {
+      // After close, modal is no longer visible
+      const closedLocator = makeLocator(false);
+      const visibleLocator = makeLocator(true);
+
+      let callCount = 0;
+      const page = {
+        locator: vi.fn().mockImplementation(() => {
+          // First call returns visible close button, subsequent calls return invisible modal
+          callCount++;
+          return callCount === 1 ? visibleLocator : closedLocator;
+        }),
+        keyboard: { press: vi.fn() },
+        waitForTimeout: vi.fn().mockResolvedValue(undefined),
+      } as unknown as Page;
+
+      const result = await closeModal(page, 'x-button');
+      expect(visibleLocator.click).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('escape method', () => {
+    it('presses Escape and returns true when modal closes', async () => {
+      // Modal not visible after Escape
+      const closedLocator = makeLocator(false);
+      const page = {
+        locator: vi.fn().mockReturnValue(closedLocator),
+        keyboard: { press: vi.fn().mockResolvedValue(undefined) },
+        waitForTimeout: vi.fn().mockResolvedValue(undefined),
+      } as unknown as Page;
+
+      const result = await closeModal(page, 'escape');
+
+      expect(page.keyboard.press).toHaveBeenCalledWith('Escape');
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('overlay method', () => {
+    it('clicks the overlay and returns true when modal closes', async () => {
+      // Visible on first check (overlay present), invisible afterwards (modal closed)
+      let locatorCallCount = 0;
+      const visibleLocator = makeLocator(true);
+      const closedLocator = makeLocator(false);
+
+      const page = {
+        locator: vi.fn().mockImplementation(() => {
+          locatorCallCount++;
+          return locatorCallCount === 1 ? visibleLocator : closedLocator;
+        }),
+        keyboard: { press: vi.fn() },
+        waitForTimeout: vi.fn().mockResolvedValue(undefined),
+      } as unknown as Page;
+
+      const result = await closeModal(page, 'overlay');
+
+      expect(visibleLocator.click).toHaveBeenCalledWith({ position: { x: 1, y: 1 } });
+      expect(result).toBe(true);
+    });
+  });
+});

package/helpers/__tests__/navigation.test.ts

@@ -0,0 +1,214 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { Page } from 'playwright';
+import { login, navigateToSection, waitForSectionLoad, switchPortal } from '../navigation';
+
+// ---------------------------------------------------------------------------
+// Mock Page factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a minimal Playwright Page mock that satisfies the calls made by the
+ * navigation helpers.  All methods are jest/vitest spies so callers can assert
+ * on them.
+ */
+function makeMockPage(overrides: Partial<Record<string, ReturnType<typeof vi.fn>>> = {}): Page {
+  return {
+    goto: vi.fn().mockResolvedValue(null),
+    fill: vi.fn().mockResolvedValue(null),
+    click: vi.fn().mockResolvedValue(null),
+    waitForNavigation: vi.fn().mockResolvedValue(null),
+    waitForURL: vi.fn().mockResolvedValue(null),
+    waitForSelector: vi.fn().mockResolvedValue(null),
+    url: vi.fn().mockReturnValue('https://app.example.com/dashboard'),
+    ...overrides,
+  } as unknown as Page;
+}
+
+// ---------------------------------------------------------------------------
+// Test config fixture
+// ---------------------------------------------------------------------------
+
+const TEST_CONFIG = {
+  modules: [
+    { id: 'dashboard', route: '/dashboard' },
+    { id: 'invoices', route: '/invoices' },
+    { id: 'reports', route: '/reports' },
+  ],
+};
+
+// ---------------------------------------------------------------------------
+// login()
+// ---------------------------------------------------------------------------
+
+describe('login(page, credentials, loginUrl)', () => {
+  let page: Page;
+
+  beforeEach(() => {
+    page = makeMockPage();
+  });
+
+  it('navigates to the provided loginUrl', async () => {
+    await login(page, { email: 'user@example.com', password: 'secret' }, 'https://app.example.com/login');
+    expect(page.goto).toHaveBeenCalledWith('https://app.example.com/login', { waitUntil: 'domcontentloaded', timeout: 10000 });
+  });
+
+  it('fills the email input', async () => {
+    await login(page, { email: 'admin@example.com', password: 'pw' }, 'https://app.example.com/login');
+    expect(page.fill).toHaveBeenCalledWith(
+      expect.stringContaining('email'),
+      'admin@example.com',
+    );
+  });
+
+  it('fills the password input', async () => {
+    await login(page, { email: 'u@e.com', password: 'hunter2' }, 'https://app.example.com/login');
+    expect(page.fill).toHaveBeenCalledWith(
+      expect.stringContaining('password'),
+      'hunter2',
+    );
+  });
+
+  it('clicks the submit button', async () => {
+    await login(page, { email: 'u@e.com', password: 'pw' }, 'https://app.example.com/login');
+    expect(page.click).toHaveBeenCalledWith(expect.stringContaining('submit'));
+  });
+
+  it('waits for URL change after clicking submit', async () => {
+    await login(page, { email: 'u@e.com', password: 'pw' }, 'https://app.example.com/login');
+    expect(page.waitForURL).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// navigateToSection()
+// ---------------------------------------------------------------------------
+
+describe('navigateToSection(page, moduleId, config)', () => {
+  let page: Page;
+
+  beforeEach(() => {
+    page = makeMockPage();
+  });
+
+  it('navigates to the correct route for a known moduleId', async () => {
+    await navigateToSection(page, 'invoices', TEST_CONFIG);
+    expect(page.goto).toHaveBeenCalledWith('https://app.example.com/invoices');
+  });
+
+  it('navigates to the correct route for a different known moduleId', async () => {
+    await navigateToSection(page, 'reports', TEST_CONFIG);
+    expect(page.goto).toHaveBeenCalledWith('https://app.example.com/reports');
+  });
+
+  it('throws when moduleId is not found in config', async () => {
+    await expect(
+      navigateToSection(page, 'nonexistent-module', TEST_CONFIG),
+    ).rejects.toThrow('nonexistent-module');
+  });
+
+  it('error message lists available module ids when moduleId is not found', async () => {
+    await expect(
+      navigateToSection(page, 'missing', TEST_CONFIG),
+    ).rejects.toThrow(/dashboard.*invoices.*reports/);
+  });
+
+  it('calls waitForSectionLoad after navigating (waitForSelector is invoked)', async () => {
+    await navigateToSection(page, 'dashboard', TEST_CONFIG);
+    // waitForSectionLoad iterates over loading selectors — at least one call expected
+    expect(page.waitForSelector).toHaveBeenCalled();
+  });
+
+  it('does not call goto when moduleId is missing', async () => {
+    await expect(
+      navigateToSection(page, 'bad-id', TEST_CONFIG),
+    ).rejects.toThrow();
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// waitForSectionLoad()
+// ---------------------------------------------------------------------------
+
+describe('waitForSectionLoad(page, timeout?)', () => {
+  let page: Page;
+
+  beforeEach(() => {
+    page = makeMockPage();
+  });
+
+  it('calls waitForSelector for each loading indicator selector', async () => {
+    await waitForSectionLoad(page);
+    // Must poll for spinners and skeletons — expect multiple selector checks
+    expect(page.waitForSelector).toHaveBeenCalledTimes(5);
+  });
+
+  it('passes state "hidden" so the wait resolves when the spinner disappears', async () => {
+    await waitForSectionLoad(page);
+    const calls = (page.waitForSelector as ReturnType<typeof vi.fn>).mock.calls;
+    for (const [, options] of calls) {
+      expect(options).toMatchObject({ state: 'hidden' });
+    }
+  });
+
+  it('uses the default timeout of 10000 ms when no timeout is provided', async () => {
+    await waitForSectionLoad(page);
+    const calls = (page.waitForSelector as ReturnType<typeof vi.fn>).mock.calls;
+    for (const [, options] of calls) {
+      expect(options).toMatchObject({ timeout: 10_000 });
+    }
+  });
+
+  it('uses the provided custom timeout', async () => {
+    const customTimeout = 5_000;
+    await waitForSectionLoad(page, customTimeout);
+    const calls = (page.waitForSelector as ReturnType<typeof vi.fn>).mock.calls;
+    for (const [, options] of calls) {
+      expect(options).toMatchObject({ timeout: customTimeout });
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// switchPortal()
+// ---------------------------------------------------------------------------
+
+describe('switchPortal(page, portalQueryParam)', () => {
+  it('navigates with ?portal=client when portalQueryParam is "client"', async () => {
+    const page = makeMockPage({
+      url: vi.fn().mockReturnValue('https://app.example.com/dashboard'),
+    });
+    await switchPortal(page, 'client');
+    expect(page.goto).toHaveBeenCalledWith(
+      expect.stringContaining('portal=client'),
+    );
+  });
+
+  it('preserves existing query params while adding portal param', async () => {
+    const page = makeMockPage({
+      url: vi.fn().mockReturnValue('https://app.example.com/invoices?tab=unpaid'),
+    });
+    await switchPortal(page, 'bookkeeper');
+    const url: string = (page.goto as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(url).toContain('tab=unpaid');
+    expect(url).toContain('portal=bookkeeper');
+  });
+
+  it('removes the portal query param when portalQueryParam is null', async () => {
+    const page = makeMockPage({
+      url: vi.fn().mockReturnValue('https://app.example.com/dashboard?portal=client&tab=all'),
+    });
+    await switchPortal(page, null);
+    const url: string = (page.goto as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(url).not.toContain('portal=');
+    expect(url).toContain('tab=all');
+  });
+
+  it('still calls goto when no portal param was set and null is passed', async () => {
+    const page = makeMockPage({
+      url: vi.fn().mockReturnValue('https://app.example.com/dashboard'),
+    });
+    await switchPortal(page, null);
+    expect(page.goto).toHaveBeenCalledTimes(1);
+  });
+});