@qaguardian/playwright-score 2.0.0 → 2.1.1

package/dist/index.js

@@ -1,10 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { globSync } from 'glob';
+import { globSync, hasMagic, Ignore } from 'glob';
 import { runEslint } from './eslint-runner.js';
 import { commonAncestorDir } from './fs-util.js';
 import { collectLocallyImportedFiles } from './import-graph.js';
 import { analyzeSource, attributeFindingScopes, countLocators, findLocalAssertionHelperNames, getTestSpans, looksLikeNonPlaywrightTest, } from './metrics.js';
+import { detectExtendedTestAliases } from './test-aliases.js';
+import { findPlaywrightConfig, findRepoBoundary, importsPlaywrightTestTransitively, isAncestorOrSame, parsePlaywrightConfig, resolveConfigScopedRoot, safeRealpath, testDirEscapesRepo, } from './playwright-config.js';
 import { DEFAULT_THRESHOLDS } from './profiles.js';
 import { computeScore } from './score-engine.js';
 export { computeScore, MODEL, locatorsScore, gradeFromScore, ratioDimensionScore, } from './score-engine.js';
@@ -55,6 +57,86 @@ const DEFAULT_IGNORE_GLOBS = [
     '**/playwright-report/**',
     '**/test-results/**',
 ];
