badgr-cli 1.1.1 → 1.1.2

package/tests/api.test.js

@@ -1,168 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { callApi, listModels, chatCompletion, submitJob, getJobStatus, listReceipts, getReceipt, runJob, serveModel, uploadBlob } from '../src/api.js';
-
-const mockConfig = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1', defaultModel: 'llama-3' };
-
-function mockFetch(data, ok = true, status = 200) {
-  global.fetch = vi.fn().mockResolvedValue({
-    ok, status,
-    json:  async () => data,
-    text:  async () => JSON.stringify(data),
-  });
-}
-
-describe('callApi', () => {
-  it('includes Authorization header', async () => {
-    mockFetch({ data: [] });
-    await callApi('/models', { apiKey: 'sk-abc', baseUrl: 'https://api.test/v1' });
-    const [, init] = global.fetch.mock.calls[0];
-    expect(init.headers.Authorization).toBe('Bearer sk-abc');
-  });
-
-  it('throws on non-ok response with status code', async () => {
-    mockFetch('Unauthorized', false, 401);
-    await expect(callApi('/models', { apiKey: 'bad', baseUrl: 'https://api.test/v1' })).rejects.toThrow('401');
-  });
-
-  it('sends JSON body for POST', async () => {
-    mockFetch({ id: 'j1' });
-    await callApi('/jobs', { method: 'POST', apiKey: 'sk-x', baseUrl: 'https://api.test/v1', body: { script: 'a.py' } });
-    expect(JSON.parse(global.fetch.mock.calls[0][1].body)).toEqual({ script: 'a.py' });
-  });
-
-  it('omits body for GET', async () => {
-    mockFetch({});
-    await callApi('/models', { apiKey: 'x', baseUrl: 'https://api.test/v1' });
-    expect(global.fetch.mock.calls[0][1].body).toBeUndefined();
-  });
-});
-
-describe('chatCompletion', () => {
-  it('POST /chat/completions with messages', async () => {
-    mockFetch({ choices: [{ message: { content: 'hi' } }] });
-    const msgs = [{ role: 'user', content: 'hello' }];
-    await chatCompletion(mockConfig, msgs);
-    const [url, init] = global.fetch.mock.calls[0];
-    expect(url).toContain('/chat/completions');
-    expect(JSON.parse(init.body).messages).toEqual(msgs);
-  });
-
-  it('uses defaultModel when no model option', async () => {
-    mockFetch({ choices: [] });
-    await chatCompletion(mockConfig, []);
-    expect(JSON.parse(global.fetch.mock.calls[0][1].body).model).toBe('llama-3');
-  });
-
-  it('uses provided model over default', async () => {
-    mockFetch({ choices: [] });
-    await chatCompletion(mockConfig, [], { model: 'gpt-4o' });
-    expect(JSON.parse(global.fetch.mock.calls[0][1].body).model).toBe('gpt-4o');
-  });
-});
-
-describe('listModels', () => {
-  it('calls GET /models', async () => {
-    mockFetch({ data: [{ id: 'llama-3' }] });
-    const result = await listModels(mockConfig);
-    expect(global.fetch).toHaveBeenCalledWith(expect.stringContaining('/models'), expect.any(Object));
-    expect(result.data[0].id).toBe('llama-3');
-  });
-});
-
-describe('submitJob / getJobStatus', () => {
-  it('POST /jobs with job body', async () => {
-    mockFetch({ jobId: 'abc-123' });
-    const result = await submitJob(mockConfig, { script: 'train.py', gpuType: 'rtx-4090' });
-    expect(result.jobId).toBe('abc-123');
-  });
-
-  it('GET /jobs/:id', async () => {
-    mockFetch({ status: 'running' });
-    await getJobStatus(mockConfig, 'job-xyz');
-    expect(global.fetch).toHaveBeenCalledWith(expect.stringContaining('/jobs/job-xyz'), expect.any(Object));
-  });
-});
-
-describe('listReceipts', () => {
-  it('calls GET /receipts', async () => {
-    mockFetch({ object: 'list', data: [] });
-    await listReceipts(mockConfig);
-    const [url] = global.fetch.mock.calls[0];
-    expect(url).toContain('/receipts');
-  });
-
-  it('appends limit query param', async () => {
-    mockFetch({ object: 'list', data: [] });
-    await listReceipts(mockConfig, { limit: 50 });
-    const [url] = global.fetch.mock.calls[0];
-    expect(url).toContain('limit=50');
-  });
-
-  it('appends status filter when provided', async () => {
-    mockFetch({ object: 'list', data: [] });
-    await listReceipts(mockConfig, { status: 'success' });
-    const [url] = global.fetch.mock.calls[0];
-    expect(url).toContain('status=success');
-  });
-});
-
-describe('getReceipt', () => {
-  it('calls GET /receipts/:id', async () => {
-    mockFetch({ request_id: 'req-123', status: 'success' });
-    const result = await getReceipt(mockConfig, 'req-123');
-    expect(global.fetch).toHaveBeenCalledWith(expect.stringContaining('/receipts/req-123'), expect.any(Object));
-    expect(result.request_id).toBe('req-123');
-  });
-});
-
-describe('runJob', () => {
-  it('POST /run with job spec', async () => {
-    mockFetch({ deployment_id: 'dep-abc', status: 'running', provider: 'runpod' });
-    const result = await runJob(mockConfig, { command: ['python', 'train.py'], gpu: 'A100' });
-    const [url, init] = global.fetch.mock.calls[0];
-    expect(url).toContain('/run');
-    expect(init.method).toBe('POST');
-    expect(JSON.parse(init.body).gpu).toBe('A100');
-    expect(result.deployment_id).toBe('dep-abc');
-  });
-});
-
-describe('serveModel', () => {
-  it('POST /serve with model spec', async () => {
-    mockFetch({ deployment_id: 'dep-xyz', status: 'running', endpoint_url: 'https://api.badgr.ai/v1' });
-    const result = await serveModel(mockConfig, { model: 'meta-llama/Llama-3.1-8B-Instruct', gpu: 'L40S' });
-    const [url, init] = global.fetch.mock.calls[0];
-    expect(url).toContain('/serve');
-    expect(init.method).toBe('POST');
-    expect(JSON.parse(init.body).model).toBe('meta-llama/Llama-3.1-8B-Instruct');
-    expect(result.deployment_id).toBe('dep-xyz');
-  });
-});
-
-describe('uploadBlob', () => {
-  it('POSTs multipart form data to /v1/uploads with Authorization, no manual Content-Type', async () => {
-    mockFetch({ upload_id: 'up_1', code_uri: 'https://api.test/v1/uploads/up_1/download?token=t' });
-    const result = await uploadBlob(mockConfig, { data: Buffer.from('hello'), filename: 'a.txt' });
-    const [url, init] = global.fetch.mock.calls[0];
-    expect(url).toBe('https://api.test/v1/uploads');
-    expect(init.method).toBe('POST');
-    expect(init.body).toBeInstanceOf(FormData);
-    expect(init.headers.Authorization).toBe('Bearer sk-test');
-    expect(init.headers['Content-Type']).toBeUndefined();
-    expect(result.upload_id).toBe('up_1');
-    expect(result.code_uri).toContain('up_1');
-  });
-
-  it('sets the Blob content type when contentType is given', async () => {
-    mockFetch({ upload_id: 'up_2', code_uri: 'https://x/up_2' });
-    await uploadBlob(mockConfig, { data: Buffer.from('x'), filename: 'a.tar.gz', contentType: 'application/gzip' });
-    const [, init] = global.fetch.mock.calls[0];
-    expect(init.body.get('file').type).toBe('application/gzip');
-  });
-
-  it('throws a clear error on a non-ok response', async () => {
-    mockFetch('boom', false, 500);
-    await expect(uploadBlob(mockConfig, { data: Buffer.from('x'), filename: 'a.txt' }))
-      .rejects.toThrow(/Upload failed: 500/);
-  });
-});

