@node-llm/testing 0.1.0 → 0.2.1

package/test/unit/scrubbing.test.ts

@@ -17,7 +17,7 @@ describe("VCR Feature 4: Automatic Scrubbing", () => {
     CASSETTE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "vcr-scrub-test-"));
     CASSETTE_PATH = path.join(CASSETTE_DIR, `${CASSETTE_NAME}.json`);
     mock = new MockProvider();
-    providerRegistry.register("mock-provider", () => mock);
+    providerRegistry.register("mock-provider", () => mock as any);
   });
 
   afterEach(() => {
@@ -29,7 +29,11 @@ describe("VCR Feature 4: Automatic Scrubbing", () => {
   });
 
   test("Automatically scrubs API keys and sensitive JSON keys", async () => {
-    const vcr = setupVCR(CASSETTE_NAME, { mode: "record", cassettesDir: CASSETTE_DIR });
+    const vcr = setupVCR(CASSETTE_NAME, {
+      mode: "record",
+      cassettesDir: CASSETTE_DIR,
+      _allowRecordingInCI: true
+    });
     const llm = NodeLLM.withProvider("mock-provider");
 
     // 1. Trigger request with secrets
@@ -50,6 +54,7 @@ describe("VCR Feature 4: Automatic Scrubbing", () => {
     const vcr = setupVCR(CASSETTE_NAME, {
       mode: "record",
       cassettesDir: CASSETTE_DIR,
+      _allowRecordingInCI: true,
       scrub: (data: unknown) => {
         // Deep string replacement on the whole interaction object
         return JSON.parse(JSON.stringify(data).replace(/sensitive-info/g, "XXXX"));
@@ -69,6 +74,7 @@ describe("VCR Feature 4: Automatic Scrubbing", () => {
     const vcr = setupVCR("custom-scrub-config", {
       mode: "record",
       cassettesDir: CASSETTE_DIR,
+      _allowRecordingInCI: true,
       sensitiveKeys: ["user_email", "internal_id"],
       sensitivePatterns: [/secret-project-[a-z]+/g]
     });
@@ -90,6 +96,7 @@ describe("VCR Feature 4: Automatic Scrubbing", () => {
     const vcr = setupVCR("defaults-plus-custom", {
       mode: "record",
       cassettesDir: CASSETTE_DIR,
+      _allowRecordingInCI: true,
       sensitiveKeys: ["custom_field"]
     });
 

package/test/unit/serializer.test.ts

@@ -0,0 +1,81 @@
+import { test, expect, describe } from "vitest";
+import { Serializer } from "../../src/Serializer.js";
+
+describe("Serializer", () => {
+  test("Handles Date objects", () => {
+    const data = { date: new Date("2023-01-01T00:00:00.000Z") };
+    const serialized = Serializer.serialize(data);
+    const deserialized = Serializer.deserialize(serialized);
+    expect(deserialized).toEqual(data);
+    expect((deserialized as any).date).toBeInstanceOf(Date);
+  });
+
+  test("Handles Map objects", () => {
+    const data = {
+      map: new Map<string, string | number>([
+        ["key", "value"],
+        ["num", 123]
+      ])
+    };
+    const serialized = Serializer.serialize(data);
+    const deserialized = Serializer.deserialize(serialized);
+    expect(deserialized).toEqual(data);
+    expect((deserialized as any).map).toBeInstanceOf(Map);
+    expect((deserialized as any).map.get("key")).toBe("value");
+  });
+
+  test("Handles Set objects", () => {
+    const data = { set: new Set([1, 2, 3, "four"]) };
+    const serialized = Serializer.serialize(data);
+    const deserialized = Serializer.deserialize(serialized);
+    expect(deserialized).toEqual(data);
+    expect((deserialized as any).set).toBeInstanceOf(Set);
+    expect((deserialized as any).set.has("four")).toBe(true);
+  });
+
+  test("Handles RegExp objects", () => {
+    const data = { regex: /abc/gi };
+    const serialized = Serializer.serialize(data);
+    const deserialized = Serializer.deserialize(serialized);
+    expect(deserialized).toEqual(data);
+    expect((deserialized as any).regex).toBeInstanceOf(RegExp);
+    expect((deserialized as any).regex.flags).toContain("g");
+    expect((deserialized as any).regex.flags).toContain("i");
+  });
+
+  test("Handles Error objects", () => {
+    const err = new Error("Test error");
+    err.name = "CustomError";
+    (err as any).customProp = "customValue";
+
+    const data = { error: err };
+    const serialized = Serializer.serialize(data);
+    const deserialized: any = Serializer.deserialize(serialized);
+
+    expect(deserialized.error).toBeInstanceOf(Error);
+    expect(deserialized.error.message).toBe("Test error");
+    expect(deserialized.error.name).toBe("CustomError");
+    expect(deserialized.error.customProp).toBe("customValue");
+    expect(deserialized.error.stack).toBeDefined();
+  });
+
+  test("Handles Buffer objects", () => {
+    if (typeof Buffer === "undefined") return; // Skip in browser-like envs if any
+    const data = { buf: Buffer.from("Hello World") };
+    const serialized = Serializer.serialize(data);
+    const deserialized: any = Serializer.deserialize(serialized);
+
+    expect(deserialized.buf).toBeInstanceOf(Buffer);
+    expect(deserialized.buf.toString()).toBe("Hello World");
+  });
+
+  test("Handles Infinity and NaN", () => {
+    const data = { inf: Infinity, negInf: -Infinity, nan: NaN };
+    const serialized = Serializer.serialize(data);
+    const deserialized: any = Serializer.deserialize(serialized);
+
+    expect(deserialized.inf).toBe(Infinity);
+    expect(deserialized.negInf).toBe(-Infinity);
+    expect(Number.isNaN(deserialized.nan)).toBe(true);
+  });
+});

package/test/unit/vcr-global-config.test.ts

@@ -33,7 +33,11 @@ describe("VCR: Global Configuration", () => {
     const CASSETTE_NAME = "global-config-keys";
     const CASSETTE_PATH = path.join(CASSETTE_DIR, `${CASSETTE_NAME}.json`);
 
-    const vcr = setupVCR(CASSETTE_NAME, { mode: "record", cassettesDir: CASSETTE_DIR });
+    const vcr = setupVCR(CASSETTE_NAME, {
+      mode: "record",
+      cassettesDir: CASSETTE_DIR,
+      _allowRecordingInCI: true
+    });
     const llm = NodeLLM.withProvider("mock-provider");
 
     await llm.chat().ask("regular question");
@@ -53,7 +57,11 @@ describe("VCR: Global Configuration", () => {
     const CASSETTE_NAME = "global-config-patterns";
     const CASSETTE_PATH = path.join(CASSETTE_DIR, `${CASSETTE_NAME}.json`);
 
-    const vcr = setupVCR(CASSETTE_NAME, { mode: "record", cassettesDir: CASSETTE_DIR });
+    const vcr = setupVCR(CASSETTE_NAME, {
+      mode: "record",
+      cassettesDir: CASSETTE_DIR,
+      _allowRecordingInCI: true
+    });
     const llm = NodeLLM.withProvider("mock-provider");
 
     await llm.chat().ask("Status of custom-secret-omega");
@@ -74,7 +82,11 @@ describe("VCR: Global Configuration", () => {
     const CASSETTE_NAME = "global-config-reset";
     const CASSETTE_PATH = path.join(CASSETTE_DIR, `${CASSETTE_NAME}.json`);
 
-    const vcr = setupVCR(CASSETTE_NAME, { mode: "record", cassettesDir: CASSETTE_DIR });
+    const vcr = setupVCR(CASSETTE_NAME, {
+      mode: "record",
+      cassettesDir: CASSETTE_DIR,
+      _allowRecordingInCI: true
+    });
     const llm = NodeLLM.withProvider("mock-provider");
 
     await llm.chat().ask("to_reset should not be redacted");

package/test/unit/vcr-mismatch.test.ts

@@ -34,7 +34,8 @@ describe("VCR: Interaction Mismatch Detection", () => {
     // First: Record with specific request
     const vcrRecord = setupVCR(CASSETTE_NAME, {
       mode: "record",
-      cassettesDir: CASSETTE_DIR
+      cassettesDir: CASSETTE_DIR,
+      _allowRecordingInCI: true
     });
     const llmRecord = NodeLLM.withProvider("mock-provider");
     await llmRecord.chat().ask("Record this question");

package/test/unit/vcr_advanced_types.test.ts

@@ -0,0 +1,72 @@
+import { test, expect, describe, afterEach } from "vitest";
+import { withVCR, describeVCR } from "../../src/vcr.js";
+import { NodeLLM, providerRegistry } from "@node-llm/core";
+import { MockProvider } from "../helpers/MockProvider.js";
+import fs from "node:fs";
+import path from "node:path";
+import { Serializer } from "../../src/Serializer.js";
+
+describe("VCR Advanced Types Persistence", () => {
+  const cassettePath = "test/cassettes/vcr-advanced-types-persistence/handles-rich-types.json";
+
+  afterEach(() => {
+    if (fs.existsSync(cassettePath)) {
+      // Clean up file
+      fs.rmSync(cassettePath);
+      // Try to clean up parent dir if empty (optional but good)
+      try {
+        fs.rmdirSync(path.dirname(cassettePath));
+      } catch {
+        /* ignore */
+      }
+    }
+  });
+
+  test("Persists Date and Map in cassettes", async () => {
+    const date = new Date("2024-01-01T00:00:00.000Z");
+    const map = new Map<string, string>([["key", "value"]]);
+
+    await describeVCR("VCR Advanced Types Persistence", async () => {
+      providerRegistry.register("mock-provider", () => new MockProvider() as any);
+
+      // 1. Record Phase
+      await withVCR(
+        "Handles Rich Types",
+        { mode: "record", _allowRecordingInCI: true },
+        async () => {
+          const llm = NodeLLM.withProvider("mock-provider");
+
+          // Pass rich types in params
+          await llm
+            .chat()
+            .withParams({
+              createdAt: date,
+              meta: map
+            })
+            .ask("Hello");
+        }
+      )();
+    });
+
+    // 2. Verify Disk Content (Serialization)
+    expect(fs.existsSync(cassettePath)).toBe(true);
+    const rawContent = fs.readFileSync(cassettePath, "utf-8");
+
+    // Should NOT contain raw ISO string only, but the typed wrapper
+    expect(rawContent).toContain('"$type": "Date"');
+    expect(rawContent).toContain('"value": "2024-01-01T00:00:00.000Z"');
+    expect(rawContent).toContain('"$type": "Map"');
+
+    // 3. Replay/Load Phase (Deserialization)
+    // We manually load to verify the deserialization logic
+    const cassette = Serializer.deserialize<any>(rawContent);
+    const request = cassette.interactions[0].request;
+
+    // Check that params are restored as real instances
+    expect(request.createdAt).toBeInstanceOf(Date);
+    expect(request.createdAt.toISOString()).toBe(date.toISOString());
+
+    expect(request.meta).toBeInstanceOf(Map);
+    expect(request.meta.get("key")).toBe("value");
+  });
+});