feat(lanes): add per-feature state + archive core (lane_features) (B)

2026-08-04 14:16:48 +07:00
parent 465dca35e5
commit 181e0f77ff
3 changed files with 373 additions and 0 deletions
@@ -0,0 +1,133 @@
+/**
+ * @file Tests for server/lib/lane-features.js: slug canonicalization,
+ * activate/archive semantics, and read access to a lane's feature history.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs");
+
+const SUITE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), "ccam-lane-features-"));
+process.env.DASHBOARD_DB_PATH = path.join(SUITE_ROOT, "dashboard.db");
+process.env.LANES_ROOT = path.join(SUITE_ROOT, "lanes");
+
+const { describe, it, after } = require("node:test");
+const assert = require("node:assert/strict");
+
+const lanesLib = require("../lib/lanes");
+const features = require("../lib/lane-features");
+
+after(() => fs.rmSync(SUITE_ROOT, { recursive: true, force: true }));
+
+let laneSeq = 0;
+function makeLane() {
+  laneSeq += 1;
+  const cwd = path.join(SUITE_ROOT, `lane-cwd-${laneSeq}`);
+  fs.mkdirSync(cwd, { recursive: true });
+  return lanesLib.createLane({ title: `lane ${laneSeq}`, cwd, kind: "managed" });
+}
+
+describe("canonicalizeSlug", () => {
+  it("drops a leading feat/ prefix", () => {
+    assert.equal(features.canonicalizeSlug("feat/my-thing"), "my-thing");
+  });
+
+  it("turns slashes and spaces into a single flat dash-separated segment", () => {
+    assert.equal(features.canonicalizeSlug("feat/some thing/ nested"), "some-thing-nested");
+  });
+
+  it("keeps dots, underscores, and case as-is (unlike worktree.js:slugify)", () => {
+    assert.equal(features.canonicalizeSlug("My_Feature.v2"), "My_Feature.v2");
+  });
+
+  it("collapses repeated separators and trims leading/trailing dashes", () => {
+    assert.equal(features.canonicalizeSlug("feat//too  many///slashes/"), "too-many-slashes");
+  });
+
+  it("refuses an empty result", () => {
+    assert.throws(
+      () => features.canonicalizeSlug("feat/"),
+      (err) => err.code === "EBADSLUG"
+    );
+    assert.throws(
+      () => features.canonicalizeSlug("   "),
+      (err) => err.code === "EBADSLUG"
+    );
+  });
+});
+
+describe("activateFeature / archiveActiveFeature", () => {
+  it("activating a brand-new slug creates a live (unarchived) feature row and points the lane at it", () => {
+    const lane = makeLane();
+    const { lane: updated, feature } = features.activateFeature(lane.id, "feat/one");
+    assert.equal(feature.slug, "one");
+    assert.equal(feature.archived_at, null);
+    assert.equal(updated.active_feature_id, feature.id);
+  });
+
+  it("activating a second slug archives the first with its final stage intact", () => {
+    const lane = makeLane();
+    features.activateFeature(lane.id, "one");
+    lanesLib.setStage(lane.id, { stage: "review", evidence: "looks good" });
+
+    const { feature: second } = features.activateFeature(lane.id, "two");
+    assert.equal(second.slug, "two");
+    assert.equal(second.archived_at, null);
+
+    const first = features.getFeature(lane.id, "one");
+    assert.notEqual(first.archived_at, null);
+    assert.equal(first.stage, "review");
+    assert.deepEqual(first.stages.review.evidence, "looks good");
+  });
+
+  it("re-activating an archived slug restores its saved stage onto the live lane row", () => {
+    const lane = makeLane();
+    features.activateFeature(lane.id, "one");
+    lanesLib.setStage(lane.id, { stage: "implement" });
+    features.activateFeature(lane.id, "two"); // archives "one" at stage=implement
+
+    const { lane: reactivated } = features.activateFeature(lane.id, "one");
+    assert.equal(reactivated.stage, "implement");
+    assert.equal(features.getFeature(lane.id, "one").archived_at, null);
+    assert.notEqual(features.getFeature(lane.id, "two").archived_at, null);
+  });
+
+  it("re-activating the CURRENTLY active slug is a no-op, not a self-archive", () => {
+    const lane = makeLane();
+    features.activateFeature(lane.id, "one");
+    lanesLib.setStage(lane.id, { stage: "review" });
+    const { lane: updated } = features.activateFeature(lane.id, "one");
+    assert.equal(updated.stage, "review");
+    assert.equal(features.getFeature(lane.id, "one").archived_at, null);
+  });
+
+  it("archiveActiveFeature returns null and touches nothing when no feature is active", () => {
+    const lane = makeLane();
+    assert.equal(features.archiveActiveFeature(lane.id), null);
+  });
+
+  it("echoes back the canonicalized slug, not the caller's raw input", () => {
+    const lane = makeLane();
+    const { feature } = features.activateFeature(lane.id, "feat/Weird Input/");
+    assert.equal(feature.slug, "Weird-Input");
+  });
+});
+
+describe("listFeatures / getFeature", () => {
+  it("lists every feature for a lane, most recently touched first", () => {
+    const lane = makeLane();
+    features.activateFeature(lane.id, "one");
+    features.activateFeature(lane.id, "two");
+    const list = features.listFeatures(lane.id);
+    assert.deepEqual(
+      list.map((f) => f.slug),
+      ["two", "one"]
+    );
+  });
+
+  it("getFeature returns null for an unknown slug", () => {
+    const lane = makeLane();
+    assert.equal(features.getFeature(lane.id, "never-activated"), null);
+  });
+});