@mesadev/sdk 0.0.5 → 0.1.0

package/tests/test-utils.ts

@@ -0,0 +1,399 @@
+import { afterEach, beforeEach, type Mock, mock } from 'bun:test';
+
+/**
+ * Mock fetch responses for unit testing
+ */
+export type MockResponse = {
+  status?: number;
+  body?: unknown;
+  text?: string;
+  headers?: Record<string, string>;
+};
+
+export type MockHandler = (url: string, init?: RequestInit) => MockResponse | Promise<MockResponse>;
+
+let mockHandler: MockHandler | null = null;
+let originalFetch: typeof fetch;
+let fetchMock: Mock<(input: RequestInfo | URL, init?: RequestInit) => Promise<Response>> | null = null;
+
+/**
+ * Set up fetch mocking for a test file.
+ * Call this at the top level of your test file.
+ */
+export function setupFetchMock() {
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    fetchMock = mock(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = typeof input === 'string' ? input : input.toString();
+
+      if (!mockHandler) {
+        throw new Error(`No mock handler set for fetch request to: ${url}`);
+      }
+
+      const result = await mockHandler(url, init);
+
+      const headers = new Headers(result.headers);
+      let responseBody: BodyInit | null = null;
+
+      if (result.text !== undefined) {
+        responseBody = result.text;
+        if (!headers.has('Content-Type')) {
+          headers.set('Content-Type', 'text/plain; charset=utf-8');
+        }
+      } else if (result.body !== undefined) {
+        responseBody = JSON.stringify(result.body);
+        if (!headers.has('Content-Type')) {
+          headers.set('Content-Type', 'application/json');
+        }
+      }
+
+      return new Response(responseBody, {
+        status: result.status ?? 200,
+        headers,
+      });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    mockHandler = null;
+    fetchMock = null;
+  });
+}
+
+/**
+ * Set the mock handler for the current test.
+ * Must be called within a test after setupFetchMock().
+ */
+export function mockFetch(handler: MockHandler) {
+  mockHandler = handler;
+}
+
+/**
+ * Create a simple mock that returns the same response for all requests.
+ */
+export function mockFetchResponse(response: MockResponse) {
+  mockFetch(() => response);
+}
+
+/**
+ * Create a mock that returns different responses based on URL patterns.
+ */
+export function mockFetchRoutes(
+  routes: Record<string, MockResponse | ((url: string, init?: RequestInit) => MockResponse)>
+) {
+  mockFetch((url, init) => {
+    for (const [pattern, handler] of Object.entries(routes)) {
+      if (url.includes(pattern)) {
+        return typeof handler === 'function' ? handler(url, init) : handler;
+      }
+    }
+    return { status: 404, body: { error: { code: 'NOT_FOUND', message: 'No mock route matched' } } };
+  });
+}
+
+/**
+ * Assert that fetch was called with expected parameters.
+ */
+function parseUrl(urlStr: string) {
+  try {
+    return new URL(urlStr);
+  } catch {
+    return new URL(urlStr, 'http://example.test');
+  }
+}
+
+export function expectFetchCalledWith(expectedUrl: string | RegExp, expectedInit?: Partial<RequestInit>) {
+  if (!fetchMock) {
+    throw new Error('fetchMock is not initialized. Make sure setupFetchMock() was called.');
+  }
+
+  const calls = fetchMock.mock.calls;
+
+  const matchingCall = calls.find((call) => {
+    const [url, init] = call as [RequestInfo | URL, RequestInit | undefined];
+    const urlStr = typeof url === 'string' ? url : url.toString();
+
+    const urlMatches = (() => {
+      if (expectedUrl instanceof RegExp) return expectedUrl.test(urlStr);
+
+      // Absolute URL string: must match exactly.
+      if (expectedUrl.includes('://')) return urlStr === expectedUrl;
+
+      const actualUrl = parseUrl(urlStr);
+      const expectedParsed = parseUrl(expectedUrl);
+
+      if (expectedUrl.includes('?')) {
+        if (actualUrl.pathname !== expectedParsed.pathname) return false;
+
+        // Compare expected query params (order-independent).
+        for (const [key, value] of expectedParsed.searchParams.entries()) {
+          if (actualUrl.searchParams.get(key) !== value) return false;
+        }
+
+        return true;
+      }
+
+      return actualUrl.pathname === expectedUrl;
+    })();
+
+    if (!urlMatches) return false;
+
+    if (expectedInit) {
+      if (expectedInit.method && init?.method !== expectedInit.method) return false;
+      if (expectedInit.body && init?.body !== expectedInit.body) return false;
+    }
+
+    return true;
+  });
+
+  if (!matchingCall) {
+    const callUrls = calls.map((call) => {
+      const [url] = call as [RequestInfo | URL];
+      return typeof url === 'string' ? url : url.toString();
+    });
+    throw new Error(
+      `Expected fetch to be called with URL matching ${expectedUrl}, but calls were: ${callUrls.join(', ') || '(none)'}`
+    );
+  }
+}
+
+/**
+ * Standard error response format
+ */
+export function errorResponse(code: string, message: string, status = 400): MockResponse {
+  return {
+    status,
+    body: { error: { code, message } },
+  };
+}
+
+// Response type definitions
+type RepoResponse = {
+  id: string;
+  org: string;
+  name: string;
+  default_branch: string;
+  size_bytes: number;
+  created_at: string;
+  last_push_at: string | null;
+};
+
+type BranchResponse = {
+  name: string;
+  head_sha: string;
+  is_default: boolean;
+};
+
+type CommitResponse = {
+  sha: string;
+  message: string;
+  branch: string;
+};
+
+type CommitListItem = {
+  sha: string;
+  message: string;
+  author: { name: string; email: string };
+  committer: { name: string; email: string };
+};
+
+type ContentDirEntryResponse =
+  | {
+      type: 'file';
+      name: string;
+      path: string;
+      sha: string;
+      size: number;
+    }
+  | {
+      type: 'dir';
+      name: string;
+      path: string;
+      sha: string;
+    };
+
+type ContentFileResponse = {
+  type: 'file';
+  name: string;
+  path: string;
+  sha: string;
+  size: number;
+  encoding: 'base64';
+  content: string;
+};
+
+type ContentDirResponse = {
+  type: 'dir';
+  name: string;
+  path: string;
+  sha: string;
+  entries: ContentDirEntryResponse[];
+  next_cursor: string | null;
+  has_more: boolean;
+};
+
+type ContentResponse = ContentFileResponse | ContentDirResponse;
+
+type ApiKeyResponse = {
+  id: string;
+  key: string;
+  name: string | null;
+  scopes: string[];
+  created_at: string;
+};
+
+type ApiKeyListItem = {
+  id: string;
+  name: string | null;
+  scopes: string[];
+  last_used_at: string | null;
+  expires_at: string | null;
+  revoked_at: string | null;
+  created_at: string;
+};
+
+type DiffResponse = {
+  base: string;
+  head: string;
+  stats: { files: number; additions: number; deletions: number; changes: number };
+  files: Array<{
+    path: string;
+    status: 'A' | 'M' | 'D' | 'R' | 'C' | 'T';
+    old_path?: string;
+    bytes?: number;
+    is_eof?: boolean;
+    raw?: string;
+  }>;
+  filtered_files: Array<{
+    path: string;
+    status: 'A' | 'M' | 'D' | 'R' | 'C' | 'T';
+    old_path?: string;
+    bytes?: number;
+    is_eof?: boolean;
+  }>;
+};
+
+/**
+ * Common mock responses for Depot API
+ */
+export const mockResponses = {
+  repo: (overrides: Partial<RepoResponse> = {}): RepoResponse => ({
+    id: 'repo_123',
+    org: 'acme',
+    name: 'test-repo',
+    default_branch: 'main',
+    size_bytes: 1024,
+    created_at: '2024-01-01T00:00:00Z',
+    last_push_at: null,
+    ...overrides,
+  }),
+
+  repoList: (repos?: RepoResponse[]) => ({
+    repos: repos ?? [mockResponses.repo()],
+    next_cursor: null,
+    has_more: false,
+  }),
+
+  branch: (overrides: Partial<BranchResponse> = {}): BranchResponse => ({
+    name: 'main',
+    head_sha: 'abc123def456',
+    is_default: true,
+    ...overrides,
+  }),
+
+  branchList: (branches?: BranchResponse[]) => ({
+    branches: branches ?? [mockResponses.branch()],
+    next_cursor: null,
+    has_more: false,
+  }),
+
+  commit: (overrides: Partial<CommitResponse> = {}): CommitResponse => ({
+    sha: 'abc123def456',
+    message: 'Test commit',
+    branch: 'main',
+    ...overrides,
+  }),
+
+  commitList: (commits?: CommitListItem[]) => ({
+    commits: commits ?? [
+      {
+        sha: 'abc123',
+        message: 'Test commit',
+        author: { name: 'Test', email: 'test@example.com' },
+        committer: { name: 'Test', email: 'test@example.com' },
+      },
+    ],
+    next_cursor: null,
+    has_more: false,
+  }),
+
+  contentDirEntry: (overrides: Partial<ContentDirEntryResponse> = {}): ContentDirEntryResponse => ({
+    type: 'file',
+    name: 'README.md',
+    path: 'README.md',
+    sha: 'blob123',
+    size: 100,
+    ...overrides,
+  }),
+
+  contentFile: (overrides: Partial<ContentFileResponse> = {}): ContentFileResponse => ({
+    type: 'file',
+    name: 'README.md',
+    path: 'README.md',
+    sha: 'blob123',
+    size: 100,
+    encoding: 'base64',
+    content: Buffer.from('# Hello').toString('base64'),
+    ...overrides,
+  }),
+
+  contentDir: (entries?: ContentDirEntryResponse[]): ContentDirResponse => ({
+    type: 'dir',
+    name: '',
+    path: '',
+    sha: 'tree123',
+    entries: entries ?? [mockResponses.contentDirEntry()],
+    next_cursor: null,
+    has_more: false,
+  }),
+
+  apiKey: (overrides: Partial<ApiKeyResponse> = {}): ApiKeyResponse => ({
+    id: 'key_123',
+    key: 'dp_live_testkey123',
+    name: null,
+    scopes: ['admin'],
+    created_at: '2024-01-01T00:00:00Z',
+    ...overrides,
+  }),
+
+  apiKeyList: (keys?: ApiKeyListItem[]) => ({
+    api_keys: keys ?? [
+      {
+        id: 'key_123',
+        name: null,
+        scopes: ['admin'],
+        last_used_at: null,
+        expires_at: null,
+        revoked_at: null,
+        created_at: '2024-01-01T00:00:00Z',
+      },
+    ],
+  }),
+
+  diff: (overrides: Partial<DiffResponse> = {}): DiffResponse => ({
+    base: 'abc123',
+    head: 'def456',
+    stats: { files: 1, additions: 10, deletions: 5, changes: 15 },
+    files: [
+      {
+        path: 'file.txt',
+        status: 'M',
+        raw: 'diff --git a/file.txt b/file.txt\n...',
+      },
+    ],
+    filtered_files: [],
+    ...overrides,
+  }),
+};

