@autotests/playwright-impact 0.1.0

package/tests/class-impact-helpers.test.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const { buildInheritanceGraph, collectImpactedClasses, getFixtureKeysForClasses } = require('../src/modules/class-impact-helpers');
+const { createTempDir, writeFile } = require('./_test-helpers');
+
+test('buildInheritanceGraph detects direct inheritance', () => {
+  const dir = createTempDir();
+  const basePath = writeFile(dir, 'Base.ts', 'export class Base {}');
+  const childPath = writeFile(dir, 'Child.ts', 'export class Child extends Base {}');
+
+  const graph = buildInheritanceGraph([basePath, childPath], fs.readFileSync);
+
+  assert.equal(graph.parentsByChild.get('Child'), 'Base');
+  assert.deepEqual(Array.from(graph.childrenByParent.get('Base') || []), ['Child']);
+});
+
+test('buildInheritanceGraph tracks multi-level inheritance', () => {
+  const dir = createTempDir();
+  const p1 = writeFile(dir, 'A.ts', 'export class A {}');
+  const p2 = writeFile(dir, 'B.ts', 'export class B extends A {}');
+  const p3 = writeFile(dir, 'C.ts', 'export class C extends B {}');
+
+  const graph = buildInheritanceGraph([p1, p2, p3], fs.readFileSync);
+
+  assert.equal(graph.parentsByChild.get('B'), 'A');
+  assert.equal(graph.parentsByChild.get('C'), 'B');
+});
+
+test('collectImpactedClasses includes base and head class names', () => {
+  const changedPomEntries = [{ status: 'M', effectivePath: 'src/pages/A.ts', oldPath: 'src/pages/A.ts', newPath: 'src/pages/A.ts' }];
+  const childrenByParent = new Map();
+  const readChangeContents = () => ({
+    baseContent: 'export class OldA {}',
+    headContent: 'export class NewA {}',
+  });
+
+  const impacted = collectImpactedClasses({ changedPomEntries, childrenByParent, baseRef: null, readChangeContents });
+
+  assert.equal(impacted.has('OldA'), true);
+  assert.equal(impacted.has('NewA'), true);
+});
+
+test('collectImpactedClasses includes descendants from graph', () => {
+  const changedPomEntries = [{ status: 'M', effectivePath: 'src/pages/A.ts', oldPath: 'src/pages/A.ts', newPath: 'src/pages/A.ts' }];
+  const childrenByParent = new Map([
+    ['Base', new Set(['Child'])],
+    ['Child', new Set(['GrandChild'])],
+  ]);
+  const readChangeContents = () => ({ baseContent: 'export class Base {}', headContent: 'export class Base {}' });
+
+  const impacted = collectImpactedClasses({ changedPomEntries, childrenByParent, baseRef: null, readChangeContents });
+
+  assert.equal(impacted.has('Base'), true);
+  assert.equal(impacted.has('Child'), true);
+  assert.equal(impacted.has('GrandChild'), true);
+});
+
+test('collectImpactedClasses handles empty entries', () => {
+  const impacted = collectImpactedClasses({
+    changedPomEntries: [],
+    childrenByParent: new Map(),
+    baseRef: null,
+    readChangeContents: () => ({ baseContent: '', headContent: '' }),
+  });
+
+  assert.equal(impacted.size, 0);
+});
+
+test('getFixtureKeysForClasses returns merged keys without duplicates', () => {
+  const impactedClasses = new Set(['A', 'B']);
+  const classToFixtureKeys = new Map([
+    ['A', new Set(['aPage', 'aExtra'])],
+    ['B', new Set(['bPage', 'aPage'])],
+  ]);
+
+  const keys = getFixtureKeysForClasses(impactedClasses, classToFixtureKeys);
+
+  assert.deepEqual(Array.from(keys).sort(), ['aExtra', 'aPage', 'bPage']);
+});
+
+test('getFixtureKeysForClasses ignores classes without mapping', () => {
+  const impactedClasses = new Set(['A', 'Unknown']);
+  const classToFixtureKeys = new Map([['A', new Set(['aPage'])]]);
+
+  const keys = getFixtureKeysForClasses(impactedClasses, classToFixtureKeys);
+
+  assert.deepEqual(Array.from(keys), ['aPage']);
+});
+
+test('buildInheritanceGraph ignores files without extends', () => {
+  const dir = createTempDir();
+  const a = writeFile(dir, 'Plain.ts', 'export class Plain {}');
+  const graph = buildInheritanceGraph([a], fs.readFileSync);
+
+  assert.equal(graph.parentsByChild.size, 0);
+  assert.equal(graph.childrenByParent.size, 0);
+});

