@cliangdev/flux-plugin 0.3.1 → 0.4.0-dev.0892a21

package/src/server/adapters/github/__tests__/index-store.test.ts

@@ -0,0 +1,319 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+const TEST_DIR = `${realpathSync(tmpdir())}/flux-github-index-test-${Date.now()}`;
+process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+let mockGetContentResponse: any = null;
+let lastPutParams: any = null;
+let mockPutShouldConflict = false;
+
+mock.module("@octokit/rest", () => ({
+  Octokit: class MockOctokit {
+    repos = {
+      getContent: async (_params: any) => {
+        if (mockGetContentResponse === null) {
+          const err: any = new Error("Not Found");
+          err.status = 404;
+          throw err;
+        }
+        return mockGetContentResponse;
+      },
+      createOrUpdateFileContents: async (params: any) => {
+        lastPutParams = params;
+        if (mockPutShouldConflict) {
+          const err: any = new Error("Conflict");
+          err.status = 409;
+          throw err;
+        }
+        return { data: { content: { sha: "new-sha-123" } } };
+      },
+    };
+  },
+}));
+
+mock.module("@octokit/graphql", () => ({
+  graphql: {
+    defaults: () => async () => ({}),
+  },
+}));
+
+describe("index-store", () => {
+  beforeEach(() => {
+    mockGetContentResponse = null;
+    lastPutParams = null;
+    mockPutShouldConflict = false;
+  });
+
+  afterEach(() => {});
+
+  async function makeClient() {
+    const { GitHubClient } = await import("../client.js");
+    return new GitHubClient({
+      token: "ghp_test",
+      owner: "test-owner",
+      repo: "test-repo",
+      projectId: "PVT_123",
+      refPrefix: "FP",
+    });
+  }
+
+  describe("readIndex", () => {
+    test("returns empty object when file does not exist (404)", async () => {
+      const { readIndex } = await import("../helpers/index-store.js");
+      const client = await makeClient();
+
+      mockGetContentResponse = null;
+
+      const result = await readIndex(client, "test-owner", "test-repo");
+      expect(result).toEqual({});
+    });
+
+    test("parses and returns existing index", async () => {
+      const { readIndex } = await import("../helpers/index-store.js");
+      const client = await makeClient();
+
+      const indexData = { "FP-P1": 1, "FP-E3": 2, "FP-T12": 5 };
+      const encoded = Buffer.from(JSON.stringify(indexData)).toString("base64");
+      mockGetContentResponse = {
+        data: {
+          sha: "existing-sha-abc",
+          content: encoded,
+          encoding: "base64",
+        },
+      };
+
+      const result = await readIndex(client, "test-owner", "test-repo");
+      expect(result).toEqual({ "FP-P1": 1, "FP-E3": 2, "FP-T12": 5 });
+    });
+  });
+
+  describe("writeIndex", () => {
+    test("includes SHA in PUT when file exists", async () => {
+      const { writeIndex } = await import("../helpers/index-store.js");
+      const client = await makeClient();
+
+      mockGetContentResponse = {
+        data: {
+          sha: "existing-sha-abc",
+          content: Buffer.from("{}").toString("base64"),
+          encoding: "base64",
+        },
+      };
+
+      await writeIndex(client, "test-owner", "test-repo", { "FP-P1": 42 });
+
+      expect(lastPutParams.sha).toBe("existing-sha-abc");
+    });
+
+    test("omits SHA when creating new file", async () => {
+      const { writeIndex } = await import("../helpers/index-store.js");
+      const client = await makeClient();
+
+      mockGetContentResponse = null;
+
+      await writeIndex(client, "test-owner", "test-repo", { "FP-P1": 42 });
+
+      expect(lastPutParams.sha).toBeUndefined();
+    });
+
+    test("throws on 409 conflict", async () => {
+      const { writeIndex } = await import("../helpers/index-store.js");
+      const client = await makeClient();
+
+      mockGetContentResponse = {
+        data: {
+          sha: "existing-sha-abc",
+          content: Buffer.from("{}").toString("base64"),
+          encoding: "base64",
+        },
+      };
+      mockPutShouldConflict = true;
+
+      await expect(
+        writeIndex(client, "test-owner", "test-repo", { "FP-P1": 42 }),
+      ).rejects.toThrow("Index conflict");
+    });
+
+    test("encodes index as base64 JSON in PUT", async () => {
+      const { writeIndex } = await import("../helpers/index-store.js");
+      const client = await makeClient();
+
+      mockGetContentResponse = null;
+
+      await writeIndex(client, "test-owner", "test-repo", { "FP-P1": 42 });
+
+      const decoded = JSON.parse(
+        Buffer.from(lastPutParams.content, "base64").toString("utf-8"),
+      );
+      expect(decoded).toEqual({ "FP-P1": 42 });
+    });
+
+    test("uses correct commit message", async () => {
+      const { writeIndex } = await import("../helpers/index-store.js");
+      const client = await makeClient();
+
+      mockGetContentResponse = null;
+
+      await writeIndex(client, "test-owner", "test-repo", {});
+
+      expect(lastPutParams.message).toBe("chore: update flux ref index");
+    });
+  });
+
+  describe("round-trip", () => {
+    test("write then read returns same data", async () => {
+      const { readIndex, writeIndex } = await import(
+        "../helpers/index-store.js"
+      );
+      const client = await makeClient();
+
+      const indexData = { "FP-P1": 42 };
+
+      mockGetContentResponse = null;
+      await writeIndex(client, "test-owner", "test-repo", indexData);
+
+      const writtenContent = lastPutParams.content;
+      mockGetContentResponse = {
+        data: {
+          sha: "new-sha-123",
+          content: writtenContent,
+          encoding: "base64",
+        },
+      };
+
+      const result = await readIndex(client, "test-owner", "test-repo");
+      expect(result).toEqual({ "FP-P1": 42 });
+    });
+  });
+});
+
+describe("GitHubAdapter index integration", () => {
+  let mockIssuesForLabel: any[] = [];
+  let mockGetContentForAdapter: any = null;
+  let lastAdapterPutParams: any = null;
+
+  beforeEach(() => {
+    mockIssuesForLabel = [];
+    mockGetContentForAdapter = null;
+    lastAdapterPutParams = null;
+  });
+
+  async function makeAdapter() {
+    const { GitHubAdapter } = await import("../adapter.js");
+    const adapter = new GitHubAdapter({
+      token: "ghp_test",
+      owner: "test-owner",
+      repo: "test-repo",
+      projectId: "PVT_123",
+      refPrefix: "FP",
+    });
+
+    (adapter as any).client.rest = {
+      repos: {
+        getContent: async (_params: any) => {
+          if (mockGetContentForAdapter === null) {
+            const err: any = new Error("Not Found");
+            err.status = 404;
+            throw err;
+          }
+          return mockGetContentForAdapter;
+        },
+        createOrUpdateFileContents: async (params: any) => {
+          lastAdapterPutParams = params;
+          return { data: { content: { sha: "new-sha-456" } } };
+        },
+      },
+      issues: {
+        listForRepo: async (_params: any) => {
+          return { data: mockIssuesForLabel };
+        },
+      },
+    };
+
+    return adapter;
+  }
+
+  test("resolveRef returns issue number from index when present", async () => {
+    const adapter = await makeAdapter();
+
+    const indexData = { "FP-P1": 7 };
+    mockGetContentForAdapter = {
+      data: {
+        sha: "some-sha",
+        content: Buffer.from(JSON.stringify(indexData)).toString("base64"),
+        encoding: "base64",
+      },
+    };
+
+    const result = await (adapter as any).resolveRef("FP-P1", "flux:prd");
+    expect(result).toBe(7);
+  });
+
+  test("resolveRef returns null when ref not in index and no issues found", async () => {
+    const adapter = await makeAdapter();
+
+    mockGetContentForAdapter = null;
+    mockIssuesForLabel = [];
+
+    const result = await (adapter as any).resolveRef("FP-P99", "flux:prd");
+    expect(result).toBeNull();
+  });
+
+  test("resolveRef repairs index when found via label search", async () => {
+    const adapter = await makeAdapter();
+
+    mockGetContentForAdapter = null;
+
+    mockIssuesForLabel = [
+      {
+        number: 15,
+        body: '<!-- flux-meta: {"ref":"FP-E5","type":"epic"} -->',
+        labels: [{ name: "flux:epic" }],
+      },
+    ];
+
+    const result = await (adapter as any).resolveRef("FP-E5", "flux:epic");
+    expect(result).toBe(15);
+
+    const written = JSON.parse(
+      Buffer.from(lastAdapterPutParams.content, "base64").toString("utf-8"),
+    );
+    expect(written["FP-E5"]).toBe(15);
+  });
+
+  test("addToIndex writes updated index with new ref", async () => {
+    const adapter = await makeAdapter();
+
+    mockGetContentForAdapter = null;
+
+    await (adapter as any).addToIndex("FP-T10", 22);
+
+    const written = JSON.parse(
+      Buffer.from(lastAdapterPutParams.content, "base64").toString("utf-8"),
+    );
+    expect(written["FP-T10"]).toBe(22);
+  });
+
+  test("removeFromIndex removes ref from index", async () => {
+    const adapter = await makeAdapter();
+
+    const indexData = { "FP-P1": 1, "FP-E2": 2 };
+    mockGetContentForAdapter = {
+      data: {
+        sha: "some-sha",
+        content: Buffer.from(JSON.stringify(indexData)).toString("base64"),
+        encoding: "base64",
+      },
+    };
+
+    await (adapter as any).removeFromIndex("FP-P1");
+
+    const written = JSON.parse(
+      Buffer.from(lastAdapterPutParams.content, "base64").toString("utf-8"),
+    );
+    expect(written["FP-P1"]).toBeUndefined();
+    expect(written["FP-E2"]).toBe(2);
+  });
+});