declapract-typescript-ehmpathy 0.49.13 → 0.49.14

package/dist/practiceTemplateImportsDeclared.declapract.integration.test.ts

@@ -0,0 +1,173 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { builtinModules } from 'node:module';
+import { join, relative } from 'node:path';
+
+import { given, then, useBeforeAll, when } from 'test-fns';
+import yaml from 'yaml';
+
+import { getAllPracticesForUsecase } from './utils/getAllPracticesForUsecase';
+
+/**
+ * .what = clamps that, in every usecase, each bare package a best-practice `.ts` template imports
+ *         is declared by a package.json of some practice in that same usecase.
+ * .why  = a practice that ships `import … from 'simple-in-memory-cache'` while no practice in the
+ *         usecase declares it emits a tree that does not compile for its adopter (#656: config's
+ *         getConfig imported two cache packages that config never declared; the cache practice
+ *         floors them `.ifInstalled()`, so no practice installed them). the dep may be owed by a
+ *         peer practice (jest by tests-any, helpful-errors by errors) — what may never happen is
+ *         that NO practice in the usecase owes it.
+ * .scope = every usecase in src/useCases.yml, every practice it resolves (extends applied).
+ * .teeth = drop `simple-in-memory-cache` from config/best-practice/package.json and every usecase
+ *          that holds config reddens with `config: src/utils/config/getConfig.ts imports
+ *          simple-in-memory-cache` in its gap list — cache's `.ifInstalled()` floor of it does not
+ *          count, since a floor installs naught (the exact #656 gap).
+ * .note = INTEGRATION by rule.forbid.unit.remote-boundaries: it walks the practice trees on disk.
+ */
+
+const PRACTICES_DIR = join(__dirname, 'practices');
+const USECASES_YML_PATH = join(__dirname, 'useCases.yml');
+
+/**
+ * .what = list every `.ts` template under a best-practice dir (declarations excluded)
+ * .why  = a `.declapract.ts` file is the declaration, never copied to an adopter
+ */
+const getAllTemplatePaths = (input: { dir: string }): string[] => {
+  if (!existsSync(input.dir)) return [];
+  return readdirSync(input.dir).flatMap((name) => {
+    const path = join(input.dir, name);
+    if (statSync(path).isDirectory()) return getAllTemplatePaths({ dir: path });
+    if (!/\.tsx?$/.test(name)) return [];
+    if (name.includes('.declapract.')) return [];
+    return [path];
+  });
+};
+
+/**
+ * .what = cast an import specifier to its package name, or null when it names no package
+ * .why  = relative paths, the `@src/` alias, and node builtins are no dependency
+ */
+const asPackageName = (input: { specifier: string }): string | null => {
+  const { specifier } = input;
+  if (specifier.startsWith('.') || specifier.startsWith('/')) return null;
+  if (specifier.startsWith('@src/') || specifier.startsWith('node:')) return null;
+  const parts = specifier.split('/');
+  const name = specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]!;
+  if (builtinModules.includes(name)) return null;
+  return name;
+};
+
+/**
+ * .what = list the package names a template imports, from its import/export statements only
+ * .why  = a bare `from '<x>'` scan also reads prose (`a role from 'bad password'`) as an import
+ */
+const getAllImportedPackages = (input: { source: string }): string[] =>
+  [
+    ...input.source.matchAll(
+      /^\s*(?:import|export)\b[^'"`;]*?\bfrom\s+['"]([^'"]+)['"]|^\s*import\s+['"]([^'"]+)['"]/gm,
+    ),
+  ]
+    .map((match) => asPackageName({ specifier: (match[1] ?? match[2])! }))
+    .filter((name): name is string => name !== null);
+
+/**
+ * .what = list the package names a practice's package.json declares (any dep section), from its
+ *         template and from the deps its `package.json.declapract.ts` writes by key
+ * .why  = a practice may declare its deps in code with no template file (tests-expo writes
+ *         `devDependencies['isomorphic-fetch'] = '^3.0.0'`)
+ * .note = the code scan reads `<x>Dependencies['<name>']` keys: it may count a dep the fix only
+ *         reads, which loosens the clamp, never a false red
+ */
+const getAllDeclaredPackages = (input: { practice: string }): string[] => {
+  const templatePath = join(PRACTICES_DIR, input.practice, 'best-practice/package.json');
+  const declarationPath = `${templatePath}.declapract.ts`;
+  const parsed = existsSync(templatePath)
+    ? (JSON.parse(readFileSync(templatePath, 'utf8')) as Record<
+        string,
+        Record<string, string>
+      >)
+    : {};
+  const writtenByCode = existsSync(declarationPath)
+    ? [
+        ...readFileSync(declarationPath, 'utf8').matchAll(
+          /[dD]ependencies\[\s*['"]([^'"]+)['"]\s*\]/g,
+        ),
+      ].map((match) => match[1]!)
+    : [];
+  // an `.ifInstalled()` floor raises a dep a repo already has and installs none, so it owes naught
+  const installed = (section: Record<string, string> | undefined): string[] =>
+    Object.entries(section ?? {})
+      .filter(([, version]) => !version.includes('.ifInstalled()'))
+      .map(([name]) => name);
+  return [
+    ...installed(parsed.dependencies),
+    ...installed(parsed.devDependencies),
+    ...installed(parsed.peerDependencies),
+    ...writtenByCode,
+  ];
+};
+
+/**
+ * .what = list `<practice>: <template> imports <package>` per import that no practice in the set declares
+ */
+const getAllImportGaps = (input: { practices: string[] }): string[] => {
+  const declared = new Set(
+    input.practices.flatMap((practice) => getAllDeclaredPackages({ practice })),
+  );
+  const gaps = input.practices.flatMap((practice) => {
+    const dir = join(PRACTICES_DIR, practice, 'best-practice');
+    return getAllTemplatePaths({ dir }).flatMap((path) =>
+      getAllImportedPackages({ source: readFileSync(path, 'utf8') })
+        .filter((name) => !declared.has(name))
+        .map((name) => `${practice}: ${relative(dir, path)} imports ${name}`),
+    );
+  });
+  return [...new Set(gaps)].sort();
+};
+
+const USECASES = Object.keys(
+  yaml.parse(readFileSync(USECASES_YML_PATH, 'utf-8'))['use-cases'],
+).sort();
+
+describe('every bare import in a best-practice template is declared within its usecase', () => {
+  given('[case0] the import scan itself', () => {
+    when('[t0] statements and prose are read', () => {
+      then('it reads import statements, and never a prose `from`', () => {
+        expect(
+          getAllImportedPackages({
+            source: [
+              "import { a } from 'pkg-a';",
+              'import {',
+              '  b,',
+              "} from '@scope/pkg-b/deep';",
+              "import 'pkg-c';",
+              "export { d } from 'pkg-d';",
+              "import x from './local';",
+              "import y from 'node:fs';",
+              "  // a role from 'bad password' is refused",
+              "throw new Error(`denied from 'psql absent'`);",
+            ].join('\n'),
+          }).sort(),
+        ).toEqual(['@scope/pkg-b', 'pkg-a', 'pkg-c', 'pkg-d']);
+      });
+    });
+  });
+
+  USECASES.forEach((usecase) => {
+    given(`[case] the ${usecase} usecase`, () => {
+      const scene = useBeforeAll(() => ({
+        gaps: getAllImportGaps({
+          practices: getAllPracticesForUsecase({
+            usecasesYmlPath: USECASES_YML_PATH,
+            usecase,
+          }),
+        }),
+      }));
+
+      when('[t0] each template import is checked against the usecase package.json set', () => {
+        then('no template imports a package that no practice in the usecase declares', () => {
+          expect(scene.gaps).toEqual([]);
+        });
+      });
+    });
+  });
+});