package/tests/file-and-git-helpers.test.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { getChangedEntries } = require('../src/modules/file-and-git-helpers');
+const { createTempDir, writeFile, initGitRepo, commitAll, run } = require('./_test-helpers');
+
+const profile = {
+  isRelevantPomPath: (filePath) => filePath.startsWith('src/pages/') && (filePath.endsWith('.ts') || filePath.endsWith('.tsx')),
+};
+
+const setupRepo = () => {
+  const dir = createTempDir();
+  initGitRepo(dir);
+  writeFile(dir, 'src/pages/Page.ts', 'export class Page { open(){ return 1; } }\n');
+  writeFile(dir, 'README.md', '# test\n');
+  commitAll(dir, 'base');
+  return dir;
+};
+
+test('getChangedEntries includes unstaged working tree changes when baseRef is provided', () => {
+  const dir = setupRepo();
+  writeFile(dir, 'README.md', '# test2\n');
+  commitAll(dir, 'commit2');
+
+  writeFile(dir, 'src/pages/Page.ts', 'export class Page { open(){ return 2; } }\n');
+
+  const noWorkingTree = getChangedEntries({
+    repoRoot: dir,
+    baseRef: 'HEAD~1',
+    includeWorkingTreeWithBase: false,
+    profile,
+    fileExtensions: ['.ts', '.tsx'],
+  });
+  const withWorkingTree = getChangedEntries({
+    repoRoot: dir,
+    baseRef: 'HEAD~1',
+    includeWorkingTreeWithBase: true,
+    profile,
+    fileExtensions: ['.ts', '.tsx'],
+  });
+
+  assert.equal(noWorkingTree.entries.some((entry) => entry.effectivePath === 'src/pages/Page.ts'), false);
+  assert.equal(withWorkingTree.entries.some((entry) => entry.effectivePath === 'src/pages/Page.ts'), true);
+});
+
+test('getChangedEntries includes staged working tree changes when baseRef is provided', () => {
+  const dir = setupRepo();
+  writeFile(dir, 'README.md', '# test2\n');
+  commitAll(dir, 'commit2');
+
+  writeFile(dir, 'src/pages/Page.ts', 'export class Page { open(){ return 3; } }\n');
+  run(dir, 'git', ['add', 'src/pages/Page.ts']);
+
+  const result = getChangedEntries({ repoRoot: dir, baseRef: 'HEAD~1', includeWorkingTreeWithBase: true, profile, fileExtensions: ['.ts', '.tsx'] });
+  assert.equal(result.entries.some((entry) => entry.effectivePath === 'src/pages/Page.ts'), true);
+});
+
+test('includeWorkingTreeWithBase disabled ignores working tree changes', () => {
+  const dir = setupRepo();
+  writeFile(dir, 'README.md', '# test2\n');
+  commitAll(dir, 'commit2');
+
+  writeFile(dir, 'src/pages/Page.ts', 'export class Page { open(){ return 10; } }\n');
+
+  const result = getChangedEntries({
+    repoRoot: dir,
+    baseRef: 'HEAD~1',
+    includeWorkingTreeWithBase: false,
+    profile,
+    fileExtensions: ['.ts', '.tsx'],
+  });
+
+  assert.equal(result.entries.some((entry) => entry.effectivePath === 'src/pages/Page.ts'), false);
+  assert.equal(result.changedEntriesBySource.fromWorkingTree, 0);
+});
+
+test('getChangedEntries includes untracked ts source entries', () => {
+  const dir = setupRepo();
+  writeFile(dir, 'src/pages/NewPage.ts', 'export class NewPage {}\n');
+
+  const result = getChangedEntries({ repoRoot: dir, baseRef: null, includeWorkingTreeWithBase: true, profile, fileExtensions: ['.ts', '.tsx'] });
+  assert.equal(result.entries.some((entry) => entry.effectivePath === 'src/pages/NewPage.ts' && entry.status === 'A'), true);
+  assert.equal(result.changedEntriesBySource.fromUntracked >= 1, true);
+});
+
+test('getChangedEntries includes untracked tsx source entries', () => {
+  const dir = setupRepo();
+  writeFile(dir, 'src/pages/NewPage.tsx', 'export class NewPage {}\n');
+
+  const result = getChangedEntries({ repoRoot: dir, baseRef: null, includeWorkingTreeWithBase: true, profile, fileExtensions: ['.ts', '.tsx'] });
+  assert.equal(result.entries.some((entry) => entry.effectivePath === 'src/pages/NewPage.tsx' && entry.status === 'A'), true);
+});
+
+test('getChangedEntries detects rename status with -M', () => {
+  const dir = setupRepo();
+  run(dir, 'git', ['mv', 'src/pages/Page.ts', 'src/pages/PageRenamed.ts']);
+
+  const result = getChangedEntries({ repoRoot: dir, baseRef: null, includeWorkingTreeWithBase: true, profile, fileExtensions: ['.ts', '.tsx'] });
+  const renameEntry = result.entries.find((entry) => entry.effectivePath === 'src/pages/PageRenamed.ts');
+
+  assert.ok(renameEntry);
+  assert.equal(renameEntry.status, 'R');
+  assert.equal(renameEntry.oldPath, 'src/pages/Page.ts');
+  assert.equal(renameEntry.newPath, 'src/pages/PageRenamed.ts');
+});
+
+test('getChangedEntries keeps higher-priority status when path appears in both diff sources', () => {
+  const dir = setupRepo();
+  run(dir, 'git', ['mv', 'src/pages/Page.ts', 'src/pages/PageRenamed.ts']);
+  commitAll(dir, 'rename page');
+
+  writeFile(dir, 'src/pages/PageRenamed.ts', 'export class Page { open(){ return 4; } }\n');
+
+  const result = getChangedEntries({ repoRoot: dir, baseRef: 'HEAD~1', includeWorkingTreeWithBase: true, profile, fileExtensions: ['.ts', '.tsx'] });
+  const entry = result.entries.find((item) => item.effectivePath === 'src/pages/PageRenamed.ts');
+
+  assert.ok(entry);
+  assert.equal(entry.status, 'R');
+});
+
+test('Combined base...HEAD and working tree diffs are unioned', () => {
+  const dir = setupRepo();
+  writeFile(dir, 'src/pages/Committed.ts', 'export class Committed { open(){ return 1; } }\n');
+  commitAll(dir, 'add committed page');
+  writeFile(dir, 'src/pages/Working.ts', 'export class Working { open(){ return 1; } }\n');
+
+  const result = getChangedEntries({
+    repoRoot: dir,
+    baseRef: 'HEAD~1',
+    includeWorkingTreeWithBase: true,
+    profile,
+    fileExtensions: ['.ts', '.tsx'],
+  });
+
+  assert.equal(result.entries.some((entry) => entry.effectivePath === 'src/pages/Committed.ts'), true);
+  assert.equal(result.entries.some((entry) => entry.effectivePath === 'src/pages/Working.ts'), true);
+  assert.equal(result.changedEntriesBySource.fromBaseHead >= 1, true);
+  assert.equal(result.changedEntriesBySource.fromWorkingTree + result.changedEntriesBySource.fromUntracked >= 1, true);
+});

