@dependabit/github-client 0.1.1

package/test/auth/oauth.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OAuthHandler } from '../../src/auth/oauth';
+
+describe('OAuthHandler', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create handler with client credentials', () => {
+      const config = {
+        clientId: 'test_client_id',
+        clientSecret: 'test_client_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+      expect(handler).toBeInstanceOf(OAuthHandler);
+    });
+
+    it('should throw error for missing clientId', () => {
+      const config = {
+        clientId: '',
+        clientSecret: 'secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      expect(() => new OAuthHandler(config)).toThrow('clientId is required');
+    });
+
+    it('should throw error for missing clientSecret', () => {
+      const config = {
+        clientId: 'client',
+        clientSecret: '',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      expect(() => new OAuthHandler(config)).toThrow('clientSecret is required');
+    });
+  });
+
+  describe('authenticate', () => {
+    it('should exchange code for access token', async () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+
+      // Mock the token exchange
+      vi.spyOn(handler as any, 'exchangeCodeForToken').mockResolvedValue({
+        access_token: 'gho_accesstoken123',
+        token_type: 'bearer',
+        scope: 'repo'
+      });
+
+      const auth = await handler.authenticate('test_code');
+
+      expect(auth).toEqual({
+        type: 'oauth',
+        token: 'gho_accesstoken123',
+        tokenType: 'bearer',
+        scope: 'repo'
+      });
+    });
+
+    it('should throw error for invalid code', async () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+
+      await expect(handler.authenticate('')).rejects.toThrow('Authorization code is required');
+    });
+
+    it('should handle token exchange failure', async () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+
+      vi.spyOn(handler as any, 'exchangeCodeForToken').mockRejectedValue(
+        new Error('Invalid authorization code')
+      );
+
+      await expect(handler.authenticate('bad_code')).rejects.toThrow('Invalid authorization code');
+    });
+  });
+
+  describe('getAuthorizationUrl', () => {
+    it('should generate authorization URL with scopes', () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+
+      const url = handler.getAuthorizationUrl(['repo', 'user']);
+
+      expect(url).toContain('https://github.com/login/oauth/authorize');
+      expect(url).toContain('client_id=test_client');
+      expect(url).toContain('redirect_uri=http%3A%2F%2Flocalhost%3A3000%2Fcallback');
+      expect(url).toContain('scope=repo+user'); // URLSearchParams uses + for spaces
+    });
+
+    it('should include state parameter for CSRF protection', () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+
+      const url = handler.getAuthorizationUrl(['repo'], 'random_state_123');
+
+      expect(url).toContain('state=random_state_123');
+    });
+  });
+
+  describe('refreshToken', () => {
+    it('should refresh expired access token', async () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+
+      vi.spyOn(handler as any, 'performTokenRefresh').mockResolvedValue({
+        access_token: 'gho_newtoken456',
+        token_type: 'bearer',
+        scope: 'repo'
+      });
+
+      const result = await handler.refreshToken('refresh_token_123');
+
+      expect(result).toEqual({
+        type: 'oauth',
+        token: 'gho_newtoken456',
+        tokenType: 'bearer',
+        scope: 'repo'
+      });
+    });
+
+    it('should throw error for missing refresh token', async () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+
+      await expect(handler.refreshToken('')).rejects.toThrow('Refresh token is required');
+    });
+  });
+
+  describe('validate', () => {
+    it('should validate OAuth configuration', () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+
+      expect(handler.validate()).toBe(true);
+    });
+
+    it('should fail validation for invalid redirect URI', () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'invalid-uri'
+      };
+      const handler = new OAuthHandler(config);
+
+      expect(handler.validate()).toBe(false);
+    });
+  });
+
+  describe('getType', () => {
+    it('should return oauth type', () => {
+      const config = {
+        clientId: 'test_client',
+        clientSecret: 'test_secret',
+        redirectUri: 'http://localhost:3000/callback'
+      };
+      const handler = new OAuthHandler(config);
+
+      expect(handler.getType()).toBe('oauth');
+    });
+  });
+});

