@indigoai-us/hq-cli 5.16.0 → 5.17.0-sources-rc.0

package/test/sources-signals/smoke.test.ts

@@ -0,0 +1,226 @@
+/**
+ * smoke.test.ts — Phase 0 infrastructure smoke test (US-001).
+ *
+ * Validates that:
+ *   1. The fixture files exist and have the expected frontmatter shape.
+ *   2. mockS3WithEntries lists and retrieves entries with full round-trip fidelity.
+ *   3. mockVaultService intercepts /membership/me and /entities/{uid}/sts correctly.
+ *   4. runCli(['hq', '--help']) exits 0 (basic wiring check).
+ *
+ * Note: assertions about 'sources'/'signals' appearing in `hq --help` are
+ * intentionally absent here — those land when US-006/US-007 register the
+ * commands and add them to buildProgram() in cli-runner.ts.
+ */
+
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { afterEach, describe, expect, it } from "vitest";
+import { GetObjectCommand, ListObjectsV2Command } from "@aws-sdk/client-s3";
+import { mockS3WithEntries } from "../helpers/s3-list-mock.js";
+import { mockVaultService } from "../helpers/vault-service-mock.js";
+import { runCli } from "../helpers/cli-runner.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const FIXTURES = join(__dirname, "../fixtures");
+const SOURCE_PATH = join(FIXTURES, "sources/meetings/sample.md");
+const SIGNAL_ACTION_PATH = join(FIXTURES, "signals/action_item/sample.md");
+const SIGNAL_SUMMARY_PATH = join(FIXTURES, "signals/summary/sample.md");
+
+// ---------------------------------------------------------------------------
+// Fixture shape tests
+// ---------------------------------------------------------------------------
+
+describe("fixtures — file shape", () => {
+  it("source fixture has expected frontmatter fields", () => {
+    const content = readFileSync(SOURCE_PATH, "utf-8");
+    expect(content).toContain("source_id:");
+    expect(content).toContain("channel: meeting");
+    expect(content).toContain("participants:");
+    expect(content).toContain("created_at:");
+  });
+
+  it("action_item signal fixture has required signal fields", () => {
+    const content = readFileSync(SIGNAL_ACTION_PATH, "utf-8");
+    expect(content).toContain("signal_id:");
+    expect(content).toContain("signal_type: action_item");
+    expect(content).toContain("source_ref:");
+    expect(content).toContain("citations:");
+    expect(content).toContain("entity_refs:");
+  });
+
+  it("summary signal fixture has required signal fields", () => {
+    const content = readFileSync(SIGNAL_SUMMARY_PATH, "utf-8");
+    expect(content).toContain("signal_type: summary");
+    expect(content).toContain("source_ref:");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// S3 mock round-trip tests
+// ---------------------------------------------------------------------------
+
+describe("mockS3WithEntries — listing", () => {
+  it("lists all entries when no prefix filter is applied", async () => {
+    const sourceContent = readFileSync(SOURCE_PATH, "utf-8");
+    const signalContent = readFileSync(SIGNAL_ACTION_PATH, "utf-8");
+
+    const client = mockS3WithEntries({
+      entries: [
+        { key: "sources/meetings/abc.md", content: sourceContent },
+        { key: "signals/action_item/xyz.md", content: signalContent },
+      ],
+    });
+
+    const result = await client.send(
+      new ListObjectsV2Command({ Bucket: "mock-bucket" }),
+    ) as { Contents: Array<{ Key: string; Size: number }> };
+
+    expect(result.Contents).toHaveLength(2);
+    const keys = result.Contents.map((c) => c.Key);
+    expect(keys).toContain("sources/meetings/abc.md");
+    expect(keys).toContain("signals/action_item/xyz.md");
+  });
+
+  it("filters by prefix — returns only matching entries", async () => {
+    const sourceContent = readFileSync(SOURCE_PATH, "utf-8");
+    const signalContent = readFileSync(SIGNAL_ACTION_PATH, "utf-8");
+
+    const client = mockS3WithEntries({
+      entries: [
+        { key: "sources/meetings/abc.md", content: sourceContent },
+        { key: "signals/action_item/xyz.md", content: signalContent },
+      ],
+    });
+
+    const sourceList = await client.send(
+      new ListObjectsV2Command({ Bucket: "mock-bucket", Prefix: "sources/meetings/" }),
+    ) as { Contents: Array<{ Key: string }> };
+
+    expect(sourceList.Contents).toHaveLength(1);
+    expect(sourceList.Contents[0].Key).toBe("sources/meetings/abc.md");
+
+    const signalList = await client.send(
+      new ListObjectsV2Command({ Bucket: "mock-bucket", Prefix: "signals/action_item/" }),
+    ) as { Contents: Array<{ Key: string }> };
+
+    expect(signalList.Contents).toHaveLength(1);
+    expect(signalList.Contents[0].Key).toBe("signals/action_item/xyz.md");
+  });
+});
+
+describe("mockS3WithEntries — get round-trip", () => {
+  it("retrieves source content and preserves exact bytes", async () => {
+    const sourceContent = readFileSync(SOURCE_PATH, "utf-8");
+
+    const client = mockS3WithEntries({
+      entries: [{ key: "sources/meetings/abc.md", content: sourceContent }],
+    });
+
+    const result = await client.send(
+      new GetObjectCommand({ Bucket: "mock-bucket", Key: "sources/meetings/abc.md" }),
+    ) as { Body: AsyncIterable<Uint8Array> };
+
+    const chunks: Buffer[] = [];
+    for await (const chunk of result.Body) {
+      chunks.push(Buffer.from(chunk));
+    }
+    const retrieved = Buffer.concat(chunks).toString("utf-8");
+
+    expect(retrieved).toBe(sourceContent);
+    // Spot-check frontmatter field survives round-trip
+    expect(retrieved).toContain("source_id: abc-meeting-001");
+  });
+
+  it("retrieves signal content and preserves exact bytes", async () => {
+    const signalContent = readFileSync(SIGNAL_ACTION_PATH, "utf-8");
+
+    const client = mockS3WithEntries({
+      entries: [{ key: "signals/action_item/xyz.md", content: signalContent }],
+    });
+
+    const result = await client.send(
+      new GetObjectCommand({ Bucket: "mock-bucket", Key: "signals/action_item/xyz.md" }),
+    ) as { Body: AsyncIterable<Uint8Array> };
+
+    const chunks: Buffer[] = [];
+    for await (const chunk of result.Body) {
+      chunks.push(Buffer.from(chunk));
+    }
+    const retrieved = Buffer.concat(chunks).toString("utf-8");
+
+    expect(retrieved).toBe(signalContent);
+    expect(retrieved).toContain("signal_type: action_item");
+  });
+
+  it("throws NoSuchKey for missing entry", async () => {
+    const client = mockS3WithEntries({ entries: [] });
+
+    await expect(
+      client.send(new GetObjectCommand({ Bucket: "mock-bucket", Key: "does/not/exist.md" })),
+    ).rejects.toMatchObject({ name: "NoSuchKey" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Vault-service mock tests
+// ---------------------------------------------------------------------------
+
+describe("mockVaultService — membership endpoint", () => {
+  let restore: (() => void) | undefined;
+
+  afterEach(() => {
+    restore?.();
+    restore = undefined;
+  });
+
+  it("GET /membership/me returns memberships for all configured entities", async () => {
+    restore = mockVaultService({
+      entities: [
+        { uid: "cmp_indigo_001", slug: "indigo", bucketName: "hq-indigo-bucket" },
+        { uid: "prs_personal_001", slug: "personal", bucketName: "hq-personal-bucket" },
+      ],
+    });
+
+    const res = await fetch("https://vault-api.example.com/membership/me");
+    const body = (await res.json()) as { memberships: Array<{ companyUid: string }> };
+
+    expect(res.status).toBe(200);
+    expect(body.memberships).toHaveLength(2);
+    const uids = body.memberships.map((m) => m.companyUid);
+    expect(uids).toContain("cmp_indigo_001");
+    expect(uids).toContain("prs_personal_001");
+  });
+
+  it("POST /entities/{uid}/sts returns credentials", async () => {
+    restore = mockVaultService({
+      entities: [{ uid: "cmp_indigo_001", slug: "indigo", bucketName: "hq-indigo-bucket" }],
+    });
+
+    const res = await fetch("https://vault-api.example.com/entities/cmp_indigo_001/sts", {
+      method: "POST",
+    });
+    const body = (await res.json()) as {
+      credentials: { accessKeyId: string };
+      bucketName: string;
+    };
+
+    expect(res.status).toBe(200);
+    expect(body.credentials.accessKeyId).toBe("ASIAMOCK000000000001");
+    expect(body.bucketName).toBe("hq-indigo-bucket");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// CLI runner
+// ---------------------------------------------------------------------------
+
+describe("runCli — basic wiring", () => {
+  it("runCli(['hq', '--help']) exits 0 and emits non-empty stdout", async () => {
+    const result = await runCli(["hq", "--help"]);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.length).toBeGreaterThan(0);
+    expect(result.stdout).toContain("hq");
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: [
+      "src/**/*.test.ts",
+      "test/sources-signals/**/*.test.ts",
+      "test/commands/**/*.test.ts",
+    ],
+  },
+});