declapract-typescript-ehmpathy 0.49.11 → 0.49.13

package/dist/.test/assets/expo-migration/declarations/practices/tests-expo/package.json.declapract.integration.test.ts

@@ -0,0 +1,94 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useBeforeAll, when } from 'test-fns';
+
+// executeApply is slow (full practice evaluation)
+jest.setTimeout(180_000);
+
+/**
+ * .what = pipeline test for the tests-expo jest-expo/rtr SDK-major gate (#584 / defect D1).
+ * .why  = the unit test proves the check/fix in isolation; only the real executeApply pipeline
+ *         proves declapract WIRES the declaration to `package.json` and reaches a fixed point on
+ *         a re-run. the crash this gate prevents is a react-19-era jest-expo (54) held onto an
+ *         expo-51 / react-18 repo — every unit suite throws at jest-expo's preset setup — so the
+ *         gate must hold jest-expo at the repo's OWN expo major (51), never bump it to 54.
+ * .note = scoped `practice: 'tests-expo'` — the declaration reads only `contents`, never
+ *         `context.projectPractices`, so a practice scope is safe (no usecase-aware branch goes
+ *         dark) and isolates the apply to tests-expo's package.json declaration alone.
+ */
+describe('tests-expo package.json — pipeline gate on the repo expo/react major', () => {
+  given('[case1] an expo-51 / react-18 repo seeded with a react-19-era jest-expo 54 the gate aligns down to the expo major (51)', () => {
+    const tempDir = genTempDir({
+      slug: 'tests-expo-major-gate',
+      clone: './src/.test/assets/expo-migration/repo-app-protools-shaped',
+      symlink: [
+        { at: 'declarations', to: './src/.test/assets/expo-migration/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const pkgPath = () => path.join(tempDir, 'package.json');
+    const readPkg = () => fs.readFile(pkgPath(), 'utf-8');
+
+    const state = useBeforeAll(async () => {
+      // seed the crash shape: a react-19-era jest-expo/rtr on an expo-51 / react-18 repo
+      const seeded = {
+        ...JSON.parse(await readPkg()),
+        devDependencies: {
+          ...JSON.parse(await readPkg()).devDependencies,
+          expo: '~51.0.0',
+          react: '18.2.0',
+          'jest-expo': '^54.0.0',
+          'react-test-renderer': '^19.0.0',
+          'babel-preset-expo': '^12.0.0',
+          'isomorphic-fetch': '^3.0.0',
+        },
+      };
+      await fs.writeFile(pkgPath(), `${JSON.stringify(seeded, null, 2)}\n`);
+      const pkgBefore = await readPkg();
+
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'tests-expo',
+        file: 'package.json',
+      });
+      const pkgAfter1 = await readPkg();
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'tests-expo',
+        file: 'package.json',
+      });
+      const pkgAfter2 = await readPkg();
+
+      return { pkgBefore, pkgAfter1, pkgAfter2 };
+    }, 170_000);
+
+    when('[t0] the tests-expo gate is applied to the seeded package.json', () => {
+      then('jest-expo is held at the repo expo major (51), not bumped to 54', () => {
+        expect(JSON.parse(state.pkgBefore).devDependencies['jest-expo']).toEqual(
+          '^54.0.0',
+        );
+        expect(JSON.parse(state.pkgAfter1).devDependencies['jest-expo']).toEqual(
+          '^51.0.0',
+        );
+      });
+
+      then('react-test-renderer is held at the repo react major (18), not 19', () => {
+        expect(
+          JSON.parse(state.pkgAfter1).devDependencies['react-test-renderer'],
+        ).toEqual('^18.0.0');
+      });
+
+      then('before + after match snapshot', () => {
+        expect(state.pkgBefore).toMatchSnapshot('package.json — before');
+        expect(state.pkgAfter1).toMatchSnapshot('package.json — after gate');
+      });
+
+      then('a second apply is a fixed point (the gate holds)', () => {
+        expect(state.pkgAfter2).toEqual(state.pkgAfter1);
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/__snapshots__/package.json.declapract.integration.test.ts.snap

@@ -0,0 +1,8 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`typescript-expo package.json the emitted build commands match snapshot: typescript-expo build commands 1`] = `
+{
+  "build": "npm run build:web",
+  "build:web": "npx expo export --platform web",
+}
+`;

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/__snapshots__/tsconfig.json.declapract.integration.test.ts.snap

@@ -0,0 +1,19 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`typescript-expo tsconfig.json the emitted tsconfig template matches snapshot: typescript-expo tsconfig.json 1`] = `
+"{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@src/*": ["src/*"],
+      "@assets/*": ["assets/*"]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx"
+  ]
+}
+"
+`;

package/dist/.test/assets/{expo-toolchain/declarations/practices/typescript-expo/best-practice → expo-migration/declarations/practices/typescript-expo}/package.json.declapract.integration.test.ts

@@ -2,7 +2,7 @@ import { FileCheckType } from 'declapract';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 
-import { check } from './package.json.declapract';
+import { check } from './best-practice/package.json.declapract';
 
 /**
  * .why integration = the build-command assertions read the shipped `package.json` template
@@ -19,7 +19,7 @@ describe('typescript-expo package.json', () => {
 
   it('the emitted build command uses metro/EAS (expo export), not tsc', () => {
     const template = JSON.parse(
-      readFileSync(path.join(__dirname, 'package.json'), 'utf-8'),
+      readFileSync(path.join(__dirname, 'best-practice/package.json'), 'utf-8'),
     );
     // `build` aliases build:web so the shared cicd `npm run build` works on expo
     expect(template.scripts.build).toEqual('npm run build:web');
@@ -27,4 +27,17 @@ describe('typescript-expo package.json', () => {
     expect(template.scripts['build:web']).toContain('expo export --platform web');
     expect(template.scripts.build).not.toContain('tsc');
   });
+
+  it('the emitted build commands match snapshot', () => {
+    // snapshot the governed build commands themselves, so a reshaped command that keeps the
+    // pinned tokens green (a reordered flag, a rephrased alias) reddens a vibecheck in review
+    // (rule.require.contract-snapshot-exhaustiveness)
+    const template = JSON.parse(
+      readFileSync(path.join(__dirname, 'best-practice/package.json'), 'utf-8'),
+    );
+    expect({
+      build: template.scripts.build,
+      'build:web': template.scripts['build:web'],
+    }).toMatchSnapshot('typescript-expo build commands');
+  });
 });

package/dist/.test/assets/{expo-fullusecase/declarations/practices/typescript-expo/best-practice → expo-migration/declarations/practices/typescript-expo}/tsconfig.json.declapract.integration.test.ts

@@ -2,7 +2,7 @@ import { FileCheckType } from 'declapract';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 
-import { check } from './tsconfig.json.declapract';
+import { check } from './best-practice/tsconfig.json.declapract';
 
 /**
  * .why integration = the template-content assertions read the shipped `tsconfig.json`
@@ -19,7 +19,7 @@ describe('typescript-expo tsconfig.json', () => {
 
   it('the emitted template is expo-shaped, not node', () => {
     const template = JSON.parse(
-      readFileSync(path.join(__dirname, 'tsconfig.json'), 'utf-8'),
+      readFileSync(path.join(__dirname, 'best-practice/tsconfig.json'), 'utf-8'),
     );
     // extends the expo base (jsx + react-native resolution), NOT @tsconfig/node20
     expect(template.extends).toEqual('expo/tsconfig.base');
@@ -29,4 +29,15 @@ describe('typescript-expo tsconfig.json', () => {
     // tsx is included (a react-native app has jsx), unlike the node tsconfig
     expect(template.include).toContain('**/*.tsx');
   });
+
+  it('the emitted tsconfig template matches snapshot', () => {
+    // snapshot the whole shipped template, so a reshape that keeps the pinned tokens green
+    // (a reordered path alias, a rephrased extends) reddens a vibecheck in review
+    // (rule.require.contract-snapshot-exhaustiveness)
+    const template = readFileSync(
+      path.join(__dirname, 'best-practice/tsconfig.json'),
+      'utf-8',
+    );
+    expect(template).toMatchSnapshot('typescript-expo tsconfig.json');
+  });
 });

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/.github/workflows/.deploy-expo.yml

@@ -3,7 +3,7 @@ name: .deploy-expo
 on:
   workflow_call:
     inputs:
-      stage:
+      access:
         type: string
         required: true
 

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/__snapshots__/changedsince-origin-main.declapract.integration.test.ts.snap

@@ -0,0 +1,8 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`tests-any changedSince=origin/main policy given: the shipped best-practice/package.json when: the changed-file test commands are read then: the emitted changed-file commands match snapshot: tests-any changed-file commands 1`] = `
+{
+  "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n "\${CI:-}" ] && echo '--ci') $([ "\${THOROUGH:-}" != "true" ] && echo '--changedSince=origin/main') $([ "\${RESNAP:-}" = "true" ] && echo '--updateSnapshot')",
+  "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n "\${CI:-}" ] && echo '--ci') $([ "\${THOROUGH:-}" != "true" ] && echo '--changedSince=origin/main') $([ "\${RESNAP:-}" = "true" ] && echo '--updateSnapshot')",
+}
+`;

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/autoprune-hooks.declapract.integration.test.ts

@@ -0,0 +1,104 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { given, then, when } from 'test-fns';
+
+/**
+ * .what = clamps that every jest config template the tests-node / tests-expo practices ship
+ *         REACHES both autoprune hooks -- never one without the other -- whether it wires the
+ *         autoprune setup DIRECTLY or through a COMPOSITE globalSetup.
+ * .why  = test-fns >=1.16 reclaims the temp dirs genTempDir makes, but jest needs TWO keys:
+ *         globalSetup stamps the run, globalTeardown reclaims its dirs. a config with globalSetup
+ *         and NO globalTeardown stamps every dir and reclaims none -- the half-wired state #590
+ *         names, which test-fns itself detects + reports but the practice must never SHIP. the
+ *         floor bump (tests-any package.json, test-fns >=1.17.0) delivers the capability; this
+ *         clamp guards the wire-up so a future edit cannot drop one key and leave the other.
+ * .why-composite = #598 makes the two node suite configs (integration + acceptance) COMPOSE an
+ *         livedb wake with autoprune's setup, so their `globalSetup` points at a local
+ *         `jest.<suite>.prepare.ts` rather than the `test-fns/autoprune.setup.jest` subpath
+ *         directly. jest allows ONE globalSetup, so the composite is how both run. this clamp
+ *         follows the indirection: a composite config still REACHES autoprune iff its globalSetup
+ *         file imports the autoprune subpath. so a drop of the autoprune import from a composite
+ *         reddens here exactly as a drop of the direct key would.
+ * .teeth = remove `globalTeardown` from any config, OR remove the autoprune setup from a direct
+ *          config, OR drop the `test-fns/autoprune.setup.jest` import from a composite globalSetup
+ *          file, and the matched case reddens (the both-reached-together assertion).
+ * .note = the subject is the shipped TEMPLATE text, read as a string -- so this clamp is
+ *         independent of which test-fns version is installed here (the autoprune subpaths only
+ *         need to load in a CONSUMER, which the floor bump guarantees). the `.declapract.test.ts`
+ *         suffix is this repo's UNIT-test marker; declapract's loader excludes `.test.ts`, so this
+ *         file is neither loaded as a declaration nor copied to a consumer.
+ */
+
+// a DIRECT config wires the setup as `globalSetup: 'test-fns/autoprune.setup.jest'`; a COMPOSITE
+// file IMPORTS it as `... from 'test-fns/autoprune.setup.jest'`. the two forms are distinct on
+// purpose: a `.why` comment may quote the `globalSetup: '...'` form as prose, so the composite
+// reach-check matches the IMPORT form (`from '...'`), which a comment does not carry -- else a
+// mere mention of the subpath in a comment would satisfy the clamp (a teeth hole caught in dogfood).
+const SETUP_DIRECT_KEY = "globalSetup: 'test-fns/autoprune.setup.jest'";
+const SETUP_IMPORT = "from 'test-fns/autoprune.setup.jest'";
+const TEARDOWN_KEY = "globalTeardown: 'test-fns/autoprune.teardown.jest'";
+
+// anchor on __dirname, not process.cwd(): the repo-root-relative paths below must point at the same
+// file wherever jest is invoked from (a nested `jest src/practices/...` run has a different cwd).
+// from this file (src/practices/tests-any/) the repo root is three segments up.
+const REPO_ROOT = join(__dirname, '../../..');
+
+// each config either wires the autoprune setup DIRECTLY, or COMPOSES it via a local globalSetup
+// file that imports the autoprune subpath. `composite` names that file, relative to the practice.
+const configs: { relPath: string; composite: string | null }[] = [
+  { relPath: 'src/practices/tests-node/best-practice/jest.unit.config.ts', composite: null },
+  {
+    relPath: 'src/practices/tests-node/best-practice/jest.integration.config.ts',
+    composite: 'src/practices/tests-node/best-practice/jest.integration.prepare.ts',
+  },
+  {
+    relPath: 'src/practices/tests-node/best-practice/jest.acceptance.config.ts',
+    composite: 'src/practices/tests-node/best-practice/jest.acceptance.prepare.ts',
+  },
+  { relPath: 'src/practices/tests-expo/best-practice/jest.unit.config.ts', composite: null },
+  { relPath: 'src/practices/tests-expo/best-practice/jest.integration.config.ts', composite: null },
+  { relPath: 'src/practices/tests-expo/best-practice/jest.acceptance.config.ts', composite: null },
+];
+
+/**
+ * .what = whether a config REACHES the autoprune setup -- directly, or through its composite.
+ * .why  = the invariant #590 guards is "setup is reached", not "setup is inline". a composite
+ *         config reaches it iff its globalSetup file imports the autoprune subpath.
+ */
+const reachesAutopruneSetup = (input: {
+  configContents: string;
+  composite: string | null;
+}): boolean => {
+  // direct: the config itself wires `globalSetup: 'test-fns/autoprune.setup.jest'`
+  if (input.configContents.includes(SETUP_DIRECT_KEY)) return true;
+
+  // composite: the config points at a local globalSetup file that IMPORTS the autoprune subpath
+  if (!input.composite) return false;
+  const compositeContents = readFileSync(join(REPO_ROOT, input.composite), 'utf8');
+  return compositeContents.includes(SETUP_IMPORT);
+};
+
+describe('autoprune hook reach across the shipped jest configs', () => {
+  for (const { relPath, composite } of configs) {
+    given(`[case] ${relPath}${composite ? ' (composite)' : ' (direct)'}`, () => {
+      const configContents = readFileSync(join(REPO_ROOT, relPath), 'utf8');
+
+      when('[t0] the shipped config is read', () => {
+        then('it reaches the autoprune setup (stamps the run)', () => {
+          expect(reachesAutopruneSetup({ configContents, composite })).toEqual(true);
+        });
+
+        then('it wires globalTeardown (reclaims the dirs)', () => {
+          expect(configContents).toContain(TEARDOWN_KEY);
+        });
+
+        then('it never ships one hook without the other (half-wired = stamp, no reclaim)', () => {
+          const reachesSetup = reachesAutopruneSetup({ configContents, composite });
+          const hasTeardown = configContents.includes(TEARDOWN_KEY);
+          expect(reachesSetup).toEqual(hasTeardown);
+        });
+      });
+    });
+  }
+});

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-import-paths/.declapract.readme.md

@@ -21,11 +21,11 @@ replaces all occurrences of `acceptance/` with `blackbox/` in import paths.
 before:
 ```typescript
 import { locally } from '../acceptance/environment';
-import { stage } from '../../acceptance/utils/environment';
+import { access } from '../../acceptance/utils/environment';
 ```
 
 after:
 ```typescript
 import { locally } from '../blackbox/environment';
-import { stage } from '../../blackbox/utils/environment';
+import { access } from '../../blackbox/utils/environment';
 ```

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-test-utils/blackbox/lambdas/<star>.ts.declapract.ts

@@ -20,7 +20,6 @@ export const fix: FileFixFunction = async (contents, context) => {
         `import { invokeLambda } from '../_utils/invokeLambda';`,
         [
           `import { invokeLambdaForTesting } from 'simple-lambda-testing-methods';`,
-          `import { stage } from '../../src/utils/environment';`,
           `import { locally } from '../environment';`,
         ].join('\n'),
       )
@@ -30,14 +29,15 @@ export const fix: FileFixFunction = async (contents, context) => {
         'invokeLambdaForTesting({',
       )
       .replace(
-        // replace the inputs
-        /name: '(\w+)',/g,
-        [
-          `service: '${projectName}',`,
-          `function: '$1',`,
-          `stage,`,
-          `locally,`,
-        ].join('\n'),
+        // replace the inputs; capture the indent that precedes `name:` so the
+        // expanded 3-line option block stays aligned with its siblings
+        /^([ \t]*)name: '(\w+)',/gm,
+        (_match, indent, fnName) =>
+          [
+            `${indent}service: '${projectName}',`,
+            `${indent}function: '${fnName}',`,
+            `${indent}locally,`,
+          ].join('\n'),
       )
       .replace(/data: /g, 'event: '),
   };

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/best-practice/package.json

