badgr-cli 1.0.0

package/tests/config.test.js

@@ -0,0 +1,73 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { rmSync, existsSync } from 'fs';
+import { loadConfig, saveConfig, requireApiKey, DEFAULTS } from '../src/config.js';
+
+const tmp = join(tmpdir(), `gpu-cli-test-${process.pid}`);
+const testConfigFile = join(tmp, 'config.json');
+
+afterEach(() => {
+  if (existsSync(tmp)) rmSync(tmp, { recursive: true, force: true });
+});
+
+describe('loadConfig', () => {
+  it('returns defaults when file does not exist', () => {
+    const config = loadConfig('/nonexistent/path/config.json');
+    expect(config.baseUrl).toBe(DEFAULTS.baseUrl);
+    expect(config.defaultModel).toBe(DEFAULTS.defaultModel);
+    expect(config.apiKey).toBeUndefined();
+  });
+
+  it('merges saved values with defaults', () => {
+    saveConfig({ apiKey: 'sk-test' }, testConfigFile);
+    const config = loadConfig(testConfigFile);
+    expect(config.apiKey).toBe('sk-test');
+    expect(config.baseUrl).toBe(DEFAULTS.baseUrl);
+  });
+
+  it('returns defaults on corrupt file', () => {
+    import('fs').then(({ writeFileSync, mkdirSync }) => {
+      mkdirSync(tmp, { recursive: true });
+      writeFileSync(testConfigFile, '{ invalid json }');
+    });
+    const config = loadConfig(testConfigFile);
+    expect(config.baseUrl).toBe(DEFAULTS.baseUrl);
+  });
+});
+
+describe('saveConfig', () => {
+  it('persists values and returns merged config', () => {
+    const saved = saveConfig({ apiKey: 'sk-123' }, testConfigFile);
+    expect(saved.apiKey).toBe('sk-123');
+    expect(saved.baseUrl).toBe(DEFAULTS.baseUrl);
+  });
+
+  it('merges with existing values', () => {
+    saveConfig({ apiKey: 'original' }, testConfigFile);
+    saveConfig({ baseUrl: 'http://localhost:8000/v1' }, testConfigFile);
+    const config = loadConfig(testConfigFile);
+    expect(config.apiKey).toBe('original');
+    expect(config.baseUrl).toBe('http://localhost:8000/v1');
+  });
+
+  it('creates missing directories', () => {
+    const deepFile = join(tmp, 'deep', 'nested', 'config.json');
+    saveConfig({ apiKey: 'deep' }, deepFile);
+    expect(existsSync(deepFile)).toBe(true);
+  });
+});
+
+describe('requireApiKey', () => {
+  it('returns the key when present', () => {
+    expect(requireApiKey({ apiKey: 'sk-abc' })).toBe('sk-abc');
+  });
+
+  it('throws an error mentioning `badgr login` when missing', () => {
+    expect(() => requireApiKey({})).toThrow('badgr login');
+  });
+
+  it('throws when apiKey is empty string', () => {
+    expect(() => requireApiKey({ apiKey: '' })).toThrow();
+  });
+});

package/tests/router.test.js

