@rvoh/psychic-spec-helpers 3.1.1 → 3.2.0

package/dist/esm/src/feature/helpers/providePuppeteerViteMatchers.js

@@ -32,8 +32,8 @@ export default function providePuppeteerViteMatchers() {
         async toMatchTextContent(page, text, opts) {
             return await toMatchTextContent(page, text, opts);
         },
-        async toNotMatchTextContent(page, text) {
-            return await toNotMatchTextContent(page, text);
+        async toNotMatchTextContent(page, text, opts) {
+            return await toNotMatchTextContent(page, text, opts);
         },
         async toHaveSelector(page, cssSelector, opts) {
             return await toHaveSelector(page, cssSelector, opts);

package/dist/esm/src/feature/internal/getAllTextContentFromPage.js

@@ -1,19 +1,35 @@
-export default async function getAllTextContentFromPage(page) {
+export default async function getAllTextContentFromPage(page, selector = 'body') {
     // Evaluate and extract all text content on the page
-    const allText = await page.evaluate(() => {
+    const allText = await page.evaluate(selector => {
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        const elements = document.body.querySelectorAll('*');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+        const roots = Array.from(document.querySelectorAll(selector));
         const textContentArray = [];
-        elements.forEach(element => {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-            if (element.textContent.trim() !== '') {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-                textContentArray.push(element.innerText.trim());
-            }
+        roots.forEach(root => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+            const elements = [root, ...Array.from(root.querySelectorAll('*'))];
+            elements.forEach(element => {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                const tagName = String(element.tagName || '').toLowerCase();
+                if (['script', 'style', 'noscript'].includes(tagName))
+                    return;
+                let elementText;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                if (typeof element.innerText === 'string') {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+                    elementText = element.innerText;
+                }
+                else {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+                    elementText = element.textContent;
+                }
+                const normalizedText = elementText?.trim();
+                if (normalizedText)
+                    textContentArray.push(normalizedText);
+            });
         });
         return textContentArray.join(' ');
-    });
+    }, selector);
     return allText;
 }

package/dist/esm/src/feature/matchers/toMatchTextContent.js

@@ -1,23 +1,27 @@
-import applyDefaultWaitForOpts from '../helpers/applyDefaultWaitForOpts.js';
-export default async function toMatchTextContent(page, text, opts = {}) {
-    try {
-        await page.waitForSelector(`${opts.selector || 'body'}::-p-text(${text.replace(/"/g, '\\"')})`, applyDefaultWaitForOpts(opts));
+import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
+import getAllTextContentFromPage from '../internal/getAllTextContentFromPage.js';
+import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
+export default async function toMatchTextContent(argumentPassedToExpect, expected, opts = {}) {
+    return await evaluateWithRetryAndTimeout(argumentPassedToExpect, async () => {
+        requirePuppeteerPage(argumentPassedToExpect);
+        const actual = await getAllTextContentFromPage(argumentPassedToExpect, opts.selector);
+        if (expected instanceof RegExp)
+            expected.lastIndex = 0;
         return {
-            pass: true,
-            message: () => {
-                throw new Error('Cannot negate toMatchTextContent, use toNotMatchTextContent instead');
-            },
+            pass: typeof expected === 'string' ? actual.includes(expected) : expected.test(actual),
+            actual,
         };
-    }
-    catch {
-        return {
-            pass: false,
-            message: () => `
+    }, {
+        successText: () => {
+            throw new Error('Cannot negate toMatchTextContent, use toNotMatchTextContent instead');
+        },
+        failureText: actual => `
 expected ${opts.selector || 'body'} with text:
-        ${text}
+        ${expected.toString()}
 
-but no text was found within that selector
+but no matching text was found within that selector:
+        ${actual}
       `,
-        };
-    }
+        timeout: opts.timeout,
+    });
 }

package/dist/esm/src/feature/matchers/toNotMatchTextContent.js

@@ -4,16 +4,18 @@ import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
 export default async function toNotMatchTextContent(argumentPassedToExpect, expected, opts = {}) {
     return await evaluateWithRetryAndTimeout(argumentPassedToExpect, async () => {
         requirePuppeteerPage(argumentPassedToExpect);
-        const actual = await getAllTextContentFromPage(argumentPassedToExpect);
+        const actual = await getAllTextContentFromPage(argumentPassedToExpect, opts.selector);
+        if (expected instanceof RegExp)
+            expected.lastIndex = 0;
         return {
-            pass: !actual.includes(expected),
+            pass: typeof expected === 'string' ? !actual.includes(expected) : !expected.test(actual),
             actual,
         };
     }, {
         successText: () => {
             throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead');
         },
-        failureText: r => `Expected ${r} to not match text ${expected}, but it did`,
+        failureText: r => `Expected ${r} to not match text ${expected.toString()}, but it did`,
         timeout: opts.timeout,
     });
 }

package/dist/types/src/feature/internal/getAllTextContentFromPage.d.ts

@@ -1,2 +1,2 @@
 import { Page } from 'puppeteer';
-export default function getAllTextContentFromPage(page: Page): Promise<string>;
+export default function getAllTextContentFromPage(page: Page, selector?: string): Promise<string>;

package/dist/types/src/feature/matchers/toMatchTextContent.d.ts

@@ -1,7 +1,9 @@
 import { Page, WaitForSelectorOptions } from 'puppeteer';
-export default function toMatchTextContent(page: Page, text: string, opts?: {
+export type TextContentMatcherExpected = string | RegExp;
+export type TextContentMatcherOpts = {
     selector?: string;
-} & WaitForSelectorOptions): Promise<{
-    pass: boolean;
+} & WaitForSelectorOptions;
+export default function toMatchTextContent(argumentPassedToExpect: Page, expected: TextContentMatcherExpected, opts?: TextContentMatcherOpts): Promise<{
     message: () => string;
+    pass: boolean;
 }>;

package/dist/types/src/feature/matchers/toNotMatchTextContent.d.ts

@@ -1,5 +1,6 @@
-import { Page, WaitForSelectorOptions } from 'puppeteer';
-export default function toNotMatchTextContent(argumentPassedToExpect: Page, expected: string, opts?: WaitForSelectorOptions): Promise<{
+import { Page } from 'puppeteer';
+import type { TextContentMatcherExpected, TextContentMatcherOpts } from './toMatchTextContent.js';
+export default function toNotMatchTextContent(argumentPassedToExpect: Page, expected: TextContentMatcherExpected, opts?: TextContentMatcherOpts): Promise<{
     message: () => string;
     pass: boolean;
 }>;

package/dist/types/src/index.d.ts

@@ -2,6 +2,7 @@ import { Page, WaitForSelectorOptions } from 'puppeteer';
 import { CustomMatcherResult } from './feature/helpers/providePuppeteerViteMatchers.js';
 import { ExpectToEvaluateOpts } from './feature/internal/evaluateWithRetryAndTimeout.js';
 import { ToFillMatcherOpts } from './feature/matchers/toFill.js';
+import type { TextContentMatcherExpected, TextContentMatcherOpts } from './feature/matchers/toMatchTextContent.js';
 export { RequestBody as OpenapiRequestBody, RequestQueryParameters as OpenapiRequestQuery, ResponseBody as OpenapiResponseBody, ResponseCodeForUri as OpenapiResponseCodeForUri, } from './unit/helpers/openapiTypeHelpers.js';
 export { DreamRequestAttributes } from './unit/helpers/typeHelpers.js';
 export { default as createPsychicServer } from './unit/createPsychicServer.js';
@@ -39,8 +40,8 @@ interface PuppeteerAssertions {
     toMatchDreamModels(expected: any): CustomMatcherResult;
     toBeWithin(precision: number, expected: number): CustomMatcherResult;
     toEqualCalendarDate(expected: any): CustomMatcherResult;
-    toMatchTextContent(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
-    toNotMatchTextContent(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toMatchTextContent(expected: TextContentMatcherExpected, opts?: TextContentMatcherOpts): Promise<CustomMatcherResult>;
+    toNotMatchTextContent(expected: TextContentMatcherExpected, opts?: TextContentMatcherOpts): Promise<CustomMatcherResult>;
     toHaveSelector(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
     toNotHaveSelector(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
     toCheck(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@rvoh/psychic-spec-helpers",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "psychic framework spec helpers",
   "author": "RVO Health",
   "repository": {

package/src/feature/helpers/providePuppeteerViteMatchers.ts

@@ -15,6 +15,10 @@ import toHavePath from '../matchers/toHavePath.js'
 import toHaveSelector from '../matchers/toHaveSelector.js'
 import toHaveUnchecked from '../matchers/toHaveUnchecked.js'
 import toHaveUrl from '../matchers/toHaveUrl.js'
+import type {
+  TextContentMatcherExpected,
+  TextContentMatcherOpts,
+} from '../matchers/toMatchTextContent.js'
 import toMatchTextContent from '../matchers/toMatchTextContent.js'
 import toNotHaveSelector from '../matchers/toNotHaveSelector.js'
 import toNotMatchTextContent from '../matchers/toNotMatchTextContent.js'
@@ -35,14 +39,18 @@ export default function providePuppeteerViteMatchers() {
   ;(global as any).expect.extend({
     async toMatchTextContent(
       page: Page,
-      text: string,
-      opts?: { selector?: string } & WaitForSelectorOptions
+      text: TextContentMatcherExpected,
+      opts?: TextContentMatcherOpts
     ) {
       return await toMatchTextContent(page, text, opts)
     },
 
-    async toNotMatchTextContent(page: Page, text: string) {
-      return await toNotMatchTextContent(page, text)
+    async toNotMatchTextContent(
+      page: Page,
+      text: TextContentMatcherExpected,
+      opts?: TextContentMatcherOpts
+    ) {
+      return await toNotMatchTextContent(page, text, opts)
     },
 
     async toHaveSelector(page: Page, cssSelector: string, opts?: WaitForSelectorOptions) {

package/src/feature/internal/getAllTextContentFromPage.ts

@@ -1,26 +1,42 @@
 import { Page } from 'puppeteer'
 
-export default async function getAllTextContentFromPage(page: Page) {
+export default async function getAllTextContentFromPage(page: Page, selector = 'body') {
   // Evaluate and extract all text content on the page
-  const allText = await page.evaluate(() => {
+  const allText = await page.evaluate(selector => {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-    const elements = document.body.querySelectorAll('*')
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+    const roots = Array.from(document.querySelectorAll(selector))
 
     const textContentArray: string[] = []
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ;(elements as any[]).forEach(element => {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-      if (element.textContent.trim() !== '') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        textContentArray.push(element.innerText.trim())
-      }
+    ;(roots as any[]).forEach(root => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+      const elements = [root, ...Array.from(root.querySelectorAll('*'))]
+
+      elements.forEach(element => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        const tagName = String(element.tagName || '').toLowerCase()
+        if (['script', 'style', 'noscript'].includes(tagName)) return
+
+        let elementText: string | undefined
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (typeof element.innerText === 'string') {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+          elementText = element.innerText
+        } else {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+          elementText = element.textContent
+        }
+
+        const normalizedText = elementText?.trim()
+        if (normalizedText) textContentArray.push(normalizedText)
+      })
     })
 
     return textContentArray.join(' ')
-  })
+  }, selector)
 
   return allText
 }

package/src/feature/matchers/toMatchTextContent.ts

@@ -1,31 +1,41 @@
 import { Page, WaitForSelectorOptions } from 'puppeteer'
-import applyDefaultWaitForOpts from '../helpers/applyDefaultWaitForOpts.js'
+import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js'
+import getAllTextContentFromPage from '../internal/getAllTextContentFromPage.js'
+import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
+
+export type TextContentMatcherExpected = string | RegExp
+export type TextContentMatcherOpts = { selector?: string } & WaitForSelectorOptions
 
 export default async function toMatchTextContent(
-  page: Page,
-  text: string,
-  opts: { selector?: string } & WaitForSelectorOptions = {}
+  argumentPassedToExpect: Page,
+  expected: TextContentMatcherExpected,
+  opts: TextContentMatcherOpts = {}
 ) {
-  try {
-    await page.waitForSelector(
-      `${opts.selector || 'body'}::-p-text(${text.replace(/"/g, '\\"')})`,
-      applyDefaultWaitForOpts(opts)
-    )
-    return {
-      pass: true,
-      message: () => {
+  return await evaluateWithRetryAndTimeout(
+    argumentPassedToExpect,
+    async () => {
+      requirePuppeteerPage(argumentPassedToExpect)
+
+      const actual = await getAllTextContentFromPage(argumentPassedToExpect, opts.selector)
+      if (expected instanceof RegExp) expected.lastIndex = 0
+
+      return {
+        pass: typeof expected === 'string' ? actual.includes(expected) : expected.test(actual),
+        actual,
+      }
+    },
+    {
+      successText: () => {
         throw new Error('Cannot negate toMatchTextContent, use toNotMatchTextContent instead')
       },
-    }
-  } catch {
-    return {
-      pass: false,
-      message: () => `
+      failureText: actual => `
 expected ${opts.selector || 'body'} with text:
-        ${text}
+        ${expected.toString()}
 
-but no text was found within that selector
+but no matching text was found within that selector:
+        ${actual}
       `,
+      timeout: opts.timeout,
     }
-  }
+  )
 }

package/src/feature/matchers/toNotMatchTextContent.ts

@@ -1,21 +1,24 @@
-import { Page, WaitForSelectorOptions } from 'puppeteer'
+import { Page } from 'puppeteer'
 import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js'
 import getAllTextContentFromPage from '../internal/getAllTextContentFromPage.js'
 import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
+import type { TextContentMatcherExpected, TextContentMatcherOpts } from './toMatchTextContent.js'
 
 export default async function toNotMatchTextContent(
   argumentPassedToExpect: Page,
-  expected: string,
-  opts: WaitForSelectorOptions = {}
+  expected: TextContentMatcherExpected,
+  opts: TextContentMatcherOpts = {}
 ) {
   return await evaluateWithRetryAndTimeout(
     argumentPassedToExpect,
     async () => {
       requirePuppeteerPage(argumentPassedToExpect)
 
-      const actual = await getAllTextContentFromPage(argumentPassedToExpect)
+      const actual = await getAllTextContentFromPage(argumentPassedToExpect, opts.selector)
+      if (expected instanceof RegExp) expected.lastIndex = 0
+
       return {
-        pass: !actual.includes(expected),
+        pass: typeof expected === 'string' ? !actual.includes(expected) : !expected.test(actual),
         actual,
       }
     },
@@ -23,7 +26,7 @@ export default async function toNotMatchTextContent(
       successText: () => {
         throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead')
       },
-      failureText: r => `Expected ${r} to not match text ${expected}, but it did`,
+      failureText: r => `Expected ${r} to not match text ${expected.toString()}, but it did`,
       timeout: opts.timeout,
     }
   )

package/src/index.ts

@@ -2,6 +2,10 @@ import { Page, WaitForSelectorOptions } from 'puppeteer'
 import { CustomMatcherResult } from './feature/helpers/providePuppeteerViteMatchers.js'
 import { ExpectToEvaluateOpts } from './feature/internal/evaluateWithRetryAndTimeout.js'
 import { ToFillMatcherOpts } from './feature/matchers/toFill.js'
+import type {
+  TextContentMatcherExpected,
+  TextContentMatcherOpts,
+} from './feature/matchers/toMatchTextContent.js'
 export {
   RequestBody as OpenapiRequestBody,
   RequestQueryParameters as OpenapiRequestQuery,
@@ -64,10 +68,14 @@ interface PuppeteerAssertions {
   toEqualCalendarDate(expected: any): CustomMatcherResult
 
   // begin: fspec matchers
-  // eslint-disable-next-line
-  toMatchTextContent(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>
-  // eslint-disable-next-line
-  toNotMatchTextContent(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>
+  toMatchTextContent(
+    expected: TextContentMatcherExpected,
+    opts?: TextContentMatcherOpts
+  ): Promise<CustomMatcherResult>
+  toNotMatchTextContent(
+    expected: TextContentMatcherExpected,
+    opts?: TextContentMatcherOpts
+  ): Promise<CustomMatcherResult>
   // eslint-disable-next-line
   toHaveSelector(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>
   // eslint-disable-next-line