@autotests/playwright-impact 0.1.0

package/src/modules/import-impact-helpers.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ts = require('typescript');
+
+const DEFAULT_EXTENSIONS = ['.ts', '.tsx'];
+
+const normalizePath = (filePath) => filePath.split(path.sep).join('/');
+
+const toAbsolute = (repoRoot, relativePath) => path.resolve(repoRoot, normalizePath(relativePath));
+
+const readTsConfigPathAliases = (repoRoot) => {
+  const tsConfigPath = path.join(repoRoot, 'tsconfig.json');
+  if (!fs.existsSync(tsConfigPath)) return [];
+
+  const rawText = fs.readFileSync(tsConfigPath, 'utf8');
+  const parsedResult = ts.parseConfigFileTextToJson(tsConfigPath, rawText);
+  const parsed = parsedResult?.config;
+  if (!parsed || typeof parsed !== 'object') return [];
+
+  const baseUrl = parsed?.compilerOptions?.baseUrl || '.';
+  const paths = parsed?.compilerOptions?.paths || {};
+  const entries = [];
+
+  for (const [aliasPattern, targets] of Object.entries(paths)) {
+    if (!Array.isArray(targets) || targets.length === 0) continue;
+    const hasWildcard = aliasPattern.includes('*');
+    const [aliasPrefix, aliasSuffix] = hasWildcard ? aliasPattern.split('*') : [aliasPattern, ''];
+
+    entries.push({
+      aliasPattern,
+      aliasPrefix,
+      aliasSuffix,
+      hasWildcard,
+      targets: targets.map((targetPattern) => {
+        const [targetPrefix, targetSuffix] = targetPattern.includes('*')
+          ? targetPattern.split('*')
+          : [targetPattern, ''];
+        return { targetPrefix, targetSuffix };
+      }),
+      baseUrlAbs: path.resolve(repoRoot, baseUrl),
+    });
+  }
+
+  return entries;
+};
+
+const getCandidateFilePaths = (basePath, fileExtensions) => {
+  const ext = path.extname(basePath).toLowerCase();
+  if (fileExtensions.includes(ext)) return [basePath];
+
+  const candidates = [];
+  candidates.push(...fileExtensions.map((fileExt) => `${basePath}${fileExt}`));
+  candidates.push(...fileExtensions.map((fileExt) => path.join(basePath, `index${fileExt}`)));
+  return candidates;
+};
+
+const resolveModuleSpecifier = ({ importerAbsPath, moduleSpecifier, repoRoot, fileExtensions, aliasEntries }) => {
+  const resolved = [];
+
+  const addResolvedFromBase = (basePathAbs) => {
+    for (const candidate of getCandidateFilePaths(basePathAbs, fileExtensions)) {
+      if (!fs.existsSync(candidate)) continue;
+      resolved.push(path.resolve(candidate));
+    }
+  };
+
+  if (moduleSpecifier.startsWith('.')) {
+    const importerDir = path.dirname(importerAbsPath);
+    addResolvedFromBase(path.resolve(importerDir, moduleSpecifier));
+    return Array.from(new Set(resolved));
+  }
+
+  // Support asset-like references passed as plain strings inside helpers,
+  // for example: "getAcademicPeriods.completed.json".
+  const looksLikeFileName = /\.[A-Za-z0-9]+$/.test(moduleSpecifier);
+  if (looksLikeFileName) {
+    // Resolve "file.ext" literals from current and parent directories.
+    // This supports helpers that reference shared mock assets from parent folders.
+    let currentDir = path.dirname(importerAbsPath);
+    const repoRootAbs = path.resolve(repoRoot);
+    while (currentDir.startsWith(repoRootAbs)) {
+      const candidate = path.resolve(currentDir, moduleSpecifier);
+      if (fs.existsSync(candidate)) resolved.push(candidate);
+      if (currentDir === repoRootAbs) break;
+      currentDir = path.dirname(currentDir);
+    }
+  }
+
+  for (const alias of aliasEntries) {
+    if (!alias.hasWildcard) {
+      if (moduleSpecifier !== alias.aliasPattern) continue;
+      for (const target of alias.targets) {
+        addResolvedFromBase(path.resolve(alias.baseUrlAbs, target.targetPrefix));
+      }
+      continue;
+    }
+
+    const startsOk = moduleSpecifier.startsWith(alias.aliasPrefix);
+    const endsOk = moduleSpecifier.endsWith(alias.aliasSuffix);
+    if (!startsOk || !endsOk) continue;
+
+    const wildcardValue = moduleSpecifier.slice(alias.aliasPrefix.length, moduleSpecifier.length - alias.aliasSuffix.length);
+    for (const target of alias.targets) {
+      const joined = `${target.targetPrefix}${wildcardValue}${target.targetSuffix}`;
+      addResolvedFromBase(path.resolve(alias.baseUrlAbs, joined));
+    }
+  }
+
+  return Array.from(new Set(resolved));
+};
+
+const extractImportSpecifiers = (sourceFile) => {
+  const specifiers = [];
+
+  const addText = (node) => {
+    if (!node || !ts.isStringLiteral(node)) return;
+    specifiers.push(node.text);
+  };
+
+  const visit = (node) => {
+    if (ts.isImportDeclaration(node)) addText(node.moduleSpecifier);
+    if (ts.isExportDeclaration(node) && node.moduleSpecifier) addText(node.moduleSpecifier);
+
+    if (ts.isCallExpression(node)) {
+      if (ts.isIdentifier(node.expression) && node.expression.text === 'require') {
+        addText(node.arguments?.[0]);
+      }
+
+      if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+        addText(node.arguments?.[0]);
+      }
+
+      for (const argument of node.arguments || []) {
+        if (!ts.isStringLiteral(argument)) continue;
+        if (!/\.[A-Za-z0-9]+$/.test(argument.text)) continue;
+        specifiers.push(argument.text);
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return specifiers;
+};
+
+const isSpecPath = (filePath, fileExtensions) => fileExtensions.some((ext) => filePath.endsWith(`.spec${ext}`));
+
+/**
+ * Select specs impacted by changed source imports/re-exports.
+ * This stage covers helper/function modules that are not represented as fixture classes.
+ */
+const selectSpecsByChangedImports = ({
+  repoRoot,
+  testsRootAbs,
+  changedPomEntries,
+  listFilesRecursive,
+  fileExtensions = DEFAULT_EXTENSIONS,
+}) => {
+  const aliasEntries = readTsConfigPathAliases(repoRoot);
+  const specFiles = listFilesRecursive(testsRootAbs).filter((filePath) => isSpecPath(filePath, fileExtensions));
+
+  const reverseDeps = new Map();
+  const visited = new Set();
+  const queue = [...specFiles];
+
+  const addReverseEdge = (dependencyAbs, importerAbs) => {
+    if (!reverseDeps.has(dependencyAbs)) reverseDeps.set(dependencyAbs, new Set());
+    reverseDeps.get(dependencyAbs).add(importerAbs);
+  };
+
+  while (queue.length > 0) {
+    const currentAbs = path.resolve(queue.shift());
+    if (visited.has(currentAbs)) continue;
+    visited.add(currentAbs);
+    if (!fs.existsSync(currentAbs)) continue;
+
+    let content;
+    try {
+      content = fs.readFileSync(currentAbs, 'utf8');
+    } catch (_error) {
+      continue;
+    }
+
+    const scriptKind = currentAbs.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+    const sourceFile = ts.createSourceFile(currentAbs, content, ts.ScriptTarget.Latest, true, scriptKind);
+    const importSpecifiers = extractImportSpecifiers(sourceFile);
+    for (const moduleSpecifier of importSpecifiers) {
+      const dependencies = resolveModuleSpecifier({
+        importerAbsPath: currentAbs,
+        moduleSpecifier,
+        repoRoot,
+        fileExtensions,
+        aliasEntries,
+      });
+
+      for (const dependencyAbs of dependencies) {
+        if (!dependencyAbs.startsWith(path.resolve(repoRoot))) continue;
+        addReverseEdge(dependencyAbs, currentAbs);
+        if (isSpecPath(dependencyAbs, fileExtensions)) continue;
+        queue.push(dependencyAbs);
+      }
+    }
+  }
+
+  const changedSeeds = new Set();
+  for (const entry of changedPomEntries) {
+    for (const candidate of [entry.effectivePath, entry.oldPath, entry.newPath]) {
+      if (!candidate) continue;
+      changedSeeds.add(toAbsolute(repoRoot, candidate));
+    }
+  }
+
+  const impactedSpecs = new Set();
+  const traverseQueue = Array.from(changedSeeds);
+  const traversed = new Set();
+  while (traverseQueue.length > 0) {
+    const current = traverseQueue.shift();
+    if (traversed.has(current)) continue;
+    traversed.add(current);
+
+    const importers = reverseDeps.get(current) || new Set();
+    for (const importerAbs of importers) {
+      if (isSpecPath(importerAbs, fileExtensions)) impactedSpecs.add(importerAbs);
+      if (!traversed.has(importerAbs)) traverseQueue.push(importerAbs);
+    }
+  }
+
+  return Array.from(impactedSpecs).sort((a, b) => a.localeCompare(b));
+};
+
+module.exports = {
+  selectSpecsByChangedImports,
+};

package/src/modules/method-filter-helpers.js

@@ -0,0 +1,338 @@
+'use strict';
+
+const fs = require('fs');
+const ts = require('typescript');
+
+const DEFAULT_SELECTION_BIAS = 'fail-open';
+const MAX_PRECISE_CHAIN_DEPTH = 2;
+
+const getFixtureKeyFromBindingElement = (element) => {
+  if (!ts.isBindingElement(element)) return null;
+
+  if (element.propertyName) {
+    if (ts.isIdentifier(element.propertyName)) return element.propertyName.text;
+    if (ts.isStringLiteral(element.propertyName) || ts.isNoSubstitutionTemplateLiteral(element.propertyName)) {
+      return element.propertyName.text;
+    }
+  }
+
+  if (ts.isIdentifier(element.name)) return element.name.text;
+  return null;
+};
+
+const extractFixtureVariablesFromSpecAst = ({ sourceFile, fixtureKeyToClass, fixtureKeys }) => {
+  // Map fixture variable names used in test callbacks to their underlying POM class.
+  const fixtureVarToClass = new Map();
+
+  const parseBindingPattern = (bindingPattern) => {
+    for (const element of bindingPattern.elements) {
+      if (!ts.isBindingElement(element)) continue;
+      const fixtureKey = getFixtureKeyFromBindingElement(element);
+      if (!fixtureKey) continue;
+      if (!fixtureKeys.has(fixtureKey)) continue;
+
+      const className = fixtureKeyToClass.get(fixtureKey);
+      if (!className) continue;
+
+      if (ts.isIdentifier(element.name)) {
+        fixtureVarToClass.set(element.name.text, className);
+        continue;
+      }
+
+      if (ts.isObjectBindingPattern(element.name) || ts.isArrayBindingPattern(element.name)) {
+        fixtureVarToClass.set(fixtureKey, className);
+      }
+    }
+  };
+
+  const visit = (node) => {
+    if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.parameters.length > 0) {
+      for (const parameter of node.parameters) {
+        if (ts.isObjectBindingPattern(parameter.name)) parseBindingPattern(parameter.name);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return fixtureVarToClass;
+};
+
+const getLiteralNameFromArgumentExpression = (node) => {
+  if (!node) return null;
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  return null;
+};
+
+const getRootIdentifierName = (node) => {
+  let current = node;
+  while (current) {
+    if (ts.isIdentifier(current)) return current.text;
+    if (ts.isPropertyAccessExpression(current) || ts.isElementAccessExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (ts.isParenthesizedExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    return null;
+  }
+  return null;
+};
+
+const getAccessChainDepth = (node) => {
+  let depth = 0;
+  let current = node;
+  while (current && (ts.isPropertyAccessExpression(current) || ts.isElementAccessExpression(current))) {
+    depth += 1;
+    current = current.expression;
+  }
+  return depth;
+};
+
+/**
+ * Stage B matcher for a single spec AST.
+ * Produces:
+ * - precise matches for known fixtureVar.method() patterns
+ * - uncertain call-site count for dynamic/alias/deep patterns
+ */
+const collectImpactedMethodMatchesInSpec = ({ sourceFile, fixtureVarToClass, impactedMethodsByClass, selectionBias }) => {
+  // Stage B checks fixtureVar.method(), fixtureVar[method](), and optional call-chain forms.
+  const preciseMatches = new Set();
+  let uncertainCallSites = 0;
+  const aliasCalls = new Map();
+
+  const includeUncertain = selectionBias === 'fail-open';
+
+  const tryRegisterAlias = (aliasName, className, methodName, isUncertain) => {
+    if (!aliasName || !className) return;
+    aliasCalls.set(aliasName, {
+      className,
+      methodName: methodName || null,
+      isUncertain: Boolean(isUncertain || !methodName),
+    });
+  };
+
+  const visit = (node) => {
+    if (ts.isVariableDeclaration(node)) {
+      if (ts.isIdentifier(node.name) && node.initializer) {
+        if (ts.isPropertyAccessExpression(node.initializer) || ts.isElementAccessExpression(node.initializer)) {
+          const rootIdentifier = getRootIdentifierName(node.initializer.expression);
+          const className = rootIdentifier ? fixtureVarToClass.get(rootIdentifier) : null;
+          if (className) {
+            const methodName = ts.isPropertyAccessExpression(node.initializer)
+              ? (ts.isIdentifier(node.initializer.name) ? node.initializer.name.text : null)
+              : getLiteralNameFromArgumentExpression(node.initializer.argumentExpression);
+            const uncertain = true;
+            tryRegisterAlias(node.name.text, className, methodName, uncertain);
+          }
+        }
+      }
+
+      if (ts.isObjectBindingPattern(node.name) && node.initializer && ts.isIdentifier(node.initializer)) {
+        const className = fixtureVarToClass.get(node.initializer.text);
+        if (className) {
+          for (const element of node.name.elements) {
+            if (!ts.isBindingElement(element)) continue;
+            const methodName = element.propertyName && ts.isIdentifier(element.propertyName)
+              ? element.propertyName.text
+              : (ts.isIdentifier(element.name) ? element.name.text : null);
+            const aliasName = ts.isIdentifier(element.name) ? element.name.text : null;
+            tryRegisterAlias(aliasName, className, methodName, true);
+          }
+        }
+      }
+    }
+
+    const isCallLike = ts.isCallExpression(node) || (typeof ts.isCallChain === 'function' && ts.isCallChain(node));
+    if (isCallLike && ts.isIdentifier(node.expression)) {
+      const alias = aliasCalls.get(node.expression.text);
+      if (alias) {
+        const impactedMethods = impactedMethodsByClass.get(alias.className) || new Set();
+        if (alias.methodName && impactedMethods.has(alias.methodName) && !alias.isUncertain) {
+          preciseMatches.add(`${alias.className}.${alias.methodName}`);
+        } else {
+          uncertainCallSites += 1;
+        }
+      }
+    }
+
+    if (isCallLike && (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
+      const calleeExpression = node.expression;
+      const objectExpr = calleeExpression.expression;
+      const rootIdentifier = getRootIdentifierName(objectExpr);
+      const className = rootIdentifier ? fixtureVarToClass.get(rootIdentifier) : null;
+
+      if (className) {
+        const impactedMethods = impactedMethodsByClass.get(className) || new Set();
+        const chainDepth = getAccessChainDepth(objectExpr);
+        const tooDeepForPrecise = chainDepth > MAX_PRECISE_CHAIN_DEPTH;
+
+        if (ts.isPropertyAccessExpression(calleeExpression) && ts.isIdentifier(calleeExpression.name)) {
+          const methodName = calleeExpression.name.text;
+          if (tooDeepForPrecise) {
+            // Deep chains are intentionally uncertain to avoid false-precise matches.
+            uncertainCallSites += 1;
+          } else if (impactedMethods.has(methodName)) {
+            preciseMatches.add(`${className}.${methodName}`);
+          }
+        }
+
+        if (ts.isElementAccessExpression(calleeExpression)) {
+          const methodName = getLiteralNameFromArgumentExpression(calleeExpression.argumentExpression);
+          if (methodName) {
+            if (tooDeepForPrecise) {
+              uncertainCallSites += 1;
+            } else if (impactedMethods.has(methodName)) {
+              preciseMatches.add(`${className}.${methodName}`);
+            }
+          } else {
+            uncertainCallSites += 1;
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+
+  return {
+    preciseMatches: Array.from(preciseMatches).sort((a, b) => a.localeCompare(b)),
+    uncertainCallSites,
+    shouldIncludeByUncertain: includeUncertain && uncertainCallSites > 0,
+  };
+};
+
+/**
+ * Final Stage B spec filter.
+ * Policy:
+ * - direct changed specs are always retained
+ * - precise matches are retained
+ * - uncertain-only specs are retained only in fail-open mode
+ */
+const filterSpecsByImpactedMethods = ({
+  selectedSpecs,
+  directChangedSpecsAbs,
+  alwaysIncludeSpecsAbs = [],
+  fixtureKeyToClass,
+  fixtureKeys,
+  impactedMethodsByClass,
+  selectionBias = DEFAULT_SELECTION_BIAS,
+}) => {
+  // Stage B keeps direct changed specs unconditionally and filters the rest by impacted calls.
+  if (selectedSpecs.length === 0) {
+    return {
+      filteredSpecs: [],
+      droppedByMethodFilter: 0,
+      retainedWithoutMethodFilter: 0,
+      selectionReasons: new Map(),
+      uncertainCallSites: 0,
+      warnings: [],
+    };
+  }
+
+  const directChangedSet = new Set(directChangedSpecsAbs);
+  const alwaysIncludeSet = new Set(alwaysIncludeSpecsAbs);
+  const selectionReasons = new Map();
+  const warnings = [];
+  let uncertainCallSitesTotal = 0;
+
+  if (impactedMethodsByClass.size === 0) {
+    let retainedWithoutMethodFilter = 0;
+    for (const specPath of selectedSpecs) {
+      if (directChangedSet.has(specPath)) {
+        selectionReasons.set(specPath, 'direct-changed-spec');
+      } else if (alwaysIncludeSet.has(specPath)) {
+        selectionReasons.set(specPath, 'matched-import-graph');
+      } else {
+        retainedWithoutMethodFilter += 1;
+        selectionReasons.set(specPath, 'retained-no-impacted-methods');
+      }
+    }
+    return {
+      filteredSpecs: selectedSpecs,
+      droppedByMethodFilter: 0,
+      retainedWithoutMethodFilter,
+      selectionReasons,
+      uncertainCallSites: 0,
+      warnings,
+    };
+  }
+
+  const filteredSpecs = [];
+  let droppedByMethodFilter = 0;
+  let retainedWithoutMethodFilter = 0;
+
+  for (const specPath of selectedSpecs) {
+    if (directChangedSet.has(specPath)) {
+      filteredSpecs.push(specPath);
+      selectionReasons.set(specPath, 'direct-changed-spec');
+      continue;
+    }
+    if (alwaysIncludeSet.has(specPath)) {
+      filteredSpecs.push(specPath);
+      selectionReasons.set(specPath, 'matched-import-graph');
+      continue;
+    }
+
+    let content;
+    try {
+      content = fs.readFileSync(specPath, 'utf8');
+    } catch (_error) {
+      retainedWithoutMethodFilter += 1;
+      filteredSpecs.push(specPath);
+      selectionReasons.set(specPath, 'retained-read-error');
+      continue;
+    }
+
+    const scriptKind = specPath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+    const sourceFile = ts.createSourceFile(specPath, content, ts.ScriptTarget.Latest, true, scriptKind);
+    const fixtureVarToClass = extractFixtureVariablesFromSpecAst({ sourceFile, fixtureKeyToClass, fixtureKeys });
+
+    if (fixtureVarToClass.size === 0) {
+      retainedWithoutMethodFilter += 1;
+      filteredSpecs.push(specPath);
+      selectionReasons.set(specPath, 'retained-no-bindings');
+      continue;
+    }
+
+    const matchResult = collectImpactedMethodMatchesInSpec({
+      sourceFile,
+      fixtureVarToClass,
+      impactedMethodsByClass,
+      selectionBias,
+    });
+    uncertainCallSitesTotal += matchResult.uncertainCallSites;
+
+    if (matchResult.preciseMatches.length > 0) {
+      filteredSpecs.push(specPath);
+      selectionReasons.set(specPath, 'matched-precise');
+      continue;
+    }
+
+    if (matchResult.shouldIncludeByUncertain) {
+      filteredSpecs.push(specPath);
+      selectionReasons.set(specPath, 'matched-uncertain-fail-open');
+      warnings.push(`Uncertain callsite retained spec: ${specPath}`);
+      continue;
+    }
+
+    droppedByMethodFilter += 1;
+  }
+
+  return {
+    filteredSpecs: filteredSpecs.sort((a, b) => a.localeCompare(b)),
+    droppedByMethodFilter,
+    retainedWithoutMethodFilter,
+    selectionReasons,
+    uncertainCallSites: uncertainCallSitesTotal,
+    warnings,
+  };
+};
+
+module.exports = {
+  filterSpecsByImpactedMethods,
+};