@dependabit/github-client 0.1.1

package/test/issues.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { IssueManager } from '../src/issues.js';
+
+// Mock the octokit module
+vi.mock('octokit', () => {
+  const mockIssuesCreate = vi.fn().mockResolvedValue({
+    data: {
+      number: 123,
+      html_url: 'https://github.com/test-owner/test-repo/issues/123',
+      labels: []
+    }
+  });
+
+  const mockIssuesGet = vi.fn().mockResolvedValue({
+    data: {
+      number: 123,
+      body: 'Existing issue body',
+      labels: [{ name: 'existing-label' }]
+    }
+  });
+
+  const mockIssuesUpdate = vi.fn().mockResolvedValue({
+    data: {
+      number: 123,
+      html_url: 'https://github.com/test-owner/test-repo/issues/123',
+      labels: []
+    }
+  });
+
+  const mockSearchIssues = vi.fn().mockResolvedValue({
+    data: {
+      items: []
+    }
+  });
+
+  class MockOctokit {
+    rest = {
+      issues: {
+        create: mockIssuesCreate,
+        get: mockIssuesGet,
+        update: mockIssuesUpdate
+      },
+      search: {
+        issuesAndPullRequests: mockSearchIssues
+      }
+    };
+  }
+
+  return {
+    Octokit: MockOctokit
+  };
+});
+
+describe('IssueManager', () => {
+  let issueManager: IssueManager;
+
+  beforeEach(() => {
+    issueManager = new IssueManager();
+    vi.clearAllMocks();
+  });
+
+  describe('createIssue', () => {
+    it('should create issue with severity label', async () => {
+      const issueData = {
+        owner: 'test-owner',
+        repo: 'test-repo',
+        title: 'Dependency Update: test-package',
+        body: 'New version detected',
+        severity: 'major' as const,
+        dependency: {
+          id: 'test-id',
+          url: 'https://github.com/owner/repo'
+        }
+      };
+
+      const result = await issueManager.createIssue(issueData);
+
+      expect(result).toBeDefined();
+      expect(result.number).toBeDefined();
+      expect(result.url).toBeDefined();
+      expect(result.labels).toContain('severity:major');
+    });
+
+    it('should include dependabit label', async () => {
+      const issueData = {
+        owner: 'test-owner',
+        repo: 'test-repo',
+        title: 'Dependency Update',
+        body: 'Changes detected',
+        severity: 'minor' as const,
+        dependency: {
+          id: 'test-id',
+          url: 'https://example.com'
+        }
+      };
+
+      const result = await issueManager.createIssue(issueData);
+
+      expect(result.labels).toContain('dependabit');
+    });
+
+    it('should handle breaking changes with appropriate label', async () => {
+      const issueData = {
+        owner: 'test-owner',
+        repo: 'test-repo',
+        title: 'Breaking Change Detected',
+        body: 'Major version update with breaking changes',
+        severity: 'breaking' as const,
+        dependency: {
+          id: 'test-id',
+          url: 'https://github.com/owner/repo'
+        }
+      };
+
+      const result = await issueManager.createIssue(issueData);
+
+      expect(result.labels).toContain('severity:breaking');
+    });
+
+    it('should assign issue to AI agent when specified', async () => {
+      const issueData = {
+        owner: 'test-owner',
+        repo: 'test-repo',
+        title: 'Dependency Update',
+        body: 'Changes detected',
+        severity: 'major' as const,
+        dependency: {
+          id: 'test-id',
+          url: 'https://example.com'
+        },
+        assignee: 'copilot'
+      };
+
+      const result = await issueManager.createIssue(issueData);
+
+      expect(result).toBeDefined();
+      expect(result.assignees).toContain('copilot');
+    });
+  });
+
+  describe('findExistingIssue', () => {
+    it('should find existing issue for dependency', async () => {
+      const params = {
+        owner: 'test-owner',
+        repo: 'test-repo',
+        dependencyId: 'test-id'
+      };
+
+      const result = await issueManager.findExistingIssue(params);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should return null when no existing issue found', async () => {
+      const params = {
+        owner: 'test-owner',
+        repo: 'test-repo',
+        dependencyId: 'non-existent-id'
+      };
+
+      const result = await issueManager.findExistingIssue(params);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('updateIssue', () => {
+    it('should update existing issue with new information', async () => {
+      const updateData = {
+        owner: 'test-owner',
+        repo: 'test-repo',
+        issueNumber: 123,
+        body: 'Updated information',
+        severity: 'breaking' as const
+      };
+
+      const result = await issueManager.updateIssue(updateData);
+
+      expect(result).toBeDefined();
+      expect(result.number).toBe(123);
+    });
+
+    it('should append to existing issue body when specified', async () => {
+      const updateData = {
+        owner: 'test-owner',
+        repo: 'test-repo',
+        issueNumber: 123,
+        body: 'Additional update',
+        append: true
+      };
+
+      const result = await issueManager.updateIssue(updateData);
+
+      expect(result).toBeDefined();
+    });
+  });
+});

package/test/rate-limit.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RateLimitHandler } from '../src/rate-limit.js';
+
+// Mock the octokit module
+vi.mock('octokit', () => {
+  const mockRateLimitGet = vi.fn().mockResolvedValue({
+    data: {
+      rate: {
+        limit: 5000,
+        remaining: 4000,
+        reset: Math.floor(Date.now() / 1000) + 3600,
+        used: 1000
+      },
+      resources: {
+        core: {
+          limit: 5000,
+          remaining: 4000,
+          reset: Math.floor(Date.now() / 1000) + 3600,
+          used: 1000
+        },
+        search: {
+          limit: 30,
+          remaining: 25,
+          reset: Math.floor(Date.now() / 1000) + 3600,
+          used: 5
+        },
+        graphql: {
+          limit: 5000,
+          remaining: 4500,
+          reset: Math.floor(Date.now() / 1000) + 3600,
+          used: 500
+        }
+      }
+    }
+  });
+
+  class MockOctokit {
+    rest = {
+      rateLimit: {
+        get: mockRateLimitGet
+      }
+    };
+  }
+
+  return {
+    Octokit: MockOctokit
+  };
+});
+
+describe('RateLimitHandler', () => {
+  let handler: RateLimitHandler;
+
+  beforeEach(() => {
+    handler = new RateLimitHandler();
+    vi.clearAllMocks();
+  });
+
+  describe('checkRateLimit', () => {
+    it('should return rate limit status', async () => {
+      const result = await handler.checkRateLimit();
+
+      expect(result).toBeDefined();
+      expect(result.limit).toBeGreaterThan(0);
+      expect(result.remaining).toBeDefined();
+      expect(result.reset).toBeInstanceOf(Date);
+    });
+
+    it('should warn when approaching rate limit', async () => {
+      const result = await handler.checkRateLimit();
+
+      if (result.remaining < result.limit * 0.1) {
+        expect(result.warning).toBeDefined();
+      }
+    });
+  });
+
+  describe('waitIfNeeded', () => {
+    it('should not wait when rate limit is sufficient', async () => {
+      const startTime = Date.now();
+      await handler.waitIfNeeded();
+      const endTime = Date.now();
+
+      expect(endTime - startTime).toBeLessThan(1000);
+    });
+
+    it('should calculate wait time when rate limited', async () => {
+      const rateLimitInfo = {
+        limit: 5000,
+        remaining: 0,
+        reset: new Date(Date.now() + 60000) // 1 minute from now
+      };
+
+      const waitTime = handler.calculateWaitTime(rateLimitInfo);
+
+      expect(waitTime).toBeGreaterThan(0);
+      expect(waitTime).toBeLessThanOrEqual(60000);
+    });
+
+    it('should return 0 wait time when not rate limited', () => {
+      const rateLimitInfo = {
+        limit: 5000,
+        remaining: 4000,
+        reset: new Date(Date.now() + 3600000)
+      };
+
+      const waitTime = handler.calculateWaitTime(rateLimitInfo);
+
+      expect(waitTime).toBe(0);
+    });
+  });
+
+  describe('reserveBudget', () => {
+    it('should reserve API call budget', async () => {
+      const result = await handler.reserveBudget(10);
+
+      expect(result).toBeDefined();
+      expect(result.reserved).toBe(true);
+    });
+
+    it('should reject when insufficient budget', async () => {
+      const result = await handler.reserveBudget(10000);
+
+      expect(result.reserved).toBe(false);
+      expect(result.reason).toBeDefined();
+    });
+
+    it('should provide wait time when budget unavailable', async () => {
+      const result = await handler.reserveBudget(10000);
+
+      if (!result.reserved) {
+        expect(result.waitTime).toBeDefined();
+      }
+    });
+  });
+
+  describe('getRateLimitStatus', () => {
+    it('should return current rate limit status', async () => {
+      const status = await handler.getRateLimitStatus();
+
+      expect(status).toBeDefined();
+      expect(status.core).toBeDefined();
+      expect(status.search).toBeDefined();
+      expect(status.graphql).toBeDefined();
+    });
+
+    it('should include percentage remaining', async () => {
+      const status = await handler.getRateLimitStatus();
+
+      expect(status.core.percentageRemaining).toBeDefined();
+      expect(status.core.percentageRemaining).toBeGreaterThanOrEqual(0);
+      expect(status.core.percentageRemaining).toBeLessThanOrEqual(100);
+    });
+  });
+});

package/test/releases.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ReleaseManager } from '../src/releases.js';
+
+// Mock the octokit module
+vi.mock('octokit', () => {
+  const mockGetLatestRelease = vi.fn().mockImplementation((params: any) => {
+    // Return 404 for specific repos
+    if (params.repo === 'no-releases') {
+      const error: any = new Error('Not Found');
+      error.status = 404;
+      return Promise.reject(error);
+    }
+    return Promise.resolve({
+      data: {
+        tag_name: 'v1.0.0',
+        name: 'Release v1.0.0',
+        published_at: '2024-01-01T00:00:00Z',
+        created_at: '2024-01-01T00:00:00Z',
+        body: 'Release notes',
+        html_url: 'https://github.com/test-owner/test-repo/releases/v1.0.0',
+        prerelease: false,
+        draft: false
+      }
+    });
+  });
+
+  const mockListReleases = vi.fn().mockImplementation((params: any) => {
+    // Return empty for specific repos
+    if (params.repo === 'no-releases') {
+      const error: any = new Error('Not Found');
+      error.status = 404;
+      return Promise.reject(error);
+    }
+    return Promise.resolve({
+      data: [
+        {
+          tag_name: 'v1.0.0',
+          name: 'Release v1.0.0',
+          published_at: '2024-01-01T00:00:00Z',
+          created_at: '2024-01-01T00:00:00Z',
+          body: 'Release notes',
+          html_url: 'https://github.com/test-owner/test-repo/releases/v1.0.0',
+          prerelease: false,
+          draft: false
+        }
+      ]
+    });
+  });
+
+  const mockGetReleaseByTag = vi.fn().mockResolvedValue({
+    data: {
+      tag_name: 'v1.0.0',
+      name: 'Release v1.0.0',
+      published_at: '2024-01-01T00:00:00Z',
+      created_at: '2024-01-01T00:00:00Z',
+      body: 'Release notes',
+      html_url: 'https://github.com/test-owner/test-repo/releases/v1.0.0',
+      prerelease: false,
+      draft: false
+    }
+  });
+
+  class MockOctokit {
+    rest = {
+      repos: {
+        getLatestRelease: mockGetLatestRelease,
+        listReleases: mockListReleases,
+        getReleaseByTag: mockGetReleaseByTag
+      }
+    };
+  }
+
+  return {
+    Octokit: MockOctokit
+  };
+});
+
+describe('ReleaseManager', () => {
+  let releaseManager: ReleaseManager;
+
+  beforeEach(() => {
+    releaseManager = new ReleaseManager();
+    vi.clearAllMocks();
+  });
+
+  describe('getLatestRelease', () => {
+    it('should fetch latest release', async () => {
+      const params = {
+        owner: 'test-owner',
+        repo: 'test-repo'
+      };
+
+      const result = await releaseManager.getLatestRelease(params);
+
+      expect(result).toBeDefined();
+      expect(result.tagName).toBeDefined();
+      expect(result.publishedAt).toBeInstanceOf(Date);
+    });
+
+    it('should return null when no releases exist', async () => {
+      const params = {
+        owner: 'test-owner',
+        repo: 'no-releases'
+      };
+
+      const result = await releaseManager.getLatestRelease(params);
+
+      expect(result).toBeNull();
+    });
+
+    it('should include release notes', async () => {
+      const params = {
+        owner: 'test-owner',
+        repo: 'test-repo'
+      };
+
+      const result = await releaseManager.getLatestRelease(params);
+
+      expect(result?.body).toBeDefined();
+      expect(result?.htmlUrl).toBeDefined();
+    });
+  });
+
+  describe('getAllReleases', () => {
+    it('should fetch all releases', async () => {
+      const params = {
+        owner: 'test-owner',
+        repo: 'test-repo'
+      };
+
+      const result = await releaseManager.getAllReleases(params);
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('should support pagination', async () => {
+      const params = {
+        owner: 'test-owner',
+        repo: 'test-repo',
+        page: 2,
+        perPage: 10
+      };
+
+      const result = await releaseManager.getAllReleases(params);
+
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it('should return empty array when no releases', async () => {
+      const params = {
+        owner: 'test-owner',
+        repo: 'no-releases'
+      };
+
+      const result = await releaseManager.getAllReleases(params);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('compareReleases', () => {
+    it('should detect new releases', () => {
+      const oldReleases = [{ tagName: 'v1.0.0', publishedAt: new Date('2024-01-01') }];
+
+      const newReleases = [
+        { tagName: 'v1.1.0', publishedAt: new Date('2024-01-02') },
+        { tagName: 'v1.0.0', publishedAt: new Date('2024-01-01') }
+      ];
+
+      const result = releaseManager.compareReleases(oldReleases, newReleases);
+
+      expect(result.newReleases).toHaveLength(1);
+      expect(result.newReleases[0].tagName).toBe('v1.1.0');
+    });
+
+    it('should return empty when no new releases', () => {
+      const oldReleases = [{ tagName: 'v1.0.0', publishedAt: new Date('2024-01-01') }];
+
+      const newReleases = [{ tagName: 'v1.0.0', publishedAt: new Date('2024-01-01') }];
+
+      const result = releaseManager.compareReleases(oldReleases, newReleases);
+
+      expect(result.newReleases).toHaveLength(0);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts", "src/**/*.spec.ts"],
+  "references": []
+}