package/dist/practiceTemplateIssueRefs.declapract.integration.test.ts

@@ -0,0 +1,124 @@
+import { readFileSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+
+import { given, then, when } from 'test-fns';
+
+import {
+  getAllPathsUnderDir,
+  PRACTICE_TREE_SKIP_DIRS,
+} from './utils/getAllPathsUnderDir';
+
+/**
+ * .what = clamps that no emitted best-practice template carries a bare issue ref (`#123`) or a
+ *         `todo:` (#648).
+ * .why  = a template is read in the consumer's tree. there a bare `#123` reads as the consumer's
+ *         own issue 123, which is some other ticket or none; and a `todo:` is a chore this repo
+ *         owes, handed to every adopter to puzzle over. a repo-qualified ref (`sdk-aws-lambda#42`)
+ *         resolves from anywhere, so it stays allowed.
+ * .teeth = add `// see #123` to any best-practice file and case1 goes red, with the file and line.
+ * .note = `*.declapract.*` files (declarations, readmes, tests) are never emitted, so they may cite
+ *         this repo's issues freely.
+ */
+
+const repoRoot = join(__dirname, '..');
+const practicesDir = join(repoRoot, 'src/practices');
+
+/**
+ * .what = a bare issue ref: `#` + 2-4 digits, not preceded by a word, path, or repo name
+ */
+const BARE_ISSUE_REF = /(^|[^\w/.-])#[0-9]{2,4}\b/;
+
+/**
+ * .what = a todo marker
+ */
+const TODO_MARKER = /\btodo:/i;
+
+/**
+ * .what = every emitted best-practice template, as an absolute path
+ * .note = a `src/.test/` dir INSIDE a best-practice tree is an emitted template (useKeyrack.ts),
+ *         so this walk enters `.test`; the `/best-practice/` filter drops the fixture dirs
+ */
+const getAllEmittedTemplatePaths = (): string[] =>
+  getAllPathsUnderDir({
+    dir: practicesDir,
+    skip: PRACTICE_TREE_SKIP_DIRS.filter((dir) => dir !== '.test'),
+  })
+    .filter((path) => path.includes('/best-practice/'))
+    .filter((path) => !path.includes('/.test/assets/'))
+    .filter((path) => !basename(path).includes('.declapract.'));
+
+/**
+ * .what = each `file:line` of an emitted template that carries a bare issue ref or a todo
+ */
+const getAllOffenses = (): string[] =>
+  getAllEmittedTemplatePaths().flatMap((path) =>
+    readFileSync(path, 'utf-8')
+      .split('\n')
+      .map((line, index) => ({ line, index }))
+      .filter(({ line }) => BARE_ISSUE_REF.test(line) || TODO_MARKER.test(line))
+      .map(
+        ({ line, index }) =>
+          `${relative(repoRoot, path)}:${index + 1}: ${line.trim()}`,
+      ),
+  );
+
+describe('practice templates carry no bare issue ref nor todo (#648)', () => {
+  given('[case1] every emitted best-practice template under src/practices', () => {
+    when('[t0] each line is read', () => {
+      then('the walk found templates to read', () => {
+        expect(getAllEmittedTemplatePaths().length).toBeGreaterThan(100);
+      });
+
+      then('no line holds a bare `#NNN` or a `todo:`', () => {
+        expect(getAllOffenses()).toEqual([]);
+      });
+    });
+  });
+
+  given('[case3] every review marker a fix writes into a consumer file', () => {
+    when('[t0] each marker line the snapshots record is read', () => {
+      // the snapshots hold the bytes a fix emits; a test title (`exports[…`) is not emitted
+      const markerLines = getAllPathsUnderDir({
+        dir: join(repoRoot, 'src'),
+        skip: ['node_modules'],
+      })
+        .filter((path) => path.endsWith('.snap'))
+        .flatMap((path) =>
+          readFileSync(path, 'utf-8')
+            .split('\n')
+            .filter((line) => line.includes('@declapract:review'))
+            .filter((line) => !line.startsWith('exports['))
+            .map((line) => `${relative(repoRoot, path)}: ${line.trim()}`),
+        );
+
+      then('the walk found markers to read', () => {
+        expect(markerLines.length).toBeGreaterThan(10);
+      });
+
+      then('no marker holds a bare `#NNN`; a ref names this repo', () => {
+        expect(markerLines.filter((line) => BARE_ISSUE_REF.test(line))).toEqual(
+          [],
+        );
+      });
+    });
+  });
+
+  given('[case2] the matchers themselves', () => {
+    when('[t0] each shape is tested', () => {
+      then('a bare ref matches, a repo-qualified ref does not', () => {
+        expect(BARE_ISSUE_REF.test('// see #123')).toBe(true);
+        expect(BARE_ISSUE_REF.test('(#585) the key')).toBe(true);
+        expect(BARE_ISSUE_REF.test('# 123 title')).toBe(false);
+        expect(BARE_ISSUE_REF.test('sdk-aws-lambda#42')).toBe(false);
+        expect(BARE_ISSUE_REF.test('https://x.com/a#123')).toBe(false);
+        expect(BARE_ISSUE_REF.test('color: #fff')).toBe(false);
+      });
+
+      then('a todo matches in any case', () => {
+        expect(TODO_MARKER.test('// todo: fix it')).toBe(true);
+        expect(TODO_MARKER.test('# TODO: fix it')).toBe(true);
+        expect(TODO_MARKER.test('todos are fine')).toBe(false);
+      });
+    });
+  });
+});

package/dist/practiceTemplateSrcAliasImports.declapract.integration.test.ts

@@ -0,0 +1,83 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+
+import { given, then, when } from 'test-fns';
+
+import { getAllPathsUnderDir } from './utils/getAllPathsUnderDir';
+
+/**
+ * .what = clamps that no best-practice template under `src/` reaches a peer `src/` file through a
+ *         `../` import; it must use the `@src/` alias (#630).
+ * .why  = a template is one file of a tree that several practices write. a `../` import pins the
+ *         template to the exact dir depth its author saw, so an adopter who moves the peer (or a
+ *         practice that relocates it) breaks the compile. `@src/` names the peer by its place in
+ *         the repo, which the shipped tsconfig paths, jest moduleNameMapper, and tsc-alias all map.
+ * .teeth = put `import { access } from '../environment';` back into
+ *          `config/best-practice/src/utils/config/getConfig.ts` and case1 goes red with that line.
+ * .note = an import that leaves `src/` (e.g. `src/.test/*` to a repo-root jest helper) has no
+ *         `@src/` form, so it is out of scope.
+ */
+
+const practicesDir = join(__dirname, 'practices');
+
+/**
+ * .what = every `.ts`/`.tsx` template a practice ships under its best-practice `src/`
+ */
+const getAllSrcTemplates = (): { practice: string; path: string }[] =>
+  readdirSync(practicesDir)
+    .map((practice) => ({
+      practice,
+      dir: join(practicesDir, practice, 'best-practice'),
+    }))
+    .filter(({ dir }) => existsSync(join(dir, 'src')))
+    .flatMap(({ practice, dir }) =>
+      getAllPathsUnderDir({ dir: join(dir, 'src'), skip: ['node_modules'] })
+        .filter((path) => /\.tsx?$/.test(path))
+        .filter((path) => !/\.declapract\.(test\.)?ts$/.test(path))
+        .map((path) => ({ practice, path: relative(dir, path) })),
+    );
+
+/**
+ * .what = the `../` import specifiers in a template that land back inside `src/`
+ * .note = path.join collapses the `..` segments, so the joined path names the import's target
+ */
+const getAllParentImportsInsideSrc = (input: {
+  practice: string;
+  path: string;
+}): string[] => {
+  const contents = readFileSync(
+    join(practicesDir, input.practice, 'best-practice', input.path),
+    'utf8',
+  );
+  const specifiers = [
+    ...contents.matchAll(/from\s+'(\.\.\/[^']*)'/g),
+    ...contents.matchAll(/import\(\s*'(\.\.\/[^']*)'\s*\)/g),
+  ].map((match) => match[1]!);
+  return specifiers.filter((specifier) =>
+    join(dirname(input.path), specifier).startsWith('src/'),
+  );
+};
+
+describe('best-practice src templates import peers via @src/, never ../ (#630)', () => {
+  const templates = getAllSrcTemplates();
+
+  given('[case0] the src templates', () => {
+    then('at least one is found, so the clamp is not vacuous', () => {
+      expect(templates.length).toBeGreaterThan(0);
+    });
+  });
+
+  given('[case1] every src template', () => {
+    when('[t0] its `../` imports are read', () => {
+      then('none lands back inside src/', () => {
+        const offenders = templates.flatMap((template) =>
+          getAllParentImportsInsideSrc(template).map(
+            (specifier) =>
+              `${template.practice}: ${template.path} ← '${specifier}'`,
+          ),
+        );
+        expect(offenders).toEqual([]);
+      });
+    });
+  });
+});

