badgr-cli 1.0.35 → 1.0.37

package/tests/down.test.js

@@ -0,0 +1,128 @@
+/**
+ * badgr down — receipt display and runtime formatting tests
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { downCommand } from '../src/commands/down.js';
+
+vi.mock('../src/api.js', () => ({
+  terminateDeployment: vi.fn(),
+  listDeployments:     vi.fn(),
+}));
+
+vi.mock('../src/store.js', () => ({
+  findDeployment:    vi.fn(() => null),
+  removeDeployment:  vi.fn(),
+  addReceipt:        vi.fn(),
+  generateReceiptId: vi.fn(() => 'rcpt-test-001'),
+}));
+
+vi.mock('../src/config.js', () => ({
+  requireApiKey: vi.fn(),
+}));
+
+import * as api   from '../src/api.js';
+import * as store from '../src/store.js';
+
+const config = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' };
+
+const chalk = {
+  bold:   s => s,
+  dim:    s => s,
+  red:    s => s,
+  yellow: s => s,
+  green:  s => s,
+  cyan:   s => s,
+};
+
+function makeStoppedDep(runtimeSeconds, costPerHour = 1.00) {
+  const now = Date.now() / 1000;
+  return {
+    deployment_id: 'dep-test-001',
+    gpu_type:      'L40S',
+    cost_per_hour: costPerHour,
+    stopped_at:    now,
+    started_at:    now - runtimeSeconds,
+  };
+}
+
+beforeEach(() => {
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  vi.resetAllMocks();
+  store.findDeployment.mockReturnValue(null);
+  store.generateReceiptId.mockReturnValue('rcpt-test-001');
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('runtime display formatting', () => {
+  it('shows minutes only for short runs (< 1h)', async () => {
+    api.terminateDeployment.mockResolvedValue(makeStoppedDep(27 * 60, 0.34));
+    const lines = [];
+    console.log.mockImplementation((...args) => lines.push(args.join(' ')));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    const runtimeLine = lines.find(l => l.includes('Runtime:'));
+    expect(runtimeLine).toMatch(/27m/);
+    expect(runtimeLine).not.toMatch(/\dh/);
+  });
+
+  it('shows hours and minutes for runs >= 1h', async () => {
+    api.terminateDeployment.mockResolvedValue(makeStoppedDep(4091 * 60, 1.00));
+    const lines = [];
+    console.log.mockImplementation((...args) => lines.push(args.join(' ')));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    const runtimeLine = lines.find(l => l.includes('Runtime:'));
+    expect(runtimeLine).toMatch(/2d 20h 11m/);
+    expect(runtimeLine).not.toMatch(/4091m/);
+  });
+
+  it('shows days, hours, minutes for multi-day runs', async () => {
+    api.terminateDeployment.mockResolvedValue(makeStoppedDep(5722 * 60, 0.46));
+    const lines = [];
+    console.log.mockImplementation((...args) => lines.push(args.join(' ')));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    const runtimeLine = lines.find(l => l.includes('Runtime:'));
+    expect(runtimeLine).toMatch(/3d 23h 22m/);
+    expect(runtimeLine).not.toMatch(/5722m/);
+  });
+});
+
+describe('receipt is recorded', () => {
+  it('adds a receipt with correct fields on stop', async () => {
+    api.terminateDeployment.mockResolvedValue(makeStoppedDep(27 * 60, 0.34));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
+      receiptId:    'rcpt-test-001',
+      deploymentId: 'dep-test-001',
+      gpu:          'L40S',
+      status:       'terminated',
+    }));
+    const call = store.addReceipt.mock.calls[0][0];
+    expect(call.runtimeSeconds).toBeCloseTo(27 * 60, -1);
+    expect(call.finalCost).toBeGreaterThan(0);
+  });
+});
+
+describe('error handling', () => {
+  it('prints error and returns when terminateDeployment throws', async () => {
+    api.terminateDeployment.mockRejectedValue(new Error('network error'));
+    const errLines = [];
+    console.error.mockImplementation(msg => errLines.push(msg));
+
+    await downCommand(config, ['dep-test-001'], chalk);
+
+    expect(errLines.join('\n')).toMatch(/network error|Could not stop/i);
+    expect(store.addReceipt).not.toHaveBeenCalled();
+  });
+});

package/tests/launch-readiness.test.js

@@ -324,3 +324,54 @@ describe('compat_failure error message', () => {
     expect(thrown.message).toMatch(/GPU type|image/i);
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 4. Stale-capacity retry — PROVISIONING_FAILED triggers one immediate retry
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('stale-capacity retry on PROVISIONING_FAILED', () => {
+  function makeProvisioningFailedErr() {
+    const err = new Error('PROVISIONING_FAILED');
+    err.errorData = { code: 'PROVISIONING_FAILED', failure_category: 'infrastructure' };
+    return err;
+  }
+
+  it('retries the API call once before escalating on PROVISIONING_FAILED (tier=2 → no tier-2 expansion)', async () => {
+    // tier=2 means no tier-2 fallback expansion, so only the stale-capacity retry fires.
+    api.callApi.mockRejectedValue(makeProvisioningFailedErr());
+
+    try {
+      await callWithFallback(
+        '/run',
+        { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' },
+        () => ({}),
+        '2',
+        chalk,
+        { thing: 'job', cmd: 'badgr run' },
+      );
+    } catch (_) {}
+
+    // First attempt + one stale-capacity retry = 2 calls minimum
+    expect(api.callApi.mock.calls.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('does NOT double-retry on non-PROVISIONING_FAILED errors', async () => {
+    const err = new Error('NO_CAPACITY_MATCH');
+    err.errorData = { code: 'NO_CAPACITY_MATCH' };
+    api.callApi.mockRejectedValue(err);
+
+    try {
+      await callWithFallback(
+        '/run',
+        { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' },
+        () => ({}),
+        '2',
+        chalk,
+        { thing: 'job', cmd: 'badgr run' },
+      );
+    } catch (_) {}
+
+    // tier=2 → no tier-2 expansion; no stale-capacity retry for NO_CAPACITY_MATCH
+    expect(api.callApi.mock.calls.length).toBe(1);
+  });
+});

package/tests/serve-lifecycle.test.js

@@ -22,6 +22,7 @@ import { serveCommand } from '../src/commands/serve.js';
 vi.mock('../src/api.js', () => ({
   callApi:             vi.fn(),
   terminateDeployment: vi.fn().mockResolvedValue({}),
+  listDeployments:     vi.fn().mockResolvedValue({ deployments: [], count: 0 }),
 }));
 
 vi.mock('../src/store.js', () => ({
@@ -107,7 +108,7 @@ describe('successful serve', () => {
       text: async () => '',
     });
 
-    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--gpu', 'L40S'], chalk);
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--gpu', 'L40S', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -131,7 +132,7 @@ describe('successful serve', () => {
 
     global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => ({}) });
 
-    const p = serveCommand(config, ['mistralai/Mistral-7B-v0.1', '--gpu', 'A100'], chalk);
+    const p = serveCommand(config, ['mistralai/Mistral-7B-v0.1', '--gpu', 'A100', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -156,7 +157,7 @@ describe('billing ends when deployment stops', () => {
 
     global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => ({}) });
 
-    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct'], chalk);
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -182,7 +183,7 @@ describe('deployment fails during startup', () => {
       .mockResolvedValueOnce(makeServeDep()) // POST /serve
       .mockResolvedValueOnce({ status: 'failed', error: 'OOM: not enough VRAM' }); // pre-health check
 
-    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct'], chalk);
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(2000);
     await p;
 
@@ -201,7 +202,7 @@ describe('deployment fails during startup', () => {
     // Health check endpoint doesn't respond (dep crashed)
     global.fetch = vi.fn().mockRejectedValue(new Error('Connection refused'));
 
-    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct'], chalk);
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
     // need to advance past the 8000ms sleep in waitForEndpoint loop
     await vi.advanceTimersByTimeAsync(10000);
     await p;
@@ -227,7 +228,7 @@ describe('health check timeout', () => {
     // Health endpoint never responds
     global.fetch = vi.fn().mockRejectedValue(new Error('ETIMEDOUT'));
 
-    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct'], chalk);
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
     // waitForEndpoint timeout is 5 * 60 * 1000 = 300000ms
     await vi.advanceTimersByTimeAsync(310000);
     await p;
@@ -256,7 +257,7 @@ describe('invalid model ID or no capacity', () => {
     const errLines = [];
     console.error.mockImplementation(msg => errLines.push(msg));
 
-    await serveCommand(config, ['invalid/nonexistent-model-xyz'], chalk);
+    await serveCommand(config, ['invalid/nonexistent-model-xyz', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     const combined = errLines.join('\n');
@@ -276,7 +277,7 @@ describe('invalid model ID or no capacity', () => {
     const errLines = [];
     console.error.mockImplementation(msg => errLines.push(msg));
 
-    await serveCommand(config, ['my-org/private-model'], chalk);
+    await serveCommand(config, ['my-org/private-model', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     // Debug info hidden by default (BADGR_DEBUG not set)
@@ -293,7 +294,7 @@ describe('invalid model ID or no capacity', () => {
     });
     api.callApi.mockRejectedValue(provErr);
 
-    await serveCommand(config, ['some/model', '--task', 'unknown_task'], chalk);
+    await serveCommand(config, ['some/model', '--task', 'unknown_task', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     expect(store.addDeployment).not.toHaveBeenCalled();
@@ -309,7 +310,7 @@ describe('--no-wait flag', () => {
     api.callApi.mockResolvedValueOnce(makeServeDep());
     global.fetch = vi.fn(); // should never be called
 
-    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--no-wait'], chalk);
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--no-wait', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(100);
     await p;
 
@@ -333,7 +334,7 @@ describe('custom image health check', () => {
 
     const p = serveCommand(
       config,
-      ['--image', 'ghcr.io/my-org/diffusers-api:latest', '--gpu', 'L40S'],
+      ['--image', 'ghcr.io/my-org/diffusers-api:latest', '--gpu', 'L40S', '--max-cost', '5'],
       chalk,
     );
     await vi.advanceTimersByTimeAsync(100);
@@ -356,7 +357,7 @@ describe('custom image health check', () => {
 
     const p = serveCommand(
       config,
-      ['--image', 'ghcr.io/my-org/comfyui-custom:latest', '--gpu', 'A100'],
+      ['--image', 'ghcr.io/my-org/comfyui-custom:latest', '--gpu', 'A100', '--max-cost', '5'],
       chalk,
     );
     await vi.advanceTimersByTimeAsync(5000);
@@ -380,7 +381,7 @@ describe('custom image health check', () => {
 
     const p = serveCommand(
       config,
-      ['--image', 'ghcr.io/my-org/stable-diffusion:latest', '--health-path', '/health'],
+      ['--image', 'ghcr.io/my-org/stable-diffusion:latest', '--health-path', '/health', '--max-cost', '5'],
       chalk,
     );
     await vi.advanceTimersByTimeAsync(5000);
@@ -404,7 +405,7 @@ describe('custom image health check', () => {
 
     const p = serveCommand(
       config,
-      ['meta-llama/Llama-3.1-8B-Instruct', '--health-path', '/v1/health'],
+      ['meta-llama/Llama-3.1-8B-Instruct', '--health-path', '/v1/health', '--max-cost', '5'],
       chalk,
     );
     await vi.advanceTimersByTimeAsync(5000);
@@ -433,7 +434,7 @@ describe('tier-2 fallback for serve', () => {
 
     global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => ({}) });
 
-    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct'], chalk);
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -450,7 +451,7 @@ describe('tier-2 fallback for serve', () => {
     });
     api.callApi.mockRejectedValueOnce(capacityErr);
 
-    await serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--no-fallback'], chalk);
+    await serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--no-fallback', '--max-cost', '5'], chalk);
 
     const postCalls = api.callApi.mock.calls.filter(c => c[1]?.method === 'POST');
     expect(postCalls.length).toBe(1);
@@ -466,7 +467,7 @@ describe('missing endpoint URL guard', () => {
   it('exits with error when backend returns no endpoint_url', async () => {
     api.callApi.mockResolvedValueOnce(makeServeDep({ endpoint_url: null, openai_base_url: null }));
 
-    await serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct'], chalk);
+    await serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({