@qaguardian/playwright-score 0.1.11 → 0.1.13

package/dist/formatters/markdown.js

@@ -24,7 +24,7 @@ export function formatMarkdown(result) {
     }
     if (result.skippedFiles?.length) {
         lines.push('');
-        lines.push(`<details><summary>Skipped — looks like a non-Playwright test (Jest/Vitest/RTL) (${result.skippedFiles.length})</summary>`);
+        lines.push(`<details><summary>Skipped — looks like a non-Playwright test (Jest/Vitest/RTL/Cypress) (${result.skippedFiles.length})</summary>`);
         lines.push('');
         for (const f of result.skippedFiles) {
             lines.push(`- \`${f}\``);

package/dist/formatters/text.js

@@ -26,7 +26,7 @@ export function formatText(result) {
     }
     if (result.skippedFiles?.length) {
         lines.push('');
-        lines.push(`Skipped (looks like a non-Playwright test — Jest/Vitest/RTL — ${result.skippedFiles.length}):`);
+        lines.push(`Skipped (looks like a non-Playwright test — Jest/Vitest/RTL/Cypress — ${result.skippedFiles.length}):`);
         for (const f of result.skippedFiles.slice(0, 20)) {
             lines.push(`  ${f}`);
         }

package/dist/index.js

@@ -14,7 +14,20 @@ export { formatJson } from './formatters/json.js';
 export { formatText } from './formatters/text.js';
 export { formatMarkdown } from './formatters/markdown.js';
 export { formatSarif } from './formatters/sarif.js';
-const SPEC_GLOBS = ['**/*.{spec,test}.{ts,tsx,js,jsx}', '**/*.spec.ts', '**/*.test.ts'];
+// `.e2e.` is a real, common convention for disambiguating end-to-end specs
+// from unit tests living in the same tree — verified against a
+// well-known, large real-world repo (cal.com: 53 real Playwright specs,
+// all named *.e2e.ts, zero *.spec.ts/*.test.ts) where a directory scan
+// previously hard-failed with "no files matched" despite a fully healthy,
+// populated suite. looksLikeNonPlaywrightTest (see metrics.ts) is the
+// safety net for a repo that uses `.e2e.` for a *different* framework —
+// Cypress specifically was common enough here to get its own explicit
+// check alongside the existing Jest/Vitest/RTL ones.
+const SPEC_GLOBS = [
+    '**/*.{spec,test,e2e}.{ts,tsx,js,jsx}',
+    '**/*.spec.ts',
+    '**/*.test.ts',
+];
 // Directory/glob expansion must never sweep in vendored or generated code —
 // verified as a real bug: scanning a project root with a plain node_modules
 // dependency that ships its own *.spec.ts files silently included them
@@ -43,7 +56,7 @@ const DEFAULT_IGNORE_GLOBS = [
  * `expanded`: everything else (matched via a directory scan or a glob
  * pattern) — subject to the looksLikePlaywrightSpec filter in scorePaths,
  * since a broad `**\/*.test.ts`-style match can just as easily sweep in
- * unrelated Jest/Vitest/RTL unit tests sitting in the same repo.
+ * unrelated Jest/Vitest/RTL/Cypress unit tests sitting in the same repo.
  */
 function expandPaths(inputs, cwd) {
     const explicit = new Set();
@@ -166,7 +179,7 @@ export async function scorePaths(options) {
             {
                 rule: 'playwright-score/no-files',
                 severity: 'error',
-                message: `${expanded.length} file(s) matched but all look like non-Playwright tests (Jest/Vitest/RTL) — nothing to score.`,
+                message: `${expanded.length} file(s) matched but all look like non-Playwright tests (Jest/Vitest/RTL/Cypress) — nothing to score.`,
                 file: cwd,
                 dimension: 'structure',
             },

package/dist/metrics.d.ts

@@ -1,30 +1,41 @@
 import type { Finding, LocatorCounts } from './types.js';
 /**
  * Heuristic: does this file show positive evidence of being a *non*-
- * Playwright test (Jest/Vitest/Mocha/Jasmine/React Testing Library), as
- * opposed to a Playwright spec that a broad `**\/*.test.ts` glob would
- * otherwise sweep in alongside real e2e specs? Used only to decide whether
- * to auto-exclude a file discovered via directory/glob expansion — never
- * applied to a file path the caller named explicitly.
+ * Playwright test (Jest/Vitest/Mocha/Jasmine/React Testing Library/
+ * Cypress), as opposed to a Playwright spec that a broad `**\/*.test.ts`
+ * glob would otherwise sweep in alongside real e2e specs? Used only to
+ * decide whether to auto-exclude a file discovered via directory/glob
+ * expansion — never applied to a file path the caller named explicitly.
  */
 export declare function looksLikeNonPlaywrightTest(source: string): boolean;
 export declare function countLocators(source: string, file?: string): LocatorCounts;
 /**
- * Names of same-file functions (function declarations, or a const bound to
- * an arrow/function expression) whose own body contains an expect(...)-
- * shaped call anywhere. Fed into playwright/expect-expect's own
- * assertFunctionNames option (see eslint-runner.ts) so a test that
- * delegates its assertion to a locally-defined helper — `audit(page,
- * path)`, `checkFlashMessageVisibility(page, msg)`, `assertDashboardLoaded`
- * — isn't flagged as having no assertions, regardless of what the helper
- * happens to be named. expect-expect can only see expect() calls written
- * directly in the test body, so without this, delegating to a helper at
- * all — an extremely common way to dedupe near-identical specs — reads as
- * "no assertions"; verified against several real production files using
- * several different naming conventions for the exact same shape.
- * Deliberately local-only: a helper imported from another file can't be
- * resolved without following module specifiers and parsing that file too,
- * well beyond what a fast, per-file syntactic check should attempt.
+ * Names of same-file assertion helpers — function declarations, a const
+ * bound to an arrow/function expression, or a class method (`kind:
+ * 'method'`, e.g. a Page Object Model's `async expectNodeVisible(name) {
+ * await expect(...) }`) — whose own body contains an expect(...)-shaped
+ * call, a `.waitFor(...)` call (see containsWaitForCall), or a call to a
+ * name already recognized by an earlier round (so e.g.
+ * `waitForNotificationAndClose()` calling `this.waitForNotification()`,
+ * itself resolved to a direct `.waitFor()` call, is recognized too —
+ * verified against a real Page Object Model, n8n's NotificationsPage,
+ * where the assertion sits two calls deep). Fed into
+ * playwright/expect-expect's own assertFunctionNames option (see
+ * eslint-runner.ts) so a test that delegates its assertion to a helper —
+ * `audit(page, path)`, `canvas.expectNodeVisible(name)`,
+ * `n8n.notifications.waitForNotificationAndClose(text)` — isn't flagged as
+ * having no assertions, regardless of what the helper is named or how
+ * deep the delegation chain runs *within this one file*. Matching is by
+ * name only, any receiver — the same tradeoff eslint-plugin-playwright's
+ * own option already makes, so this doesn't introduce a new risk, just
+ * extends an already-accepted one from free functions to methods too; a
+ * coincidental name collision between an asserting and non-asserting
+ * function is the known, accepted failure mode, same as before.
+ * Deliberately single-file only: resolving `this.foo()` across file
+ * boundaries needs real type resolution, well beyond what a fast,
+ * syntactic per-file check should attempt (cross-*file* delegation is
+ * handled separately, at the call site in index.ts, by running this same
+ * function against each imported dependency file too).
  */
 export declare function findLocalAssertionHelperNames(source: string, file?: string): string[];
 /** Count test( / test.only( / test.skip( / test.fixme( style declarations (approx). */

package/dist/metrics.js

@@ -13,18 +13,27 @@ import { countSloc } from './sloc.js';
 // in one real suite). Denylisting known non-Playwright frameworks is much
 // safer — a missed rare/unusual file just scores harmlessly, where a
 // falsely-skipped real spec silently stops being scored at all.
-const NON_PLAYWRIGHT_IMPORT_RE = /from\s+['"](?:vitest|jest|@jest\/[a-z-]+|mocha|jasmine|chai|@testing-library\/[a-z-]+)['"]/;
+const NON_PLAYWRIGHT_IMPORT_RE = /from\s+['"](?:vitest|jest|@jest\/[a-z-]+|mocha|jasmine|chai|@testing-library\/[a-z-]+|cypress)['"]/;
 const RTL_API_RE = /\bscreen\.(?:getBy|queryBy|findBy|getAllBy|queryAllBy|findAllBy)\w*\(|\btoBeInTheDocument\(/;
+// Cypress's `cy` command object is globally available without an import in
+// the framework's default setup, the same way RTL's `screen` often is —
+// matched on specific, common Cypress command names (not a bare `cy.`
+// prefix) to avoid colliding with an unrelated local variable named `cy`.
+// Added alongside SPEC_GLOBS picking up `*.e2e.*` by default (see
+// index.ts): `.e2e.` is Cypress's own scaffolding convention too, so
+// broadening spec discovery to that suffix needed this as a companion
+// safety net, not just Playwright's own conventions.
+const CYPRESS_API_RE = /\bcy\.(?:visit|get|contains|click|type|should|intercept|wait|request|fixture)\(/;
 /**
  * Heuristic: does this file show positive evidence of being a *non*-
- * Playwright test (Jest/Vitest/Mocha/Jasmine/React Testing Library), as
- * opposed to a Playwright spec that a broad `**\/*.test.ts` glob would
- * otherwise sweep in alongside real e2e specs? Used only to decide whether
- * to auto-exclude a file discovered via directory/glob expansion — never
- * applied to a file path the caller named explicitly.
+ * Playwright test (Jest/Vitest/Mocha/Jasmine/React Testing Library/
+ * Cypress), as opposed to a Playwright spec that a broad `**\/*.test.ts`
+ * glob would otherwise sweep in alongside real e2e specs? Used only to
+ * decide whether to auto-exclude a file discovered via directory/glob
+ * expansion — never applied to a file path the caller named explicitly.
  */
 export function looksLikeNonPlaywrightTest(source) {
-    return NON_PLAYWRIGHT_IMPORT_RE.test(source) || RTL_API_RE.test(source);
+    return NON_PLAYWRIGHT_IMPORT_RE.test(source) || RTL_API_RE.test(source) || CYPRESS_API_RE.test(source);
 }
 const NATIVE_METHODS = new Set([
     'getByRole',
@@ -172,27 +181,88 @@ function containsExpectCall(node) {
     return found;
 }
 /**
- * Names of same-file functions (function declarations, or a const bound to
- * an arrow/function expression) whose own body contains an expect(...)-
- * shaped call anywhere. Fed into playwright/expect-expect's own
- * assertFunctionNames option (see eslint-runner.ts) so a test that
- * delegates its assertion to a locally-defined helper — `audit(page,
- * path)`, `checkFlashMessageVisibility(page, msg)`, `assertDashboardLoaded`
- * — isn't flagged as having no assertions, regardless of what the helper
- * happens to be named. expect-expect can only see expect() calls written
- * directly in the test body, so without this, delegating to a helper at
- * all — an extremely common way to dedupe near-identical specs — reads as
- * "no assertions"; verified against several real production files using
- * several different naming conventions for the exact same shape.
- * Deliberately local-only: a helper imported from another file can't be
- * resolved without following module specifiers and parsing that file too,
- * well beyond what a fast, per-file syntactic check should attempt.
+ * `locator.waitFor({ state: ... })` (state defaults to `'visible'` when
+ * omitted) has no purpose other than verifying the element reaches a
+ * state — unlike an action method (`.click()`, `.fill()`) that also
+ * happens to throw on failure as a side effect, this call exists only to
+ * check something, functionally equivalent to
+ * `expect(locator).toBeVisible()`/`toBeHidden()`. Matched on the exact
+ * property name `waitFor` (not a prefix), so it can't be confused with
+ * Page's differently-named `waitForEvent`/`waitForURL`/`waitForResponse`/
+ * `waitForLoadState`/`waitForTimeout`, none of which are assertions.
+ */
+function containsWaitForCall(node) {
+    let found = false;
+    walk(node, (n) => {
+        if (found || n.type !== 'CallExpression')
+            return;
+        const callee = n.callee;
+        if (callee?.type !== 'MemberExpression' || callee.computed)
+            return;
+        const property = callee.property;
+        if (property?.type === 'Identifier' && property.name === 'waitFor')
+            found = true;
+    });
+    return found;
+}
+/** Does `node`'s body contain a call (any receiver, matched by name only —
+ * same name-based matching eslint-plugin-playwright's own
+ * assertFunctionNames option uses) to one of `names`? */
+function containsCallToAnyName(node, names) {
+    if (names.size === 0)
+        return false;
+    let found = false;
+    walk(node, (n) => {
+        if (found || n.type !== 'CallExpression')
+            return;
+        const callee = n.callee;
+        let name;
+        if (callee?.type === 'Identifier') {
+            name = callee.name;
+        }
+        else if (callee?.type === 'MemberExpression' && !callee.computed) {
+            const property = callee.property;
+            if (property?.type === 'Identifier')
+                name = property.name;
+        }
+        if (name && names.has(name))
+            found = true;
+    });
+    return found;
+}
+/**
+ * Names of same-file assertion helpers — function declarations, a const
+ * bound to an arrow/function expression, or a class method (`kind:
+ * 'method'`, e.g. a Page Object Model's `async expectNodeVisible(name) {
+ * await expect(...) }`) — whose own body contains an expect(...)-shaped
+ * call, a `.waitFor(...)` call (see containsWaitForCall), or a call to a
+ * name already recognized by an earlier round (so e.g.
+ * `waitForNotificationAndClose()` calling `this.waitForNotification()`,
+ * itself resolved to a direct `.waitFor()` call, is recognized too —
+ * verified against a real Page Object Model, n8n's NotificationsPage,
+ * where the assertion sits two calls deep). Fed into
+ * playwright/expect-expect's own assertFunctionNames option (see
+ * eslint-runner.ts) so a test that delegates its assertion to a helper —
+ * `audit(page, path)`, `canvas.expectNodeVisible(name)`,
+ * `n8n.notifications.waitForNotificationAndClose(text)` — isn't flagged as
+ * having no assertions, regardless of what the helper is named or how
+ * deep the delegation chain runs *within this one file*. Matching is by
+ * name only, any receiver — the same tradeoff eslint-plugin-playwright's
+ * own option already makes, so this doesn't introduce a new risk, just
+ * extends an already-accepted one from free functions to methods too; a
+ * coincidental name collision between an asserting and non-asserting
+ * function is the known, accepted failure mode, same as before.
+ * Deliberately single-file only: resolving `this.foo()` across file
+ * boundaries needs real type resolution, well beyond what a fast,
+ * syntactic per-file check should attempt (cross-*file* delegation is
+ * handled separately, at the call site in index.ts, by running this same
+ * function against each imported dependency file too).
  */
 export function findLocalAssertionHelperNames(source, file) {
     const ast = parseSource(source, file);
     if (!ast)
         return [];
-    const names = new Set();
+    const candidates = [];
     walk(ast, (node) => {
         let name;
         let body;
@@ -212,9 +282,35 @@ export function findLocalAssertionHelperNames(source, file) {
                 body = init;
             }
         }
-        if (name && body && containsExpectCall(body))
-            names.add(name);
+        else if (node.type === 'MethodDefinition') {
+            const key = node.key;
+            if (!node.computed && key?.type === 'Identifier' && node.kind === 'method') {
+                name = key.name;
+                body = node.value;
+            }
+        }
+        if (name && body)
+            candidates.push({ name, body });
     });
+    const names = new Set();
+    for (const c of candidates) {
+        if (containsExpectCall(c.body) || containsWaitForCall(c.body))
+            names.add(c.name);
+    }
+    // Fixed-point: naturally bounded by candidates.length rounds, since each
+    // round adds at least one name or the loop stops.
+    let added = true;
+    while (added) {
+        added = false;
+        for (const c of candidates) {
+            if (names.has(c.name))
+                continue;
+            if (containsCallToAnyName(c.body, names)) {
+                names.add(c.name);
+                added = true;
+            }
+        }
+    }
     return [...names];
 }
 const TEST_NON_DECL_RE = /\btest\.(describe|step|beforeEach|afterEach|beforeAll|afterAll|use|setTimeout|info|expect)\b/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qaguardian/playwright-score",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Deterministic, AI-free Playwright spec quality score (sqs-v1). Lint + score with standard and guardian profiles.",
   "type": "module",
   "main": "./dist/index.js",