@qaguardian/playwright-score 2.0.0 → 2.1.1

package/dist/rules/base-plugin.js

@@ -1,18 +1,28 @@
-function isSkipCallee(callee) {
+/**
+ * `testNames` is `'test'` plus any `test.extend(...)`-derived fixture
+ * aliases detected by test-aliases.ts (see eslint-runner.ts, which feeds
+ * this rule's `testAliasNames` option) — a suite that always declares its
+ * tests via `loggedTest.skip(...)` instead of `test.skip(...)` still needs
+ * the always-skipped-declaration check below, same as upstream
+ * eslint-plugin-playwright's own rules need the alias for no-standalone-
+ * expect (see METHODOLOGY.md/test-aliases.ts).
+ */
+function isSkipCallee(callee, testNames) {
     if (!callee || callee.type !== 'MemberExpression' || callee.computed)
         return false;
     const obj = callee.object;
     const prop = callee.property;
     if (prop?.type !== 'Identifier' || prop.name !== 'skip')
         return false;
-    // test.skip(...)
-    if (obj?.type === 'Identifier' && obj.name === 'test')
+    // test.skip(...) / loggedTest.skip(...)
+    if (obj?.type === 'Identifier' && obj.name && testNames.has(obj.name))
         return true;
-    // test.describe.skip(...)
+    // test.describe.skip(...) / loggedTest.describe.skip(...)
     if (obj?.type === 'MemberExpression' &&
         !obj.computed &&
         obj.object?.type === 'Identifier' &&
-        obj.object.name === 'test' &&
+        obj.object.name &&
+        testNames.has(obj.object.name) &&
         obj.property?.type === 'Identifier' &&
         obj.property.name === 'describe') {
         return true;
@@ -52,12 +62,23 @@ const noSkippedTestDeclaration = {
         messages: {
             skipped: 'Unexpected use of the .skip() annotation to declare an always-skipped test.',
         },
-        schema: [],
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    testAliasNames: { items: { type: 'string' }, type: 'array' },
+                },
+                type: 'object',
+            },
+        ],
     },
     create(context) {
+        const testAliasNames = context.options[0]
+            ?.testAliasNames ?? [];
+        const testNames = new Set(['test', ...testAliasNames]);
         return {
             CallExpression(node) {
-                if (!isSkipCallee(node.callee))
+                if (!isSkipCallee(node.callee, testNames))
                     return;
                 const args = node.arguments ?? [];
                 const lastArg = args[args.length - 1];
@@ -645,15 +666,17 @@ const noTrivialAssertion = {
         };
     },
 };
-function isTestDeclarationCallee(callee) {
+/** `testNames` — see isSkipCallee's doc comment above; same alias treatment. */
+function isTestDeclarationCallee(callee, testNames) {
     if (!callee)
         return false;
-    if (callee.type === 'Identifier' && callee.name === 'test')
+    if (callee.type === 'Identifier' && callee.name && testNames.has(callee.name))
         return true;
     if (callee.type === 'MemberExpression' &&
         !callee.computed &&
         callee.object?.type === 'Identifier' &&
-        callee.object.name === 'test' &&
+        callee.object.name &&
+        testNames.has(callee.object.name) &&
         callee.property?.type === 'Identifier' &&
         (callee.property.name === 'only' || callee.property.name === 'fixme')) {
         return true;
@@ -683,12 +706,23 @@ const noSoftAssertionOnlyTest = {
         messages: {
             softOnly: 'This test only uses expect.soft(...) assertions — a failed check is recorded but never fails the test. Use a hard expect() for anything that should stop the test.',
         },
-        schema: [],
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    testAliasNames: { items: { type: 'string' }, type: 'array' },
+                },
+                type: 'object',
+            },
+        ],
     },
     create(context) {
+        const testAliasNames = context.options[0]
+            ?.testAliasNames ?? [];
+        const testNames = new Set(['test', ...testAliasNames]);
         return {
             CallExpression(node) {
-                if (!isTestDeclarationCallee(node.callee))
+                if (!isTestDeclarationCallee(node.callee, testNames))
                     return;
                 const args = node.arguments ?? [];
                 const body = args[args.length - 1];

package/dist/test-aliases.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Detects identifiers bound (directly, or via a local import/re-export
+ * chain of any depth) to `<base>.extend(...)` where `<base>` is `test`
+ * imported from `@playwright/test`, or is itself such an extended test.
+ * Returns the flat set of alias name strings (e.g. `loggedTest`,
+ * `testWithAssets`) usable anywhere they're called across the scored
+ * files — callers feed this into `eslint-runner.ts`'s
+ * `settings.playwright.globalAliases.test` and into `metrics.ts`'s
+ * `getTestSpans`/`countTests` and `base-plugin.ts`'s test-name checks.
+ *
+ * `sources`/`importedFiles` are the same maps `index.ts` already builds
+ * (scored spec files, and their transitively-collected local relative
+ * imports — see `collectLocallyImportedFiles`); this function does not
+ * walk the filesystem itself beyond resolving relative specifiers already
+ * present in those files' own import/export statements, and never
+ * escapes `boundaryDir` (same safety rule as `import-graph.ts`).
+ */
+export declare function detectExtendedTestAliases(sources: Map<string, string>, importedFiles: Map<string, string>, boundaryDir: string): string[];

package/dist/test-aliases.js

@@ -0,0 +1,218 @@
+import { parseForESLint } from '@typescript-eslint/parser';
+import { resolveRelativeImport } from './import-graph.js';
+function isRelativeSpecifier(value) {
+    return typeof value === 'string' && value.startsWith('.');
+}
+function parseFileInfo(source, file) {
+    let ast;
+    try {
+        ast = parseForESLint(source, {
+            ecmaVersion: 2022,
+            sourceType: 'module',
+            ecmaFeatures: { jsx: /\.(tsx|jsx)$/.test(file) },
+        }).ast;
+    }
+    catch {
+        return undefined;
+    }
+    const playwrightTestLocalNames = new Set();
+    const extendDeclarations = [];
+    const directExportNames = new Set();
+    const imports = [];
+    const reExports = [];
+    function collectExtendFromVariableDeclaration(decl) {
+        const declarations = (decl.declarations ?? []);
+        for (const d of declarations) {
+            if (d.id?.type !== 'Identifier' || !d.id.name || !d.init)
+                continue;
+            const init = d.init;
+            if (init.type === 'CallExpression' &&
+                init.callee?.type === 'MemberExpression') {
+                const callee = init.callee;
+                const property = callee.property;
+                const object = callee.object;
+                if (!callee.computed &&
+                    property?.type === 'Identifier' &&
+                    property.name === 'extend' &&
+                    object?.type === 'Identifier' &&
+                    object.name) {
+                    extendDeclarations.push({ declaredName: d.id.name, baseName: object.name });
+                }
+            }
+        }
+    }
+    // Generic subtree walk to find `const X = Y.extend(...)` anywhere (not
+    // just top-level) — a fixture module may nest these inside a helper.
+    function walk(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item);
+            return;
+        }
+        const obj = node;
+        if (obj.type === 'VariableDeclaration')
+            collectExtendFromVariableDeclaration(obj);
+        for (const key in obj) {
+            if (key === 'parent')
+                continue;
+            const value = obj[key];
+            if (value && typeof value === 'object')
+                walk(value);
+        }
+    }
+    for (const node of ast.body ?? []) {
+        if (node.type === 'ImportDeclaration') {
+            const src = node.source?.value;
+            if (!isRelativeSpecifier(src)) {
+                if (src === '@playwright/test') {
+                    for (const spec of (node.specifiers ?? [])) {
+                        if (spec.type !== 'ImportSpecifier')
+                            continue;
+                        const importedName = spec.imported?.name ?? spec.imported?.value;
+                        if (importedName === 'test' && spec.local?.name) {
+                            playwrightTestLocalNames.add(spec.local.name);
+                        }
+                    }
+                }
+                continue;
+            }
+            for (const spec of (node.specifiers ?? [])) {
+                if (spec.type !== 'ImportSpecifier')
+                    continue;
+                const importedName = spec.imported?.name ?? spec.imported?.value;
+                if (importedName && spec.local?.name) {
+                    imports.push({ localName: spec.local.name, importedName, source: src });
+                }
+            }
+        }
+        else if (node.type === 'ExportNamedDeclaration') {
+            const declaration = node.declaration;
+            const src = node.source?.value;
+            if (declaration?.type === 'VariableDeclaration') {
+                collectExtendFromVariableDeclaration(declaration);
+                for (const d of (declaration.declarations ?? [])) {
+                    if (d.id?.type === 'Identifier' && d.id.name)
+                        directExportNames.add(d.id.name);
+                }
+            }
+            else {
+                for (const spec of (node.specifiers ?? [])) {
+                    const localName = spec.local?.name ?? spec.local?.value;
+                    const exportedName = spec.exported?.name ?? spec.exported?.value;
+                    if (!localName || !exportedName)
+                        continue;
+                    reExports.push({
+                        exportedName,
+                        localName,
+                        source: isRelativeSpecifier(src) ? src : undefined,
+                    });
+                }
+            }
+        }
+    }
+    // Fixtures modules commonly declare the extend() call inside a nested
+    // scope too (e.g. wrapped in a `(() => {...})()` IIFE is rare, but
+    // multiple top-level `const`s are common) — the top-level pass above
+    // already covers the overwhelming majority; this catches the rest
+    // without a second parse.
+    walk(ast.body ?? []);
+    return {
+        playwrightTestLocalNames,
+        extendDeclarations,
+        directExportNames,
+        imports,
+        reExports,
+    };
+}
+/**
+ * Detects identifiers bound (directly, or via a local import/re-export
+ * chain of any depth) to `<base>.extend(...)` where `<base>` is `test`
+ * imported from `@playwright/test`, or is itself such an extended test.
+ * Returns the flat set of alias name strings (e.g. `loggedTest`,
+ * `testWithAssets`) usable anywhere they're called across the scored
+ * files — callers feed this into `eslint-runner.ts`'s
+ * `settings.playwright.globalAliases.test` and into `metrics.ts`'s
+ * `getTestSpans`/`countTests` and `base-plugin.ts`'s test-name checks.
+ *
+ * `sources`/`importedFiles` are the same maps `index.ts` already builds
+ * (scored spec files, and their transitively-collected local relative
+ * imports — see `collectLocallyImportedFiles`); this function does not
+ * walk the filesystem itself beyond resolving relative specifiers already
+ * present in those files' own import/export statements, and never
+ * escapes `boundaryDir` (same safety rule as `import-graph.ts`).
+ */
+export function detectExtendedTestAliases(sources, importedFiles, boundaryDir) {
+    const allFiles = new Map([...sources, ...importedFiles]);
+    const parsed = new Map();
+    for (const [file, source] of allFiles) {
+        const info = parseFileInfo(source, file);
+        if (info)
+            parsed.set(file, info);
+    }
+    const localAlias = new Map();
+    const exportedAlias = new Map();
+    for (const file of parsed.keys()) {
+        localAlias.set(file, new Set());
+        exportedAlias.set(file, new Set());
+    }
+    const resolve = (fromFile, specifier) => resolveRelativeImport(fromFile, specifier, boundaryDir);
+    // Bounded fixed point: each round can only add names (monotonic), and
+    // there are at most parsed.size * (max names per file) additions total —
+    // capping rounds at file count + a small constant is generous relative
+    // to any real import-chain depth (mirrors import-graph.ts's own
+    // MAX_DEPTH-style bound).
+    const maxRounds = parsed.size + 5;
+    for (let round = 0; round < maxRounds; round++) {
+        let changed = false;
+        for (const [file, info] of parsed) {
+            const known = localAlias.get(file);
+            const exported = exportedAlias.get(file);
+            for (const { declaredName, baseName } of info.extendDeclarations) {
+                if (known.has(declaredName))
+                    continue;
+                if (info.playwrightTestLocalNames.has(baseName) || known.has(baseName)) {
+                    known.add(declaredName);
+                    changed = true;
+                }
+            }
+            for (const { localName, importedName, source } of info.imports) {
+                if (known.has(localName))
+                    continue;
+                const resolved = resolve(file, source);
+                if (!resolved)
+                    continue;
+                if (exportedAlias.get(resolved)?.has(importedName)) {
+                    known.add(localName);
+                    changed = true;
+                }
+            }
+            for (const name of known) {
+                if (info.directExportNames.has(name) && !exported.has(name)) {
+                    exported.add(name);
+                    changed = true;
+                }
+            }
+            for (const { exportedName, localName, source } of info.reExports) {
+                if (exported.has(exportedName))
+                    continue;
+                const isAlias = source
+                    ? !!resolve(file, source) && exportedAlias.get(resolve(file, source))?.has(localName)
+                    : known.has(localName);
+                if (isAlias) {
+                    exported.add(exportedName);
+                    changed = true;
+                }
+            }
+        }
+        if (!changed)
+            break;
+    }
+    const result = new Set();
+    for (const names of localAlias.values()) {
+        for (const name of names)
+            result.add(name);
+    }
+    return [...result].sort();
+}

package/dist/types.d.ts

@@ -74,6 +74,14 @@ export interface ScoreResult {
      * if they'd otherwise be skipped.
      */
     skippedFiles?: string[];
+    /**
+     * A playwright.config.* was found at or above a scanned directory but
+     * could not be read statically (a dynamic value, e.g. `process.env`, a
+     * spread, or an unsupported export shape) — discovery fell back to
+     * today's filename-suffix behavior for that directory instead of acting
+     * on a partial or guessed reading. See playwright-config.ts.
+     */
+    configWarnings?: string[];
 }
 export interface ScoreOptions {
     paths: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qaguardian/playwright-score",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "Deterministic, AI-free Playwright spec quality score — the weighted share of your tests that are clean.",
   "type": "module",
   "main": "./dist/index.js",