Dec 10, 2025 · Dec 10, 2025 · Dec 10, 2025 · Dec 10, 2025 · Dec 15, 2025 · Dec 15, 2025
diff --git a/.github/workflows/playwright.yml b/.github/workflows/playwright.yml
 name: Playwright Tests
 on:
  push:
    branches: [ main, staging ]
  pull_request:
    branches: [ main, staging ]
 jobs:
  test:
    timeout-minutes: 60
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-node@v4
      with:
        node-version: lts/*
    - name: Install dependencies
      run: npm ci
    - name: Install Playwright Browsers
      run: npx playwright install --with-deps
    - name: Run Playwright tests
      run: npx playwright test
    - uses: actions/upload-artifact@v4
      if: ${{ !cancelled() }}
      with:
        name: playwright-report
        path: playwright-report/
        retention-days: 30
diff --git a/.gitignore b/.gitignore
 .jinja_cache/
 demo_tokens.py
 .DS_Store

 # Playwright
 /playwright-report/
 /blob-report/
 /playwright/.cache/
 /playwright/.auth/
diff --git a/e2e/infra/api/apiRequests.ts b/e2e/infra/api/apiRequests.ts
 /* eslint-disable @typescript-eslint/no-explicit-any */

 import { APIRequestContext, request } from "@playwright/test"


 const getRequest = async (url: string, headers?: Record<string, string>, body?: any, availableRequest?: APIRequestContext) => {
  const requestOptions = {
    data: body,
    headers: headers || undefined,
  };

  const requestContext = availableRequest || (await request.newContext());
  const response = await requestContext.get(url, requestOptions);
  return response;
 };

 const postRequest = async (url: string, body?: any, availableRequest?: APIRequestContext, headers?: Record<string, string>) => {
  const requestOptions = {
    data: body,
    headers: headers || undefined,
  };

  const requestContext = availableRequest || (await request.newContext());
  const response = await requestContext.post(url, requestOptions);
  return response;
 };

 const deleteRequest = async (url: string, headers?: Record<string, string>, body?: any) => {
  const requestOptions = {
    data: body,
    headers: headers || undefined,
  };

  const requestContext = await request.newContext();
  const response = await requestContext.delete(url, requestOptions);
  return response;
 };

 const patchRequest = async (url: string, body?: any, availableRequest?: APIRequestContext, headers?: Record<string, string>) => {
  const requestOptions = {
    data: body,
    headers: headers || undefined,
  };

  const requestContext = availableRequest || (await request.newContext());
  const response = await requestContext.patch(url, requestOptions);
  return response;
 };

 export { getRequest, deleteRequest, postRequest, patchRequest }
diff --git a/e2e/infra/ui/basePage.ts b/e2e/infra/ui/basePage.ts
 import { Page } from "playwright";

 export default class BasePage {
  protected page: Page;

  constructor(page: Page) {
    this.page = page;
  }

  async initPage() {
    await this.page.waitForLoadState();
  }

  getCurrentURL(): string {
    return this.page.url();
  }

  async refreshPage() {
    await this.page.reload({ waitUntil: "networkidle" });
  }

  async waitForResponse(url: string) {
    const response = await this.page.waitForResponse(url);
    return response;
  }

  async waitForUrl(url: string) {
    return this.page.waitForURL(url);
  }
 }
diff --git a/e2e/infra/ui/browserWrapper.ts b/e2e/infra/ui/browserWrapper.ts
 import { chromium, Browser, BrowserContext, Page, firefox } from 'playwright';
 import { test } from '@playwright/test';
 import BasePage from './basePage';

 async function launchBrowser(projectName: string): Promise<Browser> {
    if (projectName.toLowerCase().includes('firefox')) {
        return firefox.launch();
    }

    return chromium.launch();
 }

 export default class BrowserWrapper {

    private browser: Browser | null = null;

    private context: BrowserContext | null = null;

    private page: Page | null = null;

    async createNewPage<T extends BasePage>(PageClass: new (page: Page) => T, url?: string) {
        if (!this.browser) {
            const projectName = test.info().project.name;
            this.browser = await launchBrowser(projectName);
        }
        if (!this.context) {
            this.context = await this.browser.newContext();
        }
        if (!this.page) {
            this.page = await this.context.newPage();
        }
        if (url) {
            await this.navigateTo(url)
        }

        const pageInstance = new PageClass(this.page);
        return pageInstance;
    }

    getContext(): BrowserContext | null {
        return this.context;
    }

    async getPage() {
        if (!this.page) {
            throw new Error('Browser is not launched yet!');
        }
        return this.page;
    }

    async setPageToFullScreen() {
        if (!this.page) {
            throw new Error('Browser is not launched yet!');
        }

        await this.page.setViewportSize({ width: 1920, height: 1080 });
    }

    async navigateTo(url: string) {
        if (!this.page) {
            throw new Error('Browser is not launched yet!');
        }
        await this.page.goto(url);
        await this.page.waitForLoadState('networkidle');
    }

    async closePage() {
        if (this.page) {
            await this.page.close();
            this.page = null;
        }
    }

    async closeBrowser() {
        await this.closePage();

        if (this.browser) {
            await this.browser.close();
        }
    }

 }