package/tests/artifactDownload.test.js

@@ -1,113 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { artifactDownloadUrl } from '../src/artifactDownload.js';
-
-describe('artifactDownloadUrl', () => {
-  it('appends /v1/deployments/.../artifacts/download when baseUrl already ends in /v1', () => {
-    expect(artifactDownloadUrl('https://aibadgr.com/v1', 'dep-abc')).toBe(
-      'https://aibadgr.com/v1/deployments/dep-abc/artifacts/download',
-    );
-  });
-
-  it('appends /v1 when baseUrl has no /v1 suffix', () => {
-    expect(artifactDownloadUrl('https://aibadgr.com', 'dep-abc')).toBe(
-      'https://aibadgr.com/v1/deployments/dep-abc/artifacts/download',
-    );
-  });
-
-  it('normalizes a trailing slash on baseUrl', () => {
-    expect(artifactDownloadUrl('https://aibadgr.com/v1/', 'dep-abc')).toBe(
-      'https://aibadgr.com/v1/deployments/dep-abc/artifacts/download',
-    );
-  });
-
-  it('treats a missing/empty baseUrl as an empty string prefix', () => {
-    expect(artifactDownloadUrl('', 'dep-abc')).toBe('/v1/deployments/dep-abc/artifacts/download');
-    expect(artifactDownloadUrl(undefined, 'dep-abc')).toBe('/v1/deployments/dep-abc/artifacts/download');
-  });
-});
-
-let tarExtractBehavior = () => {};
-
-// Matches the real node-tar v7 export shape: named exports only, no
-// default — the mock previously provided both shapes ({ default: { x }, x
-// }), which silently masked a real bug where the source destructured
-// `{ default: tar }` and crashed with "Cannot read properties of undefined
-// (reading 'x')" on every real extraction (found via a live artifact
-// download, never caught by this test).
-vi.mock('tar', () => {
-  const x = vi.fn(async opts => tarExtractBehavior(opts));
-  return { x };
-});
-
-const { downloadAndExtractArtifact } = await import('../src/artifactDownload.js');
-
-describe('downloadAndExtractArtifact', () => {
-  const config = { apiKey: 'test-key', baseUrl: 'https://example.test/v1' };
-  let destDir;
-
-  beforeEach(() => {
-    tarExtractBehavior = ({ cwd }) => {
-      fs.writeFileSync(path.join(cwd, 'marker.txt'), 'ok');
-    };
-    destDir = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'badgr-artifact-dl-')), 'dest');
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    delete global.fetch;
-    fs.rmSync(path.dirname(destDir), { recursive: true, force: true });
-  });
-
-  it('creates destDir, downloads, and extracts', async () => {
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, arrayBuffer: async () => new ArrayBuffer(8) });
-    await downloadAndExtractArtifact(config, 'dep-abc', destDir);
-
-    expect(fs.existsSync(destDir)).toBe(true);
-    expect(fs.existsSync(path.join(destDir, 'marker.txt'))).toBe(true);
-    expect(global.fetch).toHaveBeenCalledWith(
-      'https://example.test/v1/deployments/dep-abc/artifacts/download',
-      { headers: { Authorization: 'Bearer test-key' } },
-    );
-  });
-
-  it('throws an Error with httpStatus/statusText/bodyText set on a non-OK response', async () => {
-    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404, statusText: 'Not Found', text: async () => 'nope' });
-    await expect(downloadAndExtractArtifact(config, 'dep-missing', destDir)).rejects.toMatchObject({
-      httpStatus: 404,
-      statusText: 'Not Found',
-      bodyText: 'nope',
-    });
-  });
-
-  it('includes the response body text in the default error message', async () => {
-    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 500, statusText: 'Internal Server Error', text: async () => 'boom' });
-    await expect(downloadAndExtractArtifact(config, 'dep-broken', destDir)).rejects.toThrow(/500 Internal Server Error — boom/);
-  });
-
-  it('propagates a network-level failure with no httpStatus set', async () => {
-    global.fetch = vi.fn().mockRejectedValue(new Error('getaddrinfo ENOTFOUND'));
-    let caught;
-    try {
-      await downloadAndExtractArtifact(config, 'dep-offline', destDir);
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeDefined();
-    expect(caught.message).toBe('getaddrinfo ENOTFOUND');
-    expect(caught.httpStatus).toBeUndefined();
-  });
-
-  it('cleans up the temp tarball file after extraction', async () => {
-    let capturedTmpFile;
-    tarExtractBehavior = ({ file }) => { capturedTmpFile = file; };
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, arrayBuffer: async () => new ArrayBuffer(8) });
-
-    await downloadAndExtractArtifact(config, 'dep-cleanup', destDir);
-
-    expect(capturedTmpFile).toBeTruthy();
-    expect(fs.existsSync(capturedTmpFile)).toBe(false);
-  });
-});

