kcg-code 0.0.0-stage → 0.2.0

package/src/server/services/__tests__/project-manager.test.ts

@@ -0,0 +1,190 @@
+/**
+ * Property & unit test `project-manager.ts` (task 8.2, 8.3).
+ * - Property 29: Pembuatan Project unik berhasil round-trip (10.4)
+ * - Property 30: Nama/path Project duplikat selalu ditolak (10.5, 10.6)
+ * - Unit 8.3: edge case path & nama (10.3, 10.7)
+ */
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import fc from "fast-check";
+import { openSessionStore } from "../../../db";
+import { createProjectManager } from "../project-manager";
+
+let root: string;
+
+const SAFE_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789_-";
+
+function safeNameArb() {
+  return fc
+    .array(fc.constantFrom(...SAFE_CHARS.split("")), { minLength: 1, maxLength: 12 })
+    .map((segs) => segs.join(""));
+}
+
+function safePathArb() {
+  return fc
+    .array(
+      fc
+        .array(fc.constantFrom(...SAFE_CHARS.split("")), { minLength: 1, maxLength: 8 })
+        .map((segs) => segs.join("")),
+      { minLength: 1, maxLength: 3 },
+    )
+    .map((segs) => segs.join("/"));
+}
+
+beforeAll(() => {
+  root = mkdtempSync(path.join(tmpdir(), "kcg-proj-"));
+});
+
+afterAll(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+/** Store fresh per-run agar nama/path antar-run tidak konflik. */
+function freshManager() {
+  const store = openSessionStore(":memory:");
+  return { store, pm: createProjectManager(root, store) };
+}
+
+// Feature: kcg-code, Property 29: Pembuatan Project unik berhasil round-trip
+test("Property 29: createProject sukses -> direktori ada & listProjects menyertakannya", () => {
+  fc.assert(
+    fc.property(safeNameArb(), safePathArb(), (name, relPath) => {
+      const { store, pm } = freshManager();
+      try {
+        const res = pm.createProject(name, relPath);
+        expect(res.ok).toBe(true);
+        if (res.ok) {
+          // Direktori dibuat bila belum ada (Requirement 10.4)
+          expect(existsSync(res.data.path)).toBe(true);
+          // Round-trip: listProjects menyertakan Project baru
+          const listed = pm.listProjects();
+          expect(listed.some((p) => p.id === res.data.id && p.name === name)).toBe(true);
+          // Store menyimpan nama & path yang sama
+          expect(res.data.path.startsWith(path.resolve(root))).toBe(true);
+        }
+      } finally {
+        store.close();
+      }
+    }),
+    { numRuns: 100 },
+  );
+});
+
+// Feature: kcg-code, Property 30: Nama atau path Project duplikat selalu ditolak
+test("Property 30: nama duplikat -> NAME_TAKEN; path duplikat -> PATH_TAKEN", () => {
+  fc.assert(
+    fc.property(safeNameArb(), safePathArb(), (name, relPath) => {
+      const { store, pm } = freshManager();
+      try {
+        const first = pm.createProject(name, relPath);
+        expect(first.ok).toBe(true);
+        const before = pm.listProjects().length;
+
+        // Nama sama, path berbeda
+        const dupName = pm.createProject(name, `${relPath}-x`);
+        expect(dupName.ok).toBe(false);
+        if (!dupName.ok) expect(dupName.error).toBe("NAME_TAKEN");
+
+        // Path sama, nama berbeda
+        const dupPath = pm.createProject(`${name}-x`, relPath);
+        expect(dupPath.ok).toBe(false);
+        if (!dupPath.ok) expect(dupPath.error).toBe("PATH_TAKEN");
+
+        // Tidak menambah baris projects baru
+        expect(pm.listProjects().length).toBe(before);
+      } finally {
+        store.close();
+      }
+    }),
+    { numRuns: 100 },
+  );
+});
+
+// ---- Task 8.3: unit test edge case path & nama ----
+test("8.3: path mengandung ../etc ditolak", () => {
+  const { pm } = freshManager();
+  const res = pm.createProject("proj", "../etc");
+  expect(res.ok).toBe(false);
+  if (!res.ok) expect(res.error).toBe("PATH_OUTSIDE_SANDBOX");
+});
+
+test("8.3: path absolut di luar sandbox ditolak", () => {
+  const { pm } = freshManager();
+  const res = pm.createProject("proj", "/etc");
+  expect(res.ok).toBe(false);
+  if (!res.ok) expect(res.error).toBe("PATH_OUTSIDE_SANDBOX");
+});
+
+test("8.3: nama direktori dengan karakter unicode diterima", () => {
+  const { store, pm } = freshManager();
+  const res = pm.createProject("proj-unicode", "proyék-✓/sub");
+  expect(res.ok).toBe(true);
+  if (res.ok) {
+    expect(existsSync(res.data.path)).toBe(true);
+    expect(res.data.path).toContain("proyék-✓");
+  }
+  store.close();
+});
+
+test("8.3: nama/path dengan karakter terlarang OS ditolak", () => {
+  const { pm } = freshManager();
+  const res = pm.createProject("proj", `bad\0dir`);
+  expect(res.ok).toBe(false);
+  if (!res.ok) expect(res.error).toBe("INVALID_PATH_CHARS");
+});
+
+test("8.3: listDirectory path tidak ditemukan -> PATH_NOT_FOUND", () => {
+  const { pm } = freshManager();
+  const res = pm.listDirectory("tidak-ada");
+  expect(res.ok).toBe(false);
+  if (!res.ok) expect(res.error).toBe("PATH_NOT_FOUND");
+});
+
+test("deleteProject: pendaftaran hilang tapi direktori kerja tetap ada", () => {
+  const { store, pm } = freshManager();
+  const created = pm.createProject("hapus-saya", "hapus-saya");
+  expect(created.ok).toBe(true);
+  if (!created.ok) return;
+
+  expect(pm.deleteProject(created.data.id).ok).toBe(true);
+  expect(pm.listProjects().some((p) => p.id === created.data.id)).toBe(false);
+  // Project hanyalah referensi ke folder — isinya milik pengguna, jangan dihapus.
+  expect(existsSync(created.data.path)).toBe(true);
+  store.close();
+});
+
+test("deleteProject: id tak dikenal -> PROJECT_NOT_FOUND", () => {
+  const { store, pm } = freshManager();
+  const res = pm.deleteProject("tidak-ada");
+  expect(res.ok).toBe(false);
+  if (!res.ok) expect(res.error).toBe("PROJECT_NOT_FOUND");
+  store.close();
+});
+
+test("getProject: mengembalikan Project yang baru dibuat", () => {
+  const { store, pm } = freshManager();
+  const created = pm.createProject("ambil-saya", "ambil-saya");
+  expect(created.ok).toBe(true);
+  if (!created.ok) return;
+
+  const got = pm.getProject(created.data.id);
+  expect(got.ok).toBe(true);
+  if (got.ok) expect(got.data.name).toBe("ambil-saya");
+  expect(pm.getProject("tidak-ada").ok).toBe(false);
+  store.close();
+});
+
+test("8.3: listDirectory hanya mengembalikan direktori (bukan file)", () => {
+  const { pm } = freshManager();
+  const sub = mkdtempSync(path.join(root, "listtest-"));
+  mkdirSync(path.join(sub, "dir1"));
+  writeFileSync(path.join(sub, "file.txt"), "x");
+  const rel = path.relative(root, sub);
+  const res = pm.listDirectory(rel);
+  expect(res.ok).toBe(true);
+  if (res.ok) {
+    expect(res.data.entries).toEqual(["dir1"]);
+  }
+});

package/src/server/services/__tests__/sandbox.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Property test `sandbox.ts` (task 7.2).
+ * - Property 27: Folder_Browser mengembalikan persis sub-direktori (10.2)
+ * - Property 28: Path di luar Sandbox_Root selalu ditolak (10.3, 10.7)
+ */
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import fc from "fast-check";
+import { openSessionStore } from "../../../db";
+import { createProjectManager } from "../project-manager";
+import { resolveWithinSandbox } from "../sandbox";
+
+let root: string;
+let outsideDir: string;
+let store: ReturnType<typeof openSessionStore>;
+
+beforeAll(() => {
+  root = mkdtempSync(path.join(tmpdir(), "kcg-sandbox-"));
+  outsideDir = mkdtempSync(path.join(tmpdir(), "kcg-outside-"));
+  mkdirSync(path.join(root, "a", "a1"), { recursive: true });
+  mkdirSync(path.join(root, "a", "a2"), { recursive: true });
+  mkdirSync(path.join(root, "b", "b1"), { recursive: true });
+  mkdirSync(path.join(root, "b", "b2"), { recursive: true });
+  writeFileSync(path.join(root, "a", "file.txt"), "x");
+  writeFileSync(path.join(root, "top.txt"), "x");
+  // Symlink yang mengarah keluar sandbox (harus ditolak).
+  symlinkSync(outsideDir, path.join(root, "evil-link"));
+  store = openSessionStore(":memory:");
+});
+
+afterAll(() => {
+  store?.close();
+  rmSync(root, { recursive: true, force: true });
+  rmSync(outsideDir, { recursive: true, force: true });
+});
+
+// Feature: kcg-code, Property 27: Folder_Browser mengembalikan persis sub-direktori dalam sandbox
+test("Property 27: listDirectory mengembalikan persis sub-direktori untuk sub-path valid", () => {
+  const pm = createProjectManager(root, store);
+  const validPaths = ["", "a", "a/a1", "a/a2", "b", "b/b1", "b/b2"];
+  const expected = new Map<string, string[]>([
+    ["", ["a", "b"]],
+    ["a", ["a1", "a2"]],
+    ["a/a1", []],
+    ["a/a2", []],
+    ["b", ["b1", "b2"]],
+    ["b/b1", []],
+    ["b/b2", []],
+  ]);
+
+  fc.assert(
+    fc.property(fc.constantFrom(...validPaths), (p) => {
+      const res = pm.listDirectory(p);
+      expect(res.ok).toBe(true);
+      if (res.ok) {
+        // Tepat himpunan sub-direktori: tidak ada yang hilang, tidak ada tambahan
+        expect(res.data.entries).toEqual(expected.get(p) ?? []);
+        // Tidak ada file, tidak ada entri dari luar sandbox
+        for (const entry of res.data.entries) {
+          expect(entry).not.toBe("file.txt");
+          expect(entry).not.toBe("top.txt");
+          expect(entry).not.toBe("evil-link");
+        }
+      }
+    }),
+    { numRuns: 100 },
+  );
+});
+
+// Feature: kcg-code, Property 28: Path di luar Sandbox_Root selalu ditolak
+test("Property 28: path dengan '..' selalu ditolak sebagai outside_sandbox", () => {
+  fc.assert(
+    fc.property(
+      fc.array(fc.constantFrom("a", "b", "c")).map((segs) => [...segs, "..", ...segs]),
+      (segs) => {
+        const p = segs.join("/");
+        const res = resolveWithinSandbox(root, p);
+        expect(res.ok).toBe(false);
+        if (!res.ok) expect(res.reason).toBe("outside_sandbox");
+      },
+    ),
+    { numRuns: 100 },
+  );
+});
+
+test("Property 28: path absolut di luar sandbox selalu ditolak", () => {
+  fc.assert(
+    fc.property(fc.constantFrom("/etc", "/tmp", "/usr", "/home"), (p) => {
+      const res = resolveWithinSandbox(root, p);
+      expect(res.ok).toBe(false);
+      if (!res.ok) expect(res.reason).toBe("outside_sandbox");
+    }),
+    { numRuns: 100 },
+  );
+});
+
+test("Property 28: symlink ke luar sandbox selalu ditolak", () => {
+  fc.assert(
+    fc.property(fc.constantFrom("evil-link", "evil-link/child", "evil-link/../.."), (p) => {
+      const res = resolveWithinSandbox(root, p);
+      expect(res.ok).toBe(false);
+      if (!res.ok) expect(res.reason).toBe("outside_sandbox");
+    }),
+    { numRuns: 100 },
+  );
+});
+
+test("Property 28: karakter terlarang OS -> invalid_chars", () => {
+  const forbiddenSeg = fc.array(fc.constantFrom("a", "b", "\0")).map((segs) => segs.join(""));
+  fc.assert(
+    fc.property(
+      fc
+        .array(forbiddenSeg, { minLength: 1, maxLength: 5 })
+        .filter((segs) => segs.some((s) => s.includes("\0"))),
+      (segs) => {
+        const res = resolveWithinSandbox(root, segs.join("/"));
+        expect(res.ok).toBe(false);
+        if (!res.ok) expect(res.reason).toBe("invalid_chars");
+      },
+    ),
+    { numRuns: 100 },
+  );
+});
+
+test("Property 28: listDirectory & createProject menolak path luar sandbox tanpa efek filesystem", () => {
+  const pm = createProjectManager(root, store);
+
+  const listRes = pm.listDirectory("../etc");
+  expect(listRes.ok).toBe(false);
+  if (!listRes.ok) expect(listRes.error).toBe("PATH_OUTSIDE_SANDBOX");
+
+  const createRes = pm.createProject("evils", "/etc/escape");
+  expect(createRes.ok).toBe(false);
+  if (!createRes.ok) expect(createRes.error).toBe("PATH_OUTSIDE_SANDBOX");
+
+  // Tidak ada direktori baru dibuat di luar sandbox
+  const outsideProbe = path.join(outsideDir, "escape");
+  expect(existsSync(outsideProbe)).toBe(false);
+});