package/dist/practiceTemplateTrailingNewline.declapract.integration.test.ts

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+
+import { given, then, when } from 'test-fns';
+
+import {
+  getAllPathsUnderDir,
+  PRACTICE_TREE_SKIP_DIRS,
+} from './utils/getAllPathsUnderDir';
+
+/**
+ * .what = clamps that every emitted best-practice template ends with a newline (#689)
+ * .why  = a template lands byte for byte in the consumer's tree. one with no final newline makes
+ *         the consumer's editor or formatter append one, and the next apply strips it again, so
+ *         the file flips on every upgrade and every save.
+ * .teeth = drop the final newline from any best-practice template and this goes red, by path.
+ * .note = `*.declapract.*` files are never emitted, so they are not read here. an empty file
+ *         holds no line to end, so it passes.
+ */
+
+const repoRoot = join(__dirname, '..');
+const practicesDir = join(repoRoot, 'src/practices');
+
+/**
+ * .what = every emitted best-practice template, as an absolute path
+ * .note = a `src/.test/` dir inside a best-practice tree is emitted, so this walk enters `.test`;
+ *         the `/best-practice/` filter drops the fixture dirs
+ */
+const getAllEmittedTemplatePaths = (): string[] =>
+  getAllPathsUnderDir({
+    dir: practicesDir,
+    skip: PRACTICE_TREE_SKIP_DIRS.filter((dir) => dir !== '.test'),
+  })
+    .filter((path) => path.includes('/best-practice/'))
+    .filter((path) => !path.includes('/.test/assets/'))
+    .filter((path) => !basename(path).includes('.declapract.'));
+
+describe('practice templates end with a newline (#689)', () => {
+  given('[case1] every emitted best-practice template under src/practices', () => {
+    when('[t0] the last byte of each is read', () => {
+      const templates = getAllEmittedTemplatePaths();
+
+      then('the walk found templates to read', () => {
+        expect(templates.length).toBeGreaterThan(100);
+      });
+
+      then('each non-empty template ends with `\\n`', () => {
+        const offenses = templates
+          .filter((path) => {
+            const contents = readFileSync(path, 'utf-8');
+            return contents.length > 0 && !contents.endsWith('\n');
+          })
+          .map((path) => relative(repoRoot, path));
+        expect(offenses).toEqual([]);
+      });
+    });
+  });
+});

