@vellumai/assistant 0.3.4 → 0.3.6

package/src/__tests__/provider-fail-open-selection.test.ts

@@ -0,0 +1,119 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  initializeProviders,
+  resolveProviderSelection,
+  getFailoverProvider,
+} from '../providers/registry.js';
+
+/**
+ * Tests for fail-open provider selection: when the configured primary provider
+ * is unavailable, the system should automatically fall back to the first
+ * available provider in the provider order.
+ */
+
+/** Initialize registry with anthropic + openai for most tests. */
+function setupTwoProviders() {
+  initializeProviders({
+    apiKeys: { anthropic: 'test-key', openai: 'test-key' },
+    provider: 'anthropic',
+    model: 'test-model',
+  });
+}
+
+/** Initialize registry with no providers (empty keys, non-registerable primary). */
+function setupNoProviders() {
+  initializeProviders({
+    apiKeys: {},
+    provider: 'gemini',
+    model: 'test-model',
+  });
+}
+
+describe('resolveProviderSelection', () => {
+  test('configured primary available → selected as primary', () => {
+    setupTwoProviders();
+    const result = resolveProviderSelection('anthropic', ['openai']);
+    expect(result.selectedPrimary).toBe('anthropic');
+    expect(result.usedFallbackPrimary).toBe(false);
+    expect(result.availableProviders).toEqual(['anthropic', 'openai']);
+  });
+
+  test('configured primary unavailable + alternate available → alternate selected', () => {
+    setupTwoProviders();
+    const result = resolveProviderSelection('gemini', ['anthropic', 'openai']);
+    expect(result.selectedPrimary).toBe('anthropic');
+    expect(result.usedFallbackPrimary).toBe(true);
+    expect(result.availableProviders).toEqual(['anthropic', 'openai']);
+  });
+
+  test('configured primary unavailable + first alternate also unavailable → second alternate selected', () => {
+    setupTwoProviders();
+    const result = resolveProviderSelection('gemini', ['fireworks', 'openai']);
+    expect(result.selectedPrimary).toBe('openai');
+    expect(result.usedFallbackPrimary).toBe(true);
+    expect(result.availableProviders).toEqual(['openai']);
+  });
+
+  test('deduplicates entries in providerOrder', () => {
+    setupTwoProviders();
+    const result = resolveProviderSelection('anthropic', ['anthropic', 'openai', 'openai']);
+    expect(result.availableProviders).toEqual(['anthropic', 'openai']);
+  });
+
+  test('unknown entries in providerOrder are filtered out', () => {
+    setupTwoProviders();
+    const result = resolveProviderSelection('anthropic', ['nonexistent', 'openai']);
+    expect(result.availableProviders).toEqual(['anthropic', 'openai']);
+  });
+
+  test('no available providers → null selectedPrimary', () => {
+    setupTwoProviders();
+    const result = resolveProviderSelection('gemini', ['fireworks', 'ollama']);
+    expect(result.selectedPrimary).toBeNull();
+    expect(result.usedFallbackPrimary).toBe(false);
+    expect(result.availableProviders).toEqual([]);
+  });
+
+  test('empty providerOrder with available primary → primary only', () => {
+    setupTwoProviders();
+    const result = resolveProviderSelection('anthropic', []);
+    expect(result.selectedPrimary).toBe('anthropic');
+    expect(result.usedFallbackPrimary).toBe(false);
+    expect(result.availableProviders).toEqual(['anthropic']);
+  });
+
+  test('empty providerOrder with unavailable primary → null', () => {
+    setupTwoProviders();
+    const result = resolveProviderSelection('gemini', []);
+    expect(result.selectedPrimary).toBeNull();
+    expect(result.availableProviders).toEqual([]);
+  });
+});
+
+describe('getFailoverProvider (fail-open)', () => {
+  test('returns provider when primary is available', () => {
+    setupTwoProviders();
+    const provider = getFailoverProvider('anthropic', ['openai']);
+    expect(provider).toBeDefined();
+  });
+
+  test('returns provider when primary is unavailable but alternate exists', () => {
+    setupTwoProviders();
+    const provider = getFailoverProvider('gemini', ['anthropic', 'openai']);
+    expect(provider).toBeDefined();
+  });
+
+  test('throws ConfigError when no providers are available', () => {
+    setupNoProviders();
+    expect(() => getFailoverProvider('gemini', ['fireworks'])).toThrow(
+      /No providers available/,
+    );
+  });
+
+  test('single available provider returns it directly (no failover wrapper)', () => {
+    setupTwoProviders();
+    const provider = getFailoverProvider('gemini', ['anthropic']);
+    // Should be a RetryProvider wrapping AnthropicProvider, not a FailoverProvider
+    expect(provider.name).not.toBe('failover');
+  });
+});

package/src/__tests__/qdrant-manager.test.ts

