chore: import upstream snapshot with attribution

tests/unit/data-dir-writable-fallback.test.ts

@@ -0,0 +1,115 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  resolveWritableDataDir,
+  getDefaultDataDir,
+  resolveDataDir,
+} from "../../src/lib/dataPaths.ts";
+
+// Running as root bypasses POSIX permission bits, so a chmod-based "unwritable"
+// directory would still be writable and the EACCES/EPERM branch never triggers.
+const IS_ROOT = typeof process.getuid === "function" && process.getuid() === 0;
+const IS_WINDOWS = process.platform === "win32";
+
+async function withTempEnv(
+  fn: (paths: { root: string; home: string }) => void | Promise<void>
+) {
+  const originalEnv = { ...process.env };
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "omni-datadir-"));
+  const home = path.join(root, "home");
+  fs.mkdirSync(home, { recursive: true });
+
+  delete process.env.DATA_DIR;
+  delete process.env.XDG_CONFIG_HOME;
+  delete process.env.APPDATA;
+  process.env.HOME = home;
+  process.env.USERPROFILE = home;
+
+  try {
+    await fn({ root, home });
+  } finally {
+    for (const key of Object.keys(process.env)) {
+      if (!(key in originalEnv)) delete process.env[key];
+    }
+    for (const [key, value] of Object.entries(originalEnv)) {
+      process.env[key] = value;
+    }
+    // Restore perms before cleanup so rmSync can delete read-only parents.
+    try {
+      fs.chmodSync(root, 0o755);
+    } catch {
+      // ignore
+    }
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+test("resolveWritableDataDir returns the configured DATA_DIR when it is writable", async () => {
+  await withTempEnv(({ root }) => {
+    const configured = path.join(root, "writable-data");
+    process.env.DATA_DIR = configured;
+
+    const resolved = resolveWritableDataDir();
+    assert.equal(resolved, path.resolve(configured));
+    // The probe creates the directory as a side effect.
+    assert.ok(fs.existsSync(configured));
+  });
+});
+
+test("resolveWritableDataDir falls back to the default dir when DATA_DIR is not writable (EACCES/EPERM)", { skip: IS_ROOT || IS_WINDOWS }, async () => {
+  await withTempEnv(({ root, home }) => {
+    // A read-only parent makes mkdir of the child fail with EACCES/EPERM.
+    const lockedParent = path.join(root, "locked");
+    fs.mkdirSync(lockedParent, { recursive: true });
+    fs.chmodSync(lockedParent, 0o555);
+
+    const configured = path.join(lockedParent, "data");
+    process.env.DATA_DIR = configured;
+
+    const resolved = resolveWritableDataDir();
+    const expectedFallback = getDefaultDataDir();
+
+    // It must NOT return the unwritable configured dir...
+    assert.notEqual(resolved, path.resolve(configured));
+    // ...and instead fall back to the default user dir (~/.omniroute under HOME).
+    assert.equal(resolved, expectedFallback);
+    assert.ok(resolved.startsWith(path.resolve(home)));
+  });
+});
+
+test("resolveWritableDataDir returns the default dir (no probe) when DATA_DIR is unset", async () => {
+  await withTempEnv(() => {
+    delete process.env.DATA_DIR;
+    const resolved = resolveWritableDataDir();
+    assert.equal(resolved, getDefaultDataDir());
+    // Matches the pure resolver when no override is present.
+    assert.equal(resolved, resolveDataDir());
+  });
+});
+
+test("resolveWritableDataDir rethrows non-permission errors", { skip: IS_WINDOWS }, async () => {
+  await withTempEnv(({ root }) => {
+    // Point DATA_DIR at a path whose parent is a regular file → ENOTDIR, not EACCES.
+    const fileParent = path.join(root, "iam-a-file");
+    fs.writeFileSync(fileParent, "x");
+
+    const configured = path.join(fileParent, "data");
+    process.env.DATA_DIR = configured;
+
+    assert.throws(() => resolveWritableDataDir(), (err: NodeJS.ErrnoException) => {
+      return err.code !== "EACCES" && err.code !== "EPERM";
+    });
+  });
+});
+
+test("resolveWritableDataDir leaves the cloud sentinel untouched", async () => {
+  await withTempEnv(() => {
+    process.env.DATA_DIR = "/some/configured/path";
+    const resolved = resolveWritableDataDir({ isCloud: true });
+    assert.equal(resolved, "/tmp");
+  });
+});