package/dist/practices/artifact/.test/assets/demo-repo-with-npx-command/declapract.use.yml

@@ -0,0 +1,3 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/artifact-only/declarations
+declarations: 'declarations/declapract.declare.yml'
+useCase: artifact-only

package/dist/practices/artifact/.test/assets/demo-repo-with-npx-command/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "test-project",
+  "version": "1.0.0",
+  "devDependencies": {
+    "simple-artifact-builder": "1.1.15"
+  },
+  "scripts": {
+    "build": "tsc -p ./tsconfig.build.json && npm run build:artifact",
+    "build:artifact": "npx simple-artifact-builder zip"
+  }
+}

package/dist/practices/artifact/__snapshots__/package.json.declapract.integration.test.ts.snap

@@ -0,0 +1,31 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`artifact package.json — an extant npx command converges (#672) given: [case1] an adopter whose build:artifact calls the bin through npx when: [t0] declapract apply runs then: before + after match snapshot: package.json — after 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "devDependencies": {
+    "simple-artifact-builder": "1.1.15"
+  },
+  "scripts": {
+    "build": "tsc -p ./tsconfig.build.json && npm run build:artifact",
+    "build:artifact": "simple-artifact-builder zip"
+  }
+}
+"
+`;
+
+exports[`artifact package.json — an extant npx command converges (#672) given: [case1] an adopter whose build:artifact calls the bin through npx when: [t0] declapract apply runs then: before + after match snapshot: package.json — before 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "devDependencies": {
+    "simple-artifact-builder": "1.1.15"
+  },
+  "scripts": {
+    "build": "tsc -p ./tsconfig.build.json && npm run build:artifact",
+    "build:artifact": "npx simple-artifact-builder zip"
+  }
+}
+"
+`;

package/dist/practices/artifact/best-practice/artifact.yml

@@ -2,6 +2,6 @@ trace:
   - 'dist/contract/handlers/**/*.js' # include all dependencies of the handlers
 
 pick:
-  - 'dist/**/*.js.map' # include all of the source maps # TODO: update simple-artifact-builder to do this automatically for all files it includes
+  - 'dist/**/*.js.map' # include all of the source maps; the builder does not pick a map beside each traced file
   - 'config/*'
   - 'package.json'

package/dist/practices/artifact/best-practice/package.json

@@ -3,6 +3,6 @@
     "simple-artifact-builder": "@declapract{check.minVersion('1.1.15')}"
   },
   "scripts": {
-    "build:artifact": "npx simple-artifact-builder zip"
+    "build:artifact": "simple-artifact-builder zip"
   }
 }