@@ -16,6 +16,13 @@ mock.module('../util/logger.js', () => ({
 
 import { QdrantManager } from '../memory/qdrant-manager.js';
 
+/** Short timeouts so tests don't wait 30s+ for readyz / shutdown grace. */
+const FAST_TIMEOUTS = {
+  readyzPollIntervalMs: 50,
+  readyzTimeoutMs: 1_500,
+  shutdownGraceMs: 500,
+} as const;
+
 function placeFakeBinary(script: string): string {
   const binaryPath = join(testDataDir, 'qdrant', 'bin', 'qdrant');
   writeFileSync(binaryPath, script);
@@ -78,11 +85,11 @@ describe('QdrantManager', () => {
     test('enters external mode when QDRANT_URL is set', async () => {
       process.env.QDRANT_URL = 'http://external:6333';
       const port = getTestPort();
-      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}`, ...FAST_TIMEOUTS });
 
       // External mode goes straight to waitForReady, which will timeout
       await expect(mgr.start()).rejects.toThrow('did not become ready');
-    }, 35_000);
+    }, 10_000);
 
     test('does not enter external mode when QDRANT_URL is empty', () => {
       process.env.QDRANT_URL = '   ';
@@ -126,12 +133,12 @@ describe('QdrantManager', () => {
       placeFakeBinary('#!/bin/sh\nexit 1');
 
       const port = getTestPort();
-      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}`, ...FAST_TIMEOUTS });
 
       try { await mgr.start(); } catch { /* readyz timeout */ }
 
       expect(existsSync(pidPath)).toBe(false);
-    }, 40_000);
+    }, 10_000);
 
     test('handles invalid PID file contents', async () => {
       const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
@@ -140,12 +147,12 @@ describe('QdrantManager', () => {
       placeFakeBinary('#!/bin/sh\nexit 1');
 
       const port = getTestPort();
-      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}`, ...FAST_TIMEOUTS });
 
       try { await mgr.start(); } catch { /* expected */ }
 
       expect(existsSync(pidPath)).toBe(false);
-    }, 40_000);
+    }, 10_000);
 
     test('handles empty PID file', async () => {
       const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
@@ -154,12 +161,12 @@ describe('QdrantManager', () => {
       placeFakeBinary('#!/bin/sh\nexit 1');
 
       const port = getTestPort();
-      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}`, ...FAST_TIMEOUTS });
 
       try { await mgr.start(); } catch { /* expected */ }
 
       expect(existsSync(pidPath)).toBe(false);
-    }, 40_000);
+    }, 10_000);
   });
 
   // ── Process Lifecycle ────────────────────────────────────────
@@ -172,7 +179,7 @@ describe('QdrantManager', () => {
       placeFakeBinary('#!/bin/sh\nexec sleep 300');
 
       const port = getTestPort();
-      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}`, ...FAST_TIMEOUTS });
 
       // Start polls readyz forever; we race it with our assertions + stop
       const startPromise = mgr.start();
@@ -192,7 +199,7 @@ describe('QdrantManager', () => {
 
       // start() should now reject because process was killed
       await expect(startPromise).rejects.toThrow('did not become ready');
-    }, 40_000);
+    }, 10_000);
 
     test('stop() escalates to SIGKILL after grace period', async () => {
       const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
@@ -201,7 +208,7 @@ describe('QdrantManager', () => {
       placeFakeBinary('#!/bin/sh\ntrap "" TERM\nexec sleep 300');
 
       const port = getTestPort();
-      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}`, ...FAST_TIMEOUTS });
 
       const startPromise = mgr.start();
       await Bun.sleep(500);
@@ -212,12 +219,12 @@ describe('QdrantManager', () => {
       await mgr.stop();
       const stopElapsed = Date.now() - stopStart;
 
-      // Grace period is 5s — should wait at least that long
-      expect(stopElapsed).toBeGreaterThanOrEqual(4500);
+      // Grace period is 500ms with FAST_TIMEOUTS — should wait at least that long
+      expect(stopElapsed).toBeGreaterThanOrEqual(400);
       expect(existsSync(pidPath)).toBe(false);
 
       await expect(startPromise).rejects.toThrow('did not become ready');
-    }, 45_000);
+    }, 10_000);
   });
 
   // ── Start Failure Cleanup ────────────────────────────────────
@@ -230,11 +237,11 @@ describe('QdrantManager', () => {
       placeFakeBinary('#!/bin/sh\nexec sleep 300');
 
       const port = getTestPort();
-      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}`, ...FAST_TIMEOUTS });
 
       await expect(mgr.start()).rejects.toThrow('did not become ready');
       expect(existsSync(pidPath)).toBe(false);
-    }, 40_000);
+    }, 10_000);
 
     test('cleans up when process exits immediately', async () => {
       const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
@@ -242,11 +249,11 @@ describe('QdrantManager', () => {
       placeFakeBinary('#!/bin/sh\nexit 1');
 
       const port = getTestPort();
-      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}`, ...FAST_TIMEOUTS });
 
       await expect(mgr.start()).rejects.toThrow('did not become ready');
       expect(existsSync(pidPath)).toBe(false);
-    }, 40_000);
+    }, 10_000);
   });
 
   // ── Binary Detection ─────────────────────────────────────────
@@ -256,12 +263,12 @@ describe('QdrantManager', () => {
       placeFakeBinary('#!/bin/sh\nexit 1');
 
       const port = getTestPort();
-      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}`, ...FAST_TIMEOUTS });
 
       try { await mgr.start(); } catch { /* readyz timeout */ }
 
       const binaryPath = join(testDataDir, 'qdrant', 'bin', 'qdrant');
       expect(existsSync(binaryPath)).toBe(true);
-    }, 40_000);
+    }, 10_000);
   });
 });