github-to-mcp-monorepo 1.0.0

package/packages/core/src/__tests__/github-client.test.ts

@@ -0,0 +1,390 @@
+/**
+ * @fileoverview Unit tests for github-client module
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { GithubClient } from '../github-client';
+
+// Mock Octokit
+vi.mock('@octokit/rest', () => ({
+  Octokit: vi.fn().mockImplementation(() => ({
+    repos: {
+      get: vi.fn(),
+      getContent: vi.fn(),
+    },
+    rateLimit: {
+      get: vi.fn(),
+    },
+  })),
+}));
+
+describe('GithubClient', () => {
+  let client: GithubClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    client = new GithubClient();
+  });
+
+  describe('parseGithubUrl', () => {
+    it('should parse basic GitHub URL', () => {
+      const url = 'https://github.com/owner/repo';
+      const result = client.parseGithubUrl(url);
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('main');
+    });
+
+    it('should parse URL with .git suffix', () => {
+      const url = 'https://github.com/owner/repo.git';
+      const result = client.parseGithubUrl(url);
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+    });
+
+    it('should parse URL with branch', () => {
+      const url = 'https://github.com/owner/repo/tree/develop';
+      const result = client.parseGithubUrl(url);
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('develop');
+    });
+
+    it('should parse URL with branch and path', () => {
+      const url = 'https://github.com/owner/repo/tree/main/src/index.ts';
+      const result = client.parseGithubUrl(url);
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('main');
+      expect(result.path).toBe('src/index.ts');
+    });
+
+    it('should throw for invalid URL', () => {
+      const url = 'https://gitlab.com/owner/repo';
+
+      expect(() => client.parseGithubUrl(url)).toThrow('Invalid GitHub URL');
+    });
+
+    it('should throw for empty URL', () => {
+      expect(() => client.parseGithubUrl('')).toThrow('Invalid GitHub URL');
+    });
+
+    it('should handle URLs with trailing slash', () => {
+      const url = 'https://github.com/owner/repo/';
+      const result = client.parseGithubUrl(url);
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+    });
+
+    it('should parse URL with special characters in repo name', () => {
+      const url = 'https://github.com/owner/my-awesome-repo';
+      const result = client.parseGithubUrl(url);
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('my-awesome-repo');
+    });
+
+    it('should handle feature branch names', () => {
+      const url = 'https://github.com/owner/repo/tree/feature/new-feature';
+      const result = client.parseGithubUrl(url);
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('feature/new-feature');
+    });
+  });
+
+  describe('getRepoMetadata', () => {
+    it('should fetch repository metadata', async () => {
+      const mockData = {
+        stargazers_count: 100,
+        language: 'TypeScript',
+        license: { spdx_id: 'MIT' },
+        description: 'A test repo',
+        default_branch: 'main',
+      };
+
+      (client as any).octokit.repos.get.mockResolvedValue({ data: mockData });
+
+      const result = await client.getRepoMetadata('owner', 'repo');
+
+      expect(result.stars).toBe(100);
+      expect(result.language).toBe('TypeScript');
+      expect(result.license).toBe('MIT');
+      expect(result.description).toBe('A test repo');
+      expect(result.defaultBranch).toBe('main');
+    });
+
+    it('should handle null license', async () => {
+      const mockData = {
+        stargazers_count: 50,
+        language: 'JavaScript',
+        license: null,
+        description: null,
+        default_branch: 'master',
+      };
+
+      (client as any).octokit.repos.get.mockResolvedValue({ data: mockData });
+
+      const result = await client.getRepoMetadata('owner', 'repo');
+
+      expect(result.license).toBeUndefined();
+      expect(result.description).toBeUndefined();
+    });
+
+    it('should handle missing language', async () => {
+      const mockData = {
+        stargazers_count: 0,
+        language: null,
+        license: null,
+        description: null,
+        default_branch: 'main',
+      };
+
+      (client as any).octokit.repos.get.mockResolvedValue({ data: mockData });
+
+      const result = await client.getRepoMetadata('owner', 'repo');
+
+      expect(result.language).toBe('unknown');
+    });
+  });
+
+  describe('getFileContent', () => {
+    it('should fetch file content', async () => {
+      const content = 'console.log("Hello");';
+      const encoded = Buffer.from(content).toString('base64');
+
+      (client as any).octokit.repos.getContent.mockResolvedValue({
+        data: {
+          type: 'file',
+          path: 'index.js',
+          content: encoded,
+          sha: 'abc123',
+        },
+      });
+
+      const result = await client.getFileContent('owner', 'repo', 'index.js');
+
+      expect(result).not.toBeNull();
+      expect(result?.content).toBe(content);
+      expect(result?.path).toBe('index.js');
+    });
+
+    it('should return null for directories', async () => {
+      (client as any).octokit.repos.getContent.mockResolvedValue({
+        data: [
+          { type: 'file', path: 'file1.ts' },
+          { type: 'file', path: 'file2.ts' },
+        ],
+      });
+
+      const result = await client.getFileContent('owner', 'repo', 'src');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null on 404 error', async () => {
+      (client as any).octokit.repos.getContent.mockRejectedValue(new Error('Not Found'));
+
+      const result = await client.getFileContent('owner', 'repo', 'nonexistent.ts');
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle file with no content', async () => {
+      (client as any).octokit.repos.getContent.mockResolvedValue({
+        data: {
+          type: 'file',
+          path: 'empty.ts',
+          content: undefined,
+          sha: 'def456',
+        },
+      });
+
+      const result = await client.getFileContent('owner', 'repo', 'empty.ts');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('listDirectory', () => {
+    it('should list directory contents', async () => {
+      (client as any).octokit.repos.getContent.mockResolvedValue({
+        data: [
+          { path: 'src', type: 'dir', sha: 'abc' },
+          { path: 'README.md', type: 'file', sha: 'def' },
+          { path: 'package.json', type: 'file', sha: 'ghi' },
+        ],
+      });
+
+      const result = await client.listDirectory('owner', 'repo', '');
+
+      expect(result).toHaveLength(3);
+      expect(result[0].type).toBe('dir');
+      expect(result[1].type).toBe('file');
+    });
+
+    it('should return empty array for file path', async () => {
+      (client as any).octokit.repos.getContent.mockResolvedValue({
+        data: { type: 'file', path: 'index.ts' },
+      });
+
+      const result = await client.listDirectory('owner', 'repo', 'index.ts');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return empty array on error', async () => {
+      (client as any).octokit.repos.getContent.mockRejectedValue(new Error('Not Found'));
+
+      const result = await client.listDirectory('owner', 'repo', 'nonexistent');
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('findApiSpecs', () => {
+    it('should find OpenAPI spec in root', async () => {
+      const specContent = JSON.stringify({
+        openapi: '3.0.0',
+        info: { title: 'API', version: '1.0.0' },
+        paths: {},
+      });
+
+      (client as any).octokit.repos.getContent.mockImplementation(async ({ path }: { path: string }) => {
+        if (path === 'openapi.json') {
+          return {
+            data: {
+              type: 'file',
+              content: Buffer.from(specContent).toString('base64'),
+              path,
+              sha: 'abc',
+            },
+          };
+        }
+        throw new Error('Not Found');
+      });
+
+      const result = await client.findApiSpecs('owner', 'repo');
+
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('openapi');
+      expect(result[0].version).toBe('3.0.0');
+    });
+
+    it('should find Swagger 2.0 spec', async () => {
+      const specContent = JSON.stringify({
+        swagger: '2.0',
+        info: { title: 'API', version: '1.0.0' },
+        paths: {},
+      });
+
+      (client as any).octokit.repos.getContent.mockImplementation(async ({ path }: { path: string }) => {
+        if (path === 'swagger.json') {
+          return {
+            data: {
+              type: 'file',
+              content: Buffer.from(specContent).toString('base64'),
+              path,
+              sha: 'abc',
+            },
+          };
+        }
+        throw new Error('Not Found');
+      });
+
+      const result = await client.findApiSpecs('owner', 'repo');
+
+      expect(result.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should return empty array when no specs found', async () => {
+      (client as any).octokit.repos.getContent.mockRejectedValue(new Error('Not Found'));
+
+      const result = await client.findApiSpecs('owner', 'repo');
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getReadme', () => {
+    it('should fetch README.md', async () => {
+      const readmeContent = '# Hello World';
+      const encoded = Buffer.from(readmeContent).toString('base64');
+
+      (client as any).octokit.repos.getContent.mockImplementation(async ({ path }: { path: string }) => {
+        if (path === 'README.md') {
+          return {
+            data: {
+              type: 'file',
+              content: encoded,
+              path,
+              sha: 'abc',
+            },
+          };
+        }
+        throw new Error('Not Found');
+      });
+
+      const result = await client.getReadme('owner', 'repo');
+
+      expect(result).toBe(readmeContent);
+    });
+
+    it('should try alternative README filenames', async () => {
+      const readmeContent = '# Hello';
+      const encoded = Buffer.from(readmeContent).toString('base64');
+
+      (client as any).octokit.repos.getContent.mockImplementation(async ({ path }: { path: string }) => {
+        if (path === 'readme.md') {
+          return {
+            data: {
+              type: 'file',
+              content: encoded,
+              path,
+              sha: 'abc',
+            },
+          };
+        }
+        throw new Error('Not Found');
+      });
+
+      const result = await client.getReadme('owner', 'repo');
+
+      expect(result).toBe(readmeContent);
+    });
+
+    it('should return null when README not found', async () => {
+      (client as any).octokit.repos.getContent.mockRejectedValue(new Error('Not Found'));
+
+      const result = await client.getReadme('owner', 'repo');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getRateLimit', () => {
+    it('should return rate limit info', async () => {
+      (client as any).octokit.rateLimit.get.mockResolvedValue({
+        data: {
+          rate: {
+            remaining: 4999,
+            limit: 5000,
+            reset: 1700000000,
+          },
+        },
+      });
+
+      const result = await client.getRateLimit();
+
+      expect(result.remaining).toBe(4999);
+      expect(result.limit).toBe(5000);
+      expect(result.reset).toBeInstanceOf(Date);
+    });
+  });
+});

package/packages/core/src/__tests__/gitlab-client.test.ts

@@ -0,0 +1,319 @@
+/**
+ * @fileoverview Unit tests for GitLab client
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { GitLabClient, createGitLabClient } from '../providers/gitlab-client';
+
+// Mock global fetch
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe('GitLabClient', () => {
+  let client: GitLabClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    client = new GitLabClient({ token: 'test-token' });
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('parseUrl', () => {
+    it('should parse simple GitLab URL', () => {
+      const result = client.parseUrl('https://gitlab.com/owner/repo');
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('main');
+    });
+
+    it('should parse GitLab URL with .git suffix', () => {
+      const result = client.parseUrl('https://gitlab.com/owner/repo.git');
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+    });
+
+    it('should parse GitLab URL with nested groups', () => {
+      const result = client.parseUrl('https://gitlab.com/group/subgroup/repo');
+
+      expect(result.owner).toBe('group/subgroup');
+      expect(result.repo).toBe('repo');
+    });
+
+    it('should parse GitLab URL with tree/branch', () => {
+      const result = client.parseUrl('https://gitlab.com/owner/repo/-/tree/develop');
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('develop');
+    });
+
+    it('should parse GitLab URL with tree/branch/path', () => {
+      const result = client.parseUrl('https://gitlab.com/owner/repo/-/tree/main/src/index.ts');
+
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('main');
+      expect(result.path).toBe('src/index.ts');
+    });
+
+    it('should throw error for invalid URL', () => {
+      expect(() => client.parseUrl('https://invalid-url.com/test')).toThrow('Invalid GitLab URL');
+    });
+  });
+
+  describe('getRepoMetadata', () => {
+    it('should fetch repository metadata', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          id: 123,
+          name: 'test-repo',
+          description: 'A test repository',
+          default_branch: 'main',
+          star_count: 50,
+          forks_count: 10,
+          open_issues_count: 5,
+          created_at: '2024-01-01T00:00:00Z',
+          last_activity_at: '2024-06-01T00:00:00Z',
+          topics: ['test', 'mcp'],
+          license: { key: 'MIT', name: 'MIT License' }
+        })
+      });
+
+      const metadata = await client.getRepoMetadata('owner', 'repo');
+
+      expect(metadata.stars).toBe(50);
+      expect(metadata.defaultBranch).toBe('main');
+      expect(metadata.license).toBe('MIT');
+      expect(metadata.description).toBe('A test repository');
+      expect(metadata.forksCount).toBe(10);
+      expect(metadata.topics).toContain('mcp');
+    });
+
+    it('should throw error on API failure', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found'
+      });
+
+      await expect(client.getRepoMetadata('owner', 'nonexistent')).rejects.toThrow('GitLab API error');
+    });
+  });
+
+  describe('getFile', () => {
+    it('should fetch file content', async () => {
+      const content = 'Hello, World!';
+      const base64Content = Buffer.from(content).toString('base64');
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          file_path: 'README.md',
+          encoding: 'base64',
+          content: base64Content,
+          blob_id: 'abc123'
+        })
+      });
+
+      const file = await client.getFile('owner', 'repo', 'README.md');
+
+      expect(file).not.toBeNull();
+      expect(file?.content).toBe(content);
+      expect(file?.path).toBe('README.md');
+      expect(file?.sha).toBe('abc123');
+    });
+
+    it('should return null for non-existent file', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404
+      });
+
+      const file = await client.getFile('owner', 'repo', 'nonexistent.md');
+
+      expect(file).toBeNull();
+    });
+  });
+
+  describe('getReadme', () => {
+    it('should fetch README content', async () => {
+      const content = '# Test Repo\n\nThis is a test.';
+      const base64Content = Buffer.from(content).toString('base64');
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          file_path: 'README.md',
+          encoding: 'base64',
+          content: base64Content,
+          blob_id: 'abc123'
+        })
+      });
+
+      const readme = await client.getReadme('owner', 'repo');
+
+      expect(readme).toBe(content);
+    });
+
+    it('should try multiple README variants', async () => {
+      // First call fails (README.md)
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 404 });
+      // Second call fails (README.MD)
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 404 });
+      // Third call succeeds (readme.md)
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          file_path: 'readme.md',
+          encoding: 'base64',
+          content: Buffer.from('Found!').toString('base64'),
+          blob_id: 'abc123'
+        })
+      });
+
+      const readme = await client.getReadme('owner', 'repo');
+
+      expect(readme).toBe('Found!');
+      expect(mockFetch).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('listFiles', () => {
+    it('should list directory contents', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => [
+          { id: '1', name: 'src', type: 'tree', path: 'src', mode: '040000' },
+          { id: '2', name: 'README.md', type: 'blob', path: 'README.md', mode: '100644' }
+        ]
+      });
+
+      const files = await client.listFiles('owner', 'repo');
+
+      expect(files).toHaveLength(2);
+      expect(files[0].type).toBe('dir');
+      expect(files[1].type).toBe('file');
+    });
+
+    it('should return empty array on error', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 404 });
+
+      const files = await client.listFiles('owner', 'repo');
+
+      expect(files).toEqual([]);
+    });
+  });
+
+  describe('searchCode', () => {
+    it('should search code in repository', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => [
+          {
+            basename: 'index',
+            data: 'function test() {}',
+            path: 'src/index.ts',
+            filename: 'index.ts',
+            id: 'abc123',
+            ref: 'main',
+            startline: 10,
+            project_id: 123
+          }
+        ]
+      });
+
+      const results = await client.searchCode('owner', 'repo', 'function');
+
+      expect(results).toHaveLength(1);
+      expect(results[0].path).toBe('src/index.ts');
+      expect(results[0].matchedLines?.[0].lineNumber).toBe(10);
+    });
+
+    it('should filter by extensions', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => [
+          { path: 'src/index.ts', filename: 'index.ts', data: 'test', id: '1', startline: 1, project_id: 1 },
+          { path: 'src/style.css', filename: 'style.css', data: 'test', id: '2', startline: 1, project_id: 1 }
+        ]
+      });
+
+      const results = await client.searchCode('owner', 'repo', 'test', {
+        extensions: ['ts']
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0].path).toBe('src/index.ts');
+    });
+  });
+
+  describe('findApiSpecs', () => {
+    it('should find OpenAPI specs', async () => {
+      const spec = { openapi: '3.0.0', info: { title: 'Test API', version: '1.0.0' } };
+
+      // Mock multiple file lookups - first fails, second succeeds
+      mockFetch
+        .mockResolvedValueOnce({ ok: false, status: 404 }) // openapi.json
+        .mockResolvedValueOnce({ ok: false, status: 404 }) // openapi.yaml
+        .mockResolvedValueOnce({ ok: false, status: 404 }) // openapi.yml
+        .mockResolvedValueOnce({ // swagger.json - succeeds
+          ok: true,
+          json: async () => ({
+            file_path: 'swagger.json',
+            encoding: 'base64',
+            content: Buffer.from(JSON.stringify(spec)).toString('base64'),
+            blob_id: 'abc123'
+          })
+        });
+
+      const specs = await client.findApiSpecs('owner', 'repo');
+
+      // May find specs in swagger.json location
+      expect(Array.isArray(specs)).toBe(true);
+    });
+  });
+
+  describe('getRateLimit', () => {
+    it('should return rate limit info', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers({
+          'RateLimit-Remaining': '100',
+          'RateLimit-Limit': '200',
+          'RateLimit-Reset': String(Math.floor(Date.now() / 1000) + 3600)
+        }),
+        json: async () => []
+      });
+
+      const rateLimit = await client.getRateLimit();
+
+      expect(rateLimit.remaining).toBe(100);
+      expect(rateLimit.limit).toBe(200);
+      expect(rateLimit.reset).toBeInstanceOf(Date);
+    });
+  });
+});
+
+describe('createGitLabClient', () => {
+  it('should create a GitLabClient instance', () => {
+    const client = createGitLabClient({ token: 'test-token' });
+
+    expect(client).toBeInstanceOf(GitLabClient);
+    expect(client.name).toBe('gitlab');
+  });
+
+  it('should create client with custom base URL', () => {
+    const client = createGitLabClient({
+      token: 'test-token',
+      baseUrl: 'https://gitlab.example.com/api/v4'
+    });
+
+    expect(client).toBeInstanceOf(GitLabClient);
+  });
+});