+/**
+ * Wraps glob's own default `Ignore` (the string-pattern matcher behind
+ * DEFAULT_IGNORE_GLOBS/testIgnore) so this package can *also* prune the
+ * walk at a symlinked directory whose realpath escapes `realRoot`,
+ * without giving up the string-pattern ignores glob's `ignore` option
+ * only accepts one or the other of (a plain string[] XOR an IgnoreLike
+ * object — see glob's own types).
+ *
+ * Only `childrenIgnored` does the extra realpath work, and only for an
+ * actual symlink: a plain (non-symlinked) directory can't walk outside a
+ * root its own parent is already inside, so resolving its realpath would
+ * just be wasted syscalls on every directory in a large tree. This is
+ * what stops discovery from following a `testDir -> /` (or any other
+ * huge, real) symlinked directory arbitrarily far (QAG-230) — the
+ * per-match realpath containment check in expandPaths below still
+ * catches an escaping *match*, but only after the walk already paid to
+ * get there; this stops the walk itself from ever descending.
+ */
+class RepoBoundaryIgnore {
+    realRoot;
+    inner;
+    constructor(patterns, realRoot) {
+        this.realRoot = realRoot;
+        this.inner = new Ignore(patterns, {});
+    }
+    ignored(p) {
+        return this.inner.ignored(p);
+    }
+    // Forwarded, not required by any globSync call this package makes today
+    // (includeChildMatches defaults to true, which never checks for this) —
+    // present anyway so relying on that default doesn't quietly become a
+    // hard requirement if it's ever overridden.
+    add(pattern) {
+        this.inner.add(pattern);
+    }
+    childrenIgnored(p) {
+        if (this.inner.childrenIgnored(p))
+            return true;
+        if (!p.isSymbolicLink())
+            return false;
+        return !isAncestorOrSame(this.realRoot, safeRealpath(p.fullpath()));
+    }
+}
+/**
+ * The literal (non-magic) leading-directory prefix of a raw glob pattern
+ * string, resolved against `cwd` — e.g. `/abs/repoB/e2e/*.spec.ts` ->
+ * `/abs/repoB/e2e`; `../repoB/e2e/*.spec.ts` -> `<cwd>/../repoB/e2e`
+ * (collapsed by path.resolve). Used to find *that pattern's own* repo
+ * boundary (QAG-230 round 3): a bare glob-pattern input isn't necessarily
+ * anywhere near `cwd`'s own repo — it can be an absolute path, or a
+ * relative one that climbs out via `../` — into a completely different
+ * repo, and computing containment from cwd's repo root regardless made
+ * every match there look like an escape (hard-failing a perfectly legit
+ * `['/abs/repoB/e2e/*.spec.ts']` down to 0 files, where the equivalent
+ * directory input `../repoB/e2e` already scored fine).
+ *
+ * Segments are checked with glob's own `hasMagic` — with `magicalBraces`
+ * on, since an unexpanded `{a,b}` segment isn't a real, literal directory
+ * name any more than a `*` is — so this only ever returns a directory
+ * that's guaranteed to be a plain path segment, never a piece the glob
+ * engine itself still has to interpret.
+ */
+function literalPrefixDir(pattern, cwd) {
+    const segments = pattern.split('/');
+    const prefix = [];
+    let sawMagic = false;
+    for (const segment of segments) {
+        if (hasMagic(segment, { magicalBraces: true })) {
+            sawMagic = true;
+            break;
+        }
+        prefix.push(segment);
+    }
+    // No magic anywhere in the pattern: it's a literal path (only reachable
+    // here because it didn't exist on disk — an existing path is handled by
+    // the file/directory branches above) — its directory is the parent of
+    // the last (literal) segment, not the whole joined string.
+    const dirSegments = sawMagic ? prefix : prefix.slice(0, -1);
+    return path.resolve(cwd, dirSegments.join('/') || '.');
+}
 /**
  * `explicit`: paths the caller named directly (a literal existing file) —
  * always scored, regardless of whether they look like a Playwright spec.
@@ -67,6 +149,7 @@ function expandPaths(inputs, cwd) {
     const explicit = new Set();
     const expanded = new Set();
     const scanRootDirs = new Set();
+    const configWarnings = [];
     for (const input of inputs) {
         const abs = path.isAbsolute(input) ? input : path.resolve(cwd, input);
         if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
@@ -81,28 +164,220 @@ function expandPaths(inputs, cwd) {
             // needs this wider boundary, not the narrower common ancestor of
             // only the matched spec files.
             scanRootDirs.add(abs);
-            for (const g of SPEC_GLOBS) {
+            // Repo boundary for this scan's per-match realpath containment check
+            // and glob-walk pruning below (see the containment check itself, and
+            // RepoBoundaryIgnore, for why this must be the *repo root*, not the
+            // narrower `abs`): a scan pointed at one monorepo package's specs
+            // must still keep an in-repo symlink that resolves to a sibling
+            // directory outside that subpath, while still rejecting anything
+            // that resolves outside the repo entirely (QAG-230). Starts with the
+            // same conservative fallback-to-`abs` findRepoBoundary uses
+            // elsewhere in this file; replaced below with the wider boundary a
+            // successfully parsed config already computes for testDirEscapesRepo,
+            // so both checks share one repo boundary instead of computing it
+            // twice.
+            let repoRootForContainment = findRepoBoundary(abs, abs);
+            // A playwright.config.* at or above this directory, when it can be
+            // read statically, is authoritative about what this target itself
+            // considers a spec — see playwright-config.ts. Falls back to the
+            // filename-suffix SPEC_GLOBS (today's behavior) whenever a config
+            // isn't found, doesn't overlap this scan, or can't be parsed
+            // statically (a dynamic/unsupported shape) — the last case surfaces
+            // a warning rather than silently guessing.
+            let globCwd = abs;
+            let specGlobs = SPEC_GLOBS;
+            let ignoreGlobs = DEFAULT_IGNORE_GLOBS;
+            let configApplied = false;
+            // Boundary for the transitive-import safety net below — widened to
+            // the config's own directory (not `abs`), for the same reason
+            // import-graph.ts already widens its own POM boundary past the
+            // matched spec files' common ancestor: a fixtures module a spec
+            // imports test/expect from commonly lives in a directory *sibling*
+            // to testDir (`playwright/fixtures` next to `playwright/tests`), not
+            // inside it. Verified against a real config (appsmithorg/appsmith)
+            // where every real spec imports `test`/`expect` from `../../fixtures`
+            // — bounding resolution to `abs` (testDir itself) made every file
+            // fail the check and silently zeroed the whole suite, the same
+            // false-negative failure mode this safety net exists to prevent.
+            let importSafetyNetBoundary = abs;
+            const configFile = findPlaywrightConfig(abs);
+            if (configFile) {
+                const parsedConfig = parsePlaywrightConfig(configFile);
+                if (!parsedConfig) {
+                    configWarnings.push(`Found ${path.relative(cwd, configFile) || configFile} but could not statically parse testDir/testMatch/testIgnore (a dynamic value or unsupported shape) — falling back to filename-based spec discovery for ${path.relative(cwd, abs) || abs}.`);
+                }
+                else {
+                    // Fallback boundary for findRepoBoundary when no .git turns up:
+                    // the config file's own directory when it sits above `abs`
+                    // (found by walking up from abs, so it's always an ancestor-or-
+                    // same of it), else `abs` itself. Never the filesystem root or
+                    // 20 levels up — see findRepoBoundary's doc comment.
+                    const repoRoot = findRepoBoundary(abs, path.dirname(configFile));
+                    repoRootForContainment = repoRoot;
+                    if (testDirEscapesRepo(parsedConfig.testDirAbs, repoRoot)) {
+                        // The config's testDir resolves outside the repo boundary
+                        // (directly, or via a symlink — see testDirEscapesRepo). Its
+                        // testMatch/testIgnore were written for that escaped testDir,
+                        // so applying them to the clamped repoRoot instead would be a
+                        // silent mismatch; fall back to filename-based discovery.
+                        configWarnings.push(`Found ${path.relative(cwd, configFile) || configFile} but its testDir (${path.relative(cwd, parsedConfig.testDirAbs) || parsedConfig.testDirAbs}) resolves outside the repository (${path.relative(cwd, repoRoot) || repoRoot}) — falling back to filename-based spec discovery for ${path.relative(cwd, abs) || abs}.`);
+                    }
+                    else {
+                        const scopedRoot = resolveConfigScopedRoot(abs, parsedConfig.testDirAbs, repoRoot);
+                        if (scopedRoot) {
+                            globCwd = scopedRoot;
+                            if (parsedConfig.testMatch)
+                                specGlobs = parsedConfig.testMatch;
+                            if (parsedConfig.testIgnore) {
+                                ignoreGlobs = [...DEFAULT_IGNORE_GLOBS, ...parsedConfig.testIgnore];
+                            }
+                            configApplied = true;
+                            importSafetyNetBoundary = path.dirname(configFile);
+                        }
+                    }
+                }
+            }
+            const realRepoRoot = safeRealpath(repoRootForContainment);
+            for (const g of specGlobs) {
                 for (const f of globSync(g, {
-                    cwd: abs,
+                    cwd: globCwd,
                     absolute: true,
                     nodir: true,
-                    ignore: DEFAULT_IGNORE_GLOBS,
+                    // RepoBoundaryIgnore keeps ignoreGlobs' own string-pattern
+                    // matching (node_modules/, testIgnore, ...) and *additionally*
+                    // stops the walk from ever descending into a symlinked directory
+                    // whose realpath escapes realRepoRoot — see its own doc comment.
+                    // Pruning during the walk (not just filtering matches after the
+                    // fact, below) is what keeps a `testDir/evil -> /` (or any
+                    // other huge, real symlinked target) from making discovery
+                    // actually walk arbitrary parts of the filesystem (QAG-230).
+                    ignore: new RepoBoundaryIgnore(ignoreGlobs, realRepoRoot),
+                    // glob's own default for `follow` is already false (don't
+                    // descend into a symlinked directory while expanding `**`), but
+                    // this is untrusted-repo territory (see testDirEscapesRepo
+                    // above), so pin it explicitly rather than relying on a default
+                    // that could change upstream.
+                    follow: false,
                 })) {
-                    expanded.add(path.resolve(f));
+                    const resolved = path.resolve(f);
+                    // testDirEscapesRepo (above) only clamps testDir itself before
+                    // it becomes a glob root — it can't see what the glob then
+                    // actually walks *through* on the way to a match. A testMatch
+                    // entry that names a symlinked directory by a literal path
+                    // segment (not a `**` wildcard) still gets followed even with
+                    // `follow: false` on the globSync call above, since that option
+                    // only stops `**` from *expanding into* a symlinked directory —
+                    // it doesn't stop a pattern from naming one explicitly (e.g.
+                    // `tests/evil -> /` with `testMatch: ['evil/**/*.ts']` walks
+                    // `/`, and every match still lexically looks like it's under
+                    // `abs`). The same gap lets an individually symlinked spec file
+                    // sitting directly in the repo (no testMatch trickery needed)
+                    // resolve to a file outside it. A lexical containment check
+                    // can't catch either case — both matches still "look" like they
+                    // live under `abs` right up until the symlink is resolved — so
+                    // this compares realpaths on both sides. Checked against the
+                    // *repo root* (realRepoRoot), not `abs` itself: a scan pointed
+                    // at one monorepo package's specs must still keep a match that
+                    // resolves, in-repo, to a sibling directory outside that
+                    // subpath — only a true escape of the repo itself is dropped
+                    // here (QAG-230; the config-scoped re-narrowing to `abs` right
+                    // below handles the "don't silently widen past what the caller
+                    // asked for" half of this separately).
+                    if (!isAncestorOrSame(realRepoRoot, safeRealpath(resolved)))
+                        continue;
+                    // resolveConfigScopedRoot always globs from testDir (Playwright's
+                    // own testMatch/testIgnore semantics — see its doc comment), which
+                    // can be wider than the directory the caller actually pointed
+                    // `scorePaths` at (a narrower `abs`, e.g. one subproject's specs
+                    // inside a monorepo testDir that also covers others). Filter back
+                    // down to what the caller asked for so scoping to testDir for
+                    // correct path matching never silently widens the scored set.
+                    if (configApplied && globCwd !== abs) {
+                        const rel = path.relative(abs, resolved);
+                        if (rel.startsWith('..') || path.isAbsolute(rel))
+                            continue;
+                    }
+                    // Extra safety net, only once config-based discovery is actually
+                    // driving this scan: testMatch can still be broader than intended
+                    // (e.g. a generic '**/*.ts'); a file that imports neither
+                    // '@playwright/test' directly nor (transitively, through a local
+                    // module) re-exports it isn't a Playwright spec regardless of
+                    // what the config's glob matched.
+                    if (configApplied) {
+                        let source;
+                        try {
+                            source = fs.readFileSync(resolved, 'utf8');
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (!importsPlaywrightTestTransitively(resolved, source, importSafetyNetBoundary))
+                            continue;
+                    }
+                    expanded.add(resolved);
                 }
             }
             continue;
         }