package/tests/artifacts.test.js

@@ -1,168 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach, afterAll } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-const _fakeConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), 'badgr-artifacts-configdir-'));
-
-vi.mock('../src/config.js', async (importOriginal) => {
-  const actual = await importOriginal();
-  return { ...actual, CONFIG_DIR: _fakeConfigDir };
-});
-
-const { parseArtifactsArgs, listFilesRecursive, artifactsCommand } = await import('../src/commands/artifacts.js');
-
-afterAll(() => {
-  fs.rmSync(_fakeConfigDir, { recursive: true, force: true });
-});
-
-describe('parseArtifactsArgs', () => {
-  it('parses the deployment id and --output', () => {
-    expect(parseArtifactsArgs(['dep-123'])).toEqual({ deploymentId: 'dep-123', flags: {} });
-    expect(parseArtifactsArgs(['dep-123', '--output', './out'])).toEqual({
-      deploymentId: 'dep-123',
-      flags: { output: './out' },
-    });
-  });
-
-  it('returns an undefined deploymentId when no positional arg is given', () => {
-    expect(parseArtifactsArgs(['--output', './out']).deploymentId).toBeUndefined();
-  });
-
-  it('parses the deployment id without any flags', () => {
-    expect(parseArtifactsArgs(['dep-xyz'])).toEqual({ deploymentId: 'dep-xyz', flags: {} });
-  });
-});
-
-describe('listFilesRecursive', () => {
-  let dir;
-
-  beforeEach(() => {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'badgr-artifacts-test-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(dir, { recursive: true, force: true });
-  });
-
-  it('lists nested files with relative paths', () => {
-    fs.mkdirSync(path.join(dir, 'playwright-report'), { recursive: true });
-    fs.writeFileSync(path.join(dir, 'playwright-report', 'index.html'), '<html></html>');
-    fs.writeFileSync(path.join(dir, 'summary.json'), '{}');
-
-    const files = listFilesRecursive(dir);
-    expect(files).toEqual(['playwright-report/index.html', 'summary.json']);
-  });
-
-  it('returns an empty array for an empty directory', () => {
-    expect(listFilesRecursive(dir)).toEqual([]);
-  });
-
-  it('lists deeply nested files and sorts the result', () => {
-    fs.mkdirSync(path.join(dir, 'a', 'b', 'c'), { recursive: true });
-    fs.writeFileSync(path.join(dir, 'a', 'b', 'c', 'deep.txt'), 'x');
-    fs.writeFileSync(path.join(dir, 'zzz.txt'), 'x');
-    fs.writeFileSync(path.join(dir, 'aaa.txt'), 'x');
-
-    expect(listFilesRecursive(dir)).toEqual(['a/b/c/deep.txt', 'aaa.txt', 'zzz.txt']);
-  });
-});
-
-let tarExtractBehavior = () => {};
-
-vi.mock('tar', () => {
-  const x = vi.fn(async opts => tarExtractBehavior(opts));
-  return { default: { x }, x };
-});
-
-function extractTestResults({ cwd }) {
-  fs.mkdirSync(path.join(cwd, 'test-results'), { recursive: true });
-  fs.writeFileSync(path.join(cwd, 'test-results', 'trace.zip'), 'fake-zip');
-}
-
-function extractNothing() {
-  // empty artifact — no files written
-}
-
-describe('artifactsCommand', () => {
-  const chalk = { red: s => s, dim: s => s, green: s => s };
-  const config = { apiKey: 'test-key', baseUrl: 'https://example.test/v1' };
-  let destDir;
-
-  beforeEach(() => {
-    process.exitCode = undefined;
-    tarExtractBehavior = extractTestResults;
-    vi.spyOn(console, 'log').mockImplementation(() => {});
-    vi.spyOn(console, 'error').mockImplementation(() => {});
-    destDir = fs.mkdtempSync(path.join(os.tmpdir(), 'badgr-artifacts-dest-'));
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    process.exitCode = undefined;
-    delete global.fetch;
-    fs.rmSync(destDir, { recursive: true, force: true });
-  });
-
-  it('requires a deployment id', async () => {
-    await artifactsCommand(config, [], chalk);
-    expect(process.exitCode).toBe(1);
-    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('Usage');
-  });
-
-  it('reports a clear error on 404 (no artifact uploaded)', async () => {
-    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404, statusText: 'Not Found', text: async () => '' });
-    await artifactsCommand(config, ['dep-missing'], chalk);
-    expect(process.exitCode).toBe(1);
-    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('No artifact found for dep-missing');
-  });
-
-  it('reports a generic error on a 500', async () => {
-    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 500, statusText: 'Internal Server Error', text: async () => 'boom' });
-    await artifactsCommand(config, ['dep-broken'], chalk);
-    expect(process.exitCode).toBe(1);
-    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('500');
-    expect(logged).toContain('boom');
-  });
-
-  it('reports a clear error when the network request itself fails', async () => {
-    global.fetch = vi.fn().mockRejectedValue(new Error('getaddrinfo ENOTFOUND'));
-    await artifactsCommand(config, ['dep-offline'], chalk);
-    expect(process.exitCode).toBe(1);
-    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('Could not reach Badgr');
-  });
-
-  it('downloads and extracts the artifact tarball, listing files', async () => {
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, arrayBuffer: async () => new ArrayBuffer(8) });
-    await artifactsCommand(config, ['dep-abc', '--output', destDir], chalk);
-
-    expect(process.exitCode).toBeUndefined();
-    expect(fs.existsSync(path.join(destDir, 'test-results', 'trace.zip'))).toBe(true);
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('test-results/trace.zip');
-    expect(logged).toContain(destDir);
-  });
-
-  it('reports an empty artifact without erroring', async () => {
-    tarExtractBehavior = extractNothing;
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, arrayBuffer: async () => new ArrayBuffer(8) });
-    await artifactsCommand(config, ['dep-empty', '--output', destDir], chalk);
-
-    expect(process.exitCode).toBeUndefined();
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('artifact was empty');
-  });
-
-  it('defaults to <CONFIG_DIR>/artifacts/<id> when --output is not given', async () => {
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, arrayBuffer: async () => new ArrayBuffer(8) });
-    await artifactsCommand(config, ['dep-default-dir'], chalk);
-
-    expect(process.exitCode).toBeUndefined();
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain(path.join(_fakeConfigDir, 'artifacts', 'dep-default-dir'));
-  });
-});