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
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
test(i18n): cover fallback merge scenarios (locale-wins, missing-key, deep, arrays) (B/G1)
diegosouzapw858d8c3103a9
diff --git a/tests/unit/i18n-fallback.test.ts b/tests/unit/i18n-fallback.test.tsnew file mode 100644index 0000000000..e66583511c--- /dev/null+++ b/tests/unit/i18n-fallback.test.ts@@ -0,0 +1,239 @@+/**+ * Tests for G1 — i18n deep-merge EN fallback (src/i18n/request.ts).+ *+ * Strategy (A): test `deepMergeFallback` directly via its named export.+ * This avoids mocking next/headers, next-intl, and dynamic imports while+ * achieving ≥90% line coverage of the merge function itself.+ */+import { test } from "node:test";+import assert from "node:assert/strict";+import { deepMergeFallback } from "../../src/i18n/request.ts";++// ---------------------------------------------------------------------------+// 1. deepMergeFallback — locale-specific key wins (target wins)+// ---------------------------------------------------------------------------++test("deepMergeFallback: locale-specific key is preserved when source has the same key", () => {+ const target: Record<string, unknown> = { greeting: "Hola" };+ const source: Record<string, unknown> = { greeting: "Hello" };+ const result = deepMergeFallback(target, source);+ assert.equal(result.greeting, "Hola", "target value must survive when both target and source have the key");+});++test("deepMergeFallback: returns the same target reference (mutates in-place)", () => {+ const target: Record<string, unknown> = { a: 1 };+ const source: Record<string, unknown> = { b: 2 };+ const result = deepMergeFallback(target, source);+ assert.equal(result, target, "must return the same object reference");+});++// ---------------------------------------------------------------------------+// 2. deepMergeFallback — missing keys are added from source (fallback wins)+// ---------------------------------------------------------------------------++test("deepMergeFallback: missing key in target is filled from source", () => {+ const target: Record<string, unknown> = { localeKey: "Hola" };+ const source: Record<string, unknown> = { localeKey: "Hello", fallbackKey: "Fallback EN" };+ const result = deepMergeFallback(target, source);+ assert.equal(result.localeKey, "Hola", "locale key must win");+ assert.equal(result.fallbackKey, "Fallback EN", "fallback key must be added");+});++test("deepMergeFallback: entire namespace missing in target is filled from source", () => {+ const target: Record<string, unknown> = { namespace1: { localeKey: "Hola" } };+ const source: Record<string, unknown> = {+ namespace1: { localeKey: "Hello", fallbackKey: "Fallback EN" },+ namespace2: { onlyEn: "Only EN" },+ };+ const result = deepMergeFallback(target, source);+ // locale key wins inside existing namespace+ assert.equal((result.namespace1 as Record<string, unknown>).localeKey, "Hola");+ // fallback key added inside existing namespace+ assert.equal((result.namespace1 as Record<string, unknown>).fallbackKey, "Fallback EN");+ // entire namespace from source added to target+ assert.deepEqual(result.namespace2, { onlyEn: "Only EN" });+});++// ---------------------------------------------------------------------------+// 3. deepMergeFallback — deep merge on nested objects+// ---------------------------------------------------------------------------++test("deepMergeFallback: deep merge recurses into nested objects", () => {+ const target: Record<string, unknown> = {+ a: {+ b: {+ locale: "es value",+ },+ },+ };+ const source: Record<string, unknown> = {+ a: {+ b: {+ locale: "en value",+ fallback: "en fallback",+ },+ c: "only in en",+ },+ };+ const result = deepMergeFallback(target, source);+ const a = result.a as Record<string, unknown>;+ const b = a.b as Record<string, unknown>;+ assert.equal(b.locale, "es value", "deeply nested locale key must win");+ assert.equal(b.fallback, "en fallback", "deeply nested missing key must be filled from fallback");+ assert.equal(a.c, "only in en", "sibling key missing in target must be filled from source");+});++test("deepMergeFallback: three levels deep — target wins at all levels", () => {+ const target: Record<string, unknown> = {+ l1: { l2: { l3: { key: "locale" } } },+ };+ const source: Record<string, unknown> = {+ l1: { l2: { l3: { key: "fallback", extra: "extra-en" }, l2extra: "l2extra-en" } },+ };+ const result = deepMergeFallback(target, source);+ const l3 = (((result.l1 as Record<string, unknown>).l2 as Record<string, unknown>).l3 as Record<string, unknown>);+ assert.equal(l3.key, "locale");+ assert.equal(l3.extra, "extra-en");+ const l2 = ((result.l1 as Record<string, unknown>).l2 as Record<string, unknown>);+ assert.equal(l2.l2extra, "l2extra-en");+});++// ---------------------------------------------------------------------------+// 4. deepMergeFallback — arrays are NOT deep-merged (scalar replacement)+// ---------------------------------------------------------------------------++test("deepMergeFallback: arrays in target are preserved as-is (not merged with source)", () => {+ const target: Record<string, unknown> = { items: ["es-a", "es-b"] };+ const source: Record<string, unknown> = { items: ["en-a", "en-b", "en-c"] };+ const result = deepMergeFallback(target, source);+ // Target already has the key, so it wins — array from source is ignored.+ assert.deepEqual(result.items, ["es-a", "es-b"]);+});++test("deepMergeFallback: array missing in target is filled from source (not merged)", () => {+ const target: Record<string, unknown> = {};+ const source: Record<string, unknown> = { tags: ["en-tag-1", "en-tag-2"] };+ const result = deepMergeFallback(target, source);+ assert.deepEqual(result.tags, ["en-tag-1", "en-tag-2"]);+});++test("deepMergeFallback: source array does NOT overwrite existing object in target", () => {+ // Source has an array where target has an object — target wins (existing value kept).+ const target: Record<string, unknown> = { data: { nested: "locale" } };+ const source: Record<string, unknown> = { data: ["en-1", "en-2"] };+ const result = deepMergeFallback(target, source);+ // target has "data" defined (as object), so source's array is ignored+ assert.deepEqual(result.data, { nested: "locale" });+});++test("deepMergeFallback: source object does NOT overwrite existing array in target", () => {+ // Source has an object where target has an array — target array wins (existing value kept).+ const target: Record<string, unknown> = { list: ["es-item"] };+ const source: Record<string, unknown> = { list: { key: "en-val" } };+ const result = deepMergeFallback(target, source);+ // target has "list" defined (as array), source is an object — since target[key] !== undefined+ // the else-if branch is skipped, so target.list remains the array.+ assert.deepEqual(result.list, ["es-item"]);+});++// ---------------------------------------------------------------------------+// 5. deepMergeFallback — null values in source / target+// ---------------------------------------------------------------------------++test("deepMergeFallback: null in source is treated as scalar (fills missing target key)", () => {+ const target: Record<string, unknown> = {};+ const source: Record<string, unknown> = { nullable: null };+ const result = deepMergeFallback(target, source);+ assert.equal(result.nullable, null);+});++test("deepMergeFallback: null in target preserves null (source object does not recurse into null)", () => {+ const target: Record<string, unknown> = { section: null };+ const source: Record<string, unknown> = { section: { key: "en-val" } };+ const result = deepMergeFallback(target, source);+ // target has "section" defined (as null — not undefined), so source's value is NOT applied.+ assert.equal(result.section, null);+});++// ---------------------------------------------------------------------------+// 6. deepMergeFallback — empty objects+// ---------------------------------------------------------------------------++test("deepMergeFallback: empty target gets all keys from source", () => {+ const target: Record<string, unknown> = {};+ const source: Record<string, unknown> = { a: "A", b: { c: "C" } };+ const result = deepMergeFallback(target, source);+ assert.equal(result.a, "A");+ assert.deepEqual(result.b, { c: "C" });+});++test("deepMergeFallback: empty source leaves target unchanged", () => {+ const target: Record<string, unknown> = { x: "locale-x" };+ const source: Record<string, unknown> = {};+ const result = deepMergeFallback(target, source);+ assert.equal(result.x, "locale-x");+ assert.equal(Object.keys(result).length, 1);+});++// ---------------------------------------------------------------------------+// 7. Scenario: realistic i18n shape — simulate en.json as fallback+// ---------------------------------------------------------------------------++test("realistic i18n: es locale with partial translations falls back to EN for missing keys", () => {+ // Simulates what getRequestConfig does:+ // localeMessages = es.json content (partial)+ // fallbackMessages = en.json content (complete)+ // messages = deepMergeFallback({ ...localeMessages }, fallbackMessages)+ const esLocale: Record<string, unknown> = {+ namespace1: {+ localeKey: "Hola",+ // fallbackKey is absent — will come from EN+ },+ // namespace2 is absent — will come from EN+ };+ const enFallback: Record<string, unknown> = {+ namespace1: {+ localeKey: "Hello",+ fallbackKey: "Fallback EN",+ },+ namespace2: {+ onlyEn: "Only EN",+ },+ };++ // Simulate what the factory does: shallow copy first so we don't mutate the import cache+ const messages = deepMergeFallback({ ...esLocale }, enFallback);++ assert.equal(messages.namespace1, esLocale.namespace1, "namespace1 object is the same reference (mutated in-place)");+ const ns1 = messages.namespace1 as Record<string, unknown>;+ assert.equal(ns1.localeKey, "Hola", "locale-specific key wins");+ assert.equal(ns1.fallbackKey, "Fallback EN", "missing key filled from EN fallback");+ assert.deepEqual(messages.namespace2, { onlyEn: "Only EN" }, "entirely missing namespace filled from EN");+});++test("realistic i18n: en locale — shallow copy means no mutation of original en object", () => {+ // When locale === 'en', the factory returns localeMessages as-is (no merge).+ // This test verifies the shallow copy pattern does not mutate the original.+ const enLocale: Record<string, unknown> = { key: "EN value" };+ const copy = { ...enLocale };+ deepMergeFallback(copy, {}); // noop — empty source+ assert.equal(enLocale.key, "EN value", "original object must not be mutated");+});++test("realistic i18n: locale invalid → DEFAULT_LOCALE applies; merge still works for non-EN default", () => {+ // If DEFAULT_LOCALE were "pt-BR" (not EN), we'd merge pt-BR with EN fallback.+ // Simulate this by merging a pt-BR partial object with EN.+ const ptBrLocale: Record<string, unknown> = {+ common: { save: "Salvar" },+ // 'common.cancel' is missing — should come from EN+ };+ const enFallback: Record<string, unknown> = {+ common: { save: "Save", cancel: "Cancel" },+ extra: { key: "Extra EN" },+ };+ const messages = deepMergeFallback({ ...ptBrLocale }, enFallback);+ const common = messages.common as Record<string, unknown>;+ assert.equal(common.save, "Salvar", "locale key wins in default locale");+ assert.equal(common.cancel, "Cancel", "missing key filled from EN");+ assert.deepEqual(messages.extra, { key: "Extra EN" }, "missing namespace filled from EN");+});