package/tests/unit/client.test.ts

@@ -0,0 +1,281 @@
+import { describe, expect, test } from 'bun:test';
+import { DepotClient } from '../../src/client';
+import { DepotError } from '../../src/errors';
+import { createDepot } from '../../src/index';
+import { Repo } from '../../src/repo';
+import {
+  errorResponse,
+  expectFetchCalledWith,
+  mockFetch,
+  mockFetchResponse,
+  mockResponses,
+  setupFetchMock,
+} from '../test-utils';
+
+setupFetchMock();
+
+describe('DepotClient', () => {
+  describe('constructor', () => {
+    test('createDepot returns a DepotClient', () => {
+      const client = createDepot({ apiKey: 'dp_live_test123', org: 'acme' });
+      expect(client).toBeInstanceOf(DepotClient);
+    });
+
+    test('uses default base URL', () => {
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      const cloneUrl = client.getCloneUrl('acme', 'my-repo');
+      expect(cloneUrl).toBe('https://dp_live_test123@depot.mesa.dev/acme/my-repo.git');
+    });
+
+    test('uses custom base URL', () => {
+      const client = new DepotClient({
+        apiKey: 'dp_live_test123',
+        org: 'acme',
+        baseUrl: 'https://custom.depot.dev',
+      });
+      const cloneUrl = client.getCloneUrl('acme', 'my-repo');
+      expect(cloneUrl).toBe('https://dp_live_test123@custom.depot.dev/acme/my-repo.git');
+    });
+
+    test('strips protocol from clone URL', () => {
+      const client = new DepotClient({
+        apiKey: 'dp_live_test123',
+        org: 'acme',
+        baseUrl: 'http://localhost:3001',
+      });
+      const cloneUrl = client.getCloneUrl('acme', 'my-repo');
+      expect(cloneUrl).toBe('https://dp_live_test123@localhost:3001/acme/my-repo.git');
+    });
+  });
+
+  describe('createRepo', () => {
+    test('creates a repository and returns Repo instance', async () => {
+      const mockRepo = mockResponses.repo({ name: 'new-repo' });
+      mockFetchResponse({ status: 201, body: mockRepo });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      const repo = await client.createRepo({ name: 'new-repo' });
+
+      expect(repo).toBeInstanceOf(Repo);
+      expect(repo.name).toBe('new-repo');
+      expect(repo.defaultBranch).toBe('main');
+      expectFetchCalledWith('/api/v1/acme/repos', { method: 'POST' });
+    });
+
+    test('sends custom default branch', async () => {
+      mockFetch((url, init) => {
+        const body = JSON.parse(init?.body as string);
+        expect(body.default_branch).toBe('master');
+        return { status: 201, body: mockResponses.repo({ default_branch: 'master' }) };
+      });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      const repo = await client.createRepo({ name: 'new-repo', defaultBranch: 'master' });
+
+      expect(repo.defaultBranch).toBe('master');
+    });
+
+    test('throws DepotError on failure', async () => {
+      mockFetchResponse(errorResponse('REPO_EXISTS', 'Repository already exists', 409));
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+
+      await expect(client.createRepo({ name: 'existing-repo' })).rejects.toThrow(DepotError);
+
+      try {
+        await client.createRepo({ name: 'existing-repo' });
+      } catch (err) {
+        expect(err).toBeInstanceOf(DepotError);
+        expect((err as DepotError).code).toBe('REPO_EXISTS');
+      }
+    });
+  });
+
+  describe('getRepo', () => {
+    test('fetches repository by name', async () => {
+      mockFetchResponse({ body: mockResponses.repo({ name: 'my-repo' }) });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      const repo = await client.getRepo('my-repo');
+
+      expect(repo).toBeInstanceOf(Repo);
+      expect(repo.name).toBe('my-repo');
+      expectFetchCalledWith('/api/v1/acme/my-repo');
+    });
+
+    test('encodes special characters in repo name', async () => {
+      mockFetchResponse({ body: mockResponses.repo({ name: 'my/repo' }) });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      await client.getRepo('my/repo');
+
+      expectFetchCalledWith('/api/v1/acme/my%2Frepo');
+    });
+
+    test('throws REPO_NOT_FOUND on 404', async () => {
+      mockFetchResponse(errorResponse('REPO_NOT_FOUND', 'Repository not found', 404));
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+
+      try {
+        await client.getRepo('nonexistent');
+        expect.unreachable('Should have thrown');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DepotError);
+        expect((err as DepotError).code).toBe('REPO_NOT_FOUND');
+      }
+    });
+  });
+
+  describe('listRepos', () => {
+    test('returns array of Repo instances', async () => {
+      mockFetchResponse({
+        body: mockResponses.repoList([mockResponses.repo({ name: 'repo-1' }), mockResponses.repo({ name: 'repo-2' })]),
+      });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      const result = await client.listRepos();
+
+      expect(result.repos).toHaveLength(2);
+      expect(result.repos[0]).toBeInstanceOf(Repo);
+      expect(result.repos[0].name).toBe('repo-1');
+      expect(result.repos[1].name).toBe('repo-2');
+      expect(result.nextCursor).toBeNull();
+      expect(result.hasMore).toBe(false);
+    });
+
+    test('returns empty array when no repos exist', async () => {
+      mockFetchResponse({ body: mockResponses.repoList([]) });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      const result = await client.listRepos();
+
+      expect(result.repos).toHaveLength(0);
+    });
+  });
+
+  describe('deleteRepo', () => {
+    test('deletes repository by name', async () => {
+      mockFetchResponse({ status: 200, body: {} });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      await client.deleteRepo('my-repo');
+
+      expectFetchCalledWith('/api/v1/acme/my-repo', { method: 'DELETE' });
+    });
+
+    test('throws on not found', async () => {
+      mockFetchResponse(errorResponse('REPO_NOT_FOUND', 'Repository not found', 404));
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+
+      await expect(client.deleteRepo('nonexistent')).rejects.toThrow(DepotError);
+    });
+  });
+
+  describe('API Key operations', () => {
+    test('createApiKey creates a new key', async () => {
+      mockFetchResponse({
+        status: 201,
+        body: mockResponses.apiKey({ name: 'CI Key', scopes: ['git:read', 'git:write'] }),
+      });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      const apiKey = await client.createApiKey({ name: 'CI Key', scopes: ['git:read', 'git:write'] });
+
+      expect(apiKey.name).toBe('CI Key');
+      expect(apiKey.scopes).toEqual(['git:read', 'git:write']);
+      expect(apiKey.key).toBe('dp_live_testkey123');
+      expectFetchCalledWith('/api/v1/api-keys', { method: 'POST' });
+    });
+
+    test('createApiKey with defaults', async () => {
+      mockFetch((url, init) => {
+        const body = JSON.parse(init?.body as string);
+        expect(body.name).toBeUndefined();
+        expect(body.scopes).toBeUndefined();
+        return { status: 201, body: mockResponses.apiKey() };
+      });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      await client.createApiKey();
+    });
+
+    test('listApiKeys returns array of keys', async () => {
+      mockFetchResponse({ body: mockResponses.apiKeyList() });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      const keys = await client.listApiKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].id).toBe('key_123');
+      expect(keys[0].key).toBeUndefined(); // key is not returned on list
+    });
+
+    test('revokeApiKey deletes the key', async () => {
+      mockFetchResponse({ status: 200, body: {} });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      await client.revokeApiKey('key_123');
+
+      expectFetchCalledWith('/api/v1/api-keys/key_123', { method: 'DELETE' });
+    });
+  });
+
+  describe('error handling', () => {
+    test('handles network errors', async () => {
+      mockFetch(() => {
+        throw new Error('Network error');
+      });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+
+      try {
+        await client.listRepos();
+        expect.unreachable('Should have thrown');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DepotError);
+        expect((err as DepotError).code).toBe('NETWORK_ERROR');
+      }
+    });
+
+    test('handles invalid JSON response', async () => {
+      mockFetch(() => ({
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+        text: '{ this is not valid JSON',
+      }));
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+
+      try {
+        await client.listRepos();
+        expect.unreachable('Should have thrown');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DepotError);
+      }
+    });
+
+    test('includes authorization header in all requests', async () => {
+      mockFetch((url, init) => {
+        const headers = init?.headers as Record<string, string>;
+        expect(headers.Authorization).toBe('Bearer dp_live_test123');
+        return { body: mockResponses.repoList() };
+      });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      await client.listRepos();
+    });
+
+    test('includes content-type header for JSON bodies', async () => {
+      mockFetch((url, init) => {
+        const headers = init?.headers as Record<string, string>;
+        expect(headers['Content-Type']).toBe('application/json');
+        return { status: 201, body: mockResponses.repo({ name: 'new-repo' }) };
+      });
+
+      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
+      await client.createRepo({ name: 'new-repo' });
+    });
+  });
+});