@@ -0,0 +1,157 @@
+import { describe, it, expect } from 'vitest';
+import {
+  findById, findByCanonical, findCheapest, listAll,
+  getRoutePlan, estimateCost,
+  GPU_CATALOG, PROVIDER_CATALOG,
+} from '../src/router.js';
+
+describe('findById', () => {
+  it('finds GPU by id', () => {
+    expect(findById('rtx-4090').name).toContain('4090');
+  });
+
+  it('returns null for unknown id', () => {
+    expect(findById('rtx-9999')).toBeNull();
+  });
+});
+
+describe('findByCanonical', () => {
+  it('finds GPU by canonical name', () => {
+    expect(findByCanonical('RTX_4090').id).toBe('rtx-4090');
+  });
+
+  it('returns null for unknown canonical', () => {
+    expect(findByCanonical('RTX_9999')).toBeNull();
+  });
+});
+
+describe('findCheapest', () => {
+  it('returns a GPU with no requirements', () => {
+    expect(findCheapest()).not.toBeNull();
+  });
+
+  it('returns the cheapest overall', () => {
+    const gpu = findCheapest();
+    const allRates = GPU_CATALOG.map(g => g.ratePerHour);
+    expect(gpu.ratePerHour).toBe(Math.min(...allRates));
+  });
+
+  it('filters by minVramGb', () => {
+    const gpu = findCheapest({ minVramGb: 40 });
+    expect(gpu.vramGb).toBeGreaterThanOrEqual(40);
+  });
+
+  it('filters by tag', () => {
+    const gpu = findCheapest({ tag: 'large-model' });
+    expect(gpu.tags).toContain('large-model');
+  });
+
+  it('returns null when no match', () => {
+    expect(findCheapest({ minVramGb: 999 })).toBeNull();
+  });
+});
+
+describe('listAll', () => {
+  it('returns all GPUs sorted by rate ascending', () => {
+    const gpus = listAll();
+    expect(gpus.length).toBe(GPU_CATALOG.length);
+    for (let i = 1; i < gpus.length; i++) {
+      expect(gpus[i].ratePerHour).toBeGreaterThanOrEqual(gpus[i - 1].ratePerHour);
+    }
+  });
+
+  it('does not mutate the original catalog', () => {
+    const before = GPU_CATALOG.map(g => g.ratePerHour);
+    listAll();
+    expect(GPU_CATALOG.map(g => g.ratePerHour)).toEqual(before);
+  });
+});
+
+describe('getRoutePlan', () => {
+  it('returns lane1 and lane2 for RTX_4090', () => {
+    const plan = getRoutePlan('RTX_4090');
+    expect(plan.lane1).toBeTruthy();
+    expect(plan.lane2.length).toBeGreaterThan(0);
+  });
+
+  it('lane2 is sorted cheapest-first', () => {
+    const plan = getRoutePlan('RTX_4090');
+    for (let i = 1; i < plan.lane2.length; i++) {
+      expect(plan.lane2[i].ratePerHour).toBeGreaterThanOrEqual(plan.lane2[i - 1].ratePerHour);
+    }
+  });
+
+  it('scales ratePerHour by count', () => {
+    const plan1 = getRoutePlan('RTX_4090', 1);
+    const plan2 = getRoutePlan('RTX_4090', 2);
+    expect(plan2.lane2[0].ratePerHour).toBeCloseTo(plan1.lane2[0].ratePerHour * 2, 5);
+  });
+
+  it('cheapestRate matches first provider rate', () => {
+    const plan = getRoutePlan('H100');
+    expect(plan.cheapestRate).toBe(plan.lane2[0].ratePerHour);
+  });
+
+  it('costWithOverhead > cheapestRate', () => {
+    const plan = getRoutePlan('RTX_4090');
+    expect(plan.costWithOverhead).toBeGreaterThan(plan.cheapestRate);
+  });
+
+  it('includes gpu info for known canonical', () => {
+    const plan = getRoutePlan('H100');
+    expect(plan.gpu).not.toBeNull();
+    expect(plan.gpu.id).toBe('h100');
+  });
+});
+
+describe('estimateCost', () => {
+  it('calculates cost for 60 minutes = 1 hour', () => {
+    expect(estimateCost(1.10, 60)).toBeCloseTo(1.10, 5);
+  });
+
+  it('calculates cost for 30 minutes = half rate', () => {
+    expect(estimateCost(2.00, 30)).toBeCloseTo(1.00, 5);
+  });
+
+  it('returns 0 for 0 minutes', () => {
+    expect(estimateCost(3.50, 0)).toBe(0);
+  });
+});
+
+describe('L40S', () => {
+  it('exists in GPU_CATALOG', () => {
+    expect(findById('l40s')).not.toBeNull();
+    expect(findByCanonical('L40S').vramGb).toBe(48);
+  });
+
+  it('has provider pricing in PROVIDER_CATALOG', () => {
+    expect(Array.isArray(PROVIDER_CATALOG['L40S'])).toBe(true);
+    expect(PROVIDER_CATALOG['L40S'].length).toBeGreaterThan(0);
+  });
+
+  it('route plan is cheapest-first for L40S', () => {
+    const plan = getRoutePlan('L40S');
+    expect(plan.lane2.length).toBeGreaterThan(0);
+    for (let i = 1; i < plan.lane2.length; i++) {
+      expect(plan.lane2[i].ratePerHour).toBeGreaterThanOrEqual(plan.lane2[i - 1].ratePerHour);
+    }
+  });
+});
+
+describe('PROVIDER_CATALOG', () => {
+  it('exists for all GPU_CATALOG canonical types', () => {
+    const catalogCanonicals = [...new Set(GPU_CATALOG.map(g => g.canonical))];
+    catalogCanonicals.forEach(c => {
+      // Some may not have provider pricing — just check the ones that do are valid arrays
+      if (PROVIDER_CATALOG[c]) {
+        expect(Array.isArray(PROVIDER_CATALOG[c])).toBe(true);
+        PROVIDER_CATALOG[c].forEach(p => {
+          expect(p.provider).toBeTruthy();
+          expect(p.ratePerHour).toBeGreaterThan(0);
+          expect(p.reliability).toBeGreaterThan(0);
+          expect(p.reliability).toBeLessThanOrEqual(1);
+        });
+      }
+    });
+  });
+});

