OmniRoute/tests/unit/provider-specific-data-schema.test.ts

import test from "node:test";
import assert from "node:assert/strict";

const { createProviderSchema, updateProviderConnectionSchema } =
  await import("../../src/shared/validation/schemas.ts");

test("provider schemas accept boolean openaiStoreEnabled in providerSpecificData", () => {
  const created = createProviderSchema.safeParse({
    provider: "codex",
    apiKey: "token",
    name: "Codex",
    providerSpecificData: {
      openaiStoreEnabled: true,
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      openaiStoreEnabled: false,
    },
  });

  assert.equal(created.success, true);
  assert.equal(updated.success, true);
});

test("provider schemas reject non-boolean openaiStoreEnabled values", () => {
  const created = createProviderSchema.safeParse({
    provider: "codex",
    apiKey: "token",
    name: "Codex",
    providerSpecificData: {
      openaiStoreEnabled: "yes",
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      openaiStoreEnabled: "no",
    },
  });

  assert.equal(created.success, false);
  assert.equal(updated.success, false);
});

test("provider schemas accept boolean preserveEncryptedReasoning in providerSpecificData", () => {
  const created = createProviderSchema.safeParse({
    provider: "codex",
    apiKey: "token",
    name: "Codex",
    providerSpecificData: { preserveEncryptedReasoning: true },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: { preserveEncryptedReasoning: false },
  });

  assert.equal(created.success, true);
  assert.equal(updated.success, true);
});

test("provider schemas reject non-boolean preserveEncryptedReasoning values", () => {
  const created = createProviderSchema.safeParse({
    provider: "codex",
    apiKey: "token",
    name: "Codex",
    providerSpecificData: { preserveEncryptedReasoning: "yes" },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: { preserveEncryptedReasoning: 1 },
  });

  assert.equal(created.success, false);
  assert.equal(updated.success, false);
});

test("provider schemas accept boolean CC-compatible request defaults", () => {
  const created = createProviderSchema.safeParse({
    provider: "anthropic-compatible-cc-demo",
    apiKey: "token",
    name: "CC Compatible",
    providerSpecificData: {
      requestDefaults: {
        context1m: true,
        redactThinking: true,
        summarizeThinking: true,
      },
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      requestDefaults: {
        context1m: false,
        redactThinking: false,
        summarizeThinking: false,
      },
    },
  });

  assert.equal(created.success, true);
  assert.equal(updated.success, true);
});

test("provider schemas reject non-boolean CC-compatible request defaults", () => {
  const created = createProviderSchema.safeParse({
    provider: "anthropic-compatible-cc-demo",
    apiKey: "token",
    name: "CC Compatible",
    providerSpecificData: {
      requestDefaults: {
        context1m: "yes",
        redactThinking: "yes",
        summarizeThinking: "yes",
      },
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      requestDefaults: {
        context1m: 1,
        redactThinking: 1,
        summarizeThinking: 1,
      },
    },
  });

  assert.equal(created.success, false);
  assert.equal(updated.success, false);
});

test("provider schemas accept Codex default priority and flex service tiers", () => {
  for (const serviceTier of ["default", "priority", "fast", "flex"]) {
    const created = createProviderSchema.safeParse({
      provider: "codex",
      apiKey: "token",
      name: "Codex",
      providerSpecificData: {
        requestDefaults: { serviceTier },
      },
    });
    const updated = updateProviderConnectionSchema.safeParse({
      providerSpecificData: {
        requestDefaults: { serviceTier },
      },
    });

    assert.equal(created.success, true, serviceTier);
    assert.equal(updated.success, true, serviceTier);
  }
});

test("provider schemas accept max but reject ultra as a server-side Codex default", () => {
  const max = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      requestDefaults: { reasoningEffort: "max" },
    },
  });
  const ultra = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      requestDefaults: { reasoningEffort: "ultra" },
    },
  });

  assert.equal(max.success, true);
  assert.equal(ultra.success, false);
});

test("provider schemas accept Codex fingerprint modes and reject unknown values", () => {
  for (const mode of ["off", "device", "session", "full"]) {
    const created = createProviderSchema.safeParse({
      provider: "codex",
      apiKey: "token",
      name: "Codex",
      providerSpecificData: { codexFingerprintMode: mode },
    });
    const updated = updateProviderConnectionSchema.safeParse({
      providerSpecificData: { codexFingerprintMode: mode },
    });
    assert.equal(created.success, true, mode);
    assert.equal(updated.success, true, mode);
  }

  const rejected = updateProviderConnectionSchema.safeParse({
    providerSpecificData: { codexFingerprintMode: "aggressive" },
  });
  assert.equal(rejected.success, false);
});

test("provider schemas reject unknown Codex service tiers", () => {
  const created = createProviderSchema.safeParse({
    provider: "codex",
    apiKey: "token",
    name: "Codex",
    providerSpecificData: {
      requestDefaults: { serviceTier: "turbo" },
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      requestDefaults: { serviceTier: "turbo" },
    },
  });

  assert.equal(created.success, false);
  assert.equal(updated.success, false);
});