package/test/auth/token.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TokenAuthHandler } from '../../src/auth/token';
+
+describe('TokenAuthHandler', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create handler with GitHub PAT token', () => {
+      const token = 'ghp_testtoken123';
+      const handler = new TokenAuthHandler(token);
+      expect(handler).toBeInstanceOf(TokenAuthHandler);
+    });
+
+    it('should create handler with API key', () => {
+      const token = 'api_key_12345';
+      const handler = new TokenAuthHandler(token);
+      expect(handler).toBeInstanceOf(TokenAuthHandler);
+    });
+
+    it('should throw error for empty token', () => {
+      expect(() => new TokenAuthHandler('')).toThrow('Token cannot be empty');
+    });
+  });
+
+  describe('authenticate', () => {
+    it('should return auth object with token', async () => {
+      const token = 'ghp_testtoken123';
+      const handler = new TokenAuthHandler(token);
+      const auth = await handler.authenticate();
+
+      expect(auth).toEqual({
+        type: 'token',
+        token: token
+      });
+    });
+
+    it('should validate token format for GitHub PAT', async () => {
+      const token = 'ghp_validtoken123456';
+      const handler = new TokenAuthHandler(token);
+      const auth = await handler.authenticate();
+
+      expect(auth.token).toBe(token);
+    });
+
+    it('should accept fine-grained tokens', async () => {
+      const token = 'github_pat_validtoken123456';
+      const handler = new TokenAuthHandler(token);
+      const auth = await handler.authenticate();
+
+      expect(auth.token).toBe(token);
+    });
+  });
+
+  describe('validate', () => {
+    it('should validate token format', () => {
+      const handler = new TokenAuthHandler('ghp_test123');
+      expect(handler.validate()).toBe(true);
+    });
+
+    it('should accept any non-empty token', () => {
+      // Token validation is lenient - allows API keys without GitHub prefix
+      const handler = new TokenAuthHandler('api_key_123');
+      expect(handler.validate()).toBe(true);
+    });
+
+    it('should accept various GitHub token prefixes', () => {
+      const validPrefixes = ['ghp_', 'gho_', 'ghu_', 'ghs_', 'ghr_', 'github_pat_'];
+
+      validPrefixes.forEach((prefix) => {
+        const handler = new TokenAuthHandler(`${prefix}test123`);
+        expect(handler.validate()).toBe(true);
+      });
+    });
+  });
+
+  describe('getType', () => {
+    it('should return token type', () => {
+      const handler = new TokenAuthHandler('ghp_test');
+      expect(handler.getType()).toBe('token');
+    });
+  });
+
+  describe('token rotation', () => {
+    it('should allow token update', () => {
+      const handler = new TokenAuthHandler('ghp_old');
+      handler.updateToken('ghp_new');
+      expect(handler.getToken()).toBe('ghp_new');
+    });
+
+    it('should throw error on empty token update', () => {
+      const handler = new TokenAuthHandler('ghp_test');
+      expect(() => handler.updateToken('')).toThrow('Token cannot be empty');
+    });
+  });
+});