package/tests/spec.test.js

@@ -0,0 +1,143 @@
+import { describe, it, expect } from 'vitest';
+import { parseSpec, validateSpec, specLines, parseFlags, normalizeGpuType } from '../src/spec.js';
+
+describe('normalizeGpuType', () => {
+  it('maps RTX-4090 to RTX_4090', () => expect(normalizeGpuType('RTX-4090')).toBe('RTX_4090'));
+  it('maps rtx4090 to RTX_4090', ()  => expect(normalizeGpuType('rtx4090')).toBe('RTX_4090'));
+  it('maps 4090 to RTX_4090', ()     => expect(normalizeGpuType('4090')).toBe('RTX_4090'));
+  it('maps h100 to H100', ()         => expect(normalizeGpuType('h100')).toBe('H100'));
+  it('maps a100 to A100', ()         => expect(normalizeGpuType('a100')).toBe('A100'));
+  it('defaults null to RTX_4090', () => expect(normalizeGpuType(null)).toBe('RTX_4090'));
+  it('uppercases unknown types', ()  => expect(normalizeGpuType('l40s')).toBe('L40S'));
+});
+
+describe('parseFlags', () => {
+  it('parses --key value pairs', () => {
+    const f = parseFlags(['--model', 'llama-3', '--gpu', 'RTX_4090']);
+    expect(f.model).toBe('llama-3');
+    expect(f.gpu).toBe('RTX_4090');
+  });
+
+  it('parses boolean flags', () => {
+    const f = parseFlags(['--dry-run']);
+    expect(f['dry-run']).toBe(true);
+  });
+
+  it('handles mixed flags and values', () => {
+    const f = parseFlags(['--model', 'gpt2', '--dry-run', '--count', '2']);
+    expect(f.model).toBe('gpt2');
+    expect(f['dry-run']).toBe(true);
+    expect(f.count).toBe('2');
+  });
+});
+
+describe('parseSpec', () => {
+  it('defaults to endpoint type with default model', () => {
+    const spec = parseSpec([]);
+    expect(spec.type).toBe('endpoint');
+    expect(spec.model).toBeTruthy();
+    expect(spec.count).toBe(1);
+    expect(spec.region).toBe('US');
+  });
+
+  it('infers job type from --image', () => {
+    const spec = parseSpec(['--image', 'vllm/vllm-openai:latest']);
+    expect(spec.type).toBe('job');
+    expect(spec.image).toBe('vllm/vllm-openai:latest');
+  });
+
+  it('respects explicit --type', () => {
+    const spec = parseSpec(['--type', 'job', '--image', 'myimg:latest']);
+    expect(spec.type).toBe('job');
+  });
+
+  it('parses all flags', () => {
+    const spec = parseSpec([
+      '--model', 'llama-3',
+      '--gpu', 'H100',
+      '--count', '2',
+      '--region', 'EU',
+      '--max-price', '3.00',
+      '--name', 'my-deploy',
+    ]);
+    expect(spec.model).toBe('llama-3');
+    expect(spec.gpu).toBe('H100');
+    expect(spec.count).toBe(2);
+    expect(spec.region).toBe('EU');
+    expect(spec.maxPrice).toBe(3.00);
+    expect(spec.name).toBe('my-deploy');
+  });
+
+  it('sets dryRun when --dry-run present', () => {
+    const spec = parseSpec(['--dry-run']);
+    expect(spec.dryRun).toBe(true);
+  });
+
+  it('normalizes GPU type', () => {
+    const spec = parseSpec(['--gpu', 'rtx-4090']);
+    expect(spec.gpu).toBe('RTX_4090');
+  });
+
+  it('--endpoint shorthand sets type to endpoint', () => {
+    const spec = parseSpec(['--endpoint', '--model', 'X']);
+    expect(spec.type).toBe('endpoint');
+  });
+
+  it('--job shorthand sets type to job', () => {
+    const spec = parseSpec(['--job', '--image', 'myimg:latest']);
+    expect(spec.type).toBe('job');
+  });
+
+  it('--type takes precedence over shorthands', () => {
+    const spec = parseSpec(['--type', 'job', '--endpoint']);
+    expect(spec.type).toBe('job');
+  });
+
+  it('parses L40S gpu', () => {
+    const spec = parseSpec(['--endpoint', '--model', 'X', '--gpu', 'L40S']);
+    expect(spec.gpu).toBe('L40S');
+  });
+});
+
+describe('validateSpec', () => {
+  it('returns no errors for valid endpoint spec', () => {
+    const spec = parseSpec(['--model', 'llama-3', '--gpu', 'RTX_4090']);
+    expect(validateSpec(spec)).toEqual([]);
+  });
+
+  it('returns error for invalid type', () => {
+    const spec = { ...parseSpec([]), type: 'invalid' };
+    const errors = validateSpec(spec);
+    expect(errors.some(e => e.includes('type'))).toBe(true);
+  });
+
+  it('returns error for count out of range', () => {
+    const spec = { ...parseSpec([]), count: 0 };
+    expect(validateSpec(spec).some(e => e.includes('count'))).toBe(true);
+  });
+
+  it('returns error for invalid region', () => {
+    const spec = { ...parseSpec([]), region: 'MARS' };
+    expect(validateSpec(spec).some(e => e.includes('region'))).toBe(true);
+  });
+});
+
+describe('specLines', () => {
+  it('includes type and gpu', () => {
+    const spec = parseSpec(['--model', 'llama-3', '--gpu', 'RTX_4090']);
+    const lines = specLines(spec);
+    expect(lines.some(l => l.includes('endpoint'))).toBe(true);
+    expect(lines.some(l => l.includes('RTX_4090'))).toBe(true);
+  });
+
+  it('includes model when present', () => {
+    const spec = parseSpec(['--model', 'llama-3']);
+    expect(specLines(spec).some(l => l.includes('llama-3'))).toBe(true);
+  });
+
+  it('omits null fields', () => {
+    const spec = { ...parseSpec([]), maxPrice: null, name: null };
+    const lines = specLines(spec);
+    expect(lines.every(l => l !== null)).toBe(true);
+  });
+});

