sensorium-mcp 3.1.2 → 3.1.3-board.10

package/dist/board/mock/api.mock.test.ts

@@ -0,0 +1,460 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { createMockApi } from "./api.mock.js";
+import { countCardsInLaneGroup, filterCardsByLaneGroup } from "../state/useBoard.js";
+
+function arrangeMockApi() {
+  return createMockApi();
+}
+
+type StatusError = Error & { status: number };
+
+function hasStatus(status: number) {
+  return (error: StatusError) => {
+    assert.equal(error.status, status);
+    return true;
+  };
+}
+
+test("mock create returns a card without the retired type field", async () => {
+  const mockApi = arrangeMockApi();
+  const created = await mockApi.createCard({ title: "No type", laneGroupId: 1 });
+  assert.equal("type" in created, false);
+  assert.equal(typeof created.correlationId, "string");
+  assert.equal(created.profileId, "default");
+  assert.equal(created.operatorReleasing, false);
+  assert.equal(created.rateLimitProvider, null);
+  assert.equal(created.retryAt, null);
+});
+
+test("mock profiles use the real route's NamedProfile array shape", async () => {
+  const profiles = await arrangeMockApi().getProfiles();
+
+  assert.equal(Array.isArray(profiles), true);
+  assert.deepEqual(profiles, [
+    {
+      id: "default",
+      name: "Default",
+      profile: {
+        createBranch: false,
+        runTests: true,
+        openPr: false,
+        expertReview: false,
+        push: false,
+        ciCheck: "none",
+        workerSplit: "single",
+      },
+      builtin: true,
+    },
+    {
+      id: "bug-fix",
+      name: "Bug fix",
+      profile: {
+        createBranch: true,
+        runTests: true,
+        openPr: true,
+        expertReview: true,
+        push: true,
+        ciCheck: "github",
+        workerSplit: "single",
+      },
+      builtin: true,
+    },
+    {
+      id: "feature",
+      name: "Feature",
+      profile: {
+        createBranch: true,
+        runTests: true,
+        build: true,
+        openPr: true,
+        expertReview: true,
+        push: true,
+        ciCheck: "github",
+        workerSplit: "single",
+      },
+      builtin: true,
+    },
+    {
+      id: "full-delivery",
+      name: "Full delivery",
+      profile: {
+        createBranch: true,
+        runTests: true,
+        build: true,
+        openPr: true,
+        expertReview: true,
+        push: true,
+        ciCheck: "github",
+        workerSplit: "single",
+      },
+      builtin: true,
+    },
+    {
+      id: "tech-debt",
+      name: "Tech debt",
+      profile: {
+        createBranch: true,
+        runTests: true,
+        openPr: true,
+        expertReview: true,
+        push: true,
+        ciCheck: "github",
+        workerSplit: "single",
+      },
+      builtin: true,
+    },
+    {
+      id: "research",
+      name: "Research",
+      profile: {
+        createBranch: false,
+        runTests: false,
+        openPr: false,
+        expertReview: false,
+        push: false,
+        ciCheck: "none",
+        workerSplit: "single",
+      },
+      builtin: true,
+    },
+  ]);
+});
+
+test("mock create rejects an unknown profile", async () => {
+  const mockApi = arrangeMockApi();
+
+  await assert.rejects(
+    mockApi.createCard({ title: "Unknown", profileId: "missing" }),
+    /Unknown profile 'missing'/,
+  );
+});
+
+test("mock create merges the selected profile with an override", async () => {
+  const mockApi = arrangeMockApi();
+
+  const created = await mockApi.createCard({
+    title: "Profile merge",
+    profileId: "bug-fix",
+    profile: { push: false },
+  });
+
+  assert.equal(created.profileId, "bug-fix");
+  assert.deepEqual(created.profile, {
+    createBranch: true,
+    runTests: true,
+    openPr: true,
+    expertReview: true,
+    push: false,
+    ciCheck: "github",
+    workerSplit: "single",
+  });
+});
+
+test("mock create accepts a named profile and returns its canonical id", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+
+  // Act
+  const created = await mockApi.createCard({
+    title: "Named profile merge",
+    profileId: "Bug fix",
+    profile: { push: false },
+  });
+
+  // Assert
+  assert.equal(created.profileId, "bug-fix");
+  assert.deepEqual(created.profile, {
+    createBranch: true,
+    runTests: true,
+    openPr: true,
+    expertReview: true,
+    push: false,
+    ciCheck: "github",
+    workerSplit: "single",
+  });
+});
+
+test("mock saveProfile rejects a duplicate name for a different id", async () => {
+  const mockApi = arrangeMockApi();
+
+  await assert.rejects(
+    mockApi.saveProfile({ id: "another-default", name: "Default", profile: {} }),
+    /A profile with this name already exists/,
+  );
+});
+
+test("active board group filter returns only cards assigned to that group", () => {
+  // Arrange
+  const cards = [
+    { cardId: 1, laneGroupId: 1 },
+    { cardId: 2, laneGroupId: 2 },
+  ];
+
+  // Act
+  const boardCards = filterCardsByLaneGroup(cards, 2);
+
+  // Assert
+  assert.deepEqual(boardCards, [{ cardId: 2, laneGroupId: 2 }]);
+});
+
+test("lane-group count includes cards in the first group", () => {
+  // Arrange
+  const cards = [
+    { cardId: 1, laneGroupId: 1 },
+    { cardId: 2, laneGroupId: 2 },
+  ];
+
+  // Act
+  const groupCount = countCardsInLaneGroup(cards, 1);
+
+  // Assert
+  assert.equal(groupCount, 1);
+});
+
+test("lane-group count includes cards in the second group", () => {
+  // Arrange
+  const cards = [
+    { cardId: 1, laneGroupId: 1 },
+    { cardId: 2, laneGroupId: 2 },
+  ];
+
+  // Act
+  const groupCount = countCardsInLaneGroup(cards, 2);
+
+  // Assert
+  assert.equal(groupCount, 1);
+});
+
+test("mock create rejects a nonexistent lane group", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+
+  // Act & Assert
+  await assert.rejects(mockApi.createCard({ title: "Lost", laneGroupId: 999 }), hasStatus(404));
+});
+
+test("mock update rejects a nonexistent lane group", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+
+  // Act & Assert
+  await assert.rejects(mockApi.updateCard(1, { laneGroupId: 999 }), hasStatus(404));
+});
+
+test("mock create rejects a non-integer lane group as 400", async () => {
+  await assert.rejects(
+    arrangeMockApi().createCard({ title: "Invalid group", laneGroupId: "missing" as never }),
+    hasStatus(400),
+  );
+});
+
+test("mock lane-group deletion rejects a nonexistent group", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+
+  // Act & Assert
+  await assert.rejects(mockApi.deleteLaneGroup(999), /Lane group 999 not found/);
+});
+
+test("mock get returns a card without the retired type field", async () => {
+  const mockApi = arrangeMockApi();
+  const loaded = await mockApi.getCard(1);
+  assert.equal("type" in loaded.card, false);
+});
+
+test("mock update returns a card without the retired type field", async () => {
+  const mockApi = arrangeMockApi();
+  const updated = await mockApi.updateCard(1, { title: "Still no type" });
+  assert.equal("type" in updated, false);
+});
+
+test("mock delete reports missing cards as 404", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+
+  // Act & Assert
+  await assert.rejects(mockApi.deleteCard(999), hasStatus(404));
+});
+
+test("mock stop rejects cards that are not running", async () => {
+  await assert.rejects(arrangeMockApi().stopCard(1), hasStatus(409));
+});
+
+test("mock comment rejects blank content", async () => {
+  await assert.rejects(arrangeMockApi().addComment(1, "   "), hasStatus(400));
+});
+
+test("mock lane-group update rejects blank names before missing ids", async () => {
+  await assert.rejects(arrangeMockApi().updateLaneGroup(999, { name: "   " }), hasStatus(400));
+});
+
+test("mock directory lookup rejects relative paths", async () => {
+  await assert.rejects(arrangeMockApi().listDir("relative/path"), hasStatus(400));
+});
+
+test("mock get reports missing cards as 404", async () => {
+  await assert.rejects(arrangeMockApi().getCard(999), hasStatus(404));
+});
+
+test("mock lane-group deletion reports missing groups as 404", async () => {
+  await assert.rejects(arrangeMockApi().deleteLaneGroup(999), hasStatus(404));
+});
+
+test("mock lane-group deletion rejects groups used by cards", async () => {
+  await assert.rejects(arrangeMockApi().deleteLaneGroup(1), hasStatus(409));
+});
+
+test("mock decision rejects blank answers", async () => {
+  await assert.rejects(arrangeMockApi().postDecision(4, "   "), hasStatus(400));
+});
+
+test("mock decision rejects cards without a pending decision", async () => {
+  await assert.rejects(arrangeMockApi().postDecision(1, "answer"), hasStatus(409));
+});
+
+test("mock update uses an explicit profile instead of merging it with profileId", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+
+  // Act
+  const updated = await mockApi.updateCard(1, {
+    profileId: "Bug fix",
+    profile: { push: false },
+  } as never);
+
+  // Assert
+  assert.equal(updated.profileId, "bug-fix");
+  assert.deepEqual(updated.profile, { push: false });
+});
+
+test("mock update accepts an explicit profile", async () => {
+  const updated = await arrangeMockApi().updateCard(1, { profile: { agentType: "codex" } });
+  assert.deepEqual(updated.profile, { agentType: "codex" });
+});
+
+test("mock update anchors a newly enabled recurring card to itself", async () => {
+  const updated = await arrangeMockApi().updateCard(1, { recurDelayMin: 15 });
+  assert.equal(updated.recurGroupId, updated.cardId);
+});
+
+test("mock update schedules recurrence when marking a recurring card done", async () => {
+  const mockApi = arrangeMockApi();
+  const recurring = await mockApi.updateCard(1, { recurDelayMin: 15 });
+  const done = await mockApi.updateCard(recurring.cardId, { status: "done" });
+  if (done.finishedAt === null) throw new Error("Done cards must have a finish time");
+  const finishedAt = done.finishedAt;
+  assert.equal(
+    done.nextSpawnAt,
+    new Date(new Date(finishedAt).getTime() + 15 * 60_000).toISOString(),
+  );
+});
+
+test("mock update does not schedule recurrence enabled in the same done patch", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+
+  // Act
+  const done = await mockApi.updateCard(1, { recurDelayMin: 15, status: "done" });
+
+  // Assert
+  assert.equal(done.nextSpawnAt, null);
+});
+
+test("mock update schedules done recurrence from the pre-patch delay", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+  const recurring = await mockApi.updateCard(1, { recurDelayMin: 15 });
+
+  // Act
+  const done = await mockApi.updateCard(recurring.cardId, { recurDelayMin: 30, status: "done" });
+
+  // Assert
+  if (done.finishedAt === null) throw new Error("Done cards must have a finish time");
+  assert.equal(
+    done.nextSpawnAt,
+    new Date(new Date(done.finishedAt).getTime() + 15 * 60_000).toISOString(),
+  );
+});
+
+test("mock update clears recurrence scheduling when recurrence is disabled", async () => {
+  const mockApi = arrangeMockApi();
+  const recurring = await mockApi.updateCard(1, { recurDelayMin: 15 });
+  const done = await mockApi.updateCard(recurring.cardId, { status: "done" });
+  const updated = await mockApi.updateCard(done.cardId, { recurDelayMin: null });
+  assert.equal(updated.nextSpawnAt, null);
+});
+
+test("mock update rejects in-progress status targets", async () => {
+  await assert.rejects(arrangeMockApi().updateCard(1, { status: "in_progress" }), hasStatus(400));
+});
+
+test("mock update rejects blocked status targets", async () => {
+  await assert.rejects(arrangeMockApi().updateCard(1, { status: "blocked" }), hasStatus(400));
+});
+
+test("mock update rejects decision-needed status targets", async () => {
+  await assert.rejects(
+    arrangeMockApi().updateCard(1, { status: "decision_needed" }),
+    hasStatus(400),
+  );
+});
+
+test("mock update rejects rate-limited status targets", async () => {
+  await assert.rejects(arrangeMockApi().updateCard(1, { status: "rate_limited" }), hasStatus(400));
+});
+
+test("mock create rejects unknown profile fields", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+
+  // Act & Assert
+  await assert.rejects(
+    mockApi.createCard({ title: "Bad field", profile: { unknown: true } as never }),
+    hasStatus(400),
+  );
+});
+
+test("mock create rejects invalid profile enums", async () => {
+  const mockApi = arrangeMockApi();
+  await assert.rejects(
+    mockApi.createCard({ title: "Bad enum", profile: { prProvider: "github" } as never }),
+    hasStatus(400),
+  );
+});
+
+test("mock create rejects invalid recurrence", async () => {
+  const mockApi = arrangeMockApi();
+  await assert.rejects(
+    mockApi.createCard({ title: "Bad recurrence", recurDelayMin: "later" as never }),
+    hasStatus(400),
+  );
+});
+
+test("mock preview resolves profileId", async () => {
+  // Arrange
+  const mockApi = arrangeMockApi();
+
+  // Act
+  const briefing = await mockApi.previewBriefing({
+    title: "Preview",
+    description: "",
+    profileId: "Feature",
+  });
+
+  // Assert
+  assert.match(briefing, /Create a work branch before changing anything/);
+});
+
+test("mock preview rejects invalid profiles", async () => {
+  const mockApi = arrangeMockApi();
+  await assert.rejects(
+    mockApi.previewBriefing({
+      title: "Bad",
+      description: "",
+      profile: { prProvider: "github" } as never,
+    }),
+    hasStatus(400),
+  );
+});