-        // treat as glob
+        // treat as glob — a raw pattern the caller passed directly (e.g.
+        // `tests/*.spec.ts`), resolved relative to `cwd` rather than a
+        // directory this function itself walked. Same realpath containment
+        // and walk-pruning as the directory branch above applies here too
+        // (QAG-230): a bare glob input is just as capable of naming a
+        // symlinked path segment explicitly, and skipping this check here
+        // would have made switching from a directory argument to an
+        // equivalent glob argument silently bypass it.
+        //
+        // The boundary itself comes from *this pattern's own* literal prefix
+        // directory (literalPrefixDir), not from `cwd` (QAG-230 round 3) — see
+        // that function's doc comment for why cwd's repo root is the wrong
+        // boundary for a pattern that points somewhere else entirely.
+        const prefixDir = literalPrefixDir(input, cwd);
+        const repoRootForPattern = safeRealpath(findRepoBoundary(prefixDir, prefixDir));
         for (const f of globSync(input, {
             cwd,
             absolute: true,
             nodir: true,
-            ignore: DEFAULT_IGNORE_GLOBS,
+            ignore: new RepoBoundaryIgnore(DEFAULT_IGNORE_GLOBS, repoRootForPattern),
+            follow: false,
         })) {
-            expanded.add(path.resolve(f));
+            const resolved = path.resolve(f);
+            if (!isAncestorOrSame(repoRootForPattern, safeRealpath(resolved)))
+                continue;
+            expanded.add(resolved);
         }
     }
