cursedbelt-server 1.0.0

package/src/testTmpRoot.spec.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'bun:test';
+import { isAbsolute, resolve, sep } from 'node:path';
+import { resolveTestTmpRoot } from '../scripts/testTmpRoot';
+
+/**
+ * 🔴 THE CHECKER CANNOT SEE THIS ONE, WHICH IS WHY IT IS A TEST.
+ *
+ * `scripts/testTmpRoot.ts` is a bun test PRELOAD: it runs before the first spec in
+ * this repo, on every `bun test`, and it decides where every `mkdtemp` in the suite
+ * lands. Until 2026-09-13 it pointed `$TMPDIR` at the PREVIOUS generation's state
+ * root — 77 MB and 259 process directories had accumulated there — and
+ * `tools/check-paths.ts` reported nothing, because the path was interpolated from
+ * `$HOME` on one line and assembled from a variable on the next. Neither line
+ * carried a shape the trigger looks for.
+ *
+ * So the gate is here instead, and it asserts the RESOLVED root rather than the
+ * source text: a previous generation's directory cannot come back through a
+ * variable, a rename, or a constant without one of these failing.
+ *
+ * This spec lives in `src/` rather than beside the file it proves because
+ * `bun run test` is `bun test src` — a spec under `scripts/` would never run, and
+ * a gate that does not run is the exact failure mode above.
+ */
+
+/** Every directory name this generation must never write into. */
+const PREVIOUS_GENERATIONS = ['app-managed', 'code-retiring', 'code-active', 'Master-Docs'];
+
+const REPO_ROOT = resolve(import.meta.dir, '..');
+
+describe('the test scratch root', () => {
+  it('lives under $FORGE_STATE when the generation supplies one', () => {
+    const root = resolveTestTmpRoot({ FORGE_STATE: '/state/cursedforge' });
+    expect(root.startsWith(`/state/cursedforge${sep}`)).toBe(true);
+  });
+
+  it('falls back to this repo, never to anything derived from $HOME', () => {
+    const root = resolveTestTmpRoot({ HOME: '/home/somebody' });
+    expect(root.startsWith(`${REPO_ROOT}${sep}`)).toBe(true);
+    expect(root).not.toContain('/home/somebody');
+    // Gitignored here, so a fallback run leaves nothing for git to report.
+    expect(root).toContain('.agent.noindex');
+  });
+
+  it('treats a blank $FORGE_STATE as no $FORGE_STATE', () => {
+    expect(resolveTestTmpRoot({ FORGE_STATE: '   ', HOME: '/home/somebody' }).startsWith(`${REPO_ROOT}${sep}`)).toBe(
+      true,
+    );
+  });
+
+  /*
+   * 🔴 `.noindex` is not decoration and is not cosmetic: it is the only marker that
+   * keeps Spotlight out of files written LATER into a tree, and a test root is
+   * written to constantly (measured 43× on this machine). Both branches carry it.
+   */
+  it('keeps a .noindex segment on every branch', () => {
+    for (const env of [{ FORGE_STATE: '/state/cursedforge' }, { HOME: '/home/somebody' }]) {
+      expect(resolveTestTmpRoot(env).split(sep).some((segment) => segment.endsWith('.noindex'))).toBe(true);
+    }
+  });
+
+  it('resolves an absolute path, whatever the caller cwd is', () => {
+    for (const env of [{ FORGE_STATE: '/state/cursedforge' }, {}]) {
+      expect(isAbsolute(resolveTestTmpRoot(env))).toBe(true);
+    }
+  });
+
+  /*
+   * The assertion the whole file exists for. Note the envs that TRY to steer it
+   * back: the previous generation's own variable, and a home that already contains
+   * its folder. Neither may reach the answer.
+   */
+  it('never resolves a previous generation, whatever the environment says', () => {
+    const envs: Array<Record<string, string | undefined>> = [
+      {},
+      { HOME: '/home/somebody' },
+      { FORGE_STATE: '/state/cursedforge', HOME: '/home/somebody' },
+      { APP_MANAGED_HOME: '/nowhere/inherited', HOME: '/home/somebody' },
+      { HOME: `/home/somebody/${PREVIOUS_GENERATIONS[0]}` },
+    ];
+    for (const env of envs) {
+      const root = resolveTestTmpRoot(env);
+      for (const name of PREVIOUS_GENERATIONS) {
+        expect(root, `resolved "${root}" for env ${JSON.stringify(env)}`).not.toContain(name);
+      }
+    }
+  });
+
+  /*
+   * And the live one: whatever this very process ended up with. The preload has
+   * already run by the time any spec does, so `$TMPDIR` here is the real answer on
+   * the real machine — the measurement the source-text assertions above cannot make.
+   */
+  it('has already pointed THIS process somewhere legitimate', () => {
+    const live = process.env.TMPDIR ?? '';
+    if (process.env.TMPDIR_TEST_PASSTHROUGH) return; // a suite asked for the system root
+    for (const name of PREVIOUS_GENERATIONS) {
+      expect(live, `$TMPDIR is "${live}"`).not.toContain(name);
+    }
+    const expected = resolveTestTmpRoot();
+    expect(live.startsWith(`${expected}${sep}`)).toBe(true);
+  });
+});