diff --git a/e2e/infra/utils.ts b/e2e/infra/utils.ts
 import { Locator, Page } from "playwright";

 export function delay(ms: number) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
 }

 export const waitForElementToBeVisible = async (
  locator: Locator,
  time = 500,
  retry = 10
 ): Promise<boolean> => {
  for (let i = 0; i < retry; i += 1) {
    try {
      if (await locator.isVisible()) {
        return true;
      }
    } catch (error) {
      console.error(`Error checking element visibility: ${error}`);
    }
    await delay(time);
  }
  return false;
 };

 export const waitForElementToNotBeVisible = async (
  locator: Locator,
  time = 500,
  retry = 10
 ): Promise<boolean> => {
  for (let i = 0; i < retry; i += 1) {
    try {
      if (!(await locator.isVisible())) {
        return true;
      }
    } catch (error) {
      console.error(`Error checking element visibility: ${error}`);
    }
    await delay(time);
  }
  return false;
 };

 export const waitForElementToBeEnabled = async (
  locator: Locator,
  time = 500,
  retry = 10
 ): Promise<boolean> => {
  for (let i = 0; i < retry; i += 1) {
    try {
      if (await locator.isEnabled()) {
        return true;
      }
    } catch (error) {
      console.error(`Error checking element enabled: ${error}`);
    }
    await delay(time);
  }
  return false;
 };

 export function getRandomString(prefix = "", delimiter = "_"): string {
  const uuid = crypto.randomUUID();
  const timestamp = Date.now();
  return `${prefix}${prefix ? delimiter : ""}${uuid}-${timestamp}`;
 }