+    // De-dupe by realpath: an in-repo symlinked spec and its real target can
+    // both independently match discovery (the symlink itself sitting under
+    // one scanned root, its target sitting somewhere else under the same
+    // repo) and would otherwise be scored twice, as if they were two
+    // different files. Keeps the first lexical path per realpath, in sorted
+    // order, so which one "wins" is deterministic rather than depending on
+    // Set insertion order. Pre-existing gap, not new to the escape fixes
+    // above — those only ever drop a true escape, never a legitimate
+    // in-repo duplicate (see CHANGELOG: this can change file counts for a
+    // repo that happens to have such a link).
+    const firstPathByRealpath = new Map();
+    // Seeded with `explicit`'s own realpaths first: an explicit target and a
+    // directory scan containing a symlink to that same file are two
+    // different literal paths for the same file, so the plain "explicit
+    // wins" delete below (which only matches identical literal paths) can't
+    // catch that pairing — without this seeding, the symlinked match survives
+    // dedup (its realpath hadn't been seen yet) and gets scored a second
+    // time alongside the explicit path.
+    for (const f of [...explicit].sort()) {
+        const real = safeRealpath(f);
+        if (!firstPathByRealpath.has(real))
+            firstPathByRealpath.set(real, f);
+    }
+    for (const f of [...expanded].sort()) {
+        const real = safeRealpath(f);
+        if (!firstPathByRealpath.has(real))
+            firstPathByRealpath.set(real, f);
+    }
+    expanded.clear();
+    for (const f of firstPathByRealpath.values())
+        expanded.add(f);
     // A file can be reached both explicitly and via expansion (e.g. an
     // explicit path plus an overlapping glob); explicit intent wins.
     for (const f of explicit)
