@lullabot/playwright-testing 0.1.0 → 1.0.1

package/src/focus.test.ts

@@ -1,34 +1,34 @@
-import {afterEach, describe, expect, it, vi} from 'vitest'
-import {blurActiveElement} from './focus'
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { blurActiveElement } from "./focus";
 
-describe('blurActiveElement', () => {
-  afterEach(() => vi.unstubAllGlobals())
+describe("blurActiveElement", () => {
+  afterEach(() => vi.unstubAllGlobals());
 
-  it('blurs a genuinely focused element', async () => {
-    const activeElement = {blur: vi.fn()}
-    const document = {activeElement, body: {}, documentElement: {}}
+  it("blurs a genuinely focused element", async () => {
+    const activeElement = { blur: vi.fn() };
+    const document = { activeElement, body: {}, documentElement: {} };
     const page = {
       evaluate: vi.fn((callback: () => boolean) => {
-        vi.stubGlobal('document', document)
-        return callback()
+        vi.stubGlobal("document", document);
+        return callback();
       }),
-    }
+    };
 
-    await expect(blurActiveElement(page as never)).resolves.toBe(true)
-    expect(activeElement.blur).toHaveBeenCalledOnce()
-  })
+    await expect(blurActiveElement(page as never)).resolves.toBe(true);
+    expect(activeElement.blur).toHaveBeenCalledOnce();
+  });
 
-  it('does not blur the document body fallback', async () => {
-    const body = {blur: vi.fn()}
-    const document = {activeElement: body, body, documentElement: {}}
+  it("does not blur the document body fallback", async () => {
+    const body = { blur: vi.fn() };
+    const document = { activeElement: body, body, documentElement: {} };
     const page = {
       evaluate: vi.fn((callback: () => boolean) => {
-        vi.stubGlobal('document', document)
-        return callback()
+        vi.stubGlobal("document", document);
+        return callback();
       }),
-    }
+    };
 
-    await expect(blurActiveElement(page as never)).resolves.toBe(false)
-    expect(body.blur).not.toHaveBeenCalled()
-  })
-})
+    await expect(blurActiveElement(page as never)).resolves.toBe(false);
+    expect(body.blur).not.toHaveBeenCalled();
+  });
+});

package/src/focus.ts

