Skip to content

Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors

test: add model resolver, stream collector, gemini helper tests

oyi7757930bae9347
diff --git a/tests/unit/gemini-helper.test.ts b/tests/unit/gemini-helper.test.ts
new file mode 100644
index 0000000000..479a9d3fa9
--- /dev/null
+++ b/tests/unit/gemini-helper.test.ts
@@ -0,0 +1,132 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const gemini = await import("../../open-sse/translator/helpers/geminiHelper.ts");
+
+test("GEMINI_UNSUPPORTED_SCHEMA_KEYS is a Set", () => {
+ assert.ok(gemini.GEMINI_UNSUPPORTED_SCHEMA_KEYS instanceof Set);
+ assert.ok(gemini.GEMINI_UNSUPPORTED_SCHEMA_KEYS.size > 0);
+});
+
+test("UNSUPPORTED_SCHEMA_CONSTRAINTS is an array", () => {
+ assert.ok(Array.isArray(gemini.UNSUPPORTED_SCHEMA_CONSTRAINTS));
+ assert.ok(gemini.UNSUPPORTED_SCHEMA_CONSTRAINTS.length > 0);
+});
+
+test("DEFAULT_SAFETY_SETTINGS is an array", () => {
+ assert.ok(Array.isArray(gemini.DEFAULT_SAFETY_SETTINGS));
+ assert.ok(gemini.DEFAULT_SAFETY_SETTINGS.length > 0);
+});
+
+test("tryParseJSON parses valid JSON", () => {
+ assert.deepEqual(gemini.tryParseJSON('{"a":1}'), { a: 1 });
+ assert.deepEqual(gemini.tryParseJSON('[1,2,3]'), [1, 2, 3]);
+ assert.equal(gemini.tryParseJSON('"hello"'), "hello");
+ assert.equal(gemini.tryParseJSON("42"), 42);
+ assert.equal(gemini.tryParseJSON("true"), true);
+ assert.equal(gemini.tryParseJSON("null"), null);
+});
+
+test("tryParseJSON returns null for invalid JSON", () => {
+ assert.equal(gemini.tryParseJSON("not json"), null);
+ assert.equal(gemini.tryParseJSON("{broken}"), null);
+ assert.equal(gemini.tryParseJSON(""), null);
+});
+
+test("tryParseJSON returns input for non-string types", () => {
+ assert.equal(gemini.tryParseJSON(null), null);
+ assert.equal(gemini.tryParseJSON(123), 123);
+});
+
+test("extractTextContent extracts string content", () => {
+ assert.equal(gemini.extractTextContent("hello world"), "hello world");
+});
+
+test("extractTextContent returns empty for null/undefined", () => {
+ assert.equal(gemini.extractTextContent(null), "");
+ assert.equal(gemini.extractTextContent(undefined), "");
+});
+
+test("extractTextContent extracts from array of content parts", () => {
+ const content = [
+ { type: "text", text: "hello" },
+ { type: "text", text: " world" },
+ ];
+ const result = gemini.extractTextContent(content);
+ assert.ok(result.includes("hello"));
+});
+
+test("extractTextContent handles object with text property", () => {
+ const content = { text: "hello" };
+ const result = gemini.extractTextContent(content);
+ assert.ok(result.includes("hello") || result === "");
+});
+
+test("generateRequestId returns a string", () => {
+ const id = gemini.generateRequestId();
+ assert.ok(typeof id === "string");
+ assert.ok(id.length > 0);
+});
+
+test("generateRequestId returns unique values", () => {
+ const id1 = gemini.generateRequestId();
+ const id2 = gemini.generateRequestId();
+ assert.notEqual(id1, id2);
+});
+
+test("generateSessionId returns a string", () => {
+ const id = gemini.generateSessionId();
+ assert.ok(typeof id === "string");
+ assert.ok(id.length > 0);
+});
+
+test("generateSessionId returns unique values", () => {
+ const id1 = gemini.generateSessionId();
+ const id2 = gemini.generateSessionId();
+ assert.notEqual(id1, id2);
+});
+
+test("convertOpenAIContentToParts handles string content", () => {
+ const parts = gemini.convertOpenAIContentToParts("hello");
+ assert.ok(Array.isArray(parts));
+ assert.ok(parts.length > 0);
+});
+
+test("convertOpenAIContentToParts handles null content", () => {
+ const parts = gemini.convertOpenAIContentToParts(null);
+ assert.ok(Array.isArray(parts));
+});
+
+test("convertOpenAIContentToParts handles array content", () => {
+ const content = [{ type: "text", text: "hello" }];
+ const parts = gemini.convertOpenAIContentToParts(content);
+ assert.ok(Array.isArray(parts));
+});
+
+test("cleanJSONSchemaForAntigravity handles null", () => {
+ const result = gemini.cleanJSONSchemaForAntigravity(null);
+ assert.ok(result === null || result === undefined || typeof result === "object");
+});
+
+test("cleanJSONSchemaForAntigravity handles object", () => {
+ const schema = { type: "object", properties: { name: { type: "string" } } };
+ const result = gemini.cleanJSONSchemaForAntigravity(schema);
+ assert.ok(typeof result === "object");
+});
+
+test("cleanJSONSchemaForAntigravity handles nested schema", () => {
+ const schema = {
+ type: "object",
+ properties: {
+ user: {
+ type: "object",
+ properties: {
+ name: { type: "string" },
+ age: { type: "number" },
+ },
+ },
+ },
+ };
+ const result = gemini.cleanJSONSchemaForAntigravity(schema);
+ assert.ok(typeof result === "object");
+});
diff --git a/tests/unit/model-resolver.test.ts b/tests/unit/model-resolver.test.ts
new file mode 100644
index 0000000000..007a97d3a6
--- /dev/null
+++ b/tests/unit/model-resolver.test.ts
@@ -0,0 +1,117 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const model = await import("../../open-sse/services/model.ts");
+
+test("resolveProviderAlias returns null for null/undefined", () => {
+ assert.equal(model.resolveProviderAlias(null), null);
+ assert.equal(model.resolveProviderAlias(undefined), null);
+});
+
+test("resolveProviderAlias returns empty string for empty string", () => {
+ const result = model.resolveProviderAlias("");
+ assert.ok(result === null || result === "");
+});
+
+test("resolveProviderAlias returns known alias", () => {
+ const result = model.resolveProviderAlias("claude");
+ assert.ok(result === "claude" || result === "anthropic" || typeof result === "string");
+});
+
+test("resolveProviderAlias returns null for unknown alias", () => {
+ const result = model.resolveProviderAlias("totally-unknown-provider");
+ assert.ok(result === null || typeof result === "string");
+});
+
+test("parseModel parses provider/model format", () => {
+ const result = model.parseModel("openai/gpt-4o");
+ assert.ok(result);
+ assert.ok(typeof result === "object");
+});
+
+test("parseModel handles plain model name", () => {
+ const result = model.parseModel("gpt-4o");
+ assert.ok(result);
+ assert.ok(typeof result === "object");
+});
+
+test("parseModel returns null-like for null/undefined", () => {
+ const result1 = model.parseModel(null);
+ const result2 = model.parseModel(undefined);
+ assert.ok(result1 !== undefined);
+ assert.ok(result2 !== undefined);
+});
+
+test("parseModel handles empty string", () => {
+ const result = model.parseModel("");
+ assert.ok(result !== undefined);
+});
+
+test("normalizeCrossProxyModelId handles plain model", () => {
+ const result = model.normalizeCrossProxyModelId("gpt-4o");
+ assert.ok(typeof result === "object");
+});
+
+test("normalizeCrossProxyModelId handles provider/model", () => {
+ const result = model.normalizeCrossProxyModelId("openai/gpt-4o");
+ assert.ok(typeof result === "object");
+});
+
+test("normalizeCrossProxyModelId handles null", () => {
+ const result = model.normalizeCrossProxyModelId(null);
+ assert.ok(typeof result === "object");
+});
+
+test("normalizeCrossProxyModelId handles undefined", () => {
+ const result = model.normalizeCrossProxyModelId(undefined);
+ assert.ok(typeof result === "object");
+});
+
+test("resolveCanonicalProviderModel returns object for known model", () => {
+ const result = model.resolveCanonicalProviderModel("gpt-4o");
+ assert.ok(typeof result === "object");
+});
+
+test("resolveCanonicalProviderModel returns object for null", () => {
+ const result = model.resolveCanonicalProviderModel(null);
+ assert.ok(typeof result === "object");
+});
+
+test("resolveModelAliasFromMap returns null for null alias", () => {
+ const result = model.resolveModelAliasFromMap(null, {});
+ assert.equal(result, null);
+});
+
+test("resolveModelAliasFromMap returns null for empty map", () => {
+ const result = model.resolveModelAliasFromMap("test", {});
+ assert.equal(result, null);
+});
+
+test("resolveModelAliasFromMap resolves alias from map", () => {
+ const aliases = { "gpt-4": "gpt-4o" };
+ const result = model.resolveModelAliasFromMap("gpt-4", aliases);
+ assert.ok(result === "gpt-4o" || result === null);
+});
+
+test("CODEX_NATIVE_UNPREFIXED_MODELS is a Set", () => {
+ assert.ok(model.CODEX_NATIVE_UNPREFIXED_MODELS instanceof Set);
+ assert.ok(model.CODEX_NATIVE_UNPREFIXED_MODELS.has("codex-auto-review"));
+});
+
+test("getModelInfoCore resolves known model", async () => {
+ const result = await model.getModelInfoCore("gpt-4o", {});
+ assert.ok(result);
+ assert.ok(typeof result === "object");
+});
+
+test("getModelInfoCore handles unknown model", async () => {
+ const result = await model.getModelInfoCore("totally-unknown-model-xyz", {});
+ assert.ok(result);
+ assert.ok(typeof result === "object");
+});
+
+test("getModelInfoCore handles null", async () => {
+ const result = await model.getModelInfoCore(null, {});
+ assert.ok(result);
+ assert.ok(typeof result === "object");
+});
diff --git a/tests/unit/stream-payload-collector.test.ts b/tests/unit/stream-payload-collector.test.ts
new file mode 100644
index 0000000000..5543c2a436
--- /dev/null
+++ b/tests/unit/stream-payload-collector.test.ts
@@ -0,0 +1,76 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const collector = await import("../../open-sse/utils/streamPayloadCollector.ts");
+
+test("compactStructuredStreamPayload returns null for null input", () => {
+ assert.equal(collector.compactStructuredStreamPayload(null), null);
+});
+
+test("compactStructuredStreamPayload returns undefined for undefined input", () => {
+ assert.equal(collector.compactStructuredStreamPayload(undefined), undefined);
+});
+
+test("compactStructuredStreamPayload passes through primitives", () => {
+ assert.equal(collector.compactStructuredStreamPayload(42), 42);
+ assert.equal(collector.compactStructuredStreamPayload("str"), "str");
+ assert.equal(collector.compactStructuredStreamPayload(true), true);
+});
+
+test("compactStructuredStreamPayload compacts objects", () => {
+ const input = { a: 1, b: "hello", c: [1, 2, 3] };
+ const result = collector.compactStructuredStreamPayload(input);
+ assert.ok(typeof result === "object");
+ assert.ok(result !== null);
+});
+
+test("compactStructuredStreamPayload handles nested objects", () => {
+ const input = { outer: { inner: { deep: "value" } } };
+ const result = collector.compactStructuredStreamPayload(input);
+ assert.ok(typeof result === "object");
+});
+
+test("compactStructuredStreamPayload handles arrays", () => {
+ const input = [1, 2, { a: 3 }];
+ const result = collector.compactStructuredStreamPayload(input);
+ assert.ok(Array.isArray(result));
+});
+
+test("buildStreamSummaryFromEvents handles empty array", () => {
+ const result = collector.buildStreamSummaryFromEvents([]);
+ assert.ok(result === null || typeof result === "object");
+});
+
+test("buildStreamSummaryFromEvents handles single event", () => {
+ const events = [{ data: '{"choices":[{"delta":{"content":"hello"}}]}' }];
+ const result = collector.buildStreamSummaryFromEvents(events);
+ assert.ok(typeof result === "object");
+});
+
+test("buildStreamSummaryFromEvents handles multiple events", () => {
+ const events = [
+ { data: '{"choices":[{"delta":{"content":"hello"}}]}' },
+ { data: '{"choices":[{"delta":{"content":" world"}}]}' },
+ { data: "[DONE]" },
+ ];
+ const result = collector.buildStreamSummaryFromEvents(events);
+ assert.ok(typeof result === "object");
+});
+
+test("createStructuredSSECollector returns collector object", () => {
+ const result = collector.createStructuredSSECollector();
+ assert.ok(typeof result === "object");
+ assert.ok(result !== null);
+});
+
+test("createStructuredSSECollector with options", () => {
+ const result = collector.createStructuredSSECollector({ maxEvents: 100 });
+ assert.ok(typeof result === "object");
+});
+
+test("createStructuredSSECollector collector has expected methods", () => {
+ const c = collector.createStructuredSSECollector();
+ assert.ok(c !== null && typeof c === "object");
+ const keys = Object.keys(c);
+ assert.ok(keys.length > 0);
+});