@@ -111,9 +386,10 @@ function expandPaths(inputs, cwd) {
         explicit: [...explicit].sort(),
         expanded: [...expanded].sort(),
         scanRootDirs: [...scanRootDirs].sort(),
+        configWarnings,
     };
 }
-function hardFail(profile, threshold, findings, extra = {}, skippedFiles) {
+function hardFail(profile, threshold, findings, extra = {}, skippedFiles, configWarnings) {
     return {
         scoreVersion: 'v4',
         profile,
@@ -142,6 +418,7 @@ function hardFail(profile, threshold, findings, extra = {}, skippedFiles) {
         },
         findings,
         ...(skippedFiles && skippedFiles.length > 0 ? { skippedFiles } : {}),
+        ...(configWarnings && configWarnings.length > 0 ? { configWarnings } : {}),
     };
 }
 /**
@@ -151,7 +428,7 @@ export async function scorePaths(options) {
     const cwd = options.cwd ?? process.cwd();
     const profile = options.profile ?? 'standard';
     const threshold = options.threshold ?? DEFAULT_THRESHOLDS[profile] ?? 80;
-    const { explicit, expanded, scanRootDirs } = expandPaths(options.paths, cwd);
+    const { explicit, expanded, scanRootDirs, configWarnings } = expandPaths(options.paths, cwd);
     if (explicit.length === 0 && expanded.length === 0) {
         // Hard-fail: empty match must never look like a healthy suite (was ~99 PASS).
         return hardFail(profile, threshold, [
@@ -162,7 +439,7 @@ export async function scorePaths(options) {
                 file: cwd,
                 dimension: 'structure',
             },
-        ]);
+        ], {}, undefined, configWarnings);
     }
     // Directory/glob matches are excluded only on positive evidence of a
     // non-Playwright test framework — see looksLikeNonPlaywrightTest. Paths
@@ -229,11 +506,20 @@ export async function scorePaths(options) {
             assertFunctionNames.add(name);
         }
     }
+    // Identifiers bound to a `test.extend(...)`-derived fixture under a
+    // custom name (same-file, or imported from a local fixtures module —
+    // see test-aliases.ts), so a suite that always declares its tests via
+    // `loggedTest(...)` instead of `test(...)` is recognized correctly by
+    // both eslint-plugin-playwright's rules (fed via runEslint's settings
+    // below) and this package's own AST checks (getTestSpans/countTests,
+    // base-plugin.ts).
+    const testAliasNames = detectExtendedTestAliases(sources, importedFiles, importBoundary);
     const eslintFindings = await runEslint({
         files,
         profile,
         cwd,
         assertFunctionNames: [...assertFunctionNames],
+        testAliasNames,
     });
     let totalSloc = 0;
     let totalTests = 0;
@@ -245,12 +531,12 @@ export async function scorePaths(options) {
     for (const file of files) {
         const source = sources.get(file) ?? '';
         const relFile = path.relative(filesBase, file) || path.basename(file);
-        const m = analyzeSource(source, relFile);
+        const m = analyzeSource(source, relFile, testAliasNames);
         totalSloc += m.sloc;
         native += m.locators.native;
         raw += m.locators.raw;
         metricFindings.push(...m.findings);
-        const spans = getTestSpans(source, relFile);
+        const spans = getTestSpans(source, relFile, testAliasNames);
         fileSpans.set(relFile, spans);
         // AST spans are the authoritative test count (they are also the
         // attribution targets); the regex count is the fallback for a file
@@ -293,5 +579,9 @@ export async function scorePaths(options) {
         nativeLocators: native,
         rawLocators: raw,
     });
-    return skippedFiles.length > 0 ? { ...result, skippedFiles } : result;
+    return {
+        ...result,
+        ...(skippedFiles.length > 0 ? { skippedFiles } : {}),
+        ...(configWarnings.length > 0 ? { configWarnings } : {}),
+    };
 }

package/dist/metrics.d.ts

@@ -61,8 +61,14 @@ export interface TestSpans {
  * for `test.fixme()` used as a statement. Spans nested inside another test
  * span (rare, but e.g. a helper declaring a test inside a test would be
  * malformed anyway) are dropped so each line maps to at most one test.
+ *
+ * `testAliasNames` (see test-aliases.ts) are identifiers bound to a
+ * `test.extend(...)`-derived fixture (`const loggedTest = test.extend(...)`,
+ * possibly imported from another file) — treated exactly like the literal
+ * `test` identifier here, same as `it`. Without this, a suite that always
+ * calls its extended fixture under a custom name would count zero tests.
  */
-export declare function getTestSpans(source: string, file?: string): TestSpans;
+export declare function getTestSpans(source: string, file?: string, testAliasNames?: readonly string[]): TestSpans;
 /**
  * Model-v3 finding attribution (see score-engine.ts): a finding inside a
  * test span belongs to that test (`scope: 'test'` + a stable
@@ -75,11 +81,18 @@ export declare function getTestSpans(source: string, file?: string): TestSpans;
  * Mutates the findings in place and returns them.
  */
 export declare function attributeFindingScopes(findings: Finding[], spansByFile: Map<string, TestSpans>): Finding[];
-/** Count test( / test.only( / test.skip( / test.fixme( style declarations (approx). */
-export declare function countTests(source: string): number;
+/**
+ * Count test( / test.only( / test.skip( / test.fixme( style declarations
+ * (approx) — the regex fallback used only when `parseSource` can't parse
+ * the file (see `getTestSpans`'s AST path, preferred whenever parsing
+ * succeeds). `testAliasNames` extends the matched identifier the same way
+ * `getTestSpans` does, so a parse-fallback file using an extended-fixture
+ * name isn't undercounted either.
+ */
+export declare function countTests(source: string, testAliasNames?: readonly string[]): number;
 export declare function findOversizedFile(source: string, file: string, maxSloc?: number): Finding[];
 export declare function findEslintDisableComments(source: string, file: string): Finding[];
-export declare function analyzeSource(source: string, file: string): {
+export declare function analyzeSource(source: string, file: string, testAliasNames?: readonly string[]): {
     sloc: number;
     tests: number;
     locators: LocatorCounts;

package/dist/metrics.js

@@ -334,13 +334,21 @@ function hasFunctionArg(node) {
  * for `test.fixme()` used as a statement. Spans nested inside another test
  * span (rare, but e.g. a helper declaring a test inside a test would be
  * malformed anyway) are dropped so each line maps to at most one test.
+ *
+ * `testAliasNames` (see test-aliases.ts) are identifiers bound to a
+ * `test.extend(...)`-derived fixture (`const loggedTest = test.extend(...)`,
+ * possibly imported from another file) — treated exactly like the literal
+ * `test` identifier here, same as `it`. Without this, a suite that always
+ * calls its extended fixture under a custom name would count zero tests.
  */
-export function getTestSpans(source, file) {
+export function getTestSpans(source, file, testAliasNames = []) {
     const tests = [];
     const hooks = [];
     const ast = parseSource(source, file);
     if (!ast)
         return { tests, hooks };
+    const aliasSet = new Set(testAliasNames);
+    const isTestName = (name) => name === 'test' || name === 'it' || aliasSet.has(name);
     walk(ast, (node) => {
         if (node.type !== 'CallExpression')
             return;
@@ -353,7 +361,7 @@ export function getTestSpans(source, file) {
         let isHook = false;
         if (callee?.type === 'Identifier') {
             const name = callee.name;
-            if (name === 'test' || name === 'it')
+            if (name && isTestName(name))
                 isTest = true;
             else if (name && HOOK_NAMES.has(name))
                 isHook = true;
@@ -361,7 +369,7 @@ export function getTestSpans(source, file) {
         else if (callee?.type === 'MemberExpression' && !callee.computed) {
             const obj = callee.object;
             const prop = callee.property;
-            if (obj?.type === 'Identifier' && (obj.name === 'test' || obj.name === 'it') && prop?.type === 'Identifier') {
+            if (obj?.type === 'Identifier' && obj.name && isTestName(obj.name) && prop?.type === 'Identifier') {
                 if (TEST_MODIFIERS.has(prop.name ?? ''))
                     isTest = true;
                 else if (HOOK_NAMES.has(prop.name ?? ''))
@@ -422,10 +430,21 @@ export function attributeFindingScopes(findings, spansByFile) {
     return findings;
 }
 const TEST_NON_DECL_RE = /\btest\.(describe|step|beforeEach|afterEach|beforeAll|afterAll|use|setTimeout|info|expect)\b/;
-/** Count test( / test.only( / test.skip( / test.fixme( style declarations (approx). */
-export function countTests(source) {
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Count test( / test.only( / test.skip( / test.fixme( style declarations
+ * (approx) — the regex fallback used only when `parseSource` can't parse
+ * the file (see `getTestSpans`'s AST path, preferred whenever parsing
+ * succeeds). `testAliasNames` extends the matched identifier the same way
+ * `getTestSpans` does, so a parse-fallback file using an extended-fixture
+ * name isn't undercounted either.
+ */
+export function countTests(source, testAliasNames = []) {
     // Playwright's real modifier API is test.fixme() — not test.fix().
-    const re = /\btest(?:\.(?:only|skip|fixme|slow))?\s*\(/g;
+    const names = ['test', ...testAliasNames].map(escapeRegExp).join('|');
+    const re = new RegExp(`\\b(?:${names})(?:\\.(?:only|skip|fixme|slow))?\\s*\\(`, 'g');
     let count = 0;
     let m;
     while ((m = re.exec(source)) !== null) {
@@ -482,10 +501,10 @@ export function findEslintDisableComments(source, file) {
     }
     return findings;
 }
-export function analyzeSource(source, file) {
+export function analyzeSource(source, file, testAliasNames = []) {
     return {
         sloc: countSloc(source),
-        tests: countTests(source),
+        tests: countTests(source, testAliasNames),
         locators: countLocators(source, file),
         // No homegrown "has no assertions" check here: playwright/expect-expect
         // (a real AST-based community rule, always enabled — see