chore: import upstream snapshot with attribution

tests/unit/cli-simulate.test.ts

@@ -0,0 +1,179 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const COMBO_RESPONSE = {
+  combos: [
+    {
+      id: "default",
+      name: "default",
+      enabled: true,
+      steps: [
+        { provider: "openai", model: "gpt-4o", inputCostPer1M: 5 },
+        { provider: "anthropic", model: "claude-3-5-sonnet", inputCostPer1M: 3 },
+      ],
+    },
+  ],
+};
+
+const HEALTH_RESPONSE = {
+  circuitBreakers: [
+    { provider: "openai", state: "CLOSED" },
+    { provider: "anthropic", state: "HALF_OPEN" },
+  ],
+};
+
+const QUOTA_RESPONSE = {
+  providers: [
+    { provider: "openai", percentRemaining: 80 },
+    { provider: "anthropic", percentRemaining: 60 },
+  ],
+};
+
+function makeResp(data: unknown, status = 200) {
+  const json = () => Promise.resolve(data);
+  const text = () => Promise.resolve(JSON.stringify(data));
+  const obj = { ok: status < 400, status, json, text, headers: new Headers() };
+  obj.json = obj.json.bind(obj);
+  obj.text = obj.text.bind(obj);
+  return obj;
+}
+
+function mockFetch(overrides: Record<string, unknown> = {}) {
+  return (url: string) => {
+    const path = new URL(url, "http://localhost").pathname;
+    if (path.includes("/api/combos"))
+      return Promise.resolve(makeResp(overrides.combos ?? COMBO_RESPONSE));
+    if (path.includes("/api/monitoring/health")) return Promise.resolve(makeResp(HEALTH_RESPONSE));
+    if (path.includes("/api/usage/quota")) return Promise.resolve(makeResp(QUOTA_RESPONSE));
+    return Promise.resolve(makeResp({}, 404));
+  };
+}
+
+async function captureOutput(fn: () => Promise<void>): Promise<{ stdout: string; stderr: string }> {
+  const stdoutChunks: string[] = [];
+  const stderrChunks: string[] = [];
+  const origOut = process.stdout.write.bind(process.stdout);
+  const origErr = process.stderr.write.bind(process.stderr);
+  process.stdout.write = (c: string | Uint8Array) => {
+    if (typeof c === "string") stdoutChunks.push(c);
+    return true;
+  };
+  process.stderr.write = (c: string | Uint8Array) => {
+    if (typeof c === "string") stderrChunks.push(c);
+    return true;
+  };
+  try {
+    await fn();
+  } finally {
+    process.stdout.write = origOut;
+    process.stderr.write = origErr;
+  }
+  return { stdout: stdoutChunks.join(""), stderr: stderrChunks.join("") };
+}
+
+test("runSimulateCommand exibe tabela com provedores do combo", async () => {
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = mockFetch() as any;
+
+  const { runSimulateCommand } = await import("../../bin/cli/commands/simulate.mjs");
+  const cmd = { optsWithGlobals: () => ({ output: "table", quiet: false }) };
+  const { stdout } = await captureOutput(() =>
+    runSimulateCommand("explique RAG", { model: "auto" }, cmd as any)
+  );
+
+  globalThis.fetch = origFetch;
+  assert.ok(stdout.includes("openai") || stdout.includes("Provider"));
+});
+
+test("runSimulateCommand --output json retorna simulatedPath completo", async () => {
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = mockFetch() as any;
+
+  const { runSimulateCommand } = await import("../../bin/cli/commands/simulate.mjs");
+  const cmd = { optsWithGlobals: () => ({ output: "json", quiet: true }) };
+  const { stdout } = await captureOutput(() =>
+    runSimulateCommand("test", { model: "auto" }, cmd as any)
+  );
+
+  globalThis.fetch = origFetch;
+  const parsed = JSON.parse(stdout);
+  assert.ok(Array.isArray(parsed));
+  assert.equal(parsed.length, 2);
+  assert.equal(parsed[0].provider, "openai");
+  assert.equal(parsed[0].order, 1);
+  assert.ok(typeof parsed[0].healthStatus === "string");
+});
+
+test("runSimulateCommand --explain imprime arvore de fallback no stderr", async () => {
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = mockFetch() as any;
+
+  const { runSimulateCommand } = await import("../../bin/cli/commands/simulate.mjs");
+  const cmd = { optsWithGlobals: () => ({ output: "table", quiet: false }) };
+  const { stderr } = await captureOutput(() =>
+    runSimulateCommand("test", { model: "auto", explain: true }, cmd as any)
+  );
+
+  globalThis.fetch = origFetch;
+  assert.ok(stderr.includes("Primary:"));
+  assert.ok(stderr.includes("anthropic"));
+});
+
+test("runSimulateCommand --file carrega JSON e usa como body", async () => {
+  const tmpDir = mkdtempSync(join(tmpdir(), "sim-test-"));
+  const filePath = join(tmpDir, "body.json");
+  writeFileSync(filePath, JSON.stringify({ messages: [{ role: "user", content: "hello" }] }));
+
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = mockFetch() as any;
+
+  const { runSimulateCommand } = await import("../../bin/cli/commands/simulate.mjs");
+  const cmd = { optsWithGlobals: () => ({ output: "json", quiet: true }) };
+  const { stdout } = await captureOutput(() =>
+    runSimulateCommand(undefined, { model: "auto", file: filePath }, cmd as any)
+  );
+
+  globalThis.fetch = origFetch;
+  const parsed = JSON.parse(stdout);
+  assert.ok(Array.isArray(parsed));
+  assert.ok(parsed.length >= 1);
+});
+
+test("runSimulateCommand --combo filtra por nome do combo", async () => {
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = mockFetch() as any;
+
+  const { runSimulateCommand } = await import("../../bin/cli/commands/simulate.mjs");
+  const cmd = { optsWithGlobals: () => ({ output: "json", quiet: true }) };
+  const { stdout } = await captureOutput(() =>
+    runSimulateCommand("test", { model: "auto", combo: "default" }, cmd as any)
+  );
+
+  globalThis.fetch = origFetch;
+  const parsed = JSON.parse(stdout);
+  assert.ok(Array.isArray(parsed));
+  assert.equal(parsed[0].provider, "openai");
+});
+
+test("runSimulateCommand quando servidor offline emite mensagem e sai com 3", async () => {
+  const origFetch = globalThis.fetch;
+  const exitCodes: (number | string)[] = [];
+  const origExit = process.exit.bind(process);
+  process.exit = ((code: number) => {
+    exitCodes.push(code);
+  }) as any;
+  globalThis.fetch = (() => Promise.reject(new Error("ECONNREFUSED"))) as any;
+
+  const { runSimulateCommand } = await import("../../bin/cli/commands/simulate.mjs");
+  const cmd = { optsWithGlobals: () => ({ output: "table", quiet: false }) };
+  const { stderr } = await captureOutput(() =>
+    runSimulateCommand("test", { model: "auto" }, cmd as any).catch(() => {})
+  );
+
+  globalThis.fetch = origFetch;
+  process.exit = origExit;
+  assert.ok(exitCodes.includes(3) || stderr.length > 0);
+});