package/tests/store.test.js

@@ -0,0 +1,126 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { rmSync, existsSync } from 'fs';
+import {
+  loadStore, saveStore,
+  addDeployment, updateDeployment, removeDeployment, findDeployment, listDeployments,
+  addReceipt, listReceipts,
+  generateDeploymentId, generateReceiptId,
+} from '../src/store.js';
+
+const tmp  = join(tmpdir(), `gpu-store-test-${process.pid}`);
+const file = join(tmp, 'deployments.json');
+
+afterEach(() => {
+  if (existsSync(tmp)) rmSync(tmp, { recursive: true, force: true });
+});
+
+const makeDep = (overrides = {}) => ({
+  id:          generateDeploymentId(),
+  name:        'test-dep',
+  type:        'endpoint',
+  gpu:         'RTX_4090',
+  count:       1,
+  status:      'running',
+  provider:    'vastai',
+  endpointUrl: 'https://api.gpu.ai/v1',
+  createdAt:   new Date().toISOString(),
+  ...overrides,
+});
+
+describe('generateDeploymentId / generateReceiptId', () => {
+  it('deploymentId starts with dep-', () => {
+    expect(generateDeploymentId()).toMatch(/^dep-[a-f0-9]{8}$/);
+  });
+
+  it('receiptId starts with rcpt-', () => {
+    expect(generateReceiptId()).toMatch(/^rcpt-[a-f0-9]{10}$/);
+  });
+
+  it('generates unique IDs', () => {
+    const ids = new Set(Array.from({ length: 50 }, () => generateDeploymentId()));
+    expect(ids.size).toBe(50);
+  });
+});
+
+describe('loadStore / saveStore', () => {
+  it('returns empty store when file does not exist', () => {
+    const store = loadStore('/nonexistent/path/deps.json');
+    expect(store.deployments).toEqual([]);
+    expect(store.receipts).toEqual([]);
+  });
+
+  it('round-trips data', () => {
+    const data = { deployments: [makeDep()], receipts: [] };
+    saveStore(data, file);
+    expect(loadStore(file).deployments).toHaveLength(1);
+  });
+});
+
+describe('addDeployment / listDeployments / findDeployment', () => {
+  it('adds and retrieves by id', () => {
+    const dep = makeDep({ id: 'dep-aaa' });
+    addDeployment(dep, file);
+    expect(findDeployment('dep-aaa', file)).toMatchObject({ id: 'dep-aaa' });
+  });
+
+  it('retrieves by name', () => {
+    addDeployment(makeDep({ name: 'my-model' }), file);
+    expect(findDeployment('my-model', file)).toMatchObject({ name: 'my-model' });
+  });
+
+  it('returns null for missing deployment', () => {
+    expect(findDeployment('not-there', file)).toBeNull();
+  });
+
+  it('listDeployments returns all', () => {
+    addDeployment(makeDep({ id: 'dep-1', name: 'd1' }), file);
+    addDeployment(makeDep({ id: 'dep-2', name: 'd2' }), file);
+    expect(listDeployments(file)).toHaveLength(2);
+  });
+});
+
+describe('updateDeployment', () => {
+  it('updates status field', () => {
+    const dep = makeDep({ id: 'dep-upd' });
+    addDeployment(dep, file);
+    const updated = updateDeployment('dep-upd', { status: 'stopped' }, file);
+    expect(updated.status).toBe('stopped');
+    expect(findDeployment('dep-upd', file).status).toBe('stopped');
+  });
+
+  it('returns null for missing deployment', () => {
+    expect(updateDeployment('dep-missing', { status: 'stopped' }, file)).toBeNull();
+  });
+});
+
+describe('removeDeployment', () => {
+  it('removes and returns deployment', () => {
+    addDeployment(makeDep({ id: 'dep-rm' }), file);
+    const removed = removeDeployment('dep-rm', file);
+    expect(removed.id).toBe('dep-rm');
+    expect(findDeployment('dep-rm', file)).toBeNull();
+  });
+
+  it('returns null when not found', () => {
+    expect(removeDeployment('dep-missing', file)).toBeNull();
+  });
+});
+
+describe('addReceipt / listReceipts', () => {
+  it('stores and retrieves receipts newest-first', () => {
+    addReceipt({ receiptId: 'r1', action: 'gpu up' }, file);
+    addReceipt({ receiptId: 'r2', action: 'gpu down' }, file);
+    const receipts = listReceipts(10, file);
+    expect(receipts[0].receiptId).toBe('r2'); // newest first
+    expect(receipts[1].receiptId).toBe('r1');
+  });
+
+  it('respects limit', () => {
+    for (let i = 0; i < 5; i++) {
+      addReceipt({ receiptId: `r${i}`, action: 'gpu up' }, file);
+    }
+    expect(listReceipts(3, file)).toHaveLength(3);
+  });
+});