@@ -4,12 +4,12 @@
     "@types/jest": "@declapract{check.minVersion('30.0.0')}",
     "jest": "@declapract{check.minVersion('30.2.0')}",
     "esbuild-register": "@declapract{check.minVersion('3.6.0')}",
-    "test-fns": "@declapract{check.minVersion('1.15.8')}",
+    "test-fns": "@declapract{check.minVersion('1.17.0')}",
     "tsx": "@declapract{check.minVersion('4.20.6')}"
   },
   "scripts": {
-    "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${THOROUGH:-}\" != \"true\" ] && echo '--changedSince=main') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
-    "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${THOROUGH:-}\" != \"true\" ] && echo '--changedSince=main') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
+    "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${THOROUGH:-}\" != \"true\" ] && echo '--changedSince=origin/main') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
+    "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${THOROUGH:-}\" != \"true\" ] && echo '--changedSince=origin/main') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
     "test:acceptance:locally": "set -eu && npm run build && LOCALLY=true jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
     "test": "set -eu && npm run test:commits && npm run test:types && npm run test:format && npm run test:lint && npm run test:unit && npm run test:integration && npm run test:acceptance:locally",
     "test:acceptance": "set -eu && npm run build && jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')"

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/changedsince-origin-main.declapract.integration.test.ts

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { given, then, when } from 'test-fns';
+
+/**
+ * .what = clamps #531: the shipped `test:unit` + `test:integration` commands scope changed-file
+ *         detection against `origin/main`, NEVER bare `main`.
+ * .why  = a local `main` drifts behind the real trunk the moment a teammate merges without a local
+ *         pull, so `--changedSince=main` drags unrelated already-merged suites into scope — the
+ *         exact stale-ref defect #531 names. `origin/main` is the true fork point, so the scope
+ *         holds only this branch's own change.
+ * .teeth = revert either command to `--changedSince=main` in best-practice/package.json and the
+ *          "no bare main" assertion reddens (the emitted `echo '--changedSince=main'` carries the
+ *          `--changedSince=main'` token; the origin form carries `--changedSince=origin/main'`,
+ *          which does NOT contain it).
+ * .note = the subject is the shipped TEMPLATE, read once from __dirname (a single static-file read,
+ *         as the kin `dpdmrc-exclude-policy` / `commitlint-body-max-line` clamps do). this file
+ *         sits at the practice ROOT, so declapract never emits it (per the #583 relocation convention).
+ */
+describe('tests-any changedSince=origin/main policy', () => {
+  given('the shipped best-practice/package.json', () => {
+    const parsed = JSON.parse(
+      readFileSync(join(__dirname, 'best-practice/package.json'), 'utf8'),
+    );
+    const scripts: Record<string, string> = parsed?.scripts ?? {};
+
+    when('the changed-file test commands are read', () => {
+      then('test:unit scopes against origin/main', () => {
+        expect(scripts['test:unit']).toContain('--changedSince=origin/main');
+      });
+
+      then('test:integration scopes against origin/main', () => {
+        expect(scripts['test:integration']).toContain(
+          '--changedSince=origin/main',
+        );
+      });
+
+      then('neither command scopes against a bare local main', () => {
+        // the emitted flag is quoted: `echo '--changedSince=origin/main'`. a bare-main revert
+        // emits `echo '--changedSince=main'`, whose `--changedSince=main'` token the origin form
+        // never carries — so this token is the precise teeth for the drift #531 forbids.
+        const bareMainToken = "--changedSince=main'";
+        expect(scripts['test:unit']).not.toContain(bareMainToken);
+        expect(scripts['test:integration']).not.toContain(bareMainToken);
+      });
+
+      // the emitted commands are the caller-faced contract: snapshot both so a reword that keeps
+      // the origin token green (a re-ordered flag, a reshaped command) reddens a vibecheck.
+      then('the emitted changed-file commands match snapshot', () => {
+        expect({
+          'test:unit': scripts['test:unit'],
+          'test:integration': scripts['test:integration'],
+        }).toMatchSnapshot('tests-any changed-file commands');
+      });
+    });
+  });
+});

package/dist/.test/assets/{expo-migration/declarations/practices/tests-any/best-practice → expo-toolchain/declarations/practices/tests-any}/package.json.shell-flags.declapract.integration.test.ts

@@ -1,5 +1,17 @@
 import { execSync } from 'child_process';
 
+/**
+ * .what = read the whitespace-split arg list out of the stand-in jest echo output.
+ * .why  = a pure transformer that names the `JEST_ARGS: …` decode, so `getJestFlags` reads
+ *         what-not-how rather than an inline regex-match + positional `match[1]` a reader must
+ *         simulate. no output line = an empty arg list.
+ */
+const asArgsFromJestEchoOutput = (input: { output: string }): string[] => {
+  const found = input.output.match(/JEST_ARGS: (.*)/);
+  if (!found) return [];
+  return found[1].split(/\s+/).filter(Boolean);
+};
+
 /**
  * Tests the shell flag expressions used in package.json test commands.
  *
@@ -32,14 +44,14 @@ describe('package.json shell flag expressions', () => {
         cleanEnv[key] = value;
       }
     }
-    // Overlay the test env vars (undefined means unset)
+    // overlay the test env vars (undefined means unset)
     for (const [key, value] of Object.entries(env)) {
       if (value !== undefined) {
         cleanEnv[key] = value;
       }
     }
 
-    // Run the command with jest replaced by echo to capture args
+    // run the command with jest replaced by echo to capture args
     const result = execSync(
       `bash -c 'jest() { echo "JEST_ARGS: $*"; }; ${command}'`,
       {
@@ -52,14 +64,12 @@ describe('package.json shell flag expressions', () => {
       },
     );
 
-    // Extract the jest args from output
-    const match = result.match(/JEST_ARGS: (.*)/);
-    if (!match) return [];
-    return match[1].split(/\s+/).filter(Boolean);
+    // read the jest args out of the stand-in echo output (named, what-not-how)
+    return asArgsFromJestEchoOutput({ output: result });
   };
 
-  // The test:unit command from package.json best-practice
-  const testUnitCommand = `set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n "\${CI:-}" ] && echo '--ci') $([ "\${THOROUGH:-}" != "true" ] && echo '--changedSince=main') $([ "\${RESNAP:-}" = "true" ] && echo '--updateSnapshot')`;
+  // the test:unit command from package.json best-practice
+  const testUnitCommand = `set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n "\${CI:-}" ] && echo '--ci') $([ "\${THOROUGH:-}" != "true" ] && echo '--changedSince=origin/main') $([ "\${RESNAP:-}" = "true" ] && echo '--updateSnapshot')`;
 
   describe('RESNAP flag', () => {
     it('should pass --updateSnapshot when RESNAP=true', () => {
@@ -89,24 +99,24 @@ describe('package.json shell flag expressions', () => {
   });
 
   describe('THOROUGH flag', () => {
-    it('should pass --changedSince=main when THOROUGH is unset (run only changed)', () => {
+    it('should pass --changedSince=origin/main when THOROUGH is unset (run only changed)', () => {
       const flags = getJestFlags(testUnitCommand, {});
-      expect(flags).toContain('--changedSince=main');
+      expect(flags).toContain('--changedSince=origin/main');
     });
 
-    it('should pass --changedSince=main when THOROUGH=false', () => {
+    it('should pass --changedSince=origin/main when THOROUGH=false', () => {
       const flags = getJestFlags(testUnitCommand, { THOROUGH: 'false' });
-      expect(flags).toContain('--changedSince=main');
+      expect(flags).toContain('--changedSince=origin/main');
     });
 
-    it('should pass --changedSince=main when THOROUGH is empty string', () => {
+    it('should pass --changedSince=origin/main when THOROUGH is empty string', () => {
       const flags = getJestFlags(testUnitCommand, { THOROUGH: '' });
-      expect(flags).toContain('--changedSince=main');
+      expect(flags).toContain('--changedSince=origin/main');
     });
 
-    it('should not pass --changedSince=main when THOROUGH=true (run all tests)', () => {
+    it('should not pass --changedSince=origin/main when THOROUGH=true (run all tests)', () => {
       const flags = getJestFlags(testUnitCommand, { THOROUGH: 'true' });
-      expect(flags).not.toContain('--changedSince=main');
+      expect(flags).not.toContain('--changedSince=origin/main');
     });
   });
 

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-expo/.declapract.integration.test.ts

@@ -92,11 +92,15 @@ describe('expo test-toolchain triad — pipeline', () => {
         expect(pkg.scripts.build).toEqual('npm run build:web');
       });
 
-      then('package.json carries the typescript + jest-expo deps at concrete versions', () => {
+      then('package.json carries the typescript dep at a concrete version, and the SDK-coupled expo deps gated to the repo majors', () => {
         const pkg = JSON.parse(state.pkgSettled!);
+        // typescript is a plain minVersion floor (tests-any), resolved concrete on pass 2
         expect(pkg.devDependencies.typescript).toEqual('5.4.5');
-        expect(pkg.devDependencies['jest-expo']).toEqual('54.0.0');
-        expect(pkg.devDependencies['react-test-renderer']).toEqual('19.0.0');
+        // jest-expo + react-test-renderer are GATED to the repo's own expo/react majors (#584):
+        // the fixture declares expo ^54 + react ^19, so the gate pins jest-expo to the expo major
+        // and react-test-renderer to the react major (caret, not a fixed pin — the major is the gate)
+        expect(pkg.devDependencies['jest-expo']).toEqual('^54.0.0');
+        expect(pkg.devDependencies['react-test-renderer']).toEqual('^19.0.0');
       });
 
       then('tsconfig.json extends the expo base, not the node base', () => {

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-expo/.test/assets/repo-expo-greenfield/package.json

@@ -1,4 +1,8 @@
 {
   "name": "test-expo-app",
-  "version": "1.0.0"
+  "version": "1.0.0",
+  "dependencies": {
+    "expo": "^54.0.0",
+    "react": "^19.0.0"
+  }
 }

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-expo/__snapshots__/.declapract.integration.test.ts.snap

@@ -48,6 +48,11 @@ const config: Config = {
   ],
   setupFilesAfterEnv: ['./jest.unit.env.ts'],
 
+  // reclaim every temp dir genTempDir made this run (test-fns autoprune). jest needs BOTH keys;
+  // one without the other stamps and never reclaims.
+  globalSetup: 'test-fns/autoprune.setup.jest',
+  globalTeardown: 'test-fns/autoprune.teardown.jest',
+
   // use 50% of threads to leave headroom for other processes
   maxWorkers: '50%', // https://stackoverflow.com/questions/71287710/why-does-jest-run-faster-with-maxworkers-50
 };
@@ -61,23 +66,27 @@ exports[`expo test-toolchain triad — pipeline given: [case1] a fresh expo repo
 "{
   "name": "test-expo-app",
   "version": "1.0.0",
+  "dependencies": {
+    "expo": "^54.0.0",
+    "react": "^19.0.0"
+  },
   "devDependencies": {
     "@jest/globals": "30.2.0",
     "@types/jest": "30.0.0",
     "jest": "30.2.0",
     "esbuild-register": "3.6.0",
-    "test-fns": "1.15.8",
+    "test-fns": "1.17.0",
     "tsx": "4.20.6",
-    "jest-expo": "54.0.0",
-    "@babel/core": "7.24.0",
-    "babel-preset-expo": "12.0.0",
-    "react-test-renderer": "19.0.0",
-    "isomorphic-fetch": "3.0.0",
+    "jest-expo": "^54.0.0",
+    "react-test-renderer": "^19.0.0",
+    "@babel/core": "^7.24.0",
+    "babel-preset-expo": "^12.0.0",
+    "isomorphic-fetch": "^3.0.0",
     "typescript": "5.4.5"
   },
   "scripts": {
-    "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${THOROUGH:-}\\" != \\"true\\" ] && echo '--changedSince=main') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
-    "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${THOROUGH:-}\\" != \\"true\\" ] && echo '--changedSince=main') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
+    "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${THOROUGH:-}\\" != \\"true\\" ] && echo '--changedSince=origin/main') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
+    "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${THOROUGH:-}\\" != \\"true\\" ] && echo '--changedSince=origin/main') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
     "test:acceptance:locally": "set -eu && npm run build && LOCALLY=true jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
     "test": "set -eu && npm run test:commits && npm run test:types && npm run test:format && npm run test:lint && npm run test:unit && npm run test:integration && npm run test:acceptance:locally",
     "test:acceptance": "set -eu && npm run build && jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",