package/dist/practices/artifact/package.json.declapract.integration.test.ts

@@ -0,0 +1,74 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useBeforeAll, when } from 'test-fns';
+
+// executeApply evaluates the whole practice
+jest.setTimeout(240_000);
+
+/**
+ * .what = proves an adopter whose package.json still calls `npx simple-artifact-builder zip`
+ *         converges on the bare command when `declapract apply` runs (#672)
+ * .why  = package.json is a CONTAINS check. a CONTAINS check alone would flag the old command
+ *         forever; the json fix must rewrite the mismatched value in place, or the adopter holds a
+ *         check that can never pass. this proves the rewrite, on the real pipeline
+ * .teeth = were the json fix to leave a mismatched value alone, after1 would still hold `npx` and
+ *          the rewrite assertion reddens
+ */
+describe('artifact package.json — an extant npx command converges (#672)', () => {
+  given('[case1] an adopter whose build:artifact calls the bin through npx', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-artifact-npx-command',
+      clone:
+        './src/practices/artifact/.test/assets/demo-repo-with-npx-command',
+      // evaluate artifact alone against the tiny repo
+      symlink: [
+        {
+          at: 'declarations',
+          to: './src/.test/assets/artifact-only/declarations',
+        },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const read = () => fs.readFile(path.join(tempDir, 'package.json'), 'utf-8');
+
+    const state = useBeforeAll(async () => {
+      const config = path.join(tempDir, 'declapract.use.yml');
+      const before = await read();
+      await executeApply({ config, practice: 'artifact', file: 'package.json' });
+      const after1 = await read();
+      await executeApply({ config, practice: 'artifact', file: 'package.json' });
+      const after2 = await read();
+      return { before, after1, after2 };
+    }, 230_000);
+
+    when('[t0] declapract apply runs', () => {
+      then('build:artifact calls simple-artifact-builder bare', () => {
+        const pkg = JSON.parse(state.after1);
+        expect(pkg.scripts['build:artifact']).toEqual(
+          'simple-artifact-builder zip',
+        );
+      });
+
+      then('the adopter-owned build command is left alone', () => {
+        const pkg = JSON.parse(state.after1);
+        expect(pkg.scripts.build).toEqual(
+          'tsc -p ./tsconfig.build.json && npm run build:artifact',
+        );
+      });
+
+      then('before + after match snapshot', () => {
+        expect(state.before).toMatchSnapshot('package.json — before');
+        expect(state.after1).toMatchSnapshot('package.json — after');
+      });
+    });
+
+    when('[t1] declapract apply runs again', () => {
+      then('the package.json is a fixed point', () => {
+        expect(state.after2).toEqual(state.after1);
+      });
+    });
+  });
+});

