Add test suite

Unit tests for all modules plus integration tests covering
text streaming, tool calls, multi-turn flows, error fixtures,
journal verification, and fixture file loading.

Author: jpr5

src/__tests__/fixture-loader.test.ts

@@ -0,0 +1,258 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadFixtureFile, loadFixturesFromDir } from "../fixture-loader.js";
+
+function makeTmpDir(): string {
+  return mkdtempSync(join(tmpdir(), "fixture-loader-test-"));
+}
+
+function writeJson(dir: string, name: string, content: unknown): string {
+  const filePath = join(dir, name);
+  writeFileSync(filePath, JSON.stringify(content), "utf-8");
+  return filePath;
+}
+
+describe("loadFixtureFile", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("loads a single fixture file with a userMessage match", () => {
+    const filePath = writeJson(tmpDir, "greeting.json", {
+      fixtures: [
+        {
+          match: { userMessage: "hello" },
+          response: { content: "Hello!" },
+        },
+      ],
+    });
+
+    const fixtures = loadFixtureFile(filePath);
+    expect(fixtures).toHaveLength(1);
+    expect(fixtures[0].match.userMessage).toBe("hello");
+    expect(fixtures[0].response).toEqual({ content: "Hello!" });
+  });
+
+  it("loads all match fields correctly", () => {
+    const filePath = writeJson(tmpDir, "full-match.json", {
+      fixtures: [
+        {
+          match: { toolCallId: "call_123", toolName: "get_weather", model: "gpt-4" },
+          response: { toolCalls: [{ name: "get_weather", arguments: "{}" }] },
+          latency: 200,
+          chunkSize: 10,
+        },
+      ],
+    });
+
+    const fixtures = loadFixtureFile(filePath);
+    expect(fixtures).toHaveLength(1);
+    const f = fixtures[0];
+    expect(f.match.toolCallId).toBe("call_123");
+    expect(f.match.toolName).toBe("get_weather");
+    expect(f.match.model).toBe("gpt-4");
+    expect(f.latency).toBe(200);
+    expect(f.chunkSize).toBe(10);
+  });
+
+  it("keeps userMessage as a string (no RegExp conversion)", () => {
+    const filePath = writeJson(tmpDir, "string-match.json", {
+      fixtures: [
+        {
+          match: { userMessage: "hello world" },
+          response: { content: "Hi!" },
+        },
+      ],
+    });
+
+    const fixtures = loadFixtureFile(filePath);
+    expect(typeof fixtures[0].match.userMessage).toBe("string");
+    expect(fixtures[0].match.userMessage).toBe("hello world");
+  });
+
+  it("omits latency and chunkSize when not present in JSON", () => {
+    const filePath = writeJson(tmpDir, "no-optional.json", {
+      fixtures: [
+        {
+          match: { userMessage: "hi" },
+          response: { content: "hey" },
+        },
+      ],
+    });
+
+    const fixtures = loadFixtureFile(filePath);
+    expect(fixtures[0].latency).toBeUndefined();
+    expect(fixtures[0].chunkSize).toBeUndefined();
+  });
+
+  it("warns and returns empty array for invalid JSON", () => {
+    const filePath = join(tmpDir, "bad.json");
+    writeFileSync(filePath, "{ not valid json", "utf-8");
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fixtures = loadFixtureFile(filePath);
+    expect(fixtures).toHaveLength(0);
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("Invalid JSON"), expect.anything());
+    warn.mockRestore();
+  });
+
+  it("warns and returns empty array when fixtures key is missing", () => {
+    const filePath = writeJson(tmpDir, "no-fixtures.json", { something: [] });
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fixtures = loadFixtureFile(filePath);
+    expect(fixtures).toHaveLength(0);
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("fixtures"));
+    warn.mockRestore();
+  });
+
+  it("warns and returns empty array when fixtures is not an array", () => {
+    const filePath = writeJson(tmpDir, "bad-fixtures.json", { fixtures: "oops" });
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fixtures = loadFixtureFile(filePath);
+    expect(fixtures).toHaveLength(0);
+    warn.mockRestore();
+  });
+
+  it("warns and returns empty array for a non-existent file", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fixtures = loadFixtureFile(join(tmpDir, "does-not-exist.json"));
+    expect(fixtures).toHaveLength(0);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining("Could not read file"),
+      expect.anything(),
+    );
+    warn.mockRestore();
+  });
+});
+
+describe("loadFixturesFromDir", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("loads multiple files and concatenates fixtures in alphabetical file order", () => {
+    writeJson(tmpDir, "b-second.json", {
+      fixtures: [{ match: { userMessage: "b" }, response: { content: "B" } }],
+    });
+    writeJson(tmpDir, "a-first.json", {
+      fixtures: [{ match: { userMessage: "a" }, response: { content: "A" } }],
+    });
+
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(2);
+    expect(fixtures[0].match.userMessage).toBe("a");
+    expect(fixtures[1].match.userMessage).toBe("b");
+  });
+
+  it("returns all fixtures from multiple entries in one file", () => {
+    writeJson(tmpDir, "multi.json", {
+      fixtures: [
+        { match: { userMessage: "one" }, response: { content: "1" } },
+        { match: { userMessage: "two" }, response: { content: "2" } },
+        { match: { userMessage: "three" }, response: { content: "3" } },
+      ],
+    });
+
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(3);
+  });
+
+  it("skips invalid JSON files with a warning, still loads valid ones", () => {
+    writeJson(tmpDir, "a-valid.json", {
+      fixtures: [{ match: { userMessage: "ok" }, response: { content: "yes" } }],
+    });
+    writeFileSync(join(tmpDir, "b-invalid.json"), "{ bad json", "utf-8");
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(1);
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("Invalid JSON"), expect.anything());
+    warn.mockRestore();
+  });
+
+  it("skips files without a fixtures array, still loads valid ones", () => {
+    writeJson(tmpDir, "a-bad.json", { notFixtures: true });
+    writeJson(tmpDir, "b-good.json", {
+      fixtures: [{ match: { userMessage: "hi" }, response: { content: "hey" } }],
+    });
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(1);
+    expect(fixtures[0].match.userMessage).toBe("hi");
+    warn.mockRestore();
+  });
+
+  it("ignores non-.json files", () => {
+    writeFileSync(join(tmpDir, "readme.txt"), "ignore me", "utf-8");
+    writeFileSync(join(tmpDir, "notes.md"), "# ignore", "utf-8");
+    writeJson(tmpDir, "actual.json", {
+      fixtures: [{ match: { userMessage: "real" }, response: { content: "yes" } }],
+    });
+
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(1);
+  });
+
+  it("returns empty array for an empty directory", () => {
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(0);
+  });
+
+  it("returns empty array and warns for a non-existent directory", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fixtures = loadFixturesFromDir(join(tmpDir, "does-not-exist"));
+    expect(fixtures).toHaveLength(0);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining("Could not read directory"),
+      expect.anything(),
+    );
+    warn.mockRestore();
+  });
+
+  it("loads fixtures from a nested subdirectory when given that path directly", () => {
+    const subDir = join(tmpDir, "sub");
+    mkdirSync(subDir);
+    writeJson(subDir, "fixtures.json", {
+      fixtures: [{ match: { userMessage: "nested" }, response: { content: "found" } }],
+    });
+
+    const fixtures = loadFixturesFromDir(subDir);
+    expect(fixtures).toHaveLength(1);
+    expect(fixtures[0].match.userMessage).toBe("nested");
+  });
+
+  it("warns and skips subdirectories, still loads sibling JSON files", () => {
+    writeJson(tmpDir, "a-valid.json", {
+      fixtures: [{ match: { userMessage: "top" }, response: { content: "yes" } }],
+    });
+    const subDir = join(tmpDir, "nested");
+    mkdirSync(subDir);
+    writeJson(subDir, "inner.json", {
+      fixtures: [{ match: { userMessage: "deep" }, response: { content: "nope" } }],
+    });
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(1);
+    expect(fixtures[0].match.userMessage).toBe("top");
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("Skipping subdirectory"));
+    warn.mockRestore();
+  });
+});