2f5babba99
The hybrid strategy now considers account quota levels when selecting accounts, preventing any single account from being drained to 0%. - Add QuotaTracker class to track per-account quota levels - Exclude accounts with critical quota (<5%) from selection - Add quota component to scoring formula (weight: 3) - Fall back to critical accounts when no alternatives exist - Add 18 new tests for quota-aware selection Scoring formula: Health×2 + Tokens×5 + Quota×3 + LRU×0.1 An attempt at resolving badrisnarayanan/antigravity-claude-proxy#171
1042 lines
44 KiB
JavaScript
1042 lines
44 KiB
JavaScript
/**
|
|
* Test Account Selection Strategies - Unit Tests
|
|
*
|
|
* Tests the strategy pattern implementation for account selection:
|
|
* - HealthTracker: health score tracking with passive recovery
|
|
* - TokenBucketTracker: token bucket rate limiting
|
|
* - StickyStrategy: cache-optimized sticky selection
|
|
* - RoundRobinStrategy: load-balanced rotation
|
|
* - HybridStrategy: smart multi-signal distribution
|
|
* - Strategy Factory: createStrategy, isValidStrategy, getStrategyLabel
|
|
*/
|
|
|
|
// Since we're in CommonJS and the module is ESM, we need to use dynamic import
|
|
async function runTests() {
|
|
console.log('╔══════════════════════════════════════════════════════════════╗');
|
|
console.log('║ ACCOUNT SELECTION STRATEGY TEST SUITE ║');
|
|
console.log('╚══════════════════════════════════════════════════════════════╝\n');
|
|
|
|
// Dynamic imports for ESM modules
|
|
const { HealthTracker } = await import('../src/account-manager/strategies/trackers/health-tracker.js');
|
|
const { TokenBucketTracker } = await import('../src/account-manager/strategies/trackers/token-bucket-tracker.js');
|
|
const { QuotaTracker } = await import('../src/account-manager/strategies/trackers/quota-tracker.js');
|
|
const { StickyStrategy } = await import('../src/account-manager/strategies/sticky-strategy.js');
|
|
const { RoundRobinStrategy } = await import('../src/account-manager/strategies/round-robin-strategy.js');
|
|
const { HybridStrategy } = await import('../src/account-manager/strategies/hybrid-strategy.js');
|
|
const { BaseStrategy } = await import('../src/account-manager/strategies/base-strategy.js');
|
|
const {
|
|
createStrategy,
|
|
isValidStrategy,
|
|
getStrategyLabel,
|
|
STRATEGY_NAMES,
|
|
DEFAULT_STRATEGY
|
|
} = await import('../src/account-manager/strategies/index.js');
|
|
|
|
let passed = 0;
|
|
let failed = 0;
|
|
|
|
function test(name, fn) {
|
|
try {
|
|
fn();
|
|
console.log(`✓ ${name}`);
|
|
passed++;
|
|
} catch (e) {
|
|
console.log(`✗ ${name}`);
|
|
console.log(` Error: ${e.message}`);
|
|
failed++;
|
|
}
|
|
}
|
|
|
|
function assertEqual(actual, expected, message = '') {
|
|
if (actual !== expected) {
|
|
throw new Error(`${message}\nExpected: ${expected}\nActual: ${actual}`);
|
|
}
|
|
}
|
|
|
|
function assertDeepEqual(actual, expected, message = '') {
|
|
if (JSON.stringify(actual) !== JSON.stringify(expected)) {
|
|
throw new Error(`${message}\nExpected: ${JSON.stringify(expected, null, 2)}\nActual: ${JSON.stringify(actual, null, 2)}`);
|
|
}
|
|
}
|
|
|
|
function assertTrue(value, message = '') {
|
|
if (!value) {
|
|
throw new Error(message || 'Expected true but got false');
|
|
}
|
|
}
|
|
|
|
function assertFalse(value, message = '') {
|
|
if (value) {
|
|
throw new Error(message || 'Expected false but got true');
|
|
}
|
|
}
|
|
|
|
function assertNull(value, message = '') {
|
|
if (value !== null) {
|
|
throw new Error(`${message}\nExpected null but got: ${value}`);
|
|
}
|
|
}
|
|
|
|
function assertWithin(actual, min, max, message = '') {
|
|
if (actual < min || actual > max) {
|
|
throw new Error(`${message}\nExpected value between ${min} and ${max}, got: ${actual}`);
|
|
}
|
|
}
|
|
|
|
// Helper to create mock accounts
|
|
function createMockAccounts(count = 3, options = {}) {
|
|
return Array.from({ length: count }, (_, i) => ({
|
|
email: `account${i + 1}@example.com`,
|
|
enabled: true,
|
|
isInvalid: false,
|
|
lastUsed: Date.now() - (i * 60000), // Stagger by 1 minute
|
|
modelRateLimits: {},
|
|
...options
|
|
}));
|
|
}
|
|
|
|
// ==========================================================================
|
|
// HEALTH TRACKER TESTS
|
|
// ==========================================================================
|
|
console.log('\n─── HealthTracker Tests ───');
|
|
|
|
test('HealthTracker: initial score is 70 by default', () => {
|
|
const tracker = new HealthTracker();
|
|
const score = tracker.getScore('new@example.com');
|
|
assertEqual(score, 70, 'Default initial score should be 70');
|
|
});
|
|
|
|
test('HealthTracker: custom initial score', () => {
|
|
const tracker = new HealthTracker({ initial: 80 });
|
|
const score = tracker.getScore('new@example.com');
|
|
assertEqual(score, 80, 'Custom initial score should be 80');
|
|
});
|
|
|
|
test('HealthTracker: recordSuccess increases score', () => {
|
|
const tracker = new HealthTracker({ initial: 70, successReward: 1 });
|
|
tracker.recordSuccess('test@example.com');
|
|
const score = tracker.getScore('test@example.com');
|
|
assertEqual(score, 71, 'Score should increase by 1 on success');
|
|
});
|
|
|
|
test('HealthTracker: recordRateLimit decreases score', () => {
|
|
const tracker = new HealthTracker({ initial: 70, rateLimitPenalty: -10 });
|
|
tracker.recordRateLimit('test@example.com');
|
|
const score = tracker.getScore('test@example.com');
|
|
assertEqual(score, 60, 'Score should decrease by 10 on rate limit');
|
|
});
|
|
|
|
test('HealthTracker: recordFailure decreases score', () => {
|
|
const tracker = new HealthTracker({ initial: 70, failurePenalty: -20 });
|
|
tracker.recordFailure('test@example.com');
|
|
const score = tracker.getScore('test@example.com');
|
|
assertEqual(score, 50, 'Score should decrease by 20 on failure');
|
|
});
|
|
|
|
test('HealthTracker: score cannot exceed maxScore', () => {
|
|
const tracker = new HealthTracker({ initial: 99, maxScore: 100, successReward: 5 });
|
|
tracker.recordSuccess('test@example.com');
|
|
const score = tracker.getScore('test@example.com');
|
|
assertEqual(score, 100, 'Score should be capped at maxScore');
|
|
});
|
|
|
|
test('HealthTracker: score cannot go below 0', () => {
|
|
const tracker = new HealthTracker({ initial: 10, failurePenalty: -50 });
|
|
tracker.recordFailure('test@example.com');
|
|
const score = tracker.getScore('test@example.com');
|
|
assertEqual(score, 0, 'Score should not go below 0');
|
|
});
|
|
|
|
test('HealthTracker: isUsable returns true when score >= minUsable', () => {
|
|
const tracker = new HealthTracker({ initial: 50, minUsable: 50 });
|
|
assertTrue(tracker.isUsable('test@example.com'), 'Should be usable at minUsable');
|
|
});
|
|
|
|
test('HealthTracker: isUsable returns false when score < minUsable', () => {
|
|
const tracker = new HealthTracker({ initial: 49, minUsable: 50 });
|
|
assertFalse(tracker.isUsable('test@example.com'), 'Should not be usable below minUsable');
|
|
});
|
|
|
|
test('HealthTracker: reset restores initial score', () => {
|
|
const tracker = new HealthTracker({ initial: 70 });
|
|
tracker.recordFailure('test@example.com'); // Score drops
|
|
tracker.reset('test@example.com');
|
|
const score = tracker.getScore('test@example.com');
|
|
assertEqual(score, 70, 'Reset should restore initial score');
|
|
});
|
|
|
|
test('HealthTracker: clear removes all scores', () => {
|
|
const tracker = new HealthTracker({ initial: 70 });
|
|
tracker.recordSuccess('a@example.com');
|
|
tracker.recordSuccess('b@example.com');
|
|
tracker.clear();
|
|
// After clear, new accounts should get initial score
|
|
assertEqual(tracker.getScore('a@example.com'), 70);
|
|
assertEqual(tracker.getScore('b@example.com'), 70);
|
|
});
|
|
|
|
test('HealthTracker: getConsecutiveFailures returns 0 for new account', () => {
|
|
const tracker = new HealthTracker();
|
|
assertEqual(tracker.getConsecutiveFailures('new@example.com'), 0);
|
|
});
|
|
|
|
test('HealthTracker: recordRateLimit increments consecutiveFailures', () => {
|
|
const tracker = new HealthTracker();
|
|
tracker.recordRateLimit('test@example.com');
|
|
assertEqual(tracker.getConsecutiveFailures('test@example.com'), 1);
|
|
tracker.recordRateLimit('test@example.com');
|
|
assertEqual(tracker.getConsecutiveFailures('test@example.com'), 2);
|
|
});
|
|
|
|
test('HealthTracker: recordFailure increments consecutiveFailures', () => {
|
|
const tracker = new HealthTracker();
|
|
tracker.recordFailure('test@example.com');
|
|
assertEqual(tracker.getConsecutiveFailures('test@example.com'), 1);
|
|
});
|
|
|
|
test('HealthTracker: recordSuccess resets consecutiveFailures', () => {
|
|
const tracker = new HealthTracker();
|
|
tracker.recordRateLimit('test@example.com');
|
|
tracker.recordRateLimit('test@example.com');
|
|
assertEqual(tracker.getConsecutiveFailures('test@example.com'), 2);
|
|
tracker.recordSuccess('test@example.com');
|
|
assertEqual(tracker.getConsecutiveFailures('test@example.com'), 0);
|
|
});
|
|
|
|
test('HealthTracker: reset clears consecutiveFailures', () => {
|
|
const tracker = new HealthTracker();
|
|
tracker.recordFailure('test@example.com');
|
|
tracker.recordFailure('test@example.com');
|
|
assertEqual(tracker.getConsecutiveFailures('test@example.com'), 2);
|
|
tracker.reset('test@example.com');
|
|
assertEqual(tracker.getConsecutiveFailures('test@example.com'), 0);
|
|
});
|
|
|
|
// ==========================================================================
|
|
// TOKEN BUCKET TRACKER TESTS
|
|
// ==========================================================================
|
|
console.log('\n─── TokenBucketTracker Tests ───');
|
|
|
|
test('TokenBucketTracker: initial tokens is 50 by default', () => {
|
|
const tracker = new TokenBucketTracker();
|
|
const tokens = tracker.getTokens('new@example.com');
|
|
assertEqual(tokens, 50, 'Default initial tokens should be 50');
|
|
});
|
|
|
|
test('TokenBucketTracker: custom initial tokens', () => {
|
|
const tracker = new TokenBucketTracker({ initialTokens: 30 });
|
|
const tokens = tracker.getTokens('new@example.com');
|
|
assertEqual(tokens, 30, 'Custom initial tokens should be 30');
|
|
});
|
|
|
|
test('TokenBucketTracker: consume decreases tokens', () => {
|
|
const tracker = new TokenBucketTracker({ initialTokens: 10, maxTokens: 10 });
|
|
const consumed = tracker.consume('test@example.com');
|
|
assertTrue(consumed, 'Consume should return true');
|
|
assertEqual(tracker.getTokens('test@example.com'), 9, 'Tokens should decrease by 1');
|
|
});
|
|
|
|
test('TokenBucketTracker: consume fails when no tokens', () => {
|
|
const tracker = new TokenBucketTracker({ initialTokens: 0, maxTokens: 10 });
|
|
const consumed = tracker.consume('test@example.com');
|
|
assertFalse(consumed, 'Consume should return false when no tokens');
|
|
});
|
|
|
|
test('TokenBucketTracker: hasTokens returns true when tokens > 0', () => {
|
|
const tracker = new TokenBucketTracker({ initialTokens: 1 });
|
|
assertTrue(tracker.hasTokens('test@example.com'), 'Should have tokens');
|
|
});
|
|
|
|
test('TokenBucketTracker: hasTokens returns false when tokens < 1', () => {
|
|
const tracker = new TokenBucketTracker({ initialTokens: 0 });
|
|
assertFalse(tracker.hasTokens('test@example.com'), 'Should not have tokens');
|
|
});
|
|
|
|
test('TokenBucketTracker: refund increases tokens', () => {
|
|
const tracker = new TokenBucketTracker({ initialTokens: 5, maxTokens: 10 });
|
|
tracker.consume('test@example.com'); // 5 -> 4
|
|
tracker.refund('test@example.com'); // 4 -> 5
|
|
assertEqual(tracker.getTokens('test@example.com'), 5, 'Refund should restore token');
|
|
});
|
|
|
|
test('TokenBucketTracker: refund cannot exceed maxTokens', () => {
|
|
const tracker = new TokenBucketTracker({ initialTokens: 10, maxTokens: 10 });
|
|
tracker.refund('test@example.com');
|
|
assertEqual(tracker.getTokens('test@example.com'), 10, 'Refund should not exceed max');
|
|
});
|
|
|
|
test('TokenBucketTracker: getMaxTokens returns configured max', () => {
|
|
const tracker = new TokenBucketTracker({ maxTokens: 100 });
|
|
assertEqual(tracker.getMaxTokens(), 100, 'getMaxTokens should return 100');
|
|
});
|
|
|
|
test('TokenBucketTracker: reset restores initial tokens', () => {
|
|
const tracker = new TokenBucketTracker({ initialTokens: 50, maxTokens: 50 });
|
|
tracker.consume('test@example.com');
|
|
tracker.consume('test@example.com');
|
|
tracker.reset('test@example.com');
|
|
assertEqual(tracker.getTokens('test@example.com'), 50, 'Reset should restore initial');
|
|
});
|
|
|
|
// ==========================================================================
|
|
// QUOTA TRACKER TESTS
|
|
// ==========================================================================
|
|
console.log('\n─── QuotaTracker Tests ───');
|
|
|
|
test('QuotaTracker: getQuotaFraction returns null for missing data', () => {
|
|
const tracker = new QuotaTracker();
|
|
const account = { email: 'test@example.com' };
|
|
assertNull(tracker.getQuotaFraction(account, 'model'), 'Missing quota should return null');
|
|
});
|
|
|
|
test('QuotaTracker: getQuotaFraction returns correct value', () => {
|
|
const tracker = new QuotaTracker();
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.75 } },
|
|
lastChecked: Date.now()
|
|
}
|
|
};
|
|
assertEqual(tracker.getQuotaFraction(account, 'model'), 0.75);
|
|
});
|
|
|
|
test('QuotaTracker: isQuotaFresh returns false when no lastChecked', () => {
|
|
const tracker = new QuotaTracker();
|
|
const account = { email: 'test@example.com' };
|
|
assertFalse(tracker.isQuotaFresh(account), 'Missing lastChecked should not be fresh');
|
|
});
|
|
|
|
test('QuotaTracker: isQuotaFresh returns true for recent data', () => {
|
|
const tracker = new QuotaTracker({ staleMs: 300000 }); // 5 min
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: { lastChecked: Date.now() - 60000 } // 1 min ago
|
|
};
|
|
assertTrue(tracker.isQuotaFresh(account), 'Recent data should be fresh');
|
|
});
|
|
|
|
test('QuotaTracker: isQuotaFresh returns false for stale data', () => {
|
|
const tracker = new QuotaTracker({ staleMs: 300000 }); // 5 min
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: { lastChecked: Date.now() - 600000 } // 10 min ago
|
|
};
|
|
assertFalse(tracker.isQuotaFresh(account), 'Old data should be stale');
|
|
});
|
|
|
|
test('QuotaTracker: isQuotaCritical returns false for unknown quota', () => {
|
|
const tracker = new QuotaTracker({ criticalThreshold: 0.05 });
|
|
const account = { email: 'test@example.com' };
|
|
assertFalse(tracker.isQuotaCritical(account, 'model'), 'Unknown quota should not be critical');
|
|
});
|
|
|
|
test('QuotaTracker: isQuotaCritical returns true when quota <= threshold', () => {
|
|
const tracker = new QuotaTracker({ criticalThreshold: 0.05 });
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.04 } },
|
|
lastChecked: Date.now()
|
|
}
|
|
};
|
|
assertTrue(tracker.isQuotaCritical(account, 'model'), 'Low quota should be critical');
|
|
});
|
|
|
|
test('QuotaTracker: isQuotaCritical returns false when quota > threshold', () => {
|
|
const tracker = new QuotaTracker({ criticalThreshold: 0.05 });
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.10 } },
|
|
lastChecked: Date.now()
|
|
}
|
|
};
|
|
assertFalse(tracker.isQuotaCritical(account, 'model'), 'Higher quota should not be critical');
|
|
});
|
|
|
|
test('QuotaTracker: isQuotaCritical returns false for stale data', () => {
|
|
const tracker = new QuotaTracker({ criticalThreshold: 0.05, staleMs: 300000 });
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.01 } },
|
|
lastChecked: Date.now() - 600000 // 10 min ago (stale)
|
|
}
|
|
};
|
|
assertFalse(tracker.isQuotaCritical(account, 'model'), 'Stale critical data should be ignored');
|
|
});
|
|
|
|
test('QuotaTracker: isQuotaLow returns true for low but not critical quota', () => {
|
|
const tracker = new QuotaTracker({ lowThreshold: 0.10, criticalThreshold: 0.05 });
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.08 } },
|
|
lastChecked: Date.now()
|
|
}
|
|
};
|
|
assertTrue(tracker.isQuotaLow(account, 'model'), 'Quota at 8% should be low');
|
|
});
|
|
|
|
test('QuotaTracker: isQuotaLow returns false for critical quota', () => {
|
|
const tracker = new QuotaTracker({ lowThreshold: 0.10, criticalThreshold: 0.05 });
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.03 } },
|
|
lastChecked: Date.now()
|
|
}
|
|
};
|
|
assertFalse(tracker.isQuotaLow(account, 'model'), 'Critical quota should not be just low');
|
|
});
|
|
|
|
test('QuotaTracker: getScore returns unknownScore for missing quota', () => {
|
|
const tracker = new QuotaTracker({ unknownScore: 50 });
|
|
const account = { email: 'test@example.com' };
|
|
assertEqual(tracker.getScore(account, 'model'), 50, 'Unknown quota should return default score');
|
|
});
|
|
|
|
test('QuotaTracker: getScore returns 0-100 based on fraction', () => {
|
|
const tracker = new QuotaTracker();
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.75 } },
|
|
lastChecked: Date.now()
|
|
}
|
|
};
|
|
assertEqual(tracker.getScore(account, 'model'), 75, 'Score should be fraction * 100');
|
|
});
|
|
|
|
test('QuotaTracker: getScore applies penalty for stale data', () => {
|
|
const tracker = new QuotaTracker({ staleMs: 300000 });
|
|
const account = {
|
|
email: 'test@example.com',
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 1.0 } },
|
|
lastChecked: Date.now() - 600000 // 10 min ago
|
|
}
|
|
};
|
|
assertEqual(tracker.getScore(account, 'model'), 90, 'Stale data should have 10% penalty');
|
|
});
|
|
|
|
// ==========================================================================
|
|
// BASE STRATEGY TESTS
|
|
// ==========================================================================
|
|
console.log('\n─── BaseStrategy Tests ───');
|
|
|
|
test('BaseStrategy: cannot be instantiated directly', () => {
|
|
try {
|
|
new BaseStrategy();
|
|
throw new Error('Should have thrown');
|
|
} catch (e) {
|
|
assertTrue(e.message.includes('abstract'), 'Should throw abstract error');
|
|
}
|
|
});
|
|
|
|
test('BaseStrategy: isAccountUsable returns false for null account', () => {
|
|
// Create a minimal subclass to test
|
|
class TestStrategy extends BaseStrategy {
|
|
selectAccount() { return { account: null, index: 0 }; }
|
|
}
|
|
const strategy = new TestStrategy();
|
|
assertFalse(strategy.isAccountUsable(null, 'model'), 'Null account should not be usable');
|
|
});
|
|
|
|
test('BaseStrategy: isAccountUsable returns false for invalid account', () => {
|
|
class TestStrategy extends BaseStrategy {
|
|
selectAccount() { return { account: null, index: 0 }; }
|
|
}
|
|
const strategy = new TestStrategy();
|
|
const account = { email: 'test@example.com', isInvalid: true };
|
|
assertFalse(strategy.isAccountUsable(account, 'model'), 'Invalid account should not be usable');
|
|
});
|
|
|
|
test('BaseStrategy: isAccountUsable returns false for disabled account', () => {
|
|
class TestStrategy extends BaseStrategy {
|
|
selectAccount() { return { account: null, index: 0 }; }
|
|
}
|
|
const strategy = new TestStrategy();
|
|
const account = { email: 'test@example.com', enabled: false };
|
|
assertFalse(strategy.isAccountUsable(account, 'model'), 'Disabled account should not be usable');
|
|
});
|
|
|
|
test('BaseStrategy: isAccountUsable returns false for rate-limited model', () => {
|
|
class TestStrategy extends BaseStrategy {
|
|
selectAccount() { return { account: null, index: 0 }; }
|
|
}
|
|
const strategy = new TestStrategy();
|
|
const account = {
|
|
email: 'test@example.com',
|
|
modelRateLimits: {
|
|
'claude-sonnet': {
|
|
isRateLimited: true,
|
|
resetTime: Date.now() + 60000 // 1 minute in future
|
|
}
|
|
}
|
|
};
|
|
assertFalse(strategy.isAccountUsable(account, 'claude-sonnet'), 'Rate-limited model should not be usable');
|
|
});
|
|
|
|
test('BaseStrategy: isAccountUsable returns true for expired rate limit', () => {
|
|
class TestStrategy extends BaseStrategy {
|
|
selectAccount() { return { account: null, index: 0 }; }
|
|
}
|
|
const strategy = new TestStrategy();
|
|
const account = {
|
|
email: 'test@example.com',
|
|
modelRateLimits: {
|
|
'claude-sonnet': {
|
|
isRateLimited: true,
|
|
resetTime: Date.now() - 1000 // 1 second in past
|
|
}
|
|
}
|
|
};
|
|
assertTrue(strategy.isAccountUsable(account, 'claude-sonnet'), 'Expired rate limit should be usable');
|
|
});
|
|
|
|
test('BaseStrategy: getUsableAccounts filters correctly', () => {
|
|
class TestStrategy extends BaseStrategy {
|
|
selectAccount() { return { account: null, index: 0 }; }
|
|
}
|
|
const strategy = new TestStrategy();
|
|
const accounts = [
|
|
{ email: 'a@example.com', enabled: true },
|
|
{ email: 'b@example.com', enabled: false },
|
|
{ email: 'c@example.com', enabled: true, isInvalid: true },
|
|
{ email: 'd@example.com', enabled: true }
|
|
];
|
|
const usable = strategy.getUsableAccounts(accounts, 'model');
|
|
assertEqual(usable.length, 2, 'Should have 2 usable accounts');
|
|
assertEqual(usable[0].account.email, 'a@example.com');
|
|
assertEqual(usable[1].account.email, 'd@example.com');
|
|
});
|
|
|
|
// ==========================================================================
|
|
// STICKY STRATEGY TESTS
|
|
// ==========================================================================
|
|
console.log('\n─── StickyStrategy Tests ───');
|
|
|
|
test('StickyStrategy: returns null for empty accounts', () => {
|
|
const strategy = new StickyStrategy();
|
|
const result = strategy.selectAccount([], 'model', { currentIndex: 0 });
|
|
assertNull(result.account, 'Should return null for empty accounts');
|
|
});
|
|
|
|
test('StickyStrategy: keeps using current account when available', () => {
|
|
const strategy = new StickyStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
|
|
const result1 = strategy.selectAccount(accounts, 'model', { currentIndex: 0 });
|
|
assertEqual(result1.account.email, 'account1@example.com');
|
|
assertEqual(result1.index, 0);
|
|
|
|
const result2 = strategy.selectAccount(accounts, 'model', { currentIndex: 0 });
|
|
assertEqual(result2.account.email, 'account1@example.com', 'Should stick to same account');
|
|
assertEqual(result2.index, 0);
|
|
});
|
|
|
|
test('StickyStrategy: switches when current account is rate-limited', () => {
|
|
const strategy = new StickyStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
// Rate-limit account1 for 5 minutes (longer than MAX_WAIT)
|
|
accounts[0].modelRateLimits = {
|
|
'model': { isRateLimited: true, resetTime: Date.now() + 300000 }
|
|
};
|
|
|
|
const result = strategy.selectAccount(accounts, 'model', { currentIndex: 0 });
|
|
assertEqual(result.account.email, 'account2@example.com', 'Should switch to next available');
|
|
assertEqual(result.index, 1);
|
|
});
|
|
|
|
test('StickyStrategy: returns waitMs when current account has short rate limit', () => {
|
|
const strategy = new StickyStrategy();
|
|
const accounts = createMockAccounts(1); // Only one account
|
|
// Rate-limit for 30 seconds (less than MAX_WAIT of 2 minutes)
|
|
accounts[0].modelRateLimits = {
|
|
'model': { isRateLimited: true, resetTime: Date.now() + 30000 }
|
|
};
|
|
|
|
const result = strategy.selectAccount(accounts, 'model', { currentIndex: 0 });
|
|
assertNull(result.account, 'Should return null when waiting');
|
|
assertWithin(result.waitMs, 29000, 31000, 'Should return ~30s wait time');
|
|
});
|
|
|
|
test('StickyStrategy: switches when current account is disabled', () => {
|
|
const strategy = new StickyStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
accounts[0].enabled = false;
|
|
|
|
const result = strategy.selectAccount(accounts, 'model', { currentIndex: 0 });
|
|
assertEqual(result.account.email, 'account2@example.com', 'Should switch to next');
|
|
});
|
|
|
|
test('StickyStrategy: switches when current account is invalid', () => {
|
|
const strategy = new StickyStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
accounts[0].isInvalid = true;
|
|
|
|
const result = strategy.selectAccount(accounts, 'model', { currentIndex: 0 });
|
|
assertEqual(result.account.email, 'account2@example.com', 'Should switch to next');
|
|
});
|
|
|
|
test('StickyStrategy: wraps around when at end of list', () => {
|
|
const strategy = new StickyStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
accounts[2].isInvalid = true; // Last account invalid
|
|
|
|
const result = strategy.selectAccount(accounts, 'model', { currentIndex: 2 });
|
|
assertEqual(result.account.email, 'account1@example.com', 'Should wrap to first');
|
|
assertEqual(result.index, 0);
|
|
});
|
|
|
|
test('StickyStrategy: clamps invalid currentIndex', () => {
|
|
const strategy = new StickyStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
|
|
const result = strategy.selectAccount(accounts, 'model', { currentIndex: 10 });
|
|
assertEqual(result.account.email, 'account1@example.com', 'Should clamp to valid index');
|
|
assertEqual(result.index, 0);
|
|
});
|
|
|
|
// ==========================================================================
|
|
// ROUND-ROBIN STRATEGY TESTS
|
|
// ==========================================================================
|
|
console.log('\n─── RoundRobinStrategy Tests ───');
|
|
|
|
test('RoundRobinStrategy: returns null for empty accounts', () => {
|
|
const strategy = new RoundRobinStrategy();
|
|
const result = strategy.selectAccount([], 'model');
|
|
assertNull(result.account, 'Should return null for empty accounts');
|
|
});
|
|
|
|
test('RoundRobinStrategy: rotates through accounts', () => {
|
|
const strategy = new RoundRobinStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
|
|
const r1 = strategy.selectAccount(accounts, 'model');
|
|
const r2 = strategy.selectAccount(accounts, 'model');
|
|
const r3 = strategy.selectAccount(accounts, 'model');
|
|
const r4 = strategy.selectAccount(accounts, 'model');
|
|
|
|
// First call starts at cursor 0, looks at (0+1)%3 = 1
|
|
// Then cursor becomes 1, next looks at (1+1)%3 = 2
|
|
// Then cursor becomes 2, next looks at (2+1)%3 = 0
|
|
// Then cursor becomes 0, next looks at (0+1)%3 = 1
|
|
assertEqual(r1.account.email, 'account2@example.com', 'First should be account2');
|
|
assertEqual(r2.account.email, 'account3@example.com', 'Second should be account3');
|
|
assertEqual(r3.account.email, 'account1@example.com', 'Third should wrap to account1');
|
|
assertEqual(r4.account.email, 'account2@example.com', 'Fourth should continue rotation');
|
|
});
|
|
|
|
test('RoundRobinStrategy: skips unavailable accounts', () => {
|
|
const strategy = new RoundRobinStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
accounts[1].enabled = false; // Disable account2
|
|
|
|
const r1 = strategy.selectAccount(accounts, 'model');
|
|
const r2 = strategy.selectAccount(accounts, 'model');
|
|
const r3 = strategy.selectAccount(accounts, 'model');
|
|
|
|
// account2 is skipped
|
|
assertEqual(r1.account.email, 'account3@example.com');
|
|
assertEqual(r2.account.email, 'account1@example.com');
|
|
assertEqual(r3.account.email, 'account3@example.com');
|
|
});
|
|
|
|
test('RoundRobinStrategy: returns null when all accounts unavailable', () => {
|
|
const strategy = new RoundRobinStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
accounts.forEach(a => a.enabled = false);
|
|
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertNull(result.account, 'Should return null when all unavailable');
|
|
});
|
|
|
|
test('RoundRobinStrategy: resetCursor resets position', () => {
|
|
const strategy = new RoundRobinStrategy();
|
|
const accounts = createMockAccounts(3);
|
|
|
|
strategy.selectAccount(accounts, 'model'); // Moves cursor
|
|
strategy.selectAccount(accounts, 'model'); // Moves cursor
|
|
strategy.resetCursor();
|
|
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertEqual(result.account.email, 'account2@example.com', 'Should start from beginning after reset');
|
|
});
|
|
|
|
// ==========================================================================
|
|
// HYBRID STRATEGY TESTS
|
|
// ==========================================================================
|
|
console.log('\n─── HybridStrategy Tests ───');
|
|
|
|
test('HybridStrategy: returns null for empty accounts', () => {
|
|
const strategy = new HybridStrategy();
|
|
const result = strategy.selectAccount([], 'model');
|
|
assertNull(result.account, 'Should return null for empty accounts');
|
|
});
|
|
|
|
test('HybridStrategy: selects best scored account', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70 },
|
|
tokenBucket: { initialTokens: 50, maxTokens: 50 }
|
|
});
|
|
const accounts = createMockAccounts(3);
|
|
// Make account3 older (higher LRU score)
|
|
accounts[2].lastUsed = Date.now() - 3600000; // 1 hour ago
|
|
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
// account3 should win due to higher LRU score
|
|
assertEqual(result.account.email, 'account3@example.com', 'Oldest account should be selected');
|
|
});
|
|
|
|
test('HybridStrategy: filters out unhealthy accounts', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 40, minUsable: 50 },
|
|
tokenBucket: { initialTokens: 50, maxTokens: 50 }
|
|
});
|
|
const accounts = createMockAccounts(3);
|
|
|
|
// All accounts start with health 40, which is below minUsable 50
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertNull(result.account, 'Should filter all accounts with low health');
|
|
});
|
|
|
|
test('HybridStrategy: filters out accounts without tokens', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70 },
|
|
tokenBucket: { initialTokens: 0, maxTokens: 50 }
|
|
});
|
|
const accounts = createMockAccounts(3);
|
|
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertNull(result.account, 'Should filter all accounts without tokens');
|
|
});
|
|
|
|
test('HybridStrategy: consumes token on selection', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70 },
|
|
tokenBucket: { initialTokens: 10, maxTokens: 50 }
|
|
});
|
|
const accounts = createMockAccounts(1);
|
|
|
|
strategy.selectAccount(accounts, 'model');
|
|
const tracker = strategy.getTokenBucketTracker();
|
|
assertEqual(tracker.getTokens(accounts[0].email), 9, 'Token should be consumed');
|
|
});
|
|
|
|
test('HybridStrategy: onSuccess increases health', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70, successReward: 5 }
|
|
});
|
|
const account = { email: 'test@example.com' };
|
|
|
|
strategy.onSuccess(account, 'model');
|
|
const tracker = strategy.getHealthTracker();
|
|
assertEqual(tracker.getScore('test@example.com'), 75, 'Health should increase');
|
|
});
|
|
|
|
test('HybridStrategy: onRateLimit decreases health', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70, rateLimitPenalty: -10 }
|
|
});
|
|
const account = { email: 'test@example.com' };
|
|
|
|
strategy.onRateLimit(account, 'model');
|
|
const tracker = strategy.getHealthTracker();
|
|
assertEqual(tracker.getScore('test@example.com'), 60, 'Health should decrease');
|
|
});
|
|
|
|
test('HybridStrategy: onFailure decreases health and refunds token', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70, failurePenalty: -20 },
|
|
tokenBucket: { initialTokens: 10, maxTokens: 50 }
|
|
});
|
|
const accounts = createMockAccounts(1);
|
|
|
|
// First consume a token
|
|
strategy.selectAccount(accounts, 'model');
|
|
const tokensBefore = strategy.getTokenBucketTracker().getTokens(accounts[0].email);
|
|
|
|
// Then fail
|
|
strategy.onFailure(accounts[0], 'model');
|
|
|
|
const healthTracker = strategy.getHealthTracker();
|
|
const tokenTracker = strategy.getTokenBucketTracker();
|
|
|
|
assertEqual(healthTracker.getScore(accounts[0].email), 50, 'Health should decrease by 20');
|
|
assertEqual(tokenTracker.getTokens(accounts[0].email), tokensBefore + 1, 'Token should be refunded');
|
|
});
|
|
|
|
test('HybridStrategy: scoring formula weights work correctly', () => {
|
|
// Test that health, tokens, and LRU all contribute to score
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 100 },
|
|
tokenBucket: { initialTokens: 50, maxTokens: 50 },
|
|
weights: { health: 2, tokens: 5, lru: 0.1 }
|
|
});
|
|
|
|
const accounts = [
|
|
{ email: 'high-health@example.com', enabled: true, lastUsed: Date.now() },
|
|
{ email: 'old-account@example.com', enabled: true, lastUsed: Date.now() - 3600000 }
|
|
];
|
|
|
|
// Both have same health and tokens, but old-account has higher LRU
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertEqual(result.account.email, 'old-account@example.com', 'Older account should win with LRU weight');
|
|
});
|
|
|
|
test('HybridStrategy: filters out accounts with critical quota', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70 },
|
|
tokenBucket: { initialTokens: 50, maxTokens: 50 },
|
|
quota: { criticalThreshold: 0.05, staleMs: 300000 }
|
|
});
|
|
|
|
const accounts = [
|
|
{
|
|
email: 'critical@example.com',
|
|
enabled: true,
|
|
lastUsed: Date.now() - 3600000, // Older (would normally win LRU)
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.02 } },
|
|
lastChecked: Date.now()
|
|
}
|
|
},
|
|
{
|
|
email: 'healthy@example.com',
|
|
enabled: true,
|
|
lastUsed: Date.now()
|
|
}
|
|
];
|
|
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertEqual(result.account.email, 'healthy@example.com', 'Critical quota account should be excluded');
|
|
});
|
|
|
|
test('HybridStrategy: prefers higher quota accounts', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70 },
|
|
tokenBucket: { initialTokens: 50, maxTokens: 50 },
|
|
quota: { weight: 3 },
|
|
weights: { health: 2, tokens: 5, quota: 3, lru: 0.1 }
|
|
});
|
|
|
|
// Create accounts with same lastUsed (equal LRU)
|
|
const now = Date.now();
|
|
const accounts = [
|
|
{
|
|
email: 'low-quota@example.com',
|
|
enabled: true,
|
|
lastUsed: now,
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.20 } },
|
|
lastChecked: now
|
|
}
|
|
},
|
|
{
|
|
email: 'high-quota@example.com',
|
|
enabled: true,
|
|
lastUsed: now,
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.80 } },
|
|
lastChecked: now
|
|
}
|
|
}
|
|
];
|
|
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertEqual(result.account.email, 'high-quota@example.com', 'Higher quota account should be preferred');
|
|
});
|
|
|
|
test('HybridStrategy: falls back when all accounts have critical quota', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70 },
|
|
tokenBucket: { initialTokens: 50, maxTokens: 50 },
|
|
quota: { criticalThreshold: 0.05, staleMs: 300000 }
|
|
});
|
|
|
|
const accounts = [
|
|
{
|
|
email: 'critical1@example.com',
|
|
enabled: true,
|
|
lastUsed: Date.now() - 60000,
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.02 } },
|
|
lastChecked: Date.now()
|
|
}
|
|
},
|
|
{
|
|
email: 'critical2@example.com',
|
|
enabled: true,
|
|
lastUsed: Date.now(),
|
|
quota: {
|
|
models: { 'model': { remainingFraction: 0.01 } },
|
|
lastChecked: Date.now()
|
|
}
|
|
}
|
|
];
|
|
|
|
// Should fall back and select an account even though all are critical
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertTrue(result.account !== null, 'Should fall back to critical quota accounts when no alternatives');
|
|
});
|
|
|
|
test('HybridStrategy: getQuotaTracker returns tracker', () => {
|
|
const strategy = new HybridStrategy();
|
|
const tracker = strategy.getQuotaTracker();
|
|
assertTrue(tracker instanceof QuotaTracker, 'Should return QuotaTracker instance');
|
|
});
|
|
|
|
// ==========================================================================
|
|
// STRATEGY FACTORY TESTS
|
|
// ==========================================================================
|
|
console.log('\n─── Strategy Factory Tests ───');
|
|
|
|
test('createStrategy: creates StickyStrategy for "sticky"', () => {
|
|
const strategy = createStrategy('sticky');
|
|
assertTrue(strategy instanceof StickyStrategy, 'Should create StickyStrategy');
|
|
});
|
|
|
|
test('createStrategy: creates RoundRobinStrategy for "round-robin"', () => {
|
|
const strategy = createStrategy('round-robin');
|
|
assertTrue(strategy instanceof RoundRobinStrategy, 'Should create RoundRobinStrategy');
|
|
});
|
|
|
|
test('createStrategy: creates RoundRobinStrategy for "roundrobin"', () => {
|
|
const strategy = createStrategy('roundrobin');
|
|
assertTrue(strategy instanceof RoundRobinStrategy, 'Should accept roundrobin alias');
|
|
});
|
|
|
|
test('createStrategy: creates HybridStrategy for "hybrid"', () => {
|
|
const strategy = createStrategy('hybrid');
|
|
assertTrue(strategy instanceof HybridStrategy, 'Should create HybridStrategy');
|
|
});
|
|
|
|
test('createStrategy: falls back to HybridStrategy for unknown strategy', () => {
|
|
const strategy = createStrategy('unknown');
|
|
assertTrue(strategy instanceof HybridStrategy, 'Should fall back to HybridStrategy');
|
|
});
|
|
|
|
test('createStrategy: uses default when null', () => {
|
|
const strategy = createStrategy(null);
|
|
assertTrue(strategy instanceof HybridStrategy, 'Null should use default HybridStrategy');
|
|
});
|
|
|
|
test('createStrategy: is case-insensitive', () => {
|
|
const s1 = createStrategy('STICKY');
|
|
const s2 = createStrategy('Hybrid');
|
|
const s3 = createStrategy('ROUND-ROBIN');
|
|
assertTrue(s1 instanceof StickyStrategy);
|
|
assertTrue(s2 instanceof HybridStrategy);
|
|
assertTrue(s3 instanceof RoundRobinStrategy);
|
|
});
|
|
|
|
test('isValidStrategy: returns true for valid strategies', () => {
|
|
assertTrue(isValidStrategy('sticky'));
|
|
assertTrue(isValidStrategy('round-robin'));
|
|
assertTrue(isValidStrategy('hybrid'));
|
|
assertTrue(isValidStrategy('roundrobin'));
|
|
});
|
|
|
|
test('isValidStrategy: returns false for invalid strategies', () => {
|
|
assertFalse(isValidStrategy('invalid'));
|
|
assertFalse(isValidStrategy(''));
|
|
assertFalse(isValidStrategy(null));
|
|
assertFalse(isValidStrategy(undefined));
|
|
});
|
|
|
|
test('getStrategyLabel: returns correct labels', () => {
|
|
assertEqual(getStrategyLabel('sticky'), 'Sticky (Cache Optimized)');
|
|
assertEqual(getStrategyLabel('round-robin'), 'Round Robin (Load Balanced)');
|
|
assertEqual(getStrategyLabel('roundrobin'), 'Round Robin (Load Balanced)');
|
|
assertEqual(getStrategyLabel('hybrid'), 'Hybrid (Smart Distribution)');
|
|
});
|
|
|
|
test('getStrategyLabel: returns default label for unknown', () => {
|
|
assertEqual(getStrategyLabel('unknown'), 'Hybrid (Smart Distribution)');
|
|
assertEqual(getStrategyLabel(null), 'Hybrid (Smart Distribution)');
|
|
});
|
|
|
|
test('STRATEGY_NAMES contains all valid strategies', () => {
|
|
assertDeepEqual(STRATEGY_NAMES, ['sticky', 'round-robin', 'hybrid']);
|
|
});
|
|
|
|
test('DEFAULT_STRATEGY is hybrid', () => {
|
|
assertEqual(DEFAULT_STRATEGY, 'hybrid');
|
|
});
|
|
|
|
// ==========================================================================
|
|
// INTEGRATION TESTS
|
|
// ==========================================================================
|
|
console.log('\n─── Integration Tests ───');
|
|
|
|
test('Integration: Hybrid strategy recovers from rate limits', () => {
|
|
const strategy = new HybridStrategy({
|
|
healthScore: { initial: 70, rateLimitPenalty: -10, minUsable: 50 }
|
|
});
|
|
const accounts = createMockAccounts(2);
|
|
|
|
// Rate limit first account multiple times
|
|
for (let i = 0; i < 3; i++) {
|
|
strategy.onRateLimit(accounts[0], 'model');
|
|
}
|
|
|
|
// Health of first account should be 40 (below minUsable 50)
|
|
const healthTracker = strategy.getHealthTracker();
|
|
assertEqual(healthTracker.getScore(accounts[0].email), 40);
|
|
assertFalse(healthTracker.isUsable(accounts[0].email));
|
|
|
|
// Selection should prefer second account
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertEqual(result.account.email, 'account2@example.com');
|
|
});
|
|
|
|
test('Integration: Token consumption limits requests', () => {
|
|
const strategy = new HybridStrategy({
|
|
tokenBucket: { initialTokens: 2, maxTokens: 10 }
|
|
});
|
|
const accounts = createMockAccounts(1);
|
|
|
|
// Consume all tokens
|
|
strategy.selectAccount(accounts, 'model'); // 2 -> 1
|
|
strategy.selectAccount(accounts, 'model'); // 1 -> 0
|
|
|
|
// Third request should fail (no tokens)
|
|
const result = strategy.selectAccount(accounts, 'model');
|
|
assertNull(result.account, 'Should return null when tokens exhausted');
|
|
});
|
|
|
|
test('Integration: Multi-model rate limiting is independent', () => {
|
|
const strategy = new StickyStrategy();
|
|
const accounts = createMockAccounts(2);
|
|
|
|
// Rate limit account1 for model-a only
|
|
accounts[0].modelRateLimits = {
|
|
'model-a': { isRateLimited: true, resetTime: Date.now() + 300000 }
|
|
};
|
|
|
|
// model-a should switch to account2
|
|
const resultA = strategy.selectAccount(accounts, 'model-a', { currentIndex: 0 });
|
|
assertEqual(resultA.account.email, 'account2@example.com');
|
|
|
|
// model-b should still use account1
|
|
const resultB = strategy.selectAccount(accounts, 'model-b', { currentIndex: 0 });
|
|
assertEqual(resultB.account.email, 'account1@example.com');
|
|
});
|
|
|
|
// Summary
|
|
console.log('\n' + '═'.repeat(60));
|
|
console.log(`Tests completed: ${passed} passed, ${failed} failed`);
|
|
|
|
if (failed > 0) {
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
runTests().catch(err => {
|
|
console.error('Test suite failed:', err);
|
|
process.exit(1);
|
|
});
|