@allwright.dev/vitest 0.0.25 → 0.0.27

package/README.md

@@ -11,3 +11,38 @@ test("opens a page", async ({ page }) => {
   expect(title.text).toContain("Example");
 });
 ```
+
+The fixture package reads the shared stack-agnostic config format through `@allwright.dev/core`.
+Use `allwright.config.yaml` by default, or `allwright.config.json` if you prefer. Both follow the same root schema in `allwright.schema.json`.
+
+```yaml
+schemaVersion: 1
+
+server:
+  addr: 127.0.0.1:50051
+
+browser:
+  name: firefox
+  binary: /Applications/Firefox.app/Contents/MacOS/firefox
+
+expect:
+  timeoutMs: 7000
+  intervalMs: 100
+
+suites:
+  smoke:
+    browser:
+      name: chromium
+```
+
+Vitest can override or select from that shared config without switching to a Vitest-specific file:
+
+```ts
+import { test } from "@allwright.dev/vitest";
+
+test.use({
+  allwright: {
+    suite: "smoke"
+  }
+});
+```

package/dist/index.d.ts

@@ -1,8 +1,12 @@
-import { Page, type Browser, type LaunchOptions, type WaitForSelectorOptions } from "@allwright.dev/core";
+import { type Browser, type BrowserKind, type LaunchOptions, type Locator, type Page, type WaitForSelectorOptions } from "@allwright.dev/core";
 import { expect as vitestExpect } from "vitest";
 export interface AllwrightVitestOptions {
     launchOptions?: LaunchOptions;
     serverAddr?: string;
+    browser?: BrowserKind;
+    browserBinary?: string;
+    configFile?: string;
+    suite?: string;
 }
 export interface AllwrightVitestFixtures {
     browser: Browser;
@@ -26,6 +30,12 @@ export interface PageExpectMatchers {
     toHaveCount(selector: string, expected: number, options?: RetryExpectationOptions): Promise<void>;
     toBeVisible(selector: string, options?: VisibleExpectationOptions): Promise<void>;
 }
+export interface LocatorExpectMatchers {
+    toHaveText(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toContainText(expected: string | RegExp, options?: TextExpectationOptions): Promise<void>;
+    toHaveCount(expected: number, options?: RetryExpectationOptions): Promise<void>;
+    toBeVisible(options?: VisibleExpectationOptions): Promise<void>;
+}
 export declare const test: import("vitest").TestAPI<{
     browser: Browser;
     page: Page;
@@ -35,8 +45,9 @@ type VitestExpect = typeof vitestExpect;
 type VitestMatcherReturn = ReturnType<VitestExpect>;
 interface AllwrightExpect extends VitestExpect {
     (actual: Page): PageExpectMatchers;
+    (actual: Locator): LocatorExpectMatchers;
     <T>(actual: T): VitestMatcherReturn;
 }
 export declare const expect: AllwrightExpect;
 export { vitestExpect };
-export type { Browser, LaunchOptions, Page };
+export type { Browser, LaunchOptions, Locator, Page };

package/dist/index.js

@@ -1,18 +1,21 @@
-import { chromium, setServerAddr, shutdown, Page, } from "@allwright.dev/core";
+import { launchConfiguredBrowser, resolveConfig, setServerAddr, shutdown, } from "@allwright.dev/core";
 import { expect as vitestExpect, test as base } from "vitest";
 export const test = base.extend({
     allwright: async ({}, use) => {
         await use({});
     },
     browser: async ({ allwright }, use) => {
-        if (allwright.serverAddr) {
-            setServerAddr(allwright.serverAddr);
+        const config = resolveVitestConfig(allwright);
+        if (config.serverAddr) {
+            setServerAddr(config.serverAddr);
         }
-        const browser = await chromium.launch(allwright.launchOptions ?? {});
+        activeExpectDefaults = config.expect;
+        const browser = await launchConfiguredBrowser(config);
         try {
             await use(browser);
         }
         finally {
+            activeExpectDefaults = {};
             await browser.close().catch(() => undefined);
             await shutdown();
         }
@@ -24,11 +27,38 @@ export const test = base.extend({
 const DEFAULT_EXPECT_TIMEOUT_MS = 5_000;
 const DEFAULT_EXPECT_INTERVAL_MS = 100;
 function isPage(value) {
-    return value instanceof Page;
+    return !!value && typeof value === "object" && typeof value.locator === "function";
 }
-async function retryExpectation(callback, options = {}) {
-    const timeoutMs = options.timeoutMs ?? DEFAULT_EXPECT_TIMEOUT_MS;
-    const intervalMs = options.intervalMs ?? DEFAULT_EXPECT_INTERVAL_MS;
+function isLocator(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        typeof value.page === "object" &&
+        typeof value.click === "function");
+}
+function resolveVitestConfig(options) {
+    const config = resolveConfig({
+        configFile: options.configFile,
+        suite: options.suite,
+    });
+    return {
+        ...config,
+        serverAddr: options.serverAddr ?? config.serverAddr,
+        browserName: options.browser ?? config.browserName,
+        browserBinary: options.browserBinary ?? config.browserBinary,
+        launchOptions: {
+            ...config.launchOptions,
+            ...(options.launchOptions ?? {}),
+            browserBinary: options.launchOptions?.browserBinary ??
+                options.browserBinary ??
+                config.browserBinary ??
+                config.launchOptions.browserBinary,
+        },
+        expect: config.expect,
+    };
+}
+async function retryExpectation(callback, options = {}, defaults = {}) {
+    const timeoutMs = options.timeoutMs ?? defaults.timeoutMs ?? DEFAULT_EXPECT_TIMEOUT_MS;
+    const intervalMs = options.intervalMs ?? defaults.intervalMs ?? DEFAULT_EXPECT_INTERVAL_MS;
     const deadline = Date.now() + timeoutMs;
     let lastError;
     while (Date.now() <= deadline) {
@@ -56,7 +86,7 @@ function createPageExpect(page) {
                     return;
                 }
                 vitestExpect(result.text).toBe(expected);
-            }, options);
+            }, options, currentExpectDefaults());
         },
         async toContainText(selector, expected, options = {}) {
             await retryExpectation(async () => {
@@ -66,13 +96,13 @@ function createPageExpect(page) {
                     return;
                 }
                 vitestExpect(result.text).toContain(expected);
-            }, options);
+            }, options, currentExpectDefaults());
         },
         async toHaveCount(selector, expected, options = {}) {
             await retryExpectation(async () => {
                 const result = await page.count(selector, {});
                 vitestExpect(result.count).toBe(expected);
-            }, options);
+            }, options, currentExpectDefaults());
         },
         async toBeVisible(selector, options = {}) {
             await retryExpectation(async () => {
@@ -81,11 +111,57 @@ function createPageExpect(page) {
                     ...(options.command ?? {}),
                 });
                 vitestExpect(result.visible).toBe(true);
-            }, options);
+            }, options, currentExpectDefaults());
         },
     };
 }
+function createLocatorExpect(locator) {
+    return {
+        async toHaveText(expected, options = {}) {
+            await retryExpectation(async () => {
+                const result = await locator.textContent(options.command ?? {});
+                if (expected instanceof RegExp) {
+                    vitestExpect(result.text).toMatch(expected);
+                    return;
+                }
+                vitestExpect(result.text).toBe(expected);
+            }, options, currentExpectDefaults());
+        },
+        async toContainText(expected, options = {}) {
+            await retryExpectation(async () => {
+                const result = await locator.textContent(options.command ?? {});
+                if (expected instanceof RegExp) {
+                    vitestExpect(result.text).toMatch(expected);
+                    return;
+                }
+                vitestExpect(result.text).toContain(expected);
+            }, options, currentExpectDefaults());
+        },
+        async toHaveCount(expected, options = {}) {
+            await retryExpectation(async () => {
+                const result = await locator.count({});
+                vitestExpect(result.count).toBe(expected);
+            }, options, currentExpectDefaults());
+        },
+        async toBeVisible(options = {}) {
+            await retryExpectation(async () => {
+                const result = await locator.waitFor({
+                    visible: true,
+                    ...(options.command ?? {}),
+                });
+                vitestExpect(result.visible).toBe(true);
+            }, options, currentExpectDefaults());
+        },
+    };
+}
+let activeExpectDefaults = {};
+function currentExpectDefaults() {
+    return activeExpectDefaults;
+}
 const expectImpl = ((actual) => {
+    if (isLocator(actual)) {
+        return createLocatorExpect(actual);
+    }
     if (isPage(actual)) {
         return createPageExpect(actual);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allwright.dev/vitest",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "Vitest fixtures for the allwright TypeScript client.",
   "license": "MIT",
   "type": "module",
@@ -39,7 +39,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@allwright.dev/core": "0.0.25"
+    "@allwright.dev/core": "0.0.27"
   },
   "devDependencies": {
     "typescript": "^5.9.2",