package/tests/file-status-compat.test.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { __testOnly } = require('../src/modules/file-and-git-helpers');
+
+const { parseChangedEntryLine, normalizeEntryStatus, mergeByPriority } = __testOnly;
+
+test('Copy status (C) treated safely as add with warning', () => {
+  const parsed = parseChangedEntryLine('C100\tsrc/a.ts\tsrc/b.ts');
+  const warnings = [];
+  const normalized = normalizeEntryStatus(parsed, warnings);
+
+  assert.equal(normalized.status, 'A');
+  assert.equal(warnings.length > 0, true);
+});
+
+test('Type change status (T) treated safely as modify with warning', () => {
+  const parsed = parseChangedEntryLine('T\tsrc/a.ts');
+  const warnings = [];
+  const normalized = normalizeEntryStatus(parsed, warnings);
+
+  assert.equal(normalized.status, 'M');
+  assert.equal(warnings.length > 0, true);
+});
+
+test('Unmerged status (U) treated safely as modify with warning', () => {
+  const parsed = parseChangedEntryLine('U\tsrc/a.ts');
+  const warnings = [];
+  const normalized = normalizeEntryStatus(parsed, warnings);
+
+  assert.equal(normalized.status, 'M');
+  assert.equal(warnings.length > 0, true);
+});
+
+test('Unknown git status triggers compat fallback with warning', () => {
+  const parsed = parseChangedEntryLine('Z\tsrc/a.ts');
+  const warnings = [];
+  const normalized = normalizeEntryStatus(parsed, warnings);
+
+  assert.equal(normalized.status, 'M');
+  assert.equal(warnings.length > 0, true);
+});
+
+test('Status merge precedence D > R > M > A is deterministic', () => {
+  const a = { status: 'A', effectivePath: 'x.ts' };
+  const m = { status: 'M', effectivePath: 'x.ts' };
+  const r = { status: 'R', effectivePath: 'x.ts', oldPath: 'old.ts', newPath: 'x.ts' };
+  const d = { status: 'D', effectivePath: 'x.ts' };
+
+  assert.equal(mergeByPriority(a, m).status, 'M');
+  assert.equal(mergeByPriority(m, r).status, 'R');
+  assert.equal(mergeByPriority(r, d).status, 'D');
+  assert.equal(mergeByPriority(d, a).status, 'D');
+});