@@ -1,4 +1,4 @@
-import {Page} from "@playwright/test";
+import { Page } from "@playwright/test";
 
 /**
  * Remove keyboard focus from the active element.
@@ -18,7 +18,12 @@ export async function blurActiveElement(page: Page): Promise<boolean> {
     // `document.activeElement` falls back to `<body>`/`<html>` when nothing is
     // focused. Blurring that paints no focus ring but can still fire `focusout`
     // handlers, so skip it and only blur a genuinely focused control.
-    if (!el || el === document.body || el === document.documentElement || typeof el.blur !== "function") {
+    if (
+      !el ||
+      el === document.body ||
+      el === document.documentElement ||
+      typeof el.blur !== "function"
+    ) {
       return false;
     }
     el.blur();

package/src/fonts.test.ts

@@ -1,17 +1,17 @@
-import {describe, expect, it, vi} from 'vitest'
-import {waitForFonts} from './fonts'
+import { describe, expect, it, vi } from "vitest";
+import { waitForFonts } from "./fonts";
 
-describe('waitForFonts', () => {
-  it('waits for the browser font set to become ready', async () => {
+describe("waitForFonts", () => {
+  it("waits for the browser font set to become ready", async () => {
     const evaluate = vi.fn(async (callback: () => Promise<void>) => {
-      const ready = Promise.resolve()
-      vi.stubGlobal('document', {fonts: {ready}})
-      await callback()
-    })
+      const ready = Promise.resolve();
+      vi.stubGlobal("document", { fonts: { ready } });
+      await callback();
+    });
 
-    await waitForFonts({evaluate} as never)
+    await waitForFonts({ evaluate } as never);
 
-    expect(evaluate).toHaveBeenCalledOnce()
-    vi.unstubAllGlobals()
-  })
-})
+    expect(evaluate).toHaveBeenCalledOnce();
+    vi.unstubAllGlobals();
+  });
+});

package/src/fonts.ts

@@ -1,4 +1,4 @@
-import {Page} from "@playwright/test";
+import { Page } from "@playwright/test";
 
 /**
  * Wait for all web fonts to finish loading.

package/src/frames.test.ts

@@ -1,6 +1,6 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi } from "vitest";
 
-import { waitForFrames } from './frames';
+import { waitForFrames } from "./frames";
 
 function makeLocator({
   connected = true,
@@ -39,8 +39,8 @@ function makePage(locators: ReturnType<typeof makeLocator>[]) {
   } as never;
 }
 
-describe('waitForFrames', () => {
-  it('waits for each visible frame URL and load state', async () => {
+describe("waitForFrames", () => {
+  it("waits for each visible frame URL and load state", async () => {
     const first = makeLocator();
     const second = makeLocator();
 
@@ -49,14 +49,16 @@ describe('waitForFrames', () => {
     for (const locator of [first, second]) {
       expect(locator.scrollIntoViewIfNeeded).toHaveBeenCalledTimes(2);
       expect(locator.element.contentFrame).toHaveBeenCalledOnce();
-      expect(locator.element.contentFrame.mock.results[0].value).toBeInstanceOf(Promise);
+      expect(locator.element.contentFrame.mock.results[0].value).toBeInstanceOf(
+        Promise,
+      );
       const frame = await locator.element.contentFrame.mock.results[0].value;
       expect(frame?.waitForURL).toHaveBeenCalledOnce();
-      expect(frame?.waitForLoadState).toHaveBeenCalledWith('load');
+      expect(frame?.waitForLoadState).toHaveBeenCalledWith("load");
     }
   });
 
-  it('ignores frames that are detached or hidden', async () => {
+  it("ignores frames that are detached or hidden", async () => {
     const detached = makeLocator({ connected: false });
     const hidden = makeLocator({ visible: false });
 
@@ -67,7 +69,7 @@ describe('waitForFrames', () => {
     expect(hidden.elementHandle).not.toHaveBeenCalled();
   });
 
-  it('tolerates an iframe that detaches before its content frame is resolved', async () => {
+  it("tolerates an iframe that detaches before its content frame is resolved", async () => {
     const locator = makeLocator({ frame: null });
 
     await expect(waitForFrames(makePage([locator]))).resolves.toBeUndefined();

package/src/frames.ts

@@ -1,4 +1,4 @@
-import {Page} from "@playwright/test";
+import { Page } from "@playwright/test";
 
 /**
  * Wait for all frames to load.
@@ -6,20 +6,20 @@ import {Page} from "@playwright/test";
  * @param page
  */
 export async function waitForFrames(page: Page): Promise<void> {
-  const locators = await page.locator('iframe');
+  const locators = await page.locator("iframe");
   // Trigger lazy-loading iframes. Since this should be fast, and we don't want to
   // have to deal with concurrency bugs, we do this in serial.
   for (const locator of await locators.all()) {
     // Ensure iframes are connected to the DOM before trying to scroll to them.
     // https://github.com/microsoft/playwright/issues/23758
-    if (await locator.evaluate(iframe => iframe.isConnected)) {
+    if (await locator.evaluate((iframe) => iframe.isConnected)) {
       if (await locator.isVisible()) {
         await locator.scrollIntoViewIfNeeded();
         await locator.scrollIntoViewIfNeeded();
         const element = await locator.elementHandle();
         const frame = await element?.contentFrame();
-        await frame?.waitForURL(new RegExp('.*/.*', 'i'));
-        await frame?.waitForLoadState('load');
+        await frame?.waitForURL(new RegExp(".*/.*", "i"));
+        await frame?.waitForLoadState("load");
       }
     }
   }