fix: update tests to handle async createClient

- Mock keytar in SDK tests to avoid OS keychain calls
- Make all tests async to await createClient/createContext
- Update CLI test to test createClient instead of ping

Co-Authored-By: martyy-code <nesalia.inc@gmail.com>

Author: codewizdave

packages/repofetch/tests/index.test.ts

@@ -1,8 +1,13 @@
 import { describe, it, expect } from 'vitest';
-import { ping } from '../src/index';
+import { createClient } from '../src/index';
 
-describe('ping', () => {
-  it('should return pong', () => {
-    expect(ping()).toBe('pong');
+describe('CLI', () => {
+  it('should create a client', async () => {
+    const client = await createClient();
+    expect(client).toBeDefined();
+    expect(client.repos).toBeDefined();
+    expect(client.search).toBeDefined();
+    expect(client.tree).toBeDefined();
+    expect(client.auth).toBeDefined();
   });
 });

packages/sdk/tests/context.test.ts

@@ -2,97 +2,101 @@
  * Tests for context creation functions.
  */
 
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { createContext, createClient, resolveConfig } from '../src/context.js';
-import type { GitHubContext } from '../src/context.js';
+
+// Mock keytar to avoid OS keychain calls in tests
+vi.mock('../src/internal/keychain.js', () => ({
+  getToken: vi.fn().mockResolvedValue(null),
+}));
 
 describe('resolveConfig', () => {
-  it('returns default values when no config provided', () => {
-    const config = resolveConfig({});
-    
+  it('returns default values when no config provided', async () => {
+    const config = await resolveConfig({});
+
     expect(config.token).toBeNull();
     expect(config.baseUrl).toBe('https://api.github.com');
     expect(typeof config.fetch).toBe('function');
   });
 
-  it('uses provided token', () => {
-    const config = resolveConfig({ token: 'my-token' });
+  it('uses provided token', async () => {
+    const config = await resolveConfig({ token: 'my-token' });
     expect(config.token).toBe('my-token');
   });
 
-  it('uses null token when explicitly set', () => {
-    const config = resolveConfig({ token: null });
+  it('uses null token when explicitly set', async () => {
+    const config = await resolveConfig({ token: null });
     expect(config.token).toBeNull();
   });
 
-  it('uses provided baseUrl', () => {
-    const config = resolveConfig({ baseUrl: 'https://github.mycompany.com/api/v3' });
+  it('uses provided baseUrl', async () => {
+    const config = await resolveConfig({ baseUrl: 'https://github.mycompany.com/api/v3' });
     expect(config.baseUrl).toBe('https://github.mycompany.com/api/v3');
   });
 
-  it('uses provided fetch', () => {
+  it('uses provided fetch', async () => {
     const customFetch = async () => new Response();
-    const config = resolveConfig({ fetch: customFetch });
+    const config = await resolveConfig({ fetch: customFetch });
     expect(config.fetch).toBe(customFetch);
   });
 });
 
 describe('createContext', () => {
-  it('creates a context object with config', () => {
-    const ctx = createContext({ token: 'test-token' });
-    
+  it('creates a context object with config', async () => {
+    const ctx = await createContext({ token: 'test-token' });
+
     expect(ctx).toHaveProperty('config');
     expect(ctx.config.token).toBe('test-token');
     expect(ctx.config.baseUrl).toBe('https://api.github.com');
   });
 
-  it('context can be used with standalone functions', () => {
-    const ctx = createContext({ token: 'test-token' });
-    
+  it('context can be used with standalone functions', async () => {
+    const ctx = await createContext({ token: 'test-token' });
+
     expect(typeof ctx.config.token).toBe('string');
     expect(typeof ctx.config.fetch).toBe('function');
   });
 });
 
 describe('createClient', () => {
-  it('creates a client with all modules attached', () => {
-    const client = createClient({ token: 'test-token' });
-    
+  it('creates a client with all modules attached', async () => {
+    const client = await createClient({ token: 'test-token' });
+
     expect(client).toHaveProperty('repos');
     expect(client).toHaveProperty('search');
     expect(client).toHaveProperty('tree');
     expect(client).toHaveProperty('auth');
   });
 
-  it('client repos module has all methods', () => {
-    const client = createClient({ token: 'test-token' });
-    
+  it('client repos module has all methods', async () => {
+    const client = await createClient({ token: 'test-token' });
+
     expect(typeof client.repos.ls).toBe('function');
     expect(typeof client.repos.read).toBe('function');
     expect(typeof client.repos.getMetadata).toBe('function');
   });
 
-  it('client search module has search method', () => {
-    const client = createClient({ token: 'test-token' });
-    
+  it('client search module has search method', async () => {
+    const client = await createClient({ token: 'test-token' });
+
     expect(typeof client.search.search).toBe('function');
   });
 
-  it('client tree module has getTree method', () => {
-    const client = createClient({ token: 'test-token' });
-    
+  it('client tree module has getTree method', async () => {
+    const client = await createClient({ token: 'test-token' });
+
     expect(typeof client.tree.getTree).toBe('function');
   });
 
-  it('client auth module has getStatus method', () => {
-    const client = createClient({ token: 'test-token' });
-    
+  it('client auth module has getStatus method', async () => {
+    const client = await createClient({ token: 'test-token' });
+
     expect(typeof client.auth.getStatus).toBe('function');
   });
 
   it('passes config through context to functions', async () => {
     let capturedConfig = null;
-    
+
     const mockFetch = async (url: string, options?: RequestInit) => {
       capturedConfig = options?.headers;
       return new Response(JSON.stringify([]), {
@@ -101,10 +105,10 @@ describe('createClient', () => {
       });
     };
 
-    const client = createClient({ token: 'my-token', fetch: mockFetch });
-    
+    const client = await createClient({ token: 'my-token', fetch: mockFetch });
+
     await client.repos.ls('owner/repo', 'src');
-    
+
     expect(capturedConfig).toEqual({
       'Accept': 'application/vnd.github.v3+json',
       'X-GitHub-Api-Version': '2022-11-28',

packages/sdk/tests/repos.test.ts

@@ -1,17 +1,22 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { createContext } from '../src/context.js';
 import { reposLs } from '../src/modules/repos.js';
 import { NotFoundError, RateLimitError, ServerError } from '../src/errors.js';
 
+// Mock keytar to avoid OS keychain calls in tests
+vi.mock('../src/internal/keychain.js', () => ({
+  getToken: vi.fn().mockResolvedValue(null),
+}));
+
 describe('reposLs', () => {
   it('returns directory contents on success', async () => {
-    const mockFetch = async (url) => {
+    const mockFetch = async () => {
       return new Response(JSON.stringify([
         { name: 'file.ts', type: 'file', size: 1024, sha: 'abc123', html_url: 'https://github.com/owner/repo/blob/main/file.ts' },
         { name: 'subdir', type: 'dir', sha: 'def456', html_url: 'https://github.com/owner/repo/tree/main/subdir' }
       ]), { status: 200, headers: { 'Content-Type': 'application/json' } });
     };
-    const ctx = createContext({ fetch: mockFetch });
+    const ctx = await createContext({ fetch: mockFetch });
     const result = await reposLs(ctx, 'owner/repo', 'src');
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -22,7 +27,7 @@ describe('reposLs', () => {
 
   it('returns NotFoundError for 404 response', async () => {
     const mockFetch = async () => new Response(JSON.stringify({ message: 'Not Found' }), { status: 404 });
-    const ctx = createContext({ fetch: mockFetch });
+    const ctx = await createContext({ fetch: mockFetch });
     const result = await reposLs(ctx, 'owner/nonexistent', 'path');
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -33,7 +38,7 @@ describe('reposLs', () => {
 
   it('returns RateLimitError for 403 response', async () => {
     const mockFetch = async () => new Response(JSON.stringify({ message: 'Rate limit' }), { status: 403, headers: { 'Retry-After': '60' } });
-    const ctx = createContext({ fetch: mockFetch });
+    const ctx = await createContext({ fetch: mockFetch });
     const result = await reposLs(ctx, 'owner/repo');
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -43,7 +48,7 @@ describe('reposLs', () => {
 
   it('returns ServerError for 500 response', async () => {
     const mockFetch = async () => new Response(JSON.stringify({ message: 'Server Error' }), { status: 500 });
-    const ctx = createContext({ fetch: mockFetch });
+    const ctx = await createContext({ fetch: mockFetch });
     const result = await reposLs(ctx, 'owner/repo');
     expect(result.ok).toBe(false);
     if (!result.ok) {