OmniRoute/tests/unit/proxy-registry.test.ts

import test from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";

const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-proxy-registry-"));
process.env.DATA_DIR = TEST_DATA_DIR;

const core = await import("../../src/lib/db/core.ts");
const providersDb = await import("../../src/lib/db/providers.ts");
const proxiesDb = await import("../../src/lib/db/proxies.ts");
const settingsDb = await import("../../src/lib/db/settings.ts");

async function resetStorage() {
  core.resetDbInstance();
  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
}

test.after(async () => {
  core.resetDbInstance();
  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
});

test("proxy registry blocks delete when proxy is still assigned", async () => {
  await resetStorage();

  const created = await proxiesDb.createProxy({
    name: "Delete Safety Proxy",
    type: "http",
    host: "127.0.0.1",
    port: 8080,
  });

  assert.ok(created?.id);
  await proxiesDb.assignProxyToScope("provider", "openai", created.id);

  await assert.rejects(
    async () => proxiesDb.deleteProxyById(created.id),
    (error) => {
      assert.equal((error as any).status, 409);
      (assert as any).equal((error as any).code, "proxy_in_use");
      return true;
    }
  );
});

test("registry assignment takes precedence over legacy proxy config", async () => {
  await resetStorage();

  const conn = await providersDb.createProviderConnection({
    provider: "openai",
    authType: "apikey",
    name: "registry-precedence",
    apiKey: "sk-test",
  });

  await settingsDb.setProxyForLevel("key", (conn as any).id, {
    type: "http",
    host: "legacy-key.local",
    port: 8080,
  });

  const providerProxy = await proxiesDb.createProxy({
    name: "Provider Proxy",
    type: "https",
    host: "provider.local",
    port: 443,
  });
  const accountProxy = await proxiesDb.createProxy({
    name: "Account Proxy",
    type: "http",
    host: "account.local",
    port: 8081,
  });

  await proxiesDb.assignProxyToScope("provider", "openai", providerProxy.id);
  await proxiesDb.assignProxyToScope("account", (conn as any).id, accountProxy.id);

  const resolved = await settingsDb.resolveProxyForConnection((conn as any).id);
  assert.equal(resolved.level, "account");
  assert.equal(resolved.source, "registry");
  assert.equal(resolved.proxy.host, "account.local");
});

test("legacy proxy config migration imports global/provider/key assignments", async () => {
  await resetStorage();

  const conn = await providersDb.createProviderConnection({
    provider: "openai",
    authType: "apikey",
    name: "legacy-import",
    apiKey: "sk-test-legacy",
  });

  await settingsDb.setProxyForLevel("global", null, {
    type: "http",
    host: "global.local",
    port: 8080,
  });
  await settingsDb.setProxyForLevel("provider", "openai", {
    type: "https",
    host: "provider-legacy.local",
    port: 443,
  });
  await settingsDb.setProxyForLevel("key", (conn as any).id, {
    type: "http",
    host: "account-legacy.local",
    port: 8082,
  });

  const result = await proxiesDb.migrateLegacyProxyConfigToRegistry();
  assert.equal(result.skipped, false);
  assert.equal(result.migrated >= 3, true);

  const resolved = await settingsDb.resolveProxyForConnection((conn as any).id);
  assert.equal(resolved.level, "account");
  assert.equal(resolved.source, "registry");
  assert.equal(resolved.proxy.host, "account-legacy.local");
});

// #2456: resolveProxyForProvider (used by the OAuth token exchange + token refresh,
// before any connection exists) only consulted the proxy registry. A proxy set the
// legacy way (/api/settings/proxy?level=provider) was ignored, so on a VPS the OAuth
// exchange went out direct and tripped Anthropic's IP rate limit. It must fall back to
// the legacy per-provider config, mirroring resolveProxyForConnection.
test("resolveProxyForProvider falls back to the legacy provider proxy config (#2456)", async () => {
  await resetStorage();

  await settingsDb.setProxyForLevel("provider", "claude", {
    type: "http",
    host: "legacy-claude-proxy.local",
    port: 3128,
  });

  // No proxy_registry assignment exists for "claude" — only the legacy config.
  const resolved = await proxiesDb.resolveProxyForProvider("claude");
  assert.ok(resolved, "expected the legacy provider proxy to be resolved");
  assert.equal((resolved as any).host, "legacy-claude-proxy.local");
  assert.equal((resolved as any).type, "http");
});

test("resolveProxyForProvider falls back to the legacy global proxy when no provider proxy (#2456)", async () => {
  await resetStorage();

  await settingsDb.setProxyForLevel("global", null, {
    type: "socks5",
    host: "legacy-global.local",
    port: 1080,
  });

  const resolved = await proxiesDb.resolveProxyForProvider("anthropic");
  assert.ok(resolved, "expected the legacy global proxy to be resolved");
  assert.equal((resolved as any).host, "legacy-global.local");
});

test("resolveProxyForProvider still prefers a registry assignment over legacy config (#2456)", async () => {
  await resetStorage();

  await settingsDb.setProxyForLevel("provider", "openai", {
    type: "http",
    host: "legacy-openai.local",
    port: 8080,
  });

  const registryProxy = await proxiesDb.createProxy({
    name: "Registry OpenAI",
    type: "https",
    host: "registry-openai.local",
    port: 443,
  });
  await proxiesDb.assignProxyToScope("provider", "openai", registryProxy.id);

  const resolved = await proxiesDb.resolveProxyForProvider("openai");
  assert.ok(resolved);
  assert.equal((resolved as any).host, "registry-openai.local", "registry assignment must win");
});

test("resolveProxyForProvider returns null when neither registry nor legacy config has a proxy (#2456)", async () => {
  await resetStorage();
  const resolved = await proxiesDb.resolveProxyForProvider("gemini");
  assert.equal(resolved, null);
});