@cliangdev/flux-plugin 0.3.1-dev.bdbaeae → 0.3.1

package/src/server/adapters/github/__tests__/documents-stats.test.ts

@@ -1,789 +0,0 @@
-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-docs-stats-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-process.env.FLUX_PROJECT_ROOT = TEST_DIR;
-
-let mockIssuesGet: any = null;
-let mockIssuesList: any[] = [];
-let mockGetContent: any = null;
-let mockGetContentByPath: Record<string, any> = {};
-let mockIssuesUpdate: any = null;
-let lastUpdateParams: any = null;
-let lastPutParams: any = null;
-let lastDeleteParams: any = null;
-let issueNodeIdCounter = 0;
-
-mock.module("@octokit/rest", () => ({
-  Octokit: class MockOctokit {
-    repos = {
-      getContent: async (_params: any) => {
-        if (mockGetContent === null) {
-          const err: any = new Error("Not Found");
-          err.status = 404;
-          throw err;
-        }
-        return mockGetContent;
-      },
-      createOrUpdateFileContents: async (params: any) => {
-        lastPutParams = params;
-        return { data: { content: { sha: "new-sha" } } };
-      },
-      deleteFile: async (params: any) => {
-        lastDeleteParams = params;
-        return { data: {} };
-      },
-    };
-    issues = {
-      get: async (_params: any) => {
-        if (mockIssuesGet === null) {
-          const err: any = new Error("Not Found");
-          err.status = 404;
-          throw err;
-        }
-        return { data: mockIssuesGet };
-      },
-      listForRepo: async (_params: any) => {
-        return { data: mockIssuesList };
-      },
-      update: async (params: any) => {
-        lastUpdateParams = params;
-        return { data: mockIssuesUpdate ?? mockIssuesGet };
-      },
-    };
-  },
-}));
-
-mock.module("@octokit/graphql", () => ({
-  graphql: {
-    defaults: (_opts: any) => {
-      return async (
-        _query: string,
-        _variables?: Record<string, unknown>,
-      ) => ({});
-    },
-  },
-}));
-
-function makeIssue(
-  overrides: Partial<{
-    number: number;
-    title: string;
-    body: string;
-    labels: string[];
-    state: "open" | "closed";
-    created_at: string;
-    updated_at: string;
-    node_id: string;
-  }> = {},
-) {
-  issueNodeIdCounter++;
-  const number = overrides.number ?? issueNodeIdCounter;
-  return {
-    number,
-    title: overrides.title ?? "Test Issue",
-    body: overrides.body ?? "",
-    labels: (overrides.labels ?? ["flux:prd", "status:draft"]).map((name) => ({
-      name,
-    })),
-    state: overrides.state ?? "open",
-    created_at: overrides.created_at ?? "2026-01-01T00:00:00Z",
-    updated_at: overrides.updated_at ?? "2026-01-01T00:00:00Z",
-    node_id: overrides.node_id ?? `MDU6SXNzdWU${number}`,
-  };
-}
-
-function makeAdapter() {
-  const { GitHubAdapter } = require("../adapter.js");
-  const adapter = new GitHubAdapter({
-    token: "ghp_test",
-    owner: "test-owner",
-    repo: "test-repo",
-    projectId: "PVT_kwDO123",
-    refPrefix: "FP",
-  });
-
-  (adapter as any).client.rest.issues = {
-    get: async (_params: any) => {
-      if (mockIssuesGet === null) {
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      }
-      return { data: mockIssuesGet };
-    },
-    listForRepo: async (_params: any) => {
-      return { data: mockIssuesList };
-    },
-    update: async (params: any) => {
-      lastUpdateParams = params;
-      return { data: mockIssuesUpdate ?? mockIssuesGet };
-    },
-  };
-
-  (adapter as any).client.rest.repos = {
-    getContent: async (params: any) => {
-      const path = params.path;
-      if (path in mockGetContentByPath) {
-        const val = mockGetContentByPath[path];
-        if (val === null) {
-          const err: any = new Error("Not Found");
-          err.status = 404;
-          throw err;
-        }
-        return val;
-      }
-      if (mockGetContent === null) {
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      }
-      return mockGetContent;
-    },
-    createOrUpdateFileContents: async (params: any) => {
-      lastPutParams = params;
-      return { data: { content: { sha: "new-sha" } } };
-    },
-    deleteFile: async (params: any) => {
-      lastDeleteParams = params;
-      return { data: {} };
-    },
-  };
-
-  (adapter as any).client.rest.request = async (url: string, _params: any) => {
-    if (url.includes("sub_issues") && url.startsWith("GET")) {
-      return { data: [] };
-    }
-    if (url.includes("sub_issues") && url.startsWith("POST")) {
-      return { data: {} };
-    }
-    throw new Error(`Unmocked request: ${url}`);
-  };
-
-  return adapter;
-}
-
-describe("GitHubAdapter Documents", () => {
-  beforeEach(() => {
-    mockIssuesGet = null;
-    mockIssuesList = [];
-    mockGetContent = null;
-    mockGetContentByPath = {};
-    mockIssuesUpdate = null;
-    lastUpdateParams = null;
-    lastPutParams = null;
-    lastDeleteParams = null;
-    issueNodeIdCounter = 0;
-  });
-
-  afterEach(() => {});
-
-  describe("saveDocument", () => {
-    test("creates file at correct path and returns Document with blob URL", async () => {
-      const prdIssue = makeIssue({
-        number: 6,
-        labels: ["flux:prd", "status:draft"],
-        body: '<!-- flux-meta\n{"ref":"FP-P6"}\n-->',
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-P6": 6 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-      mockIssuesGet = prdIssue;
-      mockGetContentByPath["prds/fp-p6/architecture.md"] = null;
-
-      const adapter = makeAdapter();
-
-      const capturedGetParams: any[] = [];
-      (adapter as any).client.rest.repos.getContent = async (params: any) => {
-        capturedGetParams.push(params);
-        if (params.path === ".flux/github-index.json") {
-          return {
-            data: {
-              sha: "sha1",
-              content: Buffer.from(JSON.stringify({ "FP-P6": 6 })).toString(
-                "base64",
-              ),
-              encoding: "base64",
-            },
-          };
-        }
-        if (params.path === "prds/fp-p6/architecture.md") {
-          const err: any = new Error("Not Found");
-          err.status = 404;
-          throw err;
-        }
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      };
-
-      const doc = await adapter.saveDocument({
-        prdRef: "FP-P6",
-        filename: "architecture.md",
-        content: "# Architecture\n\nDetails here.",
-      });
-
-      expect(lastPutParams.path).toBe("prds/fp-p6/architecture.md");
-      expect(lastPutParams.content).toBe(
-        Buffer.from("# Architecture\n\nDetails here.").toString("base64"),
-      );
-      expect(doc.url).toBe(
-        "https://github.com/test-owner/test-repo/blob/main/prds/fp-p6/architecture.md",
-      );
-      expect(doc.prdRef).toBe("FP-P6");
-      expect(doc.filename).toBe("architecture.md");
-    });
-
-    test("updates existing file using current SHA (no conflict error)", async () => {
-      const prdIssue = makeIssue({
-        number: 6,
-        labels: ["flux:prd", "status:draft"],
-        body: '<!-- flux-meta\n{"ref":"FP-P6"}\n-->\n\n## Supporting Documents\n\n- [architecture.md](https://github.com/test-owner/test-repo/blob/main/prds/fp-p6/architecture.md)',
-      });
-
-      mockIssuesGet = prdIssue;
-
-      const adapter = makeAdapter();
-
-      (adapter as any).client.rest.repos.getContent = async (params: any) => {
-        if (params.path === ".flux/github-index.json") {
-          return {
-            data: {
-              sha: "sha-index",
-              content: Buffer.from(JSON.stringify({ "FP-P6": 6 })).toString(
-                "base64",
-              ),
-              encoding: "base64",
-            },
-          };
-        }
-        if (params.path === "prds/fp-p6/architecture.md") {
-          return {
-            data: {
-              sha: "existing-file-sha",
-              content: Buffer.from("# Old Architecture").toString("base64"),
-              encoding: "base64",
-            },
-          };
-        }
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      };
-
-      const doc = await adapter.saveDocument({
-        prdRef: "FP-P6",
-        filename: "architecture.md",
-        content: "# New Architecture",
-      });
-
-      expect(lastPutParams.sha).toBe("existing-file-sha");
-      expect(doc.filename).toBe("architecture.md");
-    });
-
-    test("adds link to PRD issue body under Supporting Documents", async () => {
-      const prdIssue = makeIssue({
-        number: 6,
-        labels: ["flux:prd", "status:draft"],
-        body: 'Some description.\n\n<!-- flux-meta\n{"ref":"FP-P6"}\n-->',
-      });
-
-      mockIssuesGet = prdIssue;
-
-      const adapter = makeAdapter();
-
-      (adapter as any).client.rest.repos.getContent = async (params: any) => {
-        if (params.path === ".flux/github-index.json") {
-          return {
-            data: {
-              sha: "sha-index",
-              content: Buffer.from(JSON.stringify({ "FP-P6": 6 })).toString(
-                "base64",
-              ),
-              encoding: "base64",
-            },
-          };
-        }
-        if (params.path === "prds/fp-p6/notes.md") {
-          const err: any = new Error("Not Found");
-          err.status = 404;
-          throw err;
-        }
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      };
-
-      await adapter.saveDocument({
-        prdRef: "FP-P6",
-        filename: "notes.md",
-        content: "# Notes",
-      });
-
-      expect(lastUpdateParams).not.toBeNull();
-      expect(lastUpdateParams.body).toContain("## Supporting Documents");
-      expect(lastUpdateParams.body).toContain("notes.md");
-      expect(lastUpdateParams.body).toContain(
-        "https://github.com/test-owner/test-repo/blob/main/prds/fp-p6/notes.md",
-      );
-    });
-
-    test("throws descriptive error on unknown PRD ref", async () => {
-      mockGetContent = null;
-      mockIssuesList = [];
-
-      const adapter = makeAdapter();
-
-      await expect(
-        adapter.saveDocument({
-          prdRef: "FP-P999",
-          filename: "missing.md",
-          content: "# Missing",
-        }),
-      ).rejects.toThrow("FP-P999");
-    });
-  });
-
-  describe("deleteDocument", () => {
-    test("deletes file and removes link from PRD body", async () => {
-      const existingBody =
-        'Description.\n\n<!-- flux-meta\n{"ref":"FP-P6"}\n-->\n\n## Supporting Documents\n\n- [architecture.md](https://github.com/test-owner/test-repo/blob/main/prds/fp-p6/architecture.md)\n- [notes.md](https://github.com/test-owner/test-repo/blob/main/prds/fp-p6/notes.md)';
-
-      const prdIssue = makeIssue({
-        number: 6,
-        labels: ["flux:prd", "status:draft"],
-        body: existingBody,
-      });
-
-      mockIssuesGet = prdIssue;
-
-      const adapter = makeAdapter();
-
-      (adapter as any).client.rest.repos.getContent = async (params: any) => {
-        if (params.path === ".flux/github-index.json") {
-          return {
-            data: {
-              sha: "sha-index",
-              content: Buffer.from(JSON.stringify({ "FP-P6": 6 })).toString(
-                "base64",
-              ),
-              encoding: "base64",
-            },
-          };
-        }
-        if (params.path === "prds/fp-p6/architecture.md") {
-          return {
-            data: {
-              sha: "file-sha-to-delete",
-              content: Buffer.from("# Architecture").toString("base64"),
-              encoding: "base64",
-            },
-          };
-        }
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      };
-
-      await adapter.deleteDocument("FP-P6", "architecture.md");
-
-      expect(lastDeleteParams.path).toBe("prds/fp-p6/architecture.md");
-      expect(lastDeleteParams.sha).toBe("file-sha-to-delete");
-      expect(lastUpdateParams).not.toBeNull();
-      expect(lastUpdateParams.body).not.toContain("architecture.md");
-      expect(lastUpdateParams.body).toContain("notes.md");
-    });
-  });
-
-  describe("getDocuments", () => {
-    test("returns empty array when PRD has no documents folder (404)", async () => {
-      const prdIssue = makeIssue({
-        number: 6,
-        labels: ["flux:prd", "status:draft"],
-        body: '<!-- flux-meta\n{"ref":"FP-P6"}\n-->',
-      });
-
-      mockIssuesGet = prdIssue;
-
-      const adapter = makeAdapter();
-
-      (adapter as any).client.rest.repos.getContent = async (params: any) => {
-        if (params.path === ".flux/github-index.json") {
-          return {
-            data: {
-              sha: "sha-index",
-              content: Buffer.from(JSON.stringify({ "FP-P6": 6 })).toString(
-                "base64",
-              ),
-              encoding: "base64",
-            },
-          };
-        }
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      };
-
-      const docs = await adapter.getDocuments("FP-P6");
-      expect(docs).toEqual([]);
-    });
-
-    test("returns correct documents with filename, content, and blob URL", async () => {
-      const adapter = makeAdapter();
-
-      (adapter as any).client.rest.repos.getContent = async (params: any) => {
-        if (params.path === ".flux/github-index.json") {
-          const err: any = new Error("Not Found");
-          err.status = 404;
-          throw err;
-        }
-        if (params.path === "prds/fp-p6") {
-          return {
-            data: [
-              {
-                type: "file",
-                name: "architecture.md",
-                path: "prds/fp-p6/architecture.md",
-                sha: "sha-arch",
-                download_url: "https://raw.githubusercontent.com/...",
-              },
-              {
-                type: "file",
-                name: "notes.md",
-                path: "prds/fp-p6/notes.md",
-                sha: "sha-notes",
-                download_url: "https://raw.githubusercontent.com/...",
-              },
-            ],
-          };
-        }
-        if (params.path === "prds/fp-p6/architecture.md") {
-          return {
-            data: {
-              sha: "sha-arch",
-              content: Buffer.from("# Architecture").toString("base64"),
-              encoding: "base64",
-            },
-          };
-        }
-        if (params.path === "prds/fp-p6/notes.md") {
-          return {
-            data: {
-              sha: "sha-notes",
-              content: Buffer.from("# Notes").toString("base64"),
-              encoding: "base64",
-            },
-          };
-        }
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      };
-
-      (adapter as any).client.rest.issues.listForRepo = async (
-        _params: any,
-      ) => ({ data: [] });
-
-      const docs = await adapter.getDocuments("FP-P6");
-
-      expect(docs.length).toBe(2);
-      const arch = docs.find((d: any) => d.filename === "architecture.md");
-      expect(arch).toBeDefined();
-      expect(arch.content).toBe("# Architecture");
-      expect(arch.url).toBe(
-        "https://github.com/test-owner/test-repo/blob/main/prds/fp-p6/architecture.md",
-      );
-      expect(arch.prdRef).toBe("FP-P6");
-    });
-
-    test("filters to only .md files", async () => {
-      const adapter = makeAdapter();
-
-      (adapter as any).client.rest.repos.getContent = async (params: any) => {
-        if (params.path === ".flux/github-index.json") {
-          const err: any = new Error("Not Found");
-          err.status = 404;
-          throw err;
-        }
-        if (params.path === "prds/fp-p6") {
-          return {
-            data: [
-              {
-                type: "file",
-                name: "architecture.md",
-                path: "prds/fp-p6/architecture.md",
-                sha: "sha-arch",
-              },
-              {
-                type: "file",
-                name: "image.png",
-                path: "prds/fp-p6/image.png",
-                sha: "sha-png",
-              },
-              {
-                type: "dir",
-                name: "subdir",
-                path: "prds/fp-p6/subdir",
-                sha: "sha-dir",
-              },
-            ],
-          };
-        }
-        if (params.path === "prds/fp-p6/architecture.md") {
-          return {
-            data: {
-              sha: "sha-arch",
-              content: Buffer.from("# Architecture").toString("base64"),
-              encoding: "base64",
-            },
-          };
-        }
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      };
-
-      (adapter as any).client.rest.issues.listForRepo = async (
-        _params: any,
-      ) => ({ data: [] });
-
-      const docs = await adapter.getDocuments("FP-P6");
-
-      expect(docs.length).toBe(1);
-      expect(docs[0].filename).toBe("architecture.md");
-    });
-  });
-});
-
-describe("GitHubAdapter Stats", () => {
-  beforeEach(() => {
-    mockIssuesGet = null;
-    mockIssuesList = [];
-    mockGetContent = null;
-    mockGetContentByPath = {};
-    mockIssuesUpdate = null;
-    lastUpdateParams = null;
-    lastPutParams = null;
-    lastDeleteParams = null;
-    issueNodeIdCounter = 0;
-  });
-
-  afterEach(() => {});
-
-  function makeStatsAdapter() {
-    const { GitHubAdapter } = require("../adapter.js");
-    const adapter = new GitHubAdapter({
-      token: "ghp_test",
-      owner: "test-owner",
-      repo: "test-repo",
-      projectId: "PVT_kwDO123",
-      refPrefix: "FP",
-    });
-
-    return adapter;
-  }
-
-  test("getStats returns Stats shape matching BackendAdapter interface", async () => {
-    const adapter = makeStatsAdapter();
-
-    (adapter as any).client.rest.issues.listForRepo = async (_params: any) => ({
-      data: [],
-    });
-    (adapter as any).client.rest.repos.getContent = async (_params: any) => {
-      const err: any = new Error("Not Found");
-      err.status = 404;
-      throw err;
-    };
-
-    const stats = await adapter.getStats();
-
-    expect(stats).toHaveProperty("prds");
-    expect(stats).toHaveProperty("epics");
-    expect(stats).toHaveProperty("tasks");
-    expect(stats.prds).toHaveProperty("total");
-    expect(stats.prds).toHaveProperty("draft");
-    expect(stats.prds).toHaveProperty("pendingReview");
-    expect(stats.prds).toHaveProperty("reviewed");
-    expect(stats.prds).toHaveProperty("approved");
-    expect(stats.prds).toHaveProperty("breakdownReady");
-    expect(stats.prds).toHaveProperty("completed");
-    expect(stats.prds).toHaveProperty("archived");
-    expect(stats.epics).toHaveProperty("total");
-    expect(stats.epics).toHaveProperty("pending");
-    expect(stats.epics).toHaveProperty("inProgress");
-    expect(stats.epics).toHaveProperty("completed");
-    expect(stats.tasks).toHaveProperty("total");
-    expect(stats.tasks).toHaveProperty("pending");
-    expect(stats.tasks).toHaveProperty("inProgress");
-    expect(stats.tasks).toHaveProperty("completed");
-  });
-
-  test("PRD counts: draft/pendingReview/etc buckets correctly counted", async () => {
-    const adapter = makeStatsAdapter();
-
-    const openPrds = [
-      makeIssue({
-        number: 1,
-        labels: ["flux:prd", "status:draft"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 2,
-        labels: ["flux:prd", "status:draft"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 3,
-        labels: ["flux:prd", "status:pending-review"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 4,
-        labels: ["flux:prd", "status:reviewed"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 5,
-        labels: ["flux:prd", "status:approved"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 6,
-        labels: ["flux:prd", "status:breakdown-ready"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 7,
-        labels: ["flux:prd", "status:completed"],
-        state: "open",
-      }),
-    ];
-
-    (adapter as any).client.rest.issues.listForRepo = async (params: any) => {
-      const labels = params.labels ?? "";
-      if (labels.includes("flux:prd") && params.state === "open") {
-        return { data: openPrds };
-      }
-      return { data: [] };
-    };
-
-    const stats = await adapter.getStats();
-
-    expect(stats.prds.draft).toBe(2);
-    expect(stats.prds.pendingReview).toBe(1);
-    expect(stats.prds.reviewed).toBe(1);
-    expect(stats.prds.approved).toBe(1);
-    expect(stats.prds.breakdownReady).toBe(1);
-    expect(stats.prds.completed).toBe(1);
-    expect(stats.prds.total).toBe(7);
-  });
-
-  test("archived = closed PRD issues; total excludes archived", async () => {
-    const adapter = makeStatsAdapter();
-
-    const openPrds = [
-      makeIssue({
-        number: 1,
-        labels: ["flux:prd", "status:draft"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 2,
-        labels: ["flux:prd", "status:approved"],
-        state: "open",
-      }),
-    ];
-    const closedPrds = [
-      makeIssue({ number: 3, labels: ["flux:prd"], state: "closed" }),
-      makeIssue({ number: 4, labels: ["flux:prd"], state: "closed" }),
-      makeIssue({ number: 5, labels: ["flux:prd"], state: "closed" }),
-    ];
-
-    (adapter as any).client.rest.issues.listForRepo = async (params: any) => {
-      const labels = params.labels ?? "";
-      if (!labels.includes("flux:prd")) return { data: [] };
-      if (params.state === "open") return { data: openPrds };
-      if (params.state === "closed") return { data: closedPrds };
-      return { data: [] };
-    };
-
-    const stats = await adapter.getStats();
-
-    expect(stats.prds.total).toBe(2);
-    expect(stats.prds.archived).toBe(3);
-  });
-
-  test("epic and task counts by open/closed state", async () => {
-    const adapter = makeStatsAdapter();
-
-    const openEpics = [
-      makeIssue({
-        number: 10,
-        labels: ["flux:epic", "status:pending"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 11,
-        labels: ["flux:epic", "status:in-progress"],
-        state: "open",
-      }),
-    ];
-    const closedEpics = [
-      makeIssue({ number: 12, labels: ["flux:epic"], state: "closed" }),
-    ];
-    const openTasks = [
-      makeIssue({
-        number: 20,
-        labels: ["flux:task", "status:pending"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 21,
-        labels: ["flux:task", "status:pending"],
-        state: "open",
-      }),
-      makeIssue({
-        number: 22,
-        labels: ["flux:task", "status:in-progress"],
-        state: "open",
-      }),
-    ];
-    const closedTasks = [
-      makeIssue({ number: 23, labels: ["flux:task"], state: "closed" }),
-      makeIssue({ number: 24, labels: ["flux:task"], state: "closed" }),
-    ];
-
-    (adapter as any).client.rest.issues.listForRepo = async (params: any) => {
-      const labels = params.labels ?? "";
-      if (labels.includes("flux:prd")) return { data: [] };
-      if (labels.includes("flux:epic") && params.state === "open")
-        return { data: openEpics };
-      if (labels.includes("flux:epic") && params.state === "closed")
-        return { data: closedEpics };
-      if (labels.includes("flux:task") && params.state === "open")
-        return { data: openTasks };
-      if (labels.includes("flux:task") && params.state === "closed")
-        return { data: closedTasks };
-      return { data: [] };
-    };
-
-    const stats = await adapter.getStats();
-
-    expect(stats.epics.total).toBe(3);
-    expect(stats.epics.pending).toBe(1);
-    expect(stats.epics.inProgress).toBe(1);
-    expect(stats.epics.completed).toBe(1);
-    expect(stats.tasks.total).toBe(5);
-    expect(stats.tasks.pending).toBe(2);
-    expect(stats.tasks.inProgress).toBe(1);
-    expect(stats.tasks.completed).toBe(2);
-  });
-});