@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/workspace-migration-033-stt-service-explicit-config.test.ts

@@ -0,0 +1,547 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { sttServiceExplicitConfigMigration } from "../workspace/migrations/033-stt-service-explicit-config.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-033-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("033-stt-service-explicit-config migration", () => {
+  test("has correct migration id", () => {
+    expect(sttServiceExplicitConfigMigration.id).toBe(
+      "033-stt-service-explicit-config",
+    );
+  });
+
+  // ─── Fresh config backfill ─────────────────────────────────────────────
+
+  test("backfills full services.stt block on config with no services key", () => {
+    writeConfig({ maxTokens: 64000 });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, unknown>;
+    const stt = services.stt as Record<string, unknown>;
+
+    expect(stt.mode).toBe("your-own");
+    expect(stt.provider).toBe("deepgram");
+    // providers is sparse — no per-provider entries seeded
+    expect(stt.providers).toEqual({});
+
+    // Other config keys preserved
+    expect(config.maxTokens).toBe(64000);
+  });
+
+  test("backfills services.stt when services exists but has no stt key", () => {
+    writeConfig({
+      services: {
+        inference: { mode: "your-own", provider: "anthropic" },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, unknown>;
+    const stt = services.stt as Record<string, unknown>;
+
+    expect(stt.mode).toBe("your-own");
+    expect(stt.provider).toBe("deepgram");
+    // providers is sparse — no per-provider entries seeded
+    expect(stt.providers).toEqual({});
+
+    // Existing services preserved
+    const inference = services.inference as Record<string, unknown>;
+    expect(inference.provider).toBe("anthropic");
+  });
+
+  test("backfills on empty config object", () => {
+    writeConfig({});
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, unknown>;
+    const stt = services.stt as Record<string, unknown>;
+
+    expect(stt.mode).toBe("your-own");
+    expect(stt.provider).toBe("deepgram");
+    // providers is sparse — no per-provider entries seeded
+    expect(stt.providers).toEqual({});
+  });
+
+  // ─── Partial STT object completion ────────────────────────────────────
+
+  test("fills in missing mode when stt has provider and providers", () => {
+    writeConfig({
+      services: {
+        stt: {
+          provider: "deepgram",
+          providers: { "openai-whisper": {}, deepgram: {} },
+        },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const stt = (config.services as Record<string, unknown>).stt as Record<
+      string,
+      unknown
+    >;
+
+    expect(stt.mode).toBe("your-own");
+    expect(stt.provider).toBe("deepgram");
+  });
+
+  test("fills in missing provider when stt has mode and providers", () => {
+    writeConfig({
+      services: {
+        stt: {
+          mode: "your-own",
+          providers: { "openai-whisper": {}, deepgram: {} },
+        },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const stt = (config.services as Record<string, unknown>).stt as Record<
+      string,
+      unknown
+    >;
+
+    expect(stt.provider).toBe("deepgram");
+    expect(stt.mode).toBe("your-own");
+  });
+
+  test("fills in missing providers as empty object when stt has mode and provider", () => {
+    writeConfig({
+      services: {
+        stt: {
+          mode: "your-own",
+          provider: "deepgram",
+        },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const stt = (config.services as Record<string, unknown>).stt as Record<
+      string,
+      unknown
+    >;
+
+    // providers is sparse — no per-provider entries seeded
+    expect(stt.providers).toEqual({});
+  });
+
+  test("does not inject per-provider entries when only openai-whisper exists in providers", () => {
+    writeConfig({
+      services: {
+        stt: {
+          mode: "your-own",
+          provider: "openai-whisper",
+          providers: { "openai-whisper": {} },
+        },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const stt = (config.services as Record<string, unknown>).stt as Record<
+      string,
+      unknown
+    >;
+    const providers = stt.providers as Record<string, unknown>;
+
+    // Existing entry preserved, no new entries injected
+    expect(providers["openai-whisper"]).toEqual({});
+    expect(providers.deepgram).toBeUndefined();
+  });
+
+  // ─── Preservation of explicit user provider overrides ─────────────────
+
+  test("preserves explicit user-defined provider value", () => {
+    writeConfig({
+      services: {
+        stt: {
+          mode: "your-own",
+          provider: "deepgram",
+          providers: { "openai-whisper": {}, deepgram: {} },
+        },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const stt = (config.services as Record<string, unknown>).stt as Record<
+      string,
+      unknown
+    >;
+
+    expect(stt.provider).toBe("deepgram");
+  });
+
+  test("preserves existing provider-specific config values", () => {
+    writeConfig({
+      services: {
+        stt: {
+          mode: "your-own",
+          provider: "deepgram",
+          providers: {
+            "openai-whisper": { customSetting: "preserved" },
+            deepgram: { model: "nova-3" },
+          },
+        },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const stt = (config.services as Record<string, unknown>).stt as Record<
+      string,
+      unknown
+    >;
+    const providers = stt.providers as Record<string, unknown>;
+    const whisper = providers["openai-whisper"] as Record<string, unknown>;
+    const deepgram = providers.deepgram as Record<string, unknown>;
+
+    expect(whisper.customSetting).toBe("preserved");
+    expect(deepgram.model).toBe("nova-3");
+  });
+
+  test("does not clobber explicit mode value", () => {
+    writeConfig({
+      services: {
+        stt: {
+          mode: "your-own",
+        },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const stt = (config.services as Record<string, unknown>).stt as Record<
+      string,
+      unknown
+    >;
+    expect(stt.mode).toBe("your-own");
+  });
+
+  test("preserves other services keys", () => {
+    writeConfig({
+      services: {
+        inference: { mode: "your-own", provider: "anthropic" },
+        tts: { mode: "your-own", provider: "elevenlabs" },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, Record<string, unknown>>;
+
+    expect(services.inference.provider).toBe("anthropic");
+    expect(services.tts.provider).toBe("elevenlabs");
+    expect(services.stt).toBeDefined();
+  });
+
+  // ─── Malformed config no-op ───────────────────────────────────────────
+
+  test("no-op when config.json does not exist", () => {
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("no-op when config.json contains invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("no-op when config.json contains a JSON array", () => {
+    writeFileSync(join(workspaceDir, "config.json"), JSON.stringify([1, 2, 3]));
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const raw = JSON.parse(
+      readFileSync(join(workspaceDir, "config.json"), "utf-8"),
+    );
+    expect(raw).toEqual([1, 2, 3]);
+  });
+
+  test("no-op when config.json contains a JSON string", () => {
+    writeFileSync(
+      join(workspaceDir, "config.json"),
+      JSON.stringify("just a string"),
+    );
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const raw = JSON.parse(
+      readFileSync(join(workspaceDir, "config.json"), "utf-8"),
+    );
+    expect(raw).toBe("just a string");
+  });
+
+  test("recovers when services.stt is a non-object value", () => {
+    writeConfig({
+      services: {
+        stt: "invalid",
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const stt = (config.services as Record<string, unknown>).stt as Record<
+      string,
+      unknown
+    >;
+
+    // ensureObj replaces the non-object with a fresh object and backfills
+    expect(stt.mode).toBe("your-own");
+    expect(stt.provider).toBe("deepgram");
+  });
+
+  test("recovers when services is a non-object value", () => {
+    writeConfig({
+      services: 42,
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, unknown>;
+    const stt = services.stt as Record<string, unknown>;
+
+    expect(stt.mode).toBe("your-own");
+    expect(stt.provider).toBe("deepgram");
+  });
+
+  // ─── Second-run idempotency ───────────────────────────────────────────
+
+  test("second run produces identical output (fresh backfill)", () => {
+    writeConfig({ maxTokens: 64000 });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+    const afterFirst = readConfig();
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+    const afterSecond = readConfig();
+
+    expect(afterSecond).toEqual(afterFirst);
+  });
+
+  test("second run produces identical output (already complete config)", () => {
+    writeConfig({
+      services: {
+        stt: {
+          mode: "your-own",
+          provider: "deepgram",
+          providers: {
+            "openai-whisper": {},
+            deepgram: { model: "nova-3" },
+          },
+        },
+      },
+    });
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+    const afterFirst = readConfig();
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+    const afterSecond = readConfig();
+
+    expect(afterSecond).toEqual(afterFirst);
+  });
+
+  test("does not write file when nothing changed (fully populated config)", () => {
+    const original = {
+      services: {
+        stt: {
+          mode: "your-own",
+          provider: "openai-whisper",
+          providers: {},
+        },
+      },
+    };
+    writeConfig(original);
+
+    // Capture the file's content before migration
+    const before = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const after = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+    // Content should be byte-identical since nothing changed
+    expect(after).toBe(before);
+  });
+
+  test("does not write file when nothing changed (config with per-provider entries from prior migration)", () => {
+    // Configs that include per-provider keys are already complete — the
+    // migration treats them as a no-op and must not rewrite the file.
+    const original = {
+      services: {
+        stt: {
+          mode: "your-own",
+          provider: "openai-whisper",
+          providers: {
+            "openai-whisper": {},
+            deepgram: {},
+          },
+        },
+      },
+    };
+    writeConfig(original);
+
+    const before = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+
+    sttServiceExplicitConfigMigration.run(workspaceDir);
+
+    const after = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+    expect(after).toBe(before);
+  });
+
+  // ─── down() ───────────────────────────────────────────────────────────
+
+  describe("down()", () => {
+    test("removes services.stt block", () => {
+      writeConfig({
+        services: {
+          inference: { mode: "your-own", provider: "anthropic" },
+          stt: {
+            mode: "your-own",
+            provider: "openai-whisper",
+            providers: { "openai-whisper": {}, deepgram: {} },
+          },
+        },
+      });
+
+      sttServiceExplicitConfigMigration.down(workspaceDir);
+
+      const config = readConfig();
+      const services = config.services as Record<string, unknown>;
+      expect(services.stt).toBeUndefined();
+      // Other services preserved
+      expect(services.inference).toBeDefined();
+    });
+
+    test("no-op when config.json does not exist", () => {
+      sttServiceExplicitConfigMigration.down(workspaceDir);
+      // Should not throw
+    });
+
+    test("no-op when config has no services key", () => {
+      writeConfig({ maxTokens: 64000 });
+
+      sttServiceExplicitConfigMigration.down(workspaceDir);
+
+      const config = readConfig();
+      expect(config.maxTokens).toBe(64000);
+    });
+
+    test("no-op when services.stt does not exist", () => {
+      writeConfig({
+        services: {
+          inference: { mode: "your-own", provider: "anthropic" },
+        },
+      });
+
+      sttServiceExplicitConfigMigration.down(workspaceDir);
+
+      const config = readConfig();
+      const services = config.services as Record<string, unknown>;
+      expect(services.inference).toBeDefined();
+    });
+
+    test("idempotent: calling down() twice is safe", () => {
+      writeConfig({
+        services: {
+          stt: {
+            mode: "your-own",
+            provider: "openai-whisper",
+            providers: { "openai-whisper": {}, deepgram: {} },
+          },
+        },
+      });
+
+      sttServiceExplicitConfigMigration.down(workspaceDir);
+      sttServiceExplicitConfigMigration.down(workspaceDir);
+
+      const config = readConfig();
+      const services = config.services as Record<string, unknown>;
+      expect(services.stt).toBeUndefined();
+    });
+
+    test("gracefully handles malformed JSON", () => {
+      writeFileSync(join(workspaceDir, "config.json"), "bad-json");
+
+      sttServiceExplicitConfigMigration.down(workspaceDir);
+
+      expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+        "bad-json",
+      );
+    });
+  });
+});