test("provider schemas accept OpenRouter preset in providerSpecificData", () => {
  const created = createProviderSchema.safeParse({
    provider: "openrouter",
    apiKey: "token",
    name: "OpenRouter",
    providerSpecificData: {
      preset: "email-copywriter",
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      preset: "code-reviewer",
    },
  });
  const padded = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      preset: `${" ".repeat(120)}prefer${" ".repeat(120)}`,
    },
  });

  assert.equal(created.success, true);
  assert.equal(updated.success, true);
  assert.equal(padded.success, true);
});

test("provider schemas reject oversized OpenRouter preset values", () => {
  const created = createProviderSchema.safeParse({
    provider: "openrouter",
    apiKey: "token",
    name: "OpenRouter",
    providerSpecificData: {
      preset: "x".repeat(201),
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      preset: 123,
    },
  });

  assert.equal(created.success, false);
  assert.equal(updated.success, false);
});

test("provider schemas accept quota scraping provider-specific strings", () => {
  const created = createProviderSchema.safeParse({
    provider: "opencode-go",
    apiKey: "token",
    name: "OpenCode Go",
    providerSpecificData: {
      opencodeGoWorkspaceId: "workspace-123",
      opencodeGoAuthCookie: "auth=cookie-value",
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      ollamaCloudUsageCookie: "__Secure-session=cookie-value",
    },
  });

  assert.equal(created.success, true);
  assert.equal(updated.success, true);
});

test("provider schemas reject malformed quota scraping provider-specific values", () => {
  const created = createProviderSchema.safeParse({
    provider: "opencode-go",
    apiKey: "token",
    name: "OpenCode Go",
    providerSpecificData: {
      opencodeGoWorkspaceId: 123,
      opencodeGoAuthCookie: "x".repeat(10001),
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      ollamaCloudUsageCookie: 123,
    },
  });

  assert.equal(created.success, false);
  assert.equal(updated.success, false);
});

test("provider schemas accept GLM team quota provider-specific strings", () => {
  const created = createProviderSchema.safeParse({
    provider: "glm-cn",
    apiKey: "id.secret",
    name: "GLM CN Team",
    providerSpecificData: {
      glmOrganizationId: "org-team",
      glmProjectId: "proj_team",
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      glmOrganizationId: "org-team",
      glmProjectId: "proj_team",
    },
  });

  assert.equal(created.success, true);
  assert.equal(updated.success, true);
});

test("provider schemas reject incomplete GLM team quota provider-specific values", () => {
  const created = createProviderSchema.safeParse({
    provider: "glm-cn",
    apiKey: "id.secret",
    name: "GLM CN Team",
    providerSpecificData: {
      glmOrganizationId: "org-only",
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      glmProjectId: 123,
    },
  });

  assert.equal(created.success, false);
  assert.equal(updated.success, false);
});

test("provider schemas accept newApiAggregatorBalance boolean in providerSpecificData", () => {
  const created = createProviderSchema.safeParse({
    provider: "openai-compatible-chat-abc",
    apiKey: "token",
    name: "My Aggregator",
    providerSpecificData: {
      newApiAggregatorBalance: true,
      quotaPerUnit: 500000,
    },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: {
      newApiAggregatorBalance: false,
    },
  });

  assert.equal(created.success, true);
  assert.equal(updated.success, true);
});

test("provider schemas reject non-boolean newApiAggregatorBalance", () => {
  const created = createProviderSchema.safeParse({
    provider: "openai-compatible-chat-abc",
    apiKey: "token",
    name: "My Aggregator",
    providerSpecificData: {
      newApiAggregatorBalance: "yes",
    },
  });

  assert.equal(created.success, false);
});

test("provider schemas reject invalid quotaPerUnit values", () => {
  const zero = createProviderSchema.safeParse({
    provider: "openai-compatible-chat-abc",
    apiKey: "token",
    name: "My Aggregator",
    providerSpecificData: {
      quotaPerUnit: 0,
    },
  });
  const negative = createProviderSchema.safeParse({
    provider: "openai-compatible-chat-abc",
    apiKey: "token",
    name: "My Aggregator",
    providerSpecificData: {
      quotaPerUnit: -100,
    },
  });
  const string = createProviderSchema.safeParse({
    provider: "openai-compatible-chat-abc",
    apiKey: "token",
    name: "My Aggregator",
    providerSpecificData: {
      quotaPerUnit: "500000",
    },
  });

  assert.equal(zero.success, false);
  assert.equal(negative.success, false);
  assert.equal(string.success, false);
});

test("provider schemas accept integer timeoutMs in providerSpecificData", () => {
  const created = createProviderSchema.safeParse({
    provider: "openai",
    apiKey: "token",
    name: "OpenAI",
    providerSpecificData: { timeoutMs: 1_800_000 },
  });
  const updated = updateProviderConnectionSchema.safeParse({
    providerSpecificData: { timeoutMs: 900_000 },
  });
  assert.equal(created.success, true);
  assert.equal(updated.success, true);
});

test("provider schemas reject invalid timeoutMs values", () => {
  for (const bad of [-1, 0, 1.5, "60000", 86_400_001]) {
    const updated = updateProviderConnectionSchema.safeParse({
      providerSpecificData: { timeoutMs: bad },
    });
    assert.equal(updated.success, false, `timeoutMs=${String(bad)} must be rejected`);
  }
});