chore: import upstream snapshot with attribution

apps/sim/providers/client-cache.test.ts

@@ -0,0 +1,107 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it, vi } from 'vitest'
+import { getCachedProviderClient } from '@/providers/client-cache'
+
+/**
+ * Builds a fresh fake "client" object on every call so identity comparisons
+ * (`toBe`) tell us whether the cache returned the memoized instance or a new one
+ * from the factory. We never construct a real SDK client — these tests exercise
+ * the cache, not any provider SDK.
+ */
+function makeFactory() {
+  return vi.fn(() => ({}) as object)
+}
+
+/**
+ * Generates a unique suffix per test so distinct tests never collide on cache
+ * keys. The cache util exposes no reset hook, so isolation is achieved by
+ * namespacing keys rather than clearing shared state.
+ */
+let keyCounter = 0
+function uniqueNs(): string {
+  keyCounter += 1
+  return `ns-${keyCounter}-${Date.now()}`
+}
+
+describe('getCachedProviderClient', () => {
+  it('returns the SAME instance for an identical key and runs the factory once (memoized)', () => {
+    const key = `anthropic::${uniqueNs()}::default`
+    const factory = makeFactory()
+
+    const first = getCachedProviderClient(key, factory)
+    const second = getCachedProviderClient(key, factory)
+
+    expect(second).toBe(first)
+    expect(factory).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns a DIFFERENT instance for a different apiKey (tenant isolation)', () => {
+    const ns = uniqueNs()
+    const factoryA = makeFactory()
+    const factoryB = makeFactory()
+
+    const tenantA = getCachedProviderClient(`anthropic::${ns}-tenant-a::default`, factoryA)
+    const tenantB = getCachedProviderClient(`anthropic::${ns}-tenant-b::default`, factoryB)
+
+    expect(tenantB).not.toBe(tenantA)
+    expect(factoryA).toHaveBeenCalledTimes(1)
+    expect(factoryB).toHaveBeenCalledTimes(1)
+  })
+
+  it('namespaces by provider: the same apiKey under different provider prefixes does not collide', () => {
+    const ns = uniqueNs()
+    const apiKey = `${ns}-shared-key`
+    const anthropicFactory = makeFactory()
+    const bedrockFactory = makeFactory()
+
+    const anthropicClient = getCachedProviderClient(`anthropic::${apiKey}`, anthropicFactory)
+    const bedrockClient = getCachedProviderClient(`bedrock::${apiKey}`, bedrockFactory)
+
+    expect(bedrockClient).not.toBe(anthropicClient)
+  })
+
+  it('treats every distinct key dimension as a distinct client', () => {
+    const ns = uniqueNs()
+    const base = `azure-anthropic::${ns}-key::https://a.example.com::2023-06-01::10.0.0.1::default`
+    const baseFactory = makeFactory()
+    const baseClient = getCachedProviderClient(base, baseFactory)
+
+    const variants = [
+      `azure-anthropic::${ns}-key::https://b.example.com::2023-06-01::10.0.0.1::default`,
+      `azure-anthropic::${ns}-key::https://a.example.com::2024-10-22::10.0.0.1::default`,
+      `azure-anthropic::${ns}-key::https://a.example.com::2023-06-01::10.0.0.2::default`,
+      `azure-anthropic::${ns}-key::https://a.example.com::2023-06-01::no-pin::default`,
+      `azure-anthropic::${ns}-key::https://a.example.com::2023-06-01::10.0.0.1::beta`,
+    ]
+
+    for (const key of variants) {
+      const factory = makeFactory()
+      const client = getCachedProviderClient(key, factory)
+      expect(client).not.toBe(baseClient)
+      expect(factory).toHaveBeenCalledTimes(1)
+    }
+  })
+
+  it('evicts the least-recently-used entry once the cache cap is exceeded', () => {
+    const ns = uniqueNs()
+    const CAP = 1_000
+
+    const oldestKey = `evict::${ns}::0`
+    const oldestFactory = makeFactory()
+    getCachedProviderClient(oldestKey, oldestFactory)
+    expect(oldestFactory).toHaveBeenCalledTimes(1)
+
+    // Fill the remaining capacity, then push one past the cap. The oldest key has
+    // not been touched since insertion, so it is the LRU eviction victim.
+    for (let i = 1; i <= CAP; i += 1) {
+      getCachedProviderClient(`evict::${ns}::${i}`, makeFactory())
+    }
+
+    const reFactory = makeFactory()
+    getCachedProviderClient(oldestKey, reFactory)
+    expect(reFactory).toHaveBeenCalledTimes(1)
+    expect(oldestFactory).toHaveBeenCalledTimes(1)
+  })
+})