package/tests/fixture-map-helpers.test.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('path');
+const { parseFixtureMappings } = require('../src/modules/fixture-map-helpers');
+const { createTempDir, writeFile } = require('./_test-helpers');
+
+test('parseFixtureMappings parses fixture to class mapping', () => {
+  const dir = createTempDir();
+  const typesPath = writeFile(
+    dir,
+    'src/fixtures/types.ts',
+    'type X = {\n  appPage: Pages.AppPage;\n  altPage: Pages.AltPage;\n};\n'
+  );
+
+  const mappings = parseFixtureMappings({ typesPath });
+
+  assert.deepEqual(Array.from(mappings.fixtureKeyToClass.entries()).sort(), [
+    ['altPage', 'AltPage'],
+    ['appPage', 'AppPage'],
+  ]);
+});
+
+test('parseFixtureMappings supports many fixture keys per class', () => {
+  const dir = createTempDir();
+  const typesPath = writeFile(
+    dir,
+    'src/fixtures/types.ts',
+    'type X = {\n  pageA: Pages.SharedPage;\n  pageB: Pages.SharedPage;\n};\n'
+  );
+
+  const mappings = parseFixtureMappings({ typesPath });
+
+  assert.deepEqual(Array.from(mappings.classToFixtureKeys.get('SharedPage') || []).sort(), ['pageA', 'pageB']);
+});
+
+test('parseFixtureMappings supports direct helper type mapping', () => {
+  const dir = createTempDir();
+  const typesPath = writeFile(
+    dir,
+    'src/fixtures/types.ts',
+    'type X = {\n  userManagementHelper: UserManagementHelper;\n  rosterHelper: RosterHelper;\n};\n'
+  );
+
+  const mappings = parseFixtureMappings({ typesPath });
+
+  assert.deepEqual(Array.from(mappings.fixtureKeyToClass.entries()).sort(), [
+    ['rosterHelper', 'RosterHelper'],
+    ['userManagementHelper', 'UserManagementHelper'],
+  ]);
+});
+
+test('parseFixtureMappings supports multi-namespace type mapping', () => {
+  const dir = createTempDir();
+  const typesPath = writeFile(
+    dir,
+    'src/fixtures/types.ts',
+    'type X = {\n  graphClient: Api.Services.GraphClient;\n};\n'
+  );
+
+  const mappings = parseFixtureMappings({ typesPath });
+  assert.equal(mappings.fixtureKeyToClass.get('graphClient'), 'GraphClient');
+});
+
+test('parseFixtureMappings supports interface inheritance and type intersections', () => {
+  const dir = createTempDir();
+  const typesPath = writeFile(
+    dir,
+    'src/fixtures/types.ts',
+    [
+      'interface BaseFixtures {',
+      '  userManagementHelper: UserManagementHelper;',
+      '}',
+      'type ServiceHelpersFixture = BaseFixtures & {',
+      '  rosterHelper: RosterHelper;',
+      '};',
+      '',
+    ].join('\n')
+  );
+
+  const mappings = parseFixtureMappings({ typesPath });
+
+  assert.equal(mappings.fixtureKeyToClass.get('userManagementHelper'), 'UserManagementHelper');
+  assert.equal(mappings.fixtureKeyToClass.get('rosterHelper'), 'RosterHelper');
+});
+
+test('parseFixtureMappings ignores non-class-like property types', () => {
+  const dir = createTempDir();
+  const typesPath = writeFile(
+    dir,
+    'src/fixtures/types.ts',
+    [
+      'type Misc = {',
+      '  retries: number;',
+      '  labels: string[];',
+      '  status: "ok" | "fail";',
+      '  page: Pages.AppPage;',
+      '};',
+      '',
+    ].join('\n')
+  );
+
+  const mappings = parseFixtureMappings({ typesPath });
+  assert.equal(mappings.fixtureKeyToClass.get('page'), 'AppPage');
+  assert.equal(mappings.fixtureKeyToClass.has('retries'), false);
+  assert.equal(mappings.fixtureKeyToClass.has('labels'), false);
+  assert.equal(mappings.fixtureKeyToClass.has('status'), false);
+});
+
+test('parseFixtureMappings returns empty maps for missing file', () => {
+  const dir = createTempDir();
+  const typesPath = path.join(dir, 'missing.ts');
+  const mappings = parseFixtureMappings({ typesPath });
+
+  assert.equal(mappings.classToFixtureKeys.size, 0);
+  assert.equal(mappings.fixtureKeyToClass.size, 0);
+});

