wehub-resource-sync
1109 lines
41 KiB
TypeScript
1109 lines
41 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
const providerPageUtils =
|
|
await import("../../src/app/(dashboard)/dashboard/providers/providerPageUtils.ts");
|
|
const providerPageStorage =
|
|
await import("../../src/app/(dashboard)/dashboard/providers/providerPageStorage.ts");
|
|
const providers = await import("../../src/shared/constants/providers.ts");
|
|
const providerCatalog = await import("../../src/lib/providers/catalog.ts");
|
|
|
|
test("merged OAuth providers keep free-tier providers in the OAuth section", () => {
|
|
const statsCalls = [];
|
|
const getProviderStats = (providerId, authType) => {
|
|
statsCalls.push({ providerId, authType });
|
|
return { total: authType === "free" ? 1 : 0 };
|
|
};
|
|
|
|
const mockOauthProviders = { claude: { name: "Claude" } };
|
|
const mockFreeProviders = { qoder: { name: "Qoder" } };
|
|
|
|
const entries = providerPageUtils.buildMergedOAuthProviderEntries(
|
|
mockOauthProviders,
|
|
mockFreeProviders,
|
|
getProviderStats
|
|
);
|
|
|
|
const oauthIds = Object.keys(mockOauthProviders);
|
|
const freeIds = Object.keys(mockFreeProviders);
|
|
|
|
assert.deepEqual(
|
|
entries.slice(0, oauthIds.length).map((entry) => entry.providerId),
|
|
oauthIds
|
|
);
|
|
assert.deepEqual(
|
|
entries.slice(oauthIds.length).map((entry) => entry.providerId),
|
|
freeIds
|
|
);
|
|
|
|
const freeEntry = entries.find((entry) => entry.providerId === freeIds[0]);
|
|
assert.ok(freeEntry, "Should find the free entry");
|
|
assert.equal(freeEntry.displayAuthType, "oauth");
|
|
assert.equal(freeEntry.toggleAuthType, "free");
|
|
assert.equal(
|
|
statsCalls.some((call) => call.providerId === freeIds[0] && call.authType === "free"),
|
|
true
|
|
);
|
|
});
|
|
|
|
test("configured-only filter keeps only providers with saved connections", () => {
|
|
const entries = [
|
|
{
|
|
providerId: "claude",
|
|
provider: { id: "claude" },
|
|
stats: { total: 2 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
{
|
|
providerId: "codex",
|
|
provider: { id: "codex" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
{
|
|
providerId: "cursor",
|
|
provider: { id: "cursor" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
];
|
|
|
|
const visible = providerPageUtils.filterConfiguredProviderEntries(entries, true);
|
|
|
|
assert.deepEqual(
|
|
visible.map((entry) => entry.providerId),
|
|
["claude", "cursor"]
|
|
);
|
|
assert.equal(providerPageUtils.filterConfiguredProviderEntries(entries, false).length, 3);
|
|
});
|
|
|
|
test("configured-only filter keeps no-auth providers even without a saved connection (#3290)", () => {
|
|
const entries = [
|
|
{
|
|
providerId: "claude",
|
|
provider: { id: "claude" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
{
|
|
providerId: "opencode",
|
|
provider: { id: "opencode" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "no-auth",
|
|
toggleAuthType: "no-auth",
|
|
},
|
|
{
|
|
providerId: "duckduckgo-web",
|
|
provider: { id: "duckduckgo-web" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "no-auth",
|
|
toggleAuthType: "no-auth",
|
|
},
|
|
];
|
|
|
|
// no-auth providers never create a DB connection row (total === 0) but are
|
|
// always usable and appear in /v1/models — they must survive the filter.
|
|
const visible = providerPageUtils.filterConfiguredProviderEntries(entries, true);
|
|
assert.deepEqual(
|
|
visible.map((entry) => entry.providerId),
|
|
["duckduckgo-web", "opencode"]
|
|
);
|
|
});
|
|
|
|
test("compact provider entries dedupe providers and move no-auth entries to the end", () => {
|
|
const openRouterFromFree = {
|
|
providerId: "openrouter",
|
|
provider: { id: "openrouter", name: "OpenRouter" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "apikey",
|
|
toggleAuthType: "apikey",
|
|
};
|
|
const openRouterFromAggregator = {
|
|
providerId: "openrouter",
|
|
provider: { id: "openrouter", name: "OpenRouter" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "apikey",
|
|
toggleAuthType: "apikey",
|
|
};
|
|
const claude = {
|
|
providerId: "claude",
|
|
provider: { id: "claude", name: "Claude" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
};
|
|
const opencode = {
|
|
providerId: "opencode",
|
|
provider: { id: "opencode", name: "OpenCode" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "no-auth",
|
|
toggleAuthType: "no-auth",
|
|
};
|
|
|
|
const visible = providerPageUtils.buildCompactProviderEntries(
|
|
[[opencode, openRouterFromFree], [claude, openRouterFromAggregator], [opencode]],
|
|
{ deferNoAuth: true }
|
|
);
|
|
|
|
assert.deepEqual(
|
|
visible.map((entry) => entry.providerId),
|
|
["openrouter", "claude", "opencode"]
|
|
);
|
|
assert.equal(visible.filter((entry) => entry.providerId === "openrouter").length, 1);
|
|
});
|
|
|
|
test("compact provider entries prefer non-no-auth duplicates over deferred no-auth entries", () => {
|
|
const noAuthEntry = {
|
|
providerId: "opencode",
|
|
provider: { id: "opencode", name: "OpenCode" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "no-auth",
|
|
toggleAuthType: "no-auth",
|
|
};
|
|
const configuredEntry = {
|
|
providerId: "opencode",
|
|
provider: { id: "opencode", name: "OpenCode" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "apikey",
|
|
toggleAuthType: "apikey",
|
|
};
|
|
|
|
const visible = providerPageUtils.buildCompactProviderEntries(
|
|
[[noAuthEntry], [configuredEntry]],
|
|
{ deferNoAuth: true }
|
|
);
|
|
|
|
assert.equal(visible.length, 1);
|
|
assert.equal(visible[0].providerId, "opencode");
|
|
assert.equal(visible[0].displayAuthType, "apikey");
|
|
});
|
|
|
|
test("search filter matches provider name and id case-insensitively", () => {
|
|
const entries = [
|
|
{
|
|
providerId: "claude",
|
|
provider: { id: "claude", name: "Claude" },
|
|
stats: { total: 2 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
{
|
|
providerId: "openai",
|
|
provider: { id: "openai", name: "OpenAI" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
{
|
|
providerId: "gemini",
|
|
provider: { id: "gemini", name: "Google Gemini" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
];
|
|
|
|
const byName = providerPageUtils.filterConfiguredProviderEntries(entries, false, "claude");
|
|
assert.deepEqual(
|
|
byName.map((e) => e.providerId),
|
|
["claude"]
|
|
);
|
|
|
|
const byNameCaseInsensitive = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
"OPENAI"
|
|
);
|
|
assert.deepEqual(
|
|
byNameCaseInsensitive.map((e) => e.providerId),
|
|
["openai"]
|
|
);
|
|
|
|
const byPartialName = providerPageUtils.filterConfiguredProviderEntries(entries, false, "google");
|
|
assert.deepEqual(
|
|
byPartialName.map((e) => e.providerId),
|
|
["gemini"]
|
|
);
|
|
|
|
const byId = providerPageUtils.filterConfiguredProviderEntries(entries, false, "gem");
|
|
assert.deepEqual(
|
|
byId.map((e) => e.providerId),
|
|
["gemini"]
|
|
);
|
|
|
|
const noMatch = providerPageUtils.filterConfiguredProviderEntries(entries, false, "xyz");
|
|
assert.equal(noMatch.length, 0);
|
|
|
|
const emptySearch = providerPageUtils.filterConfiguredProviderEntries(entries, false, "");
|
|
assert.equal(emptySearch.length, 3);
|
|
|
|
const whitespaceSearch = providerPageUtils.filterConfiguredProviderEntries(entries, false, " ");
|
|
assert.equal(whitespaceSearch.length, 3);
|
|
});
|
|
|
|
test("search and configured-only filters work together", () => {
|
|
const entries = [
|
|
{
|
|
providerId: "claude",
|
|
provider: { id: "claude", name: "Claude" },
|
|
stats: { total: 2 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
{
|
|
providerId: "openai",
|
|
provider: { id: "openai", name: "OpenAI" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
{
|
|
providerId: "gemini",
|
|
provider: { id: "gemini", name: "Google Gemini" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "oauth",
|
|
toggleAuthType: "oauth",
|
|
},
|
|
];
|
|
|
|
const configuredAndSearched = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
true,
|
|
"claude"
|
|
);
|
|
assert.deepEqual(
|
|
configuredAndSearched.map((e) => e.providerId),
|
|
["claude"]
|
|
);
|
|
|
|
const configuredButNoMatch = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
true,
|
|
"openai"
|
|
);
|
|
assert.equal(configuredButNoMatch.length, 0);
|
|
});
|
|
|
|
test("configured-only preference parser only enables explicit true values", () => {
|
|
assert.equal(providerPageStorage.parseConfiguredOnlyPreference("true"), true);
|
|
assert.equal(providerPageStorage.parseConfiguredOnlyPreference("false"), false);
|
|
assert.equal(providerPageStorage.parseConfiguredOnlyPreference(null), false);
|
|
assert.equal(providerPageStorage.parseConfiguredOnlyPreference(undefined), false);
|
|
});
|
|
|
|
test("provider display mode preference parser accepts only known modes", () => {
|
|
assert.equal(providerPageStorage.parseProviderDisplayModePreference("all"), "all");
|
|
assert.equal(providerPageStorage.parseProviderDisplayModePreference("configured"), "configured");
|
|
assert.equal(providerPageStorage.parseProviderDisplayModePreference("compact"), "compact");
|
|
assert.equal(providerPageStorage.parseProviderDisplayModePreference("true"), null);
|
|
assert.equal(providerPageStorage.parseProviderDisplayModePreference(null), null);
|
|
});
|
|
|
|
test("configured-only filter is ignored before the first provider is connected", () => {
|
|
assert.equal(providerPageUtils.shouldApplyConfiguredOnlyFilter(true, 0), false);
|
|
assert.equal(providerPageUtils.shouldApplyConfiguredOnlyFilter(false, 0), false);
|
|
assert.equal(providerPageUtils.shouldApplyConfiguredOnlyFilter(true, 1), true);
|
|
});
|
|
|
|
test("compact display mode always uses the configured provider set", () => {
|
|
assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("all", 0), false);
|
|
assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("all", 2), false);
|
|
assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("configured", 0), false);
|
|
assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("configured", 2), true);
|
|
assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("compact", 0), true);
|
|
assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("compact", 2), true);
|
|
});
|
|
|
|
test("first-provider hint is shown only when no providers are connected and search is empty", () => {
|
|
assert.equal(providerPageUtils.shouldShowFirstProviderHint(0, ""), true);
|
|
assert.equal(providerPageUtils.shouldShowFirstProviderHint(0, " "), true);
|
|
assert.equal(providerPageUtils.shouldShowFirstProviderHint(0, "codex"), false);
|
|
assert.equal(providerPageUtils.shouldShowFirstProviderHint(1, ""), false);
|
|
});
|
|
|
|
test("configured-only preference storage round-trips correctly", () => {
|
|
const storage = new Map();
|
|
const mockStorage = {
|
|
getItem(key) {
|
|
return storage.has(key) ? storage.get(key) : null;
|
|
},
|
|
setItem(key, value) {
|
|
storage.set(key, value);
|
|
},
|
|
removeItem(key) {
|
|
storage.delete(key);
|
|
},
|
|
};
|
|
|
|
assert.equal(providerPageStorage.readConfiguredOnlyPreference(mockStorage), false);
|
|
|
|
providerPageStorage.writeConfiguredOnlyPreference(true, mockStorage);
|
|
assert.equal(storage.get(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY), "true");
|
|
assert.equal(providerPageStorage.readConfiguredOnlyPreference(mockStorage), true);
|
|
|
|
providerPageStorage.writeConfiguredOnlyPreference(false, mockStorage);
|
|
assert.equal(storage.has(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY), false);
|
|
assert.equal(providerPageStorage.readConfiguredOnlyPreference(mockStorage), false);
|
|
});
|
|
|
|
test("provider display mode storage round-trips and migrates the old configured-only key", () => {
|
|
const storage = new Map();
|
|
const mockStorage = {
|
|
getItem(key) {
|
|
return storage.has(key) ? storage.get(key) : null;
|
|
},
|
|
setItem(key, value) {
|
|
storage.set(key, value);
|
|
},
|
|
removeItem(key) {
|
|
storage.delete(key);
|
|
},
|
|
};
|
|
|
|
assert.equal(providerPageStorage.readProviderDisplayModePreference(mockStorage), "all");
|
|
|
|
storage.set(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY, "true");
|
|
assert.equal(providerPageStorage.readProviderDisplayModePreference(mockStorage), "configured");
|
|
assert.equal(storage.get(providerPageStorage.PROVIDER_DISPLAY_MODE_STORAGE_KEY), "configured");
|
|
assert.equal(storage.has(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY), false);
|
|
|
|
providerPageStorage.writeProviderDisplayModePreference("compact", mockStorage);
|
|
assert.equal(storage.get(providerPageStorage.PROVIDER_DISPLAY_MODE_STORAGE_KEY), "compact");
|
|
assert.equal(storage.has(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY), false);
|
|
assert.equal(providerPageStorage.readProviderDisplayModePreference(mockStorage), "compact");
|
|
|
|
providerPageStorage.writeProviderDisplayModePreference("all", mockStorage);
|
|
assert.equal(storage.has(providerPageStorage.PROVIDER_DISPLAY_MODE_STORAGE_KEY), false);
|
|
assert.equal(providerPageStorage.readProviderDisplayModePreference(mockStorage), "all");
|
|
});
|
|
|
|
test("static catalog entries resolve local, search, audio, web-cookie and upstream providers", () => {
|
|
const freeProvider = providerPageUtils.resolveDashboardProviderInfo("amazon-q");
|
|
const localProvider = providerPageUtils.resolveDashboardProviderInfo("sdwebui");
|
|
const localChatProvider = providerPageUtils.resolveDashboardProviderInfo("lm-studio");
|
|
const lemonadeProvider = providerPageUtils.resolveDashboardProviderInfo("lemonade");
|
|
const searchProvider = providerPageUtils.resolveDashboardProviderInfo("brave-search");
|
|
const youcomSearchProvider = providerPageUtils.resolveDashboardProviderInfo("youcom-search");
|
|
const audioProvider = providerPageUtils.resolveDashboardProviderInfo("assemblyai");
|
|
const awsPollyProvider = providerPageUtils.resolveDashboardProviderInfo("aws-polly");
|
|
const webCookieProvider = providerPageUtils.resolveDashboardProviderInfo("grok-web");
|
|
const apiKeyProvider = providerPageUtils.resolveDashboardProviderInfo("glhf");
|
|
const gitlabProvider = providerPageUtils.resolveDashboardProviderInfo("gitlab");
|
|
const gitlabDuoProvider = providerPageUtils.resolveDashboardProviderInfo("gitlab-duo");
|
|
const chutesProvider = providerPageUtils.resolveDashboardProviderInfo("chutes");
|
|
const datarobotProvider = providerPageUtils.resolveDashboardProviderInfo("datarobot");
|
|
const clarifaiProvider = providerPageUtils.resolveDashboardProviderInfo("clarifai");
|
|
const empowerProvider = providerPageUtils.resolveDashboardProviderInfo("empower");
|
|
const nousProvider = providerPageUtils.resolveDashboardProviderInfo("nous-research");
|
|
const poeProvider = providerPageUtils.resolveDashboardProviderInfo("poe");
|
|
const azureOpenAiProvider = providerPageUtils.resolveDashboardProviderInfo("azure-openai");
|
|
const azureAiProvider = providerPageUtils.resolveDashboardProviderInfo("azure-ai");
|
|
const watsonxProvider = providerPageUtils.resolveDashboardProviderInfo("watsonx");
|
|
const ociProvider = providerPageUtils.resolveDashboardProviderInfo("oci");
|
|
const sapProvider = providerPageUtils.resolveDashboardProviderInfo("sap");
|
|
const modalProvider = providerPageUtils.resolveDashboardProviderInfo("modal");
|
|
const rekaProvider = providerPageUtils.resolveDashboardProviderInfo("reka");
|
|
const nlpCloudProvider = providerPageUtils.resolveDashboardProviderInfo("nlpcloud");
|
|
const runwayProvider = providerPageUtils.resolveDashboardProviderInfo("runwayml");
|
|
const embeddingProvider = providerPageUtils.resolveDashboardProviderInfo("voyage-ai");
|
|
const rerankProvider = providerPageUtils.resolveDashboardProviderInfo("jina-ai");
|
|
const perplexityWebProvider = providerPageUtils.resolveDashboardProviderInfo("perplexity-web");
|
|
const blackboxWebProvider = providerPageUtils.resolveDashboardProviderInfo("blackbox-web");
|
|
const museSparkWebProvider = providerPageUtils.resolveDashboardProviderInfo("muse-spark-web");
|
|
const upstreamProvider = providerPageUtils.resolveDashboardProviderInfo("cliproxyapi");
|
|
|
|
assert.equal(freeProvider?.category, "oauth");
|
|
assert.equal(freeProvider?.name, providers.OAUTH_PROVIDERS["amazon-q"].name);
|
|
|
|
assert.equal(localProvider?.category, "local");
|
|
assert.equal(localProvider?.name, providers.LOCAL_PROVIDERS.sdwebui.name);
|
|
assert.equal(localChatProvider?.category, "local");
|
|
assert.equal(localChatProvider?.name, providers.LOCAL_PROVIDERS["lm-studio"].name);
|
|
assert.equal(lemonadeProvider?.category, "local");
|
|
assert.equal(lemonadeProvider?.name, providers.LOCAL_PROVIDERS.lemonade.name);
|
|
|
|
assert.equal(searchProvider?.category, "search");
|
|
assert.equal(searchProvider?.name, providers.SEARCH_PROVIDERS["brave-search"].name);
|
|
assert.equal(youcomSearchProvider?.category, "search");
|
|
assert.equal(youcomSearchProvider?.name, providers.SEARCH_PROVIDERS["youcom-search"].name);
|
|
|
|
assert.equal(audioProvider?.category, "audio");
|
|
assert.equal(audioProvider?.name, providers.AUDIO_ONLY_PROVIDERS.assemblyai.name);
|
|
assert.equal(awsPollyProvider?.category, "audio");
|
|
assert.equal(awsPollyProvider?.name, providers.AUDIO_ONLY_PROVIDERS["aws-polly"].name);
|
|
|
|
assert.equal(apiKeyProvider?.category, "apikey");
|
|
assert.equal(apiKeyProvider?.name, providers.APIKEY_PROVIDERS.glhf.name);
|
|
assert.equal(gitlabProvider?.category, "apikey");
|
|
assert.equal(gitlabProvider?.name, providers.APIKEY_PROVIDERS.gitlab.name);
|
|
assert.equal(gitlabDuoProvider?.category, "oauth");
|
|
assert.equal(gitlabDuoProvider?.name, providers.OAUTH_PROVIDERS["gitlab-duo"].name);
|
|
assert.equal(chutesProvider?.category, "apikey");
|
|
assert.equal(chutesProvider?.name, providers.APIKEY_PROVIDERS.chutes.name);
|
|
assert.equal(datarobotProvider?.category, "apikey");
|
|
assert.equal(datarobotProvider?.name, providers.APIKEY_PROVIDERS.datarobot.name);
|
|
assert.equal(clarifaiProvider?.category, "apikey");
|
|
assert.equal(clarifaiProvider?.name, providers.APIKEY_PROVIDERS.clarifai.name);
|
|
assert.equal(empowerProvider?.category, "apikey");
|
|
assert.equal(empowerProvider?.name, providers.APIKEY_PROVIDERS.empower.name);
|
|
assert.equal(nousProvider?.category, "apikey");
|
|
assert.equal(nousProvider?.name, providers.APIKEY_PROVIDERS["nous-research"].name);
|
|
assert.equal(poeProvider?.category, "apikey");
|
|
assert.equal(poeProvider?.name, providers.APIKEY_PROVIDERS.poe.name);
|
|
assert.equal(azureOpenAiProvider?.category, "apikey");
|
|
assert.equal(azureOpenAiProvider?.name, providers.APIKEY_PROVIDERS["azure-openai"].name);
|
|
assert.equal(azureAiProvider?.category, "apikey");
|
|
assert.equal(azureAiProvider?.name, providers.APIKEY_PROVIDERS["azure-ai"].name);
|
|
assert.equal(watsonxProvider?.category, "apikey");
|
|
assert.equal(watsonxProvider?.name, providers.APIKEY_PROVIDERS.watsonx.name);
|
|
assert.equal(ociProvider?.category, "apikey");
|
|
assert.equal(ociProvider?.name, providers.APIKEY_PROVIDERS.oci.name);
|
|
assert.equal(sapProvider?.category, "apikey");
|
|
assert.equal(sapProvider?.name, providers.APIKEY_PROVIDERS.sap.name);
|
|
assert.equal(modalProvider?.category, "apikey");
|
|
assert.equal(modalProvider?.name, providers.APIKEY_PROVIDERS.modal.name);
|
|
assert.equal(rekaProvider?.category, "apikey");
|
|
assert.equal(rekaProvider?.name, providers.APIKEY_PROVIDERS.reka.name);
|
|
assert.equal(nlpCloudProvider?.category, "apikey");
|
|
assert.equal(nlpCloudProvider?.name, providers.APIKEY_PROVIDERS.nlpcloud.name);
|
|
assert.equal(runwayProvider?.category, "apikey");
|
|
assert.equal(runwayProvider?.name, providers.APIKEY_PROVIDERS.runwayml.name);
|
|
|
|
assert.equal(embeddingProvider?.category, "apikey");
|
|
assert.equal(embeddingProvider?.name, providers.APIKEY_PROVIDERS["voyage-ai"].name);
|
|
|
|
assert.equal(rerankProvider?.category, "apikey");
|
|
assert.equal(rerankProvider?.name, providers.APIKEY_PROVIDERS["jina-ai"].name);
|
|
|
|
assert.equal(webCookieProvider?.category, "web-cookie");
|
|
assert.equal(webCookieProvider?.name, providers.WEB_COOKIE_PROVIDERS["grok-web"].name);
|
|
|
|
assert.equal(perplexityWebProvider?.category, "web-cookie");
|
|
assert.equal(perplexityWebProvider?.name, providers.WEB_COOKIE_PROVIDERS["perplexity-web"].name);
|
|
|
|
assert.equal(blackboxWebProvider?.category, "web-cookie");
|
|
assert.equal(blackboxWebProvider?.name, providers.WEB_COOKIE_PROVIDERS["blackbox-web"].name);
|
|
|
|
assert.equal(museSparkWebProvider?.category, "web-cookie");
|
|
assert.equal(museSparkWebProvider?.name, providers.WEB_COOKIE_PROVIDERS["muse-spark-web"].name);
|
|
|
|
assert.equal(upstreamProvider?.category, "upstream-proxy");
|
|
assert.equal(
|
|
upstreamProvider?.name,
|
|
providerCatalog.STATIC_PROVIDER_CATALOG_GROUPS["upstream-proxy"].providers.cliproxyapi.name
|
|
);
|
|
});
|
|
|
|
test("managed provider connection ids include supported static categories and exclude upstream proxy", () => {
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("qoder"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("glhf"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("gitlab"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("cablyai"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("thebai"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("fenayai"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("chutes"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("datarobot"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("clarifai"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("empower"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("nous-research"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("poe"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("azure-openai"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("azure-ai"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("bedrock"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("watsonx"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("oci"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("sap"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("modal"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("reka"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("nlpcloud"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("runwayml"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("voyage-ai"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("jina-ai"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("sdwebui"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("lm-studio"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("vllm"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("lemonade"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("assemblyai"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("aws-polly"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("grok-web"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("perplexity-web"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("blackbox-web"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("muse-spark-web"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("brave-search"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("youcom-search"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("cliproxyapi"), false);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("claude"), false);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("jules"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("devin"), true);
|
|
assert.equal(providerCatalog.isManagedProviderConnectionId("codex-cloud"), true);
|
|
});
|
|
|
|
test("grok-web taxonomy stays web-cookie only and does not leak into api-key entries", () => {
|
|
assert.equal("grok-web" in providers.APIKEY_PROVIDERS, false);
|
|
assert.equal("grok-web" in providers.WEB_COOKIE_PROVIDERS, true);
|
|
assert.equal("sdwebui" in providers.APIKEY_PROVIDERS, false);
|
|
assert.equal("sdwebui" in providers.LOCAL_PROVIDERS, true);
|
|
assert.equal("lm-studio" in providers.APIKEY_PROVIDERS, false);
|
|
assert.equal("lm-studio" in providers.LOCAL_PROVIDERS, true);
|
|
assert.equal("vllm" in providers.APIKEY_PROVIDERS, false);
|
|
assert.equal("vllm" in providers.LOCAL_PROVIDERS, true);
|
|
assert.equal("lemonade" in providers.APIKEY_PROVIDERS, false);
|
|
assert.equal("lemonade" in providers.LOCAL_PROVIDERS, true);
|
|
assert.equal("comfyui" in providers.APIKEY_PROVIDERS, false);
|
|
assert.equal("comfyui" in providers.LOCAL_PROVIDERS, true);
|
|
assert.equal("blackbox-web" in providers.APIKEY_PROVIDERS, false);
|
|
assert.equal("blackbox-web" in providers.WEB_COOKIE_PROVIDERS, true);
|
|
assert.equal("muse-spark-web" in providers.APIKEY_PROVIDERS, false);
|
|
assert.equal("muse-spark-web" in providers.WEB_COOKIE_PROVIDERS, true);
|
|
assert.equal("glhf" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("gitlab" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("gitlab-duo" in providers.OAUTH_PROVIDERS, true);
|
|
assert.equal("cablyai" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("thebai" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("fenayai" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("chutes" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("datarobot" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("clarifai" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("empower" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("nous-research" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("poe" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("azure-ai" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("bedrock" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("watsonx" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("oci" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("sap" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("modal" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("reka" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("nlpcloud" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("runwayml" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("voyage-ai" in providers.APIKEY_PROVIDERS, true);
|
|
assert.equal("jina-ai" in providers.APIKEY_PROVIDERS, true);
|
|
|
|
const apiKeyEntries = providerPageUtils.buildStaticProviderEntries("apikey", () => ({
|
|
total: 0,
|
|
}));
|
|
const localEntries = providerPageUtils.buildStaticProviderEntries("local", () => ({
|
|
total: 0,
|
|
}));
|
|
const webCookieEntries = providerPageUtils.buildStaticProviderEntries("web-cookie", () => ({
|
|
total: 0,
|
|
}));
|
|
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "sdwebui"),
|
|
false
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "comfyui"),
|
|
false
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "lm-studio"),
|
|
false
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "vllm"),
|
|
false
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "lemonade"),
|
|
false
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "grok-web"),
|
|
false
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "glhf"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "gitlab"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "cablyai"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "thebai"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "fenayai"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "chutes"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "datarobot"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "clarifai"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "empower"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "nous-research"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "poe"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "azure-ai"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "bedrock"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "watsonx"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "oci"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "sap"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "modal"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "reka"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "nlpcloud"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "runwayml"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "voyage-ai"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
apiKeyEntries.some((entry) => entry.providerId === "jina-ai"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
localEntries.some((entry) => entry.providerId === "sdwebui"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
localEntries.some((entry) => entry.providerId === "comfyui"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
localEntries.some((entry) => entry.providerId === "lm-studio"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
localEntries.some((entry) => entry.providerId === "vllm"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
localEntries.some((entry) => entry.providerId === "lemonade"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
webCookieEntries.some((entry) => entry.providerId === "grok-web"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
webCookieEntries.some((entry) => entry.providerId === "blackbox-web"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
webCookieEntries.some((entry) => entry.providerId === "muse-spark-web"),
|
|
true
|
|
);
|
|
});
|
|
|
|
test("compatible catalog entries keep dynamic compatible metadata", () => {
|
|
const compatibleProvider = providerPageUtils.resolveDashboardProviderInfo(
|
|
"openai-compatible-lab",
|
|
{
|
|
providerNode: {
|
|
id: "openai-compatible-lab",
|
|
type: "openai-compatible",
|
|
apiType: "responses",
|
|
baseUrl: "https://example.test",
|
|
iconUrl: "https://cdn.example.com/icons/lab.png",
|
|
},
|
|
compatibleLabels: {
|
|
ccCompatibleName: "CC Compatible",
|
|
anthropicCompatibleName: "Anthropic Compatible",
|
|
openAiCompatibleName: "OpenAI Compatible",
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.equal(compatibleProvider?.category, "compatible");
|
|
assert.equal(compatibleProvider?.displayAuthType, "compatible");
|
|
assert.equal(compatibleProvider?.toggleAuthType, "apikey");
|
|
assert.equal(compatibleProvider?.apiType, "responses");
|
|
assert.equal(compatibleProvider?.baseUrl, "https://example.test");
|
|
// #2166: custom remote icon URL passthrough.
|
|
assert.equal(compatibleProvider?.iconUrl, "https://cdn.example.com/icons/lab.png");
|
|
});
|
|
|
|
test("model search filter matches providers by model id", async () => {
|
|
const { getModelsByProviderId } = await import("../../src/shared/constants/models.ts");
|
|
|
|
const entries = [
|
|
{
|
|
providerId: "trae",
|
|
provider: { name: "Trae" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "oauth" as const,
|
|
toggleAuthType: "oauth" as const,
|
|
},
|
|
{
|
|
providerId: "openai",
|
|
provider: { name: "OpenAI" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "apikey" as const,
|
|
toggleAuthType: "apikey" as const,
|
|
},
|
|
{
|
|
providerId: "minimax",
|
|
provider: { name: "MiniMax" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "apikey" as const,
|
|
toggleAuthType: "apikey" as const,
|
|
},
|
|
{
|
|
providerId: "nonexistent-provider-xyz",
|
|
provider: { name: "No Models" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "apikey" as const,
|
|
toggleAuthType: "apikey" as const,
|
|
},
|
|
];
|
|
|
|
// "minimax-m3" model id exists in trae, opencode, bazaarlink, cerebras
|
|
const byModelId = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
undefined,
|
|
undefined,
|
|
"minimax-m3"
|
|
);
|
|
const matchedIds = byModelId.map((e) => e.providerId);
|
|
assert.ok(matchedIds.includes("trae"), "trae should match minimax-m3 by model id");
|
|
assert.ok(!matchedIds.includes("openai"), "openai should not match minimax-m3");
|
|
|
|
// "MiniMax-M3" model id exists in minimax provider itself (different casing)
|
|
// getModelsByProviderId("minimax") should include MiniMax-M3
|
|
const minimaxModels = getModelsByProviderId("minimax");
|
|
const hasMinimaxM3 = minimaxModels.some((m) => m.id === "MiniMax-M3");
|
|
if (hasMinimaxM3) {
|
|
const byMinimaxM3 = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
undefined,
|
|
undefined,
|
|
"MiniMax-M3"
|
|
);
|
|
assert.ok(
|
|
byMinimaxM3.map((e) => e.providerId).includes("minimax"),
|
|
"minimax should match MiniMax-M3 by model id"
|
|
);
|
|
}
|
|
|
|
// Provider with no models shouldn't match
|
|
const byNonexistentModel = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
undefined,
|
|
undefined,
|
|
"model-that-does-not-exist"
|
|
);
|
|
assert.equal(byNonexistentModel.length, 0);
|
|
|
|
// Empty model search returns all
|
|
const byEmptyModel = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
undefined,
|
|
undefined,
|
|
""
|
|
);
|
|
assert.equal(byEmptyModel.length, entries.length);
|
|
|
|
// Whitespace-only model search returns all
|
|
const byWhitespaceModel = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
undefined,
|
|
undefined,
|
|
" "
|
|
);
|
|
assert.equal(byWhitespaceModel.length, entries.length);
|
|
});
|
|
|
|
test("model search filter matches by model name", () => {
|
|
const entries = [
|
|
{
|
|
providerId: "minimax",
|
|
provider: { name: "MiniMax" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "apikey" as const,
|
|
toggleAuthType: "apikey" as const,
|
|
},
|
|
{
|
|
providerId: "openai",
|
|
provider: { name: "OpenAI" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "apikey" as const,
|
|
toggleAuthType: "apikey" as const,
|
|
},
|
|
];
|
|
|
|
// "MiniMax M3" is the model name for the MiniMax provider's MiniMax-M3 model
|
|
const byName = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
undefined,
|
|
undefined,
|
|
"MiniMax M3"
|
|
);
|
|
assert.ok(
|
|
byName.map((e) => e.providerId).includes("minimax"),
|
|
"minimax should match by model name 'MiniMax M3'"
|
|
);
|
|
assert.ok(
|
|
!byName.map((e) => e.providerId).includes("openai"),
|
|
"openai should not match 'MiniMax M3'"
|
|
);
|
|
});
|
|
|
|
test("model search filter combines with configured-only and text search", () => {
|
|
const entries = [
|
|
{
|
|
providerId: "trae",
|
|
provider: { name: "Trae" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "oauth" as const,
|
|
toggleAuthType: "oauth" as const,
|
|
},
|
|
{
|
|
providerId: "opencode",
|
|
provider: { name: "OpenCode" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "no-auth" as const,
|
|
toggleAuthType: "no-auth" as const,
|
|
},
|
|
{
|
|
providerId: "minimax",
|
|
provider: { name: "MiniMax" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "apikey" as const,
|
|
toggleAuthType: "apikey" as const,
|
|
},
|
|
{
|
|
providerId: "openai",
|
|
provider: { name: "OpenAI" },
|
|
stats: { total: 1 },
|
|
displayAuthType: "apikey" as const,
|
|
toggleAuthType: "apikey" as const,
|
|
},
|
|
];
|
|
|
|
// Model filter + configured-only: only configured providers with minimax-m3
|
|
const modelAndConfigured = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
true,
|
|
undefined,
|
|
undefined,
|
|
"minimax-m3"
|
|
);
|
|
const modelAndConfigIds = modelAndConfigured.map((e) => e.providerId);
|
|
// trae has minimax-m3 AND is configured (total > 0)
|
|
assert.ok(modelAndConfigIds.includes("trae"), "configured trae should match minimax-m3");
|
|
// opencode has minimax-m3 but is no-auth (always visible regardless of configured filter)
|
|
// bazaarlink is not in our test entries
|
|
assert.ok(
|
|
!modelAndConfigIds.includes("openai"),
|
|
"openai should not match minimax-m3 model filter"
|
|
);
|
|
|
|
// Model filter + text search: both must match (AND logic)
|
|
const modelAndSearch = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
"Trae",
|
|
undefined,
|
|
"minimax-m3"
|
|
);
|
|
assert.deepEqual(
|
|
modelAndSearch.map((e) => e.providerId),
|
|
["trae"],
|
|
"only trae matches both search 'Trae' AND model 'minimax-m3'"
|
|
);
|
|
|
|
// Model filter that matches nothing with valid text search
|
|
const noModelMatch = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
undefined,
|
|
undefined,
|
|
"nonexistent-model-xyz"
|
|
);
|
|
assert.equal(noModelMatch.length, 0);
|
|
});
|
|
|
|
test("model search filter is case-insensitive and partial-match", () => {
|
|
const entries = [
|
|
{
|
|
providerId: "trae",
|
|
provider: { name: "Trae" },
|
|
stats: { total: 0 },
|
|
displayAuthType: "oauth" as const,
|
|
toggleAuthType: "oauth" as const,
|
|
},
|
|
];
|
|
|
|
// Case insensitive
|
|
const byUppercase = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
undefined,
|
|
undefined,
|
|
"MINIMAX-M3"
|
|
);
|
|
assert.equal(byUppercase.length, 1, "model search should be case-insensitive");
|
|
|
|
// Partial match
|
|
const byPartial = providerPageUtils.filterConfiguredProviderEntries(
|
|
entries,
|
|
false,
|
|
undefined,
|
|
undefined,
|
|
"minimax"
|
|
);
|
|
assert.equal(byPartial.length, 1, "partial model id 'minimax' should match 'minimax-m3'");
|
|
});
|
|
|
|
// #4613: buildCompatibleProviderGroups partitions provider nodes into the
|
|
// openai-compatible / anthropic-compatible / claude-code-compatible buckets the
|
|
// providers page renders. The memoization in page.tsx wraps this pure helper, so
|
|
// guarding the partition logic here is the regression that matters (Rule #18).
|
|
test("buildCompatibleProviderGroups partitions nodes by type + claude-code prefix", () => {
|
|
const labels = {
|
|
openaiCompatibleName: "OpenAI-compatible",
|
|
anthropicCompatibleName: "Anthropic-compatible",
|
|
claudeCodeCompatibleName: "Claude Code-compatible",
|
|
};
|
|
|
|
const groups = providerPageUtils.buildCompatibleProviderGroups(
|
|
[
|
|
{
|
|
id: "my-oai",
|
|
name: "My OAI",
|
|
type: "openai-compatible",
|
|
apiType: "responses",
|
|
iconUrl: "https://cdn.example.com/icons/my-oai.png",
|
|
},
|
|
{ id: "my-anthropic", name: "My Claude", type: "anthropic-compatible" },
|
|
{ id: "anthropic-compatible-cc-acme", name: "Acme CC", type: "anthropic-compatible" },
|
|
{ id: "ignored-node", name: "Ignored", type: "unsupported-provider" },
|
|
// name omitted → falls back to the provided label
|
|
{ id: "anon-oai", type: "openai-compatible" },
|
|
],
|
|
labels
|
|
);
|
|
|
|
assert.deepEqual(
|
|
groups.openai.map((p) => p.id),
|
|
["my-oai", "anon-oai"],
|
|
"openai-compatible nodes land in the openai bucket"
|
|
);
|
|
assert.equal(groups.openai[0].apiType, "responses", "apiType is preserved");
|
|
assert.equal(
|
|
groups.openai[1].name,
|
|
labels.openaiCompatibleName,
|
|
"missing name falls back to the openai-compatible label"
|
|
);
|
|
|
|
// #2166: custom remote icon URL passthrough.
|
|
assert.equal(
|
|
groups.openai[0].iconUrl,
|
|
"https://cdn.example.com/icons/my-oai.png",
|
|
"iconUrl is preserved for nodes that set it"
|
|
);
|
|
assert.equal(groups.openai[1].iconUrl, undefined, "iconUrl is undefined when the node has none");
|
|
|
|
assert.deepEqual(
|
|
groups.anthropic.map((p) => p.id),
|
|
["my-anthropic"],
|
|
"plain anthropic-compatible nodes land in the anthropic bucket"
|
|
);
|
|
|
|
assert.deepEqual(
|
|
groups.claudeCode.map((p) => p.id),
|
|
["anthropic-compatible-cc-acme"],
|
|
"anthropic-compatible nodes with the cc- prefix land in the claudeCode bucket"
|
|
);
|
|
});
|
|
|
|
test("connectionMatchesProviderCard counts a dual-auth provider's PAT (apikey) connection on its OAuth card", () => {
|
|
const { connectionMatchesProviderCard } = providerPageUtils;
|
|
|
|
// qoder is OAuth-categorized but its working auth is a PAT (authType "apikey").
|
|
// Regression: the OAuth card must count the PAT connection, else the dashboard
|
|
// shows a connected qoder as "not connected".
|
|
assert.equal(
|
|
connectionMatchesProviderCard({ provider: "qoder", authType: "apikey" }, "qoder", "oauth"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
connectionMatchesProviderCard({ provider: "qoder", authType: "oauth" }, "qoder", "oauth"),
|
|
true
|
|
);
|
|
|
|
// A normal OAuth-only provider must NOT count an apikey connection on its OAuth card.
|
|
assert.equal(
|
|
connectionMatchesProviderCard({ provider: "claude", authType: "apikey" }, "claude", "oauth"),
|
|
false
|
|
);
|
|
assert.equal(
|
|
connectionMatchesProviderCard({ provider: "claude", authType: "oauth" }, "claude", "oauth"),
|
|
true
|
|
);
|
|
|
|
// Provider mismatch and the "free" card (counts everything) behave as expected.
|
|
assert.equal(
|
|
connectionMatchesProviderCard({ provider: "openai", authType: "apikey" }, "qoder", "oauth"),
|
|
false
|
|
);
|
|
assert.equal(
|
|
connectionMatchesProviderCard({ provider: "qoder", authType: "apikey" }, "qoder", "free"),
|
|
true
|
|
);
|
|
|
|
// Defensive: a null/undefined connection must not throw (gemini-code-assist).
|
|
assert.equal(connectionMatchesProviderCard(null, "qoder", "oauth"), false);
|
|
assert.equal(connectionMatchesProviderCard(undefined, "qoder", "oauth"), false);
|
|
});
|