package/test/commits.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { fetchCommits, getCommitDiff, parseCommitFiles } from '../src/commits.js';
+
+// Mock the octokit module
+const mockListCommits = vi.fn();
+const mockGetCommit = vi.fn();
+
+vi.mock('octokit', () => {
+  class MockOctokit {
+    rest = {
+      repos: {
+        listCommits: mockListCommits,
+        getCommit: mockGetCommit
+      }
+    };
+  }
+
+  return {
+    Octokit: MockOctokit
+  };
+});
+
+describe('Commit Analysis Tests', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('fetchCommits', () => {
+    it('should fetch commits from GitHub API', async () => {
+      const mockCommits = [
+        {
+          sha: 'abc123',
+          commit: {
+            message: 'feat: add new dependency',
+            author: { name: 'Test User', date: '2024-01-01T00:00:00Z' }
+          }
+        },
+        {
+          sha: 'def456',
+          commit: {
+            message: 'fix: update README',
+            author: { name: 'Test User', date: '2024-01-01T01:00:00Z' }
+          }
+        }
+      ];
+
+      mockListCommits.mockResolvedValue({
+        data: mockCommits
+      });
+
+      const client = {
+        getOctokit: () => ({ rest: { repos: { listCommits: mockListCommits } } })
+      } as any;
+      const result = await fetchCommits(client, 'owner', 'repo', { since: '2024-01-01T00:00:00Z' });
+
+      expect(result).toHaveLength(2);
+      expect(result[0].sha).toBe('abc123');
+      expect(result[1].sha).toBe('def456');
+      expect(mockListCommits).toHaveBeenCalledWith({
+        owner: 'owner',
+        repo: 'repo',
+        since: '2024-01-01T00:00:00Z'
+      });
+    });
+
+    it('should handle empty commit list', async () => {
+      mockListCommits.mockResolvedValue({ data: [] });
+
+      const client = {
+        getOctokit: () => ({ rest: { repos: { listCommits: mockListCommits } } })
+      } as any;
+      const result = await fetchCommits(client, 'owner', 'repo');
+
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('getCommitDiff', () => {
+    it('should fetch commit diff with file changes', async () => {
+      const mockCommitData = {
+        sha: 'abc123',
+        files: [
+          {
+            filename: 'README.md',
+            status: 'modified',
+            additions: 5,
+            deletions: 2,
+            changes: 7,
+            patch: '@@ -1,3 +1,6 @@\n-Old line\n+New line\n+Another line'
+          },
+          {
+            filename: 'src/index.ts',
+            status: 'added',
+            additions: 10,
+            deletions: 0,
+            changes: 10,
+            patch: '@@ -0,0 +1,10 @@\n+export function test() {}'
+          }
+        ]
+      };
+
+      mockGetCommit.mockResolvedValue({ data: mockCommitData });
+
+      const client = {
+        getOctokit: () => ({ rest: { repos: { getCommit: mockGetCommit } } })
+      } as any;
+      const result = await getCommitDiff(client, 'owner', 'repo', 'abc123');
+
+      expect(result.sha).toBe('abc123');
+      expect(result.files).toHaveLength(2);
+      expect(result.files[0].filename).toBe('README.md');
+      expect(result.files[0].status).toBe('modified');
+      expect(result.files[1].filename).toBe('src/index.ts');
+      expect(result.files[1].status).toBe('added');
+    });
+
+    it('should handle commit without file changes', async () => {
+      mockGetCommit.mockResolvedValue({
+        data: { sha: 'abc123', files: [] }
+      });
+
+      const client = {
+        getOctokit: () => ({ rest: { repos: { getCommit: mockGetCommit } } })
+      } as any;
+      const result = await getCommitDiff(client, 'owner', 'repo', 'abc123');
+
+      expect(result.files).toHaveLength(0);
+    });
+  });
+
+  describe('parseCommitFiles', () => {
+    it('should extract changed files from commit', () => {
+      const files = [
+        { filename: 'README.md', status: 'modified' as const, patch: '...' },
+        { filename: 'src/index.ts', status: 'added' as const, patch: '...' },
+        { filename: 'docs/guide.md', status: 'modified' as const, patch: '...' },
+        { filename: 'test.ts', status: 'removed' as const }
+      ];
+
+      const result = parseCommitFiles(files);
+
+      expect(result.modified).toContain('README.md');
+      expect(result.modified).toContain('docs/guide.md');
+      expect(result.added).toContain('src/index.ts');
+      expect(result.removed).toContain('test.ts');
+    });
+
+    it('should handle empty file list', () => {
+      const result = parseCommitFiles([]);
+
+      expect(result.added).toHaveLength(0);
+      expect(result.modified).toHaveLength(0);
+      expect(result.removed).toHaveLength(0);
+    });
+
+    it('should group files by type of change', () => {
+      const files = [
+        { filename: 'file1.md', status: 'added' as const, patch: '...' },
+        { filename: 'file2.md', status: 'added' as const, patch: '...' },
+        { filename: 'file3.md', status: 'modified' as const, patch: '...' }
+      ];
+
+      const result = parseCommitFiles(files);
+
+      expect(result.added).toHaveLength(2);
+      expect(result.modified).toHaveLength(1);
+    });
+  });
+});

package/test/feedback.test.ts

@@ -0,0 +1,203 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { FeedbackListener } from '../src/feedback.js';
+import type { IssueManagerInterface } from '../src/feedback.js';
+
+describe('FeedbackListener', () => {
+  let mockIssueManager: IssueManagerInterface;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Mock IssueManager
+    mockIssueManager = {
+      listIssues: vi.fn(),
+      getIssue: vi.fn()
+    } as IssueManagerInterface;
+  });
+
+  describe('constructor', () => {
+    it('should create listener with issue manager', () => {
+      const listener = new FeedbackListener(mockIssueManager);
+      expect(listener).toBeInstanceOf(FeedbackListener);
+    });
+
+    it('should accept custom labels', () => {
+      const config = {
+        truePositiveLabel: 'confirmed',
+        falsePositiveLabel: 'not-a-bug'
+      };
+      const listener = new FeedbackListener(mockIssueManager, config);
+      expect(listener).toBeInstanceOf(FeedbackListener);
+    });
+  });
+
+  describe('collectFeedback', () => {
+    it('should collect issues with feedback labels', async () => {
+      const mockIssues = [
+        { number: 1, labels: ['false-positive'], title: 'Test 1', created_at: '2026-01-01' },
+        { number: 2, labels: ['true-positive'], title: 'Test 2', created_at: '2026-01-02' },
+        { number: 3, labels: ['false-positive'], title: 'Test 3', created_at: '2026-01-03' }
+      ];
+
+      vi.mocked(mockIssueManager.listIssues).mockResolvedValue(mockIssues as any);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const feedback = await listener.collectFeedback();
+
+      expect(feedback.truePositives).toHaveLength(1);
+      expect(feedback.falsePositives).toHaveLength(2);
+      expect(feedback.total).toBe(3);
+    });
+
+    it('should filter by date range', async () => {
+      const mockIssues = [
+        {
+          number: 1,
+          labels: ['false-positive'],
+          title: 'Old issue',
+          created_at: '2025-12-01T00:00:00Z'
+        },
+        {
+          number: 2,
+          labels: ['false-positive'],
+          title: 'Recent issue',
+          created_at: '2026-01-25T00:00:00Z'
+        }
+      ];
+
+      vi.mocked(mockIssueManager.listIssues).mockResolvedValue(mockIssues as any);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const startDate = new Date('2026-01-01');
+      const feedback = await listener.collectFeedback({ startDate });
+
+      expect(feedback.falsePositives).toHaveLength(1);
+      expect(feedback.falsePositives[0].number).toBe(2);
+    });
+
+    it('should handle empty results', async () => {
+      vi.mocked(mockIssueManager.listIssues).mockResolvedValue([]);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const feedback = await listener.collectFeedback();
+
+      expect(feedback.truePositives).toHaveLength(0);
+      expect(feedback.falsePositives).toHaveLength(0);
+      expect(feedback.total).toBe(0);
+    });
+
+    it('should filter by repository', async () => {
+      const mockIssues = [
+        { number: 1, labels: ['false-positive'], title: 'Test', repository: 'owner/repo1' },
+        { number: 2, labels: ['false-positive'], title: 'Test', repository: 'owner/repo2' }
+      ];
+
+      vi.mocked(mockIssueManager.listIssues).mockResolvedValue(mockIssues as any);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const feedback = await listener.collectFeedback({ repository: 'owner/repo1' });
+
+      expect(feedback.falsePositives).toHaveLength(1);
+    });
+  });
+
+  describe('getFeedbackRate', () => {
+    it('should calculate false positive rate', async () => {
+      const mockIssues = [
+        { number: 1, labels: ['false-positive'], title: 'FP1' },
+        { number: 2, labels: ['true-positive'], title: 'TP1' },
+        { number: 3, labels: ['true-positive'], title: 'TP2' },
+        { number: 4, labels: ['false-positive'], title: 'FP2' }
+      ];
+
+      vi.mocked(mockIssueManager.listIssues).mockResolvedValue(mockIssues as any);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const rate = await listener.getFeedbackRate();
+
+      expect(rate.falsePositiveRate).toBe(0.5); // 2 FP out of 4 total
+      expect(rate.truePositiveRate).toBe(0.5); // 2 TP out of 4 total
+      expect(rate.totalFeedback).toBe(4);
+    });
+
+    it('should return 0 for empty feedback', async () => {
+      vi.mocked(mockIssueManager.listIssues).mockResolvedValue([]);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const rate = await listener.getFeedbackRate();
+
+      expect(rate.falsePositiveRate).toBe(0);
+      expect(rate.truePositiveRate).toBe(0);
+      expect(rate.totalFeedback).toBe(0);
+    });
+  });
+
+  describe('getRecentFeedback', () => {
+    it('should get feedback from last 30 days', async () => {
+      const now = new Date('2026-01-31');
+      const mockIssues = [
+        {
+          number: 1,
+          labels: ['false-positive'],
+          title: 'Recent',
+          created_at: '2026-01-20T00:00:00Z'
+        },
+        {
+          number: 2,
+          labels: ['false-positive'],
+          title: 'Old',
+          created_at: '2025-12-15T00:00:00Z'
+        }
+      ];
+
+      vi.mocked(mockIssueManager.listIssues).mockResolvedValue(mockIssues as any);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const feedback = await listener.getRecentFeedback(30, now);
+
+      expect(feedback.falsePositives).toHaveLength(1);
+      expect(feedback.falsePositives[0].number).toBe(1);
+    });
+
+    it('should default to current date', async () => {
+      vi.mocked(mockIssueManager.listIssues).mockResolvedValue([]);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const feedback = await listener.getRecentFeedback(30);
+
+      expect(feedback).toBeDefined();
+    });
+  });
+
+  describe('monitorIssue', () => {
+    it('should check if issue has feedback label', async () => {
+      const issue = {
+        number: 1,
+        labels: ['false-positive'],
+        title: 'Test'
+      };
+
+      vi.mocked(mockIssueManager.getIssue).mockResolvedValue(issue as any);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const hasFeedback = await listener.monitorIssue(1);
+
+      expect(hasFeedback).toBe(true);
+    });
+
+    it('should return false for issues without feedback labels', async () => {
+      const issue = {
+        number: 1,
+        labels: ['bug', 'enhancement'],
+        title: 'Test'
+      };
+
+      vi.mocked(mockIssueManager.getIssue).mockResolvedValue(issue as any);
+
+      const listener = new FeedbackListener(mockIssueManager);
+      const hasFeedback = await listener.monitorIssue(1);
+
+      expect(hasFeedback).toBe(false);
+    });
+  });
+});