package/tests/format-analyze-result.test.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { formatSelectionReasonsForLog } = require('../src/format-analyze-result');
+
+test('formatSelectionReasonsForLog returns empty string for empty input', () => {
+  const result = formatSelectionReasonsForLog({ selectedSpecs: [], selectionReasons: new Map(), repoRoot: process.cwd() });
+  assert.equal(result, '');
+});
+
+test('formatSelectionReasonsForLog truncates output by maxLines', () => {
+  const repoRoot = '/repo';
+  const selectedSpecs = ['/repo/tests/a.spec.ts', '/repo/tests/b.spec.ts', '/repo/tests/c.spec.ts'];
+  const selectionReasons = new Map([
+    ['/repo/tests/a.spec.ts', 'reason A'],
+    ['/repo/tests/b.spec.ts', 'reason B'],
+    ['/repo/tests/c.spec.ts', 'reason C'],
+  ]);
+
+  const result = formatSelectionReasonsForLog({ selectedSpecs, selectionReasons, repoRoot, maxLines: 2 });
+
+  assert.match(result, /a\.spec\.ts: reason A/);
+  assert.match(result, /b\.spec\.ts: reason B/);
+  assert.match(result, /\.\.\. 1 more selected specs with reasons/);
+});

package/tests/global-watch-helpers.test.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { evaluateGlobalWatch, __testOnly } = require('../src/modules/global-watch-helpers');
+const { createTempDir, writeFile } = require('./_test-helpers');
+const { listFilesRecursive } = require('../src/modules/file-and-git-helpers');
+
+test('global watch glob matching works for changed entry path', () => {
+  const dir = createTempDir();
+  writeFile(dir, 'src/fixtures/types.ts', 'type T = {};\n');
+
+  const result = evaluateGlobalWatch({
+    repoRoot: dir,
+    changedEntries: [{ status: 'M', effectivePath: 'src/fixtures/types.ts', oldPath: 'src/fixtures/types.ts', newPath: 'src/fixtures/types.ts' }],
+    patterns: ['src/fixtures/**'],
+    listFilesRecursive,
+  });
+
+  assert.equal(result.matchedPaths.includes('src/fixtures/types.ts'), true);
+});
+
+test('global watch reads tsconfig JSONC aliases and resolves closure transitively', () => {
+  const dir = createTempDir();
+  writeFile(
+    dir,
+    'tsconfig.json',
+    [
+      '{',
+      '  "compilerOptions": {',
+      '    "baseUrl": "./",',
+      '    "paths": {',
+      '      "@lib/*": ["./src/lib/*"],',
+      '    },',
+      '  },',
+      '}',
+      '',
+    ].join('\n')
+  );
+  writeFile(dir, 'src/watch.ts', 'import { a } from "@lib/a"; export const w = a;\n');
+  writeFile(dir, 'src/lib/a.ts', 'export { b } from "./b"; export const a = 1;\n');
+  writeFile(dir, 'src/lib/b.ts', 'export const b = 2;\n');
+
+  const closure = __testOnly.resolveGlobalWatchClosure({
+    repoRoot: dir,
+    patterns: ['src/watch.ts'],
+    listFilesRecursive,
+  });
+
+  assert.equal(closure.resolvedFilesRelative.includes('src/watch.ts'), true);
+  assert.equal(closure.resolvedFilesRelative.includes('src/lib/a.ts'), true);
+  assert.equal(closure.resolvedFilesRelative.includes('src/lib/b.ts'), true);
+});
+
+test('global watch resolves asset string dependency with parent fallback', () => {
+  const dir = createTempDir();
+  writeFile(
+    dir,
+    'src/api/mocks/helpers/setup.ts',
+    'export const x = async (m) => m.mockOperations("k", "data.json");\n'
+  );
+  writeFile(dir, 'src/api/mocks/data.json', '{"ok":true}\n');
+
+  const closure = __testOnly.resolveGlobalWatchClosure({
+    repoRoot: dir,
+    patterns: ['src/api/mocks/helpers/setup.ts'],
+    listFilesRecursive,
+  });
+
+  assert.equal(closure.resolvedFilesRelative.includes('src/api/mocks/data.json'), true);
+});
+
+test('global watch matches changed rename entries by old/new/effective path', () => {
+  const dir = createTempDir();
+  writeFile(dir, 'src/global-setup-stem.ts', 'export default async () => {};\n');
+
+  const result = evaluateGlobalWatch({
+    repoRoot: dir,
+    changedEntries: [
+      {
+        status: 'R',
+        effectivePath: 'src/global-setup-stem-renamed.ts',
+        oldPath: 'src/global-setup-stem.ts',
+        newPath: 'src/global-setup-stem-renamed.ts',
+      },
+    ],
+    patterns: ['src/global-setup-stem.ts'],
+    listFilesRecursive,
+  });
+
+  assert.equal(result.matchedPaths.includes('src/global-setup-stem.ts'), true);
+});