diff --git a/e2e/logic/api/apiCalls.ts b/e2e/logic/api/apiCalls.ts
diff --git a/e2e/logic/api/apiResponses.ts b/e2e/logic/api/apiResponses.ts
diff --git a/e2e/logic/pom/homePage.ts b/e2e/logic/pom/homePage.ts
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,27 @@
		name: Playwright Tests
		on:
		push:
		branches: [ main, staging ]
		pull_request:
		branches: [ main, staging ]
		jobs:
		test:
		timeout-minutes: 60
		runs-on: ubuntu-latest
		steps:
		- uses: actions/checkout@v4
		- uses: actions/setup-node@v4
		with:
		node-version: lts/*
		- name: Install dependencies
		run: npm ci
		- name: Install Playwright Browsers
		run: npx playwright install --with-deps
		- name: Run Playwright tests
Copy link overcut-aibotDec 10, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [blocker]: Playwright CI never launches backend. The Playwright workflow installs dependencies and immediately runs`npx playwright test`, but it neither starts the QueryWeaver backend/frontend nor sets`PLAYWRIGHT_BASE_URL`, so every navigation/API helper will hit an empty localhost port and time out on CI. Add a step (or Playwright`webServer` config) that starts the API/frontend, waits for it to become reachable, and exports`PLAYWRIGHT_BASE_URL` before the tests run. Copy link overcut-aibotDec 10, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [blocker] This job installs deps and immediately executes`npx playwright test`, but it never starts the QueryWeaver API/UI (or configures Playwright’s`webServer`). With no server listening on`http://localhost:5000` every navigation/auth request in the suite will hit`ECONNREFUSED` on CI. Please add a step (or`webServer` config) that boots the backend and waits for it to be ready before running the tests so the workflow can actually exercise the app.
		run: npx playwright test
		- uses: actions/upload-artifact@v4
		if: ${{ !cancelled() }}
		with:
		name: playwright-report
		path: playwright-report/
		retention-days: 30
FixedShow fixedHide fixed
Original file line number	Diff line number	Diff line change
Expand Up		@@ -25,3 +25,9 @@ node_modules/
		.jinja_cache/
		demo_tokens.py
		.DS_Store

		# Playwright
		/playwright-report/
		/blob-report/
		/playwright/.cache/
		/playwright/.auth/
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,50 @@
		/* eslint-disable @typescript-eslint/no-explicit-any */

		import { APIRequestContext, request } from "@playwright/test"


		const getRequest = async (url: string, headers?: Record<string, string>, body?: any, availableRequest?: APIRequestContext) => {
Copy link overcut-aibotDec 10, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [major]: API request contexts leak. Each helper creates a`request.newContext()` when one isn’t supplied but never disposes it, so repeated calls leak HTTP sessions/processes and eventually hang the runner. Track whether the helper created the context (e.g.,`const shouldDispose = !availableRequest`) and`await requestContext.dispose()` in a finally block when true.
		const requestOptions = {
		data: body,
		headers: headers \|\| undefined,
		};

		const requestContext = availableRequest \|\| (await request.newContext());
Copy link overcut-aibotDec 10, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [major] Each helper here spins up a fresh`APIRequestContext` when one isn’t provided, but none of them ever dispose it. In a longer suite these stacks of orphaned contexts leak HTTP sessions/processes until Playwright hangs or hits the browser limit. Please track whether the helper created the context (e.g.`const shouldDispose = !availableRequest`) and call`await requestContext.dispose()` in a`finally` block when appropriate so we don’t leak resources between API calls.
		const response = await requestContext.get(url, requestOptions);
		return response;
		};

		const postRequest = async (url: string, body?: any, availableRequest?: APIRequestContext, headers?: Record<string, string>) => {
		const requestOptions = {
		data: body,
		headers: headers \|\| undefined,
		};

		const requestContext = availableRequest \|\| (await request.newContext());
		const response = await requestContext.post(url, requestOptions);
		return response;
		};

		const deleteRequest = async (url: string, headers?: Record<string, string>, body?: any) => {
Copy link overcut-aibotDec 10, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [major]: DELETE helpers drop authentication.`deleteRequest` always creates a brand-new`APIRequestContext`, so`deleteGraph`/`deleteToken` lose the cookies/headers established by login and the backend rejects the call. Allow callers to pass an existing request context (like the GET/POST helpers do) so authenticated state is preserved for DELETE operations.
		const requestOptions = {
		data: body,
		headers: headers \|\| undefined,
		};

		const requestContext = await request.newContext();
Copy link overcut-aibotDec 10, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [major] Unlike the GET/POST/PATCH helpers,`deleteRequest` always creates a brand‑new`APIRequestContext`, so callers such as`deleteGraph`/`deleteToken` drop the authenticated session they just established and hit the endpoint without cookies/headers. Please accept the optional`availableRequest` parameter (mirroring the other helpers) and reuse it so DELETE calls keep the same auth context as the rest of the API interactions.
		const response = await requestContext.delete(url, requestOptions);
		return response;
		};

		const patchRequest = async (url: string, body?: any, availableRequest?: APIRequestContext, headers?: Record<string, string>) => {
		const requestOptions = {
		data: body,
		headers: headers \|\| undefined,
		};

		const requestContext = availableRequest \|\| (await request.newContext());
		const response = await requestContext.patch(url, requestOptions);
		return response;
		};

		export { getRequest, deleteRequest, postRequest, patchRequest }
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,30 @@
		import { Page } from "playwright";

		export default class BasePage {
		protected page: Page;

		constructor(page: Page) {
		this.page = page;
		}

		async initPage() {
		await this.page.waitForLoadState();
		}

		getCurrentURL(): string {
		return this.page.url();
		}

		async refreshPage() {
		await this.page.reload({ waitUntil: "networkidle" });
		}

		async waitForResponse(url: string) {
		const response = await this.page.waitForResponse(url);
		return response;
		}

		async waitForUrl(url: string) {
		return this.page.waitForURL(url);
		}
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,82 @@
		import { chromium, Browser, BrowserContext, Page, firefox } from 'playwright';
		import { test } from '@playwright/test';
		import BasePage from './basePage';

		async function launchBrowser(projectName: string): Promise<Browser> {
		if (projectName.toLowerCase().includes('firefox')) {
		return firefox.launch();
		}

		return chromium.launch();
		}

		export default class BrowserWrapper {

		private browser: Browser \| null = null;

		private context: BrowserContext \| null = null;

		private page: Page \| null = null;

		async createNewPage<T extends BasePage>(PageClass: new (page: Page) => T, url?: string) {
		if (!this.browser) {
		const projectName = test.info().project.name;
		this.browser = await launchBrowser(projectName);
		}
		if (!this.context) {
		this.context = await this.browser.newContext();
		}
		if (!this.page) {
		this.page = await this.context.newPage();
		}
		if (url) {
		await this.navigateTo(url)
		}

		const pageInstance = new PageClass(this.page);
		return pageInstance;
		}

		getContext(): BrowserContext \| null {
		return this.context;
		}

		async getPage() {
		if (!this.page) {
		throw new Error('Browser is not launched yet!');
		}
		return this.page;
		}

		async setPageToFullScreen() {
		if (!this.page) {
		throw new Error('Browser is not launched yet!');
		}

		await this.page.setViewportSize({ width: 1920, height: 1080 });
		}

		async navigateTo(url: string) {
		if (!this.page) {
		throw new Error('Browser is not launched yet!');
		}
		await this.page.goto(url);
		await this.page.waitForLoadState('networkidle');
		}

		async closePage() {
		if (this.page) {
		await this.page.close();
		this.page = null;
		}
		}

		async closeBrowser() {
Copy link overcut-aibotDec 10, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [major]: Wrapper reuses handles after closing.`closeBrowser()` closes the page/browser but leaves`this.browser` and`this.context` populated, so the next`createNewPage()` reuses handles Playwright has already torn down and throws target-closed errors. After closing, dispose the context and set both`this.browser` and`this.context` to null (or recreate them) so later calls relaunch cleanly. Copy link overcut-aibotDec 10, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [major]`closeBrowser()` only closes the page and then the raw browser handle, but it never closes the active`BrowserContext` or reset`this.browser`/`this.context` to`null`. After one test finishes those fields keep pointing at Playwright objects that have already been torn down, so the next`createNewPage` will try to reuse a dead context and throw`browserContext.newPage: Protocol error: Target closed`. Please`await this.context?.close()` and null the fields (browser/context/page) when shutting down so a subsequent run can relaunch cleanly.
		await this.closePage();

		if (this.browser) {
		await this.browser.close();
		}
		}

		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,67 @@
		import { Locator, Page } from "playwright";

		export function delay(ms: number) {
		return new Promise((resolve) => {
		setTimeout(resolve, ms);
		});
		}

		export const waitForElementToBeVisible = async (
		locator: Locator,
		time = 500,
		retry = 10
		): Promise<boolean> => {
		for (let i = 0; i < retry; i += 1) {
		try {
		if (await locator.isVisible()) {
		return true;
		}
		} catch (error) {
		console.error(`Error checking element visibility: ${error}`);
		}
		await delay(time);
		}
		return false;
		};

		export const waitForElementToNotBeVisible = async (
		locator: Locator,
		time = 500,
		retry = 10
		): Promise<boolean> => {
		for (let i = 0; i < retry; i += 1) {
		try {
		if (!(await locator.isVisible())) {
		return true;
		}
		} catch (error) {
		console.error(`Error checking element visibility: ${error}`);
		}
		await delay(time);
		}
		return false;
		};

		export const waitForElementToBeEnabled = async (
		locator: Locator,
		time = 500,
		retry = 10
		): Promise<boolean> => {
		for (let i = 0; i < retry; i += 1) {
		try {
		if (await locator.isEnabled()) {
		return true;
		}
		} catch (error) {
		console.error(`Error checking element enabled: ${error}`);
		}
		await delay(time);
		}
		return false;
		};

		export function getRandomString(prefix = "", delimiter = "_"): string {
		const uuid = crypto.randomUUID();
		const timestamp = Date.now();
		return `${prefix}${prefix ? delimiter : ""}${uuid}-${timestamp}`;
		}