package/dist/practices/bottleneck/.declapract.integration.test.ts

@@ -0,0 +1,96 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+// executeApply is slow (full practice evaluation), so grant a generous limit
+jest.setTimeout(180_000);
+
+const FIXTURES = './src/practices/bottleneck/bad-practices/bottleneck/.test/assets';
+
+/**
+ * .what = end-to-end proof of the bottleneck → with-bottleneck move, through the REAL apply.
+ * .why  = the fix reads the consumer's src via getProjectRootDirectory() to decide whether
+ *   bottleneck may leave (#663, F42); only the pipeline proves that read lands on the real repo.
+ */
+describe('bottleneck bad-practice', () => {
+  const genRepo = (input: { fixture: string; slug: string }) =>
+    genTempDir({
+      slug: input.slug,
+      clone: `${FIXTURES}/${input.fixture}`,
+      symlink: [
+        { at: 'declarations', to: './src/.test/assets/bottleneck/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+  const applyFix = (input: { tempDir: string }) =>
+    executeApply({
+      config: path.join(input.tempDir, 'declapract.use.yml'),
+      practice: 'bottleneck',
+      file: 'package.json',
+    });
+
+  given('[case1] bottleneck@2.x and no src import of it', () => {
+    const tempDir = genRepo({
+      fixture: 'demo-repo-without-bottleneck-import',
+      slug: 'declapract-bottleneck-unused',
+    });
+    const read = () => fs.readFile(path.join(tempDir, 'package.json'), 'utf-8');
+
+    when('[t0] the fix is applied', () => {
+      const result = useThen('apply twice', async () => {
+        const before = await read();
+        await applyFix({ tempDir });
+        const once = await read();
+        await applyFix({ tempDir });
+        const twice = await read();
+        return { before, once, twice };
+      });
+
+      then('with-bottleneck is pinned at 0.1.2 and bottleneck leaves', () => {
+        const pkg = JSON.parse(result.once);
+        expect(pkg.dependencies['with-bottleneck']).toEqual('0.1.2');
+        expect(pkg.dependencies.bottleneck).toBeUndefined();
+        expect(result.before).toMatchSnapshot('package.json — before');
+        expect(result.once).toMatchSnapshot('package.json — after');
+      });
+
+      then('the second apply is a no-op', () => {
+        expect(result.twice).toEqual(result.once);
+      });
+    });
+  });
+
+  given('[case2] bottleneck@2.x and a src file that imports it', () => {
+    const tempDir = genRepo({
+      fixture: 'demo-repo-with-bottleneck-import',
+      slug: 'declapract-bottleneck-imported',
+    });
+    const read = () => fs.readFile(path.join(tempDir, 'package.json'), 'utf-8');
+
+    when('[t0] the fix is applied', () => {
+      const result = useThen('apply twice', async () => {
+        const before = await read();
+        await applyFix({ tempDir });
+        const once = await read();
+        await applyFix({ tempDir });
+        const twice = await read();
+        return { before, once, twice };
+      });
+
+      then('with-bottleneck is added at 0.1.2 and bottleneck stays, so the import still builds', () => {
+        const pkg = JSON.parse(result.once);
+        expect(pkg.dependencies['with-bottleneck']).toEqual('0.1.2');
+        expect(pkg.dependencies.bottleneck).toEqual('2.19.5');
+        expect(result.before).toMatchSnapshot('package.json — before');
+        expect(result.once).toMatchSnapshot('package.json — after');
+      });
+
+      then('the second apply is a no-op', () => {
+        expect(result.twice).toEqual(result.once);
+      });
+    });
+  });
+});