tlc-claude-code 2.4.10 → 2.5.0

package/server/lib/github/gh-client.test.js

@@ -0,0 +1,499 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  checkAuth,
+  createIssue,
+  closeIssue,
+  listIssues,
+  assignIssue,
+  addLabels,
+  createPr,
+  linkPrToIssue,
+  detectRepo,
+} from './gh-client.js';
+
+describe('gh-client', () => {
+  describe('checkAuth', () => {
+    it('parses gh auth status JSON correctly', () => {
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify({
+        user: 'octocat',
+        oauth_token: 'gho_xxx',
+        scopes: 'repo,read:org,project',
+      }));
+
+      const result = checkAuth({ exec: mockExec });
+
+      expect(result.authenticated).toBe(true);
+      expect(result.user).toBe('octocat');
+      expect(result.scopes).toEqual(['repo', 'read:org', 'project']);
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.stringContaining('gh auth status'),
+        expect.objectContaining({ encoding: 'utf-8' })
+      );
+    });
+
+    it('detects missing project scope', () => {
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify({
+        user: 'octocat',
+        oauth_token: 'gho_xxx',
+        scopes: 'repo,read:org',
+      }));
+
+      const result = checkAuth({ exec: mockExec });
+
+      expect(result.authenticated).toBe(true);
+      expect(result.scopes).not.toContain('project');
+    });
+
+    it('returns structured error when gh not installed', () => {
+      const error = new Error('command not found: gh');
+      error.stderr = Buffer.from('command not found: gh');
+      const mockExec = vi.fn().mockImplementation(() => { throw error; });
+
+      const result = checkAuth({ exec: mockExec });
+
+      expect(result.authenticated).toBe(false);
+      expect(result.error).toContain('not found');
+      expect(result.code).toBe('GH_NOT_FOUND');
+    });
+
+    it('returns structured error on auth failure', () => {
+      const error = new Error('not logged in');
+      error.stderr = Buffer.from('auth login required');
+      const mockExec = vi.fn().mockImplementation(() => { throw error; });
+
+      const result = checkAuth({ exec: mockExec });
+
+      expect(result.authenticated).toBe(false);
+      expect(result.code).toBe('GH_AUTH_REQUIRED');
+    });
+  });
+
+  describe('createIssue', () => {
+    it('constructs correct command with all args', () => {
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify({ number: 42, url: 'https://github.com/owner/repo/issues/42' }));
+
+      createIssue({
+        owner: 'myorg',
+        repo: 'myrepo',
+        title: 'Bug report',
+        body: 'Something broke',
+        labels: ['bug', 'urgent'],
+        assignees: ['alice', 'bob'],
+        exec: mockExec,
+      });
+
+      const cmd = mockExec.mock.calls[0][0];
+      expect(cmd).toContain('gh issue create');
+      expect(cmd).toContain("--repo 'myorg/myrepo'");
+      expect(cmd).toContain("--title 'Bug report'");
+      expect(cmd).toContain("--body 'Something broke'");
+      expect(cmd).toContain("--label 'bug,urgent'");
+      expect(cmd).toContain("--assignee 'alice,bob'");
+      expect(cmd).toContain('--json number,url,id');
+    });
+
+    it('constructs command with only required args (no labels/assignees)', () => {
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify({ number: 1, url: 'https://github.com/o/r/issues/1' }));
+
+      createIssue({
+        owner: 'o',
+        repo: 'r',
+        title: 'Simple issue',
+        body: 'Details',
+        exec: mockExec,
+      });
+
+      const cmd = mockExec.mock.calls[0][0];
+      expect(cmd).toContain('gh issue create');
+      expect(cmd).toContain("--repo 'o/r'");
+      expect(cmd).toContain("--title 'Simple issue'");
+      expect(cmd).not.toContain('--label');
+      expect(cmd).not.toContain('--assignee');
+    });
+
+    it('parses JSON response for number and url', () => {
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify({
+        number: 7,
+        url: 'https://github.com/owner/repo/issues/7',
+      }));
+
+      const result = createIssue({
+        owner: 'owner',
+        repo: 'repo',
+        title: 'Test',
+        body: 'Body',
+        exec: mockExec,
+      });
+
+      expect(result.number).toBe(7);
+      expect(result.url).toBe('https://github.com/owner/repo/issues/7');
+    });
+
+    it('returns structured error on failure', () => {
+      const error = new Error('API error');
+      error.stderr = Buffer.from('GraphQL: Could not resolve');
+      const mockExec = vi.fn().mockImplementation(() => { throw error; });
+
+      const result = createIssue({
+        owner: 'o',
+        repo: 'r',
+        title: 'Test',
+        body: 'Body',
+        exec: mockExec,
+      });
+
+      expect(result.error).toBeDefined();
+      expect(result.code).toBe('GH_API_ERROR');
+    });
+  });
+
+  describe('closeIssue', () => {
+    it('calls correct command', () => {
+      const mockExec = vi.fn().mockReturnValue('');
+
+      const result = closeIssue({
+        owner: 'myorg',
+        repo: 'myrepo',
+        number: 42,
+        exec: mockExec,
+      });
+
+      const cmd = mockExec.mock.calls[0][0];
+      expect(cmd).toContain('gh issue close 42');
+      expect(cmd).toContain("--repo 'myorg/myrepo'");
+      expect(result.closed).toBe(true);
+    });
+
+    it('returns structured error on failure', () => {
+      const error = new Error('not found');
+      error.stderr = Buffer.from('issue not found');
+      const mockExec = vi.fn().mockImplementation(() => { throw error; });
+
+      const result = closeIssue({
+        owner: 'o',
+        repo: 'r',
+        number: 999,
+        exec: mockExec,
+      });
+
+      expect(result.error).toBeDefined();
+      expect(result.code).toBe('GH_API_ERROR');
+    });
+  });
+
+  describe('listIssues', () => {
+    it('filters by labels and state', () => {
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify([
+        { number: 1, title: 'Bug', state: 'OPEN', labels: [{ name: 'bug' }], assignees: [] },
+      ]));
+
+      listIssues({
+        owner: 'o',
+        repo: 'r',
+        labels: ['bug', 'p1'],
+        state: 'closed',
+        limit: 50,
+        exec: mockExec,
+      });
+
+      const cmd = mockExec.mock.calls[0][0];
+      expect(cmd).toContain("--label 'bug,p1'");
+      expect(cmd).toContain("--state 'closed'");
+      expect(cmd).toContain('--limit 50');
+    });
+
+    it('defaults to state=open, limit=100', () => {
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify([]));
+
+      listIssues({
+        owner: 'o',
+        repo: 'r',
+        exec: mockExec,
+      });
+
+      const cmd = mockExec.mock.calls[0][0];
+      expect(cmd).toContain("--state 'open'");
+      expect(cmd).toContain('--limit 100');
+    });
+
+    it('returns parsed array', () => {
+      const items = [
+        { number: 1, title: 'First', state: 'OPEN', labels: [], assignees: [] },
+        { number: 2, title: 'Second', state: 'OPEN', labels: [], assignees: [] },
+      ];
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify(items));
+
+      const result = listIssues({ owner: 'o', repo: 'r', exec: mockExec });
+
+      expect(result).toHaveLength(2);
+      expect(result[0].number).toBe(1);
+      expect(result[1].title).toBe('Second');
+    });
+  });
+
+  describe('assignIssue', () => {
+    it('adds multiple assignees', () => {
+      const mockExec = vi.fn().mockReturnValue('');
+
+      const result = assignIssue({
+        owner: 'o',
+        repo: 'r',
+        number: 10,
+        assignees: ['alice', 'bob', 'charlie'],
+        exec: mockExec,
+      });
+
+      const cmd = mockExec.mock.calls[0][0];
+      expect(cmd).toContain('gh issue edit 10');
+      expect(cmd).toContain("--repo 'o/r'");
+      expect(cmd).toContain("--add-assignee 'alice,bob,charlie'");
+      expect(result.assigned).toBe(true);
+    });
+
+    it('returns structured error on failure', () => {
+      const error = new Error('forbidden');
+      error.stderr = Buffer.from('permission denied');
+      const mockExec = vi.fn().mockImplementation(() => { throw error; });
+
+      const result = assignIssue({
+        owner: 'o',
+        repo: 'r',
+        number: 10,
+        assignees: ['alice'],
+        exec: mockExec,
+      });
+
+      expect(result.error).toBeDefined();
+      expect(result.code).toBe('GH_API_ERROR');
+    });
+  });
+
+  describe('addLabels', () => {
+    it('adds multiple labels', () => {
+      const mockExec = vi.fn().mockReturnValue('');
+
+      const result = addLabels({
+        owner: 'o',
+        repo: 'r',
+        number: 5,
+        labels: ['enhancement', 'priority:high'],
+        exec: mockExec,
+      });
+
+      const cmd = mockExec.mock.calls[0][0];
+      expect(cmd).toContain('gh issue edit 5');
+      expect(cmd).toContain("--repo 'o/r'");
+      expect(cmd).toContain("--add-label 'enhancement,priority:high'");
+      expect(result.labeled).toBe(true);
+    });
+
+    it('returns structured error on failure', () => {
+      const error = new Error('label not found');
+      error.stderr = Buffer.from('label "unknown" not found');
+      const mockExec = vi.fn().mockImplementation(() => { throw error; });
+
+      const result = addLabels({
+        owner: 'o',
+        repo: 'r',
+        number: 5,
+        labels: ['unknown'],
+        exec: mockExec,
+      });
+
+      expect(result.error).toBeDefined();
+      expect(result.code).toBe('GH_API_ERROR');
+    });
+  });
+
+  describe('createPr', () => {
+    it('constructs correct command', () => {
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify({
+        number: 99,
+        url: 'https://github.com/o/r/pull/99',
+      }));
+
+      const result = createPr({
+        owner: 'o',
+        repo: 'r',
+        title: 'Add feature X',
+        body: 'Implements feature X',
+        base: 'main',
+        head: 'feature/x',
+        exec: mockExec,
+      });
+
+      const cmd = mockExec.mock.calls[0][0];
+      expect(cmd).toContain('gh pr create');
+      expect(cmd).toContain("--repo 'o/r'");
+      expect(cmd).toContain("--title 'Add feature X'");
+      expect(cmd).toContain("--body 'Implements feature X'");
+      expect(cmd).toContain("--base 'main'");
+      expect(cmd).toContain("--head 'feature/x'");
+      expect(cmd).toContain('--json number,url');
+      expect(result.number).toBe(99);
+      expect(result.url).toBe('https://github.com/o/r/pull/99');
+    });
+
+    it('returns structured error on failure', () => {
+      const error = new Error('already exists');
+      error.stderr = Buffer.from('a]pull request already exists');
+      const mockExec = vi.fn().mockImplementation(() => { throw error; });
+
+      const result = createPr({
+        owner: 'o',
+        repo: 'r',
+        title: 'Test',
+        body: 'Body',
+        base: 'main',
+        head: 'branch',
+        exec: mockExec,
+      });
+
+      expect(result.error).toBeDefined();
+      expect(result.code).toBe('GH_API_ERROR');
+    });
+  });
+
+  describe('linkPrToIssue', () => {
+    it('fetches existing body and appends Closes references', () => {
+      const mockExec = vi.fn()
+        .mockReturnValueOnce(JSON.stringify({ body: 'Original PR body' }))
+        .mockReturnValueOnce('');
+
+      const result = linkPrToIssue({
+        owner: 'o',
+        repo: 'r',
+        prNumber: 99,
+        issueNumbers: [10, 15],
+        exec: mockExec,
+      });
+
+      // First call: fetch current body
+      const viewCmd = mockExec.mock.calls[0][0];
+      expect(viewCmd).toContain('gh pr view 99');
+      expect(viewCmd).toContain("--repo 'o/r'");
+      expect(viewCmd).toContain('--json body');
+
+      // Second call: edit with appended Closes
+      const editCmd = mockExec.mock.calls[1][0];
+      expect(editCmd).toContain('gh pr edit 99');
+      expect(editCmd).toContain("--repo 'o/r'");
+      expect(editCmd).toContain('Closes #10');
+      expect(editCmd).toContain('Closes #15');
+      expect(editCmd).toContain('Original PR body');
+      expect(result.linked).toBe(true);
+    });
+
+    it('handles PR with no existing body', () => {
+      const mockExec = vi.fn()
+        .mockReturnValueOnce(JSON.stringify({ body: '' }))
+        .mockReturnValueOnce('');
+
+      const result = linkPrToIssue({
+        owner: 'o',
+        repo: 'r',
+        prNumber: 50,
+        issueNumbers: [3],
+        exec: mockExec,
+      });
+
+      const editCmd = mockExec.mock.calls[1][0];
+      expect(editCmd).toContain('Closes #3');
+      expect(result.linked).toBe(true);
+    });
+
+    it('handles PR with null body', () => {
+      const mockExec = vi.fn()
+        .mockReturnValueOnce(JSON.stringify({ body: null }))
+        .mockReturnValueOnce('');
+
+      const result = linkPrToIssue({
+        owner: 'o',
+        repo: 'r',
+        prNumber: 50,
+        issueNumbers: [3],
+        exec: mockExec,
+      });
+
+      const editCmd = mockExec.mock.calls[1][0];
+      expect(editCmd).toContain('Closes #3');
+      expect(result.linked).toBe(true);
+    });
+
+    it('returns structured error on failure', () => {
+      const error = new Error('not found');
+      error.stderr = Buffer.from('pull request not found');
+      const mockExec = vi.fn().mockImplementation(() => { throw error; });
+
+      const result = linkPrToIssue({
+        owner: 'o',
+        repo: 'r',
+        prNumber: 999,
+        issueNumbers: [1],
+        exec: mockExec,
+      });
+
+      expect(result.error).toBeDefined();
+      expect(result.code).toBe('GH_API_ERROR');
+    });
+  });
+
+  describe('detectRepo', () => {
+    it('extracts owner and name', () => {
+      const mockExec = vi.fn().mockReturnValue(JSON.stringify({
+        owner: { login: 'myorg' },
+        name: 'myrepo',
+        url: 'https://github.com/myorg/myrepo',
+      }));
+
+      const result = detectRepo({ exec: mockExec });
+
+      expect(result.owner).toBe('myorg');
+      expect(result.repo).toBe('myrepo');
+      expect(result.url).toBe('https://github.com/myorg/myrepo');
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.stringContaining('gh repo view'),
+        expect.objectContaining({ encoding: 'utf-8' })
+      );
+    });
+
+    it('returns null when not a GitHub repo', () => {
+      const error = new Error('not a git repository');
+      error.stderr = Buffer.from('not a git repository');
+      const mockExec = vi.fn().mockImplementation(() => { throw error; });
+
+      const result = detectRepo({ exec: mockExec });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('error handling', () => {
+    it('all errors return structured { error, code } objects, never throw', () => {
+      const error = new Error('something went wrong');
+      error.stderr = Buffer.from('unexpected error');
+      const failExec = vi.fn().mockImplementation(() => { throw error; });
+
+      // None of these should throw
+      const results = [
+        checkAuth({ exec: failExec }),
+        createIssue({ owner: 'o', repo: 'r', title: 't', body: 'b', exec: failExec }),
+        closeIssue({ owner: 'o', repo: 'r', number: 1, exec: failExec }),
+        listIssues({ owner: 'o', repo: 'r', exec: failExec }),
+        assignIssue({ owner: 'o', repo: 'r', number: 1, assignees: ['a'], exec: failExec }),
+        addLabels({ owner: 'o', repo: 'r', number: 1, labels: ['l'], exec: failExec }),
+        createPr({ owner: 'o', repo: 'r', title: 't', body: 'b', base: 'main', head: 'h', exec: failExec }),
+        linkPrToIssue({ owner: 'o', repo: 'r', prNumber: 1, issueNumbers: [1], exec: failExec }),
+      ];
+
+      for (const result of results) {
+        expect(result).toHaveProperty('error');
+        expect(result).toHaveProperty('code');
+      }
+
+      // detectRepo returns null instead of error object
+      const detectResult = detectRepo({ exec: failExec });
+      expect(detectResult).toBeNull();
+    });
+  });
+});