@littlebearapps/platform-admin-sdk 2.0.0 → 2.1.0

package/templates/standard/tests/unit/error-collector/dedup.test.ts

@@ -0,0 +1,350 @@
+/**
+ * Tests for error collector deduplication logic
+ * @see docs/plans/task-86-deduplication-implementation-plan.md
+ *
+ * These tests verify the deduplication behavior by testing the helper
+ * functions and their interactions with KV and GitHub.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+/**
+ * Mock KV namespace for testing lock functionality
+ */
+function createMockKV() {
+  const store = new Map<string, { value: string; expiry?: number }>();
+
+  return {
+    get: vi.fn(async (key: string) => {
+      const entry = store.get(key);
+      if (!entry) return null;
+      if (entry.expiry && Date.now() > entry.expiry) {
+        store.delete(key);
+        return null;
+      }
+      return entry.value;
+    }),
+    put: vi.fn(async (key: string, value: string, options?: { expirationTtl?: number }) => {
+      const expiry = options?.expirationTtl ? Date.now() + options.expirationTtl * 1000 : undefined;
+      store.set(key, { value, expiry });
+    }),
+    delete: vi.fn(async (key: string) => {
+      store.delete(key);
+    }),
+    _store: store, // For test inspection
+  };
+}
+
+describe('KV-based Issue Locking', () => {
+  describe('acquireIssueLock simulation', () => {
+    it('acquires lock when none exists', async () => {
+      const kv = createMockKV();
+      const fingerprint = 'abc123';
+      const lockKey = `ISSUE_LOCK:${fingerprint}`;
+
+      // Simulate acquireIssueLock
+      const existing = await kv.get(lockKey);
+      expect(existing).toBeNull();
+
+      await kv.put(lockKey, Date.now().toString(), { expirationTtl: 60 });
+
+      // Lock should now exist
+      const afterLock = await kv.get(lockKey);
+      expect(afterLock).not.toBeNull();
+    });
+
+    it('returns false when lock already held', async () => {
+      const kv = createMockKV();
+      const fingerprint = 'abc123';
+      const lockKey = `ISSUE_LOCK:${fingerprint}`;
+
+      // First worker acquires lock
+      await kv.put(lockKey, Date.now().toString(), { expirationTtl: 60 });
+
+      // Second worker tries to acquire
+      const existing = await kv.get(lockKey);
+      expect(existing).not.toBeNull();
+      // Second worker should skip (existing !== null means lock is held)
+    });
+
+    it('releases lock correctly', async () => {
+      const kv = createMockKV();
+      const fingerprint = 'abc123';
+      const lockKey = `ISSUE_LOCK:${fingerprint}`;
+
+      // Acquire lock
+      await kv.put(lockKey, Date.now().toString(), { expirationTtl: 60 });
+      expect(await kv.get(lockKey)).not.toBeNull();
+
+      // Release lock
+      await kv.delete(lockKey);
+      expect(await kv.get(lockKey)).toBeNull();
+    });
+  });
+
+  describe('Lock key format', () => {
+    it('uses correct key format', () => {
+      const fingerprint = 'a1b2c3d4e5f6';
+      const lockKey = `ISSUE_LOCK:${fingerprint}`;
+      expect(lockKey).toBe('ISSUE_LOCK:a1b2c3d4e5f6');
+    });
+  });
+});
+
+describe('findExistingIssueByFingerprint logic', () => {
+  const SKIP_REOPEN_LABELS = ['cf:muted', 'cf:wont-fix'];
+
+  describe('issue selection', () => {
+    it('returns null when no issues found', () => {
+      const issues: Array<{ number: number; state: string; labels: Array<{ name: string }> }> = [];
+      expect(issues.length).toBe(0);
+      // findExistingIssueByFingerprint returns null when issues.length === 0
+    });
+
+    it('prefers open over closed issues', () => {
+      const issues = [
+        { number: 100, state: 'closed', labels: [] },
+        { number: 101, state: 'open', labels: [] },
+        { number: 102, state: 'closed', labels: [] },
+      ];
+
+      const openIssue = issues.find((i) => i.state === 'open');
+      expect(openIssue).toBeDefined();
+      expect(openIssue?.number).toBe(101);
+    });
+
+    it('returns most recent closed issue when no open issues exist', () => {
+      const issues = [
+        { number: 100, state: 'closed', labels: [] },
+        { number: 99, state: 'closed', labels: [] },
+      ];
+
+      const openIssue = issues.find((i) => i.state === 'open');
+      expect(openIssue).toBeUndefined();
+
+      // Falls back to first result (most recent by search relevance)
+      const closedIssue = issues[0];
+      expect(closedIssue.number).toBe(100);
+    });
+  });
+
+  describe('label checking', () => {
+    it('sets shouldSkip=true for cf:muted issues', () => {
+      const issue = {
+        number: 100,
+        state: 'closed',
+        labels: [{ name: 'cf:muted' }, { name: 'cf:error:auto-generated' }],
+      };
+
+      const labelNames = issue.labels.map((l) => l.name);
+      const shouldSkip = SKIP_REOPEN_LABELS.some((l) => labelNames.includes(l));
+
+      expect(shouldSkip).toBe(true);
+    });
+
+    it('sets shouldSkip=true for cf:wont-fix issues', () => {
+      const issue = {
+        number: 100,
+        state: 'closed',
+        labels: [{ name: 'cf:wont-fix' }],
+      };
+
+      const labelNames = issue.labels.map((l) => l.name);
+      const shouldSkip = SKIP_REOPEN_LABELS.some((l) => labelNames.includes(l));
+
+      expect(shouldSkip).toBe(true);
+    });
+
+    it('sets shouldSkip=false for regular issues', () => {
+      const issue = {
+        number: 100,
+        state: 'closed',
+        labels: [{ name: 'cf:error:auto-generated' }, { name: 'cf:priority:p2' }],
+      };
+
+      const labelNames = issue.labels.map((l) => l.name);
+      const shouldSkip = SKIP_REOPEN_LABELS.some((l) => labelNames.includes(l));
+
+      expect(shouldSkip).toBe(false);
+    });
+  });
+});
+
+describe('formatRecurrenceComment', () => {
+  const mockEvent = {
+    scriptName: 'test-worker',
+    scriptVersion: { id: 'abc123def456' },
+    event: {
+      rayId: 'ray-id-123',
+      request: {
+        cf: { colo: 'SYD' },
+        headers: {},
+        url: 'https://example.com/test',
+        method: 'GET',
+      },
+    },
+    exceptions: [
+      {
+        name: 'Error',
+        message: 'Test error message that is quite long and should be truncated',
+        timestamp: Date.now(),
+      },
+    ],
+    logs: [],
+    outcome: 'exception' as const,
+    eventTimestamp: Date.now(),
+  };
+
+  it('formats reopen comment with regression context', () => {
+    const comment = formatRecurrenceCommentMock(mockEvent, 'exception', 5, true);
+
+    expect(comment).toContain('Error Recurrence (Reopened)');
+    expect(comment).toContain('reopened because the error recurred');
+    expect(comment).toContain('Total Occurrences');
+    expect(comment).toContain('5');
+  });
+
+  it('formats occurrence update comment', () => {
+    const comment = formatRecurrenceCommentMock(mockEvent, 'soft_error', 10, false);
+
+    expect(comment).toContain('New Occurrence');
+    expect(comment).not.toContain('reopened');
+    expect(comment).toContain('10');
+  });
+
+  it('includes stack trace for exceptions', () => {
+    const comment = formatRecurrenceCommentMock(mockEvent, 'exception', 1, true);
+
+    expect(comment).toContain('Exception');
+    expect(comment).toContain('Error:');
+    expect(comment).toContain('Test error message');
+  });
+
+  it('includes Ray ID when available', () => {
+    const comment = formatRecurrenceCommentMock(mockEvent, 'exception', 1, false);
+
+    expect(comment).toContain('Ray ID');
+    expect(comment).toContain('ray-id-123');
+  });
+
+  it('includes colo when available', () => {
+    const comment = formatRecurrenceCommentMock(mockEvent, 'exception', 1, false);
+
+    expect(comment).toContain('Colo');
+    expect(comment).toContain('SYD');
+  });
+});
+
+/**
+ * Mock implementation of formatRecurrenceComment for testing
+ * This mirrors the logic in error-collector.ts
+ */
+function formatRecurrenceCommentMock(
+  event: {
+    scriptName: string;
+    scriptVersion?: { id?: string };
+    event?: {
+      rayId?: string;
+      request?: {
+        cf?: { colo?: string };
+        headers?: Record<string, string>;
+      };
+    };
+    exceptions: Array<{ name: string; message: string; timestamp: number }>;
+  },
+  errorType: string,
+  occurrenceCount: number,
+  isReopen: boolean
+): string {
+  const timestamp = new Date().toISOString();
+  const rayId = event.event?.rayId || event.event?.request?.headers?.['cf-ray'];
+
+  let comment = isReopen ? `## Error Recurrence (Reopened)\n\n` : `## New Occurrence\n\n`;
+
+  comment += `| | |\n|---|---|\n`;
+  comment += `| **Time** | ${timestamp} |\n`;
+  comment += `| **Total Occurrences** | ${occurrenceCount} |\n`;
+  comment += `| **Worker** | \`${event.scriptName}\` |\n`;
+
+  if (event.scriptVersion?.id) {
+    comment += `| **Version** | \`${event.scriptVersion.id.slice(0, 8)}\` |\n`;
+  }
+  if (rayId) {
+    comment += `| **Ray ID** | \`${rayId}\` |\n`;
+  }
+  if (event.event?.request?.cf?.colo) {
+    comment += `| **Colo** | ${event.event.request.cf.colo} |\n`;
+  }
+
+  if (errorType === 'exception' && event.exceptions.length > 0) {
+    const exc = event.exceptions[0];
+    const stackPreview = exc.message?.slice(0, 300) || 'N/A';
+    comment += `\n### Exception\n\`\`\`\n${exc.name}: ${stackPreview}${exc.message?.length > 300 ? '...' : ''}\n\`\`\`\n`;
+  }
+
+  if (isReopen) {
+    comment += `\n> This issue was reopened because the error recurred after being closed.\n`;
+  }
+
+  return comment;
+}
+
+describe('Decision Matrix', () => {
+  /**
+   * Test the decision matrix from the plan:
+   * | Scenario | Existing Issue State | Action |
+   * |----------|---------------------|--------|
+   * | Fingerprint match in D1 + KV | N/A | Current flow (update count) |
+   * | Fingerprint match in D1 only | N/A | Current flow (update count) |
+   * | No D1 match, GitHub has open issue | Open | Add comment, link D1 record |
+   * | No D1 match, GitHub has closed issue | Closed | Check labels -> Reopen + comment + regression label |
+   * | No D1 match, GitHub has muted/wontfix issue | Closed | Skip (don't reopen, don't create new) |
+   * | No match anywhere | N/A | Create new issue |
+   */
+
+  describe('fingerprint match scenarios', () => {
+    it('KV cache hit should return existing issue (no GitHub search)', () => {
+      // When KV cache has the fingerprint, we don't need to search GitHub
+      const kvCacheHit = true;
+      const shouldSearchGitHub = !kvCacheHit;
+      expect(shouldSearchGitHub).toBe(false);
+    });
+
+    it('D1 match with issue_number should return existing issue (no GitHub search)', () => {
+      const d1Record = { fingerprint: 'abc123', github_issue_number: 100 };
+      const hasIssueNumber = d1Record.github_issue_number !== undefined;
+      expect(hasIssueNumber).toBe(true);
+    });
+  });
+
+  describe('no D1 match scenarios', () => {
+    it('GitHub open issue found should add comment and link D1', () => {
+      const existingIssue = { number: 100, state: 'open', shouldSkip: false };
+      const action = existingIssue.state === 'open' ? 'add-comment' : 'reopen-and-comment';
+      expect(action).toBe('add-comment');
+    });
+
+    it('GitHub closed issue found should reopen with regression label', () => {
+      const existingIssue = { number: 100, state: 'closed', shouldSkip: false };
+      const action = existingIssue.state === 'closed' ? 'reopen-and-comment' : 'add-comment';
+      expect(action).toBe('reopen-and-comment');
+    });
+
+    it('GitHub muted/wontfix issue should be skipped', () => {
+      const existingIssue = { number: 100, state: 'closed', shouldSkip: true };
+      expect(existingIssue.shouldSkip).toBe(true);
+      // Action: link D1 record but don't reopen or create new
+    });
+
+    it('no match anywhere should create new issue', () => {
+      const searchResult = { found: false as const };
+      expect(searchResult.found).toBe(false);
+      // Action: create new issue
+    });
+
+    it('GitHub search failure should skip issue creation', () => {
+      const searchResult = { found: 'error' as const, error: new Error('502 Bad Gateway') };
+      expect(searchResult.found).toBe('error');
+      // Action: skip issue creation, error is still tracked in D1
+    });
+  });
+});

package/templates/standard/tests/unit/error-collector/github.test.ts

@@ -0,0 +1,187 @@
+/**
+ * Tests for GitHubClient searchIssues functionality
+ * @see docs/plans/task-86-deduplication-implementation-plan.md
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock fetch globally using vitest
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+// Mock crypto.subtle for JWT generation
+const mockSubtle = {
+  importKey: vi.fn().mockResolvedValue({}),
+  sign: vi.fn().mockResolvedValue(new ArrayBuffer(256)),
+};
+vi.stubGlobal('crypto', { subtle: mockSubtle });
+
+// Import after mocking
+import { GitHubClient } from '../../../workers/lib/error-collector/github';
+
+import type { Env } from '../../../workers/lib/error-collector/types';
+
+const mockEnv = {
+  GITHUB_APP_ID: 'test-app-id',
+  GITHUB_APP_PRIVATE_KEY: btoa(
+    '-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----'
+  ),
+  GITHUB_APP_INSTALLATION_ID: 'test-installation-id',
+} as unknown as Env;
+
+describe('GitHubClient.searchIssues', () => {
+  let client: GitHubClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    client = new GitHubClient(mockEnv);
+
+    // Mock successful token fetch
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ token: 'test-token' }),
+    });
+  });
+
+  it('returns matching issues sorted by relevance', async () => {
+    const mockIssues = {
+      total_count: 2,
+      items: [
+        {
+          number: 123,
+          state: 'open',
+          title: 'Test Issue 1',
+          body: 'Fingerprint: `abc123`',
+          labels: [{ name: 'cf:error:auto-generated' }],
+        },
+        {
+          number: 122,
+          state: 'closed',
+          title: 'Test Issue 2',
+          body: 'Fingerprint: `abc123`',
+          labels: [{ name: 'cf:error:auto-generated' }],
+        },
+      ],
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve(mockIssues),
+    });
+
+    const result = await client.searchIssues('owner', 'repo', '"Fingerprint: `abc123`" in:body');
+
+    expect(result).toHaveLength(2);
+    expect(result[0].number).toBe(123);
+    expect(result[0].state).toBe('open');
+    expect(result[1].number).toBe(122);
+    expect(result[1].state).toBe('closed');
+  });
+
+  it('handles empty results', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ total_count: 0, items: [] }),
+    });
+
+    const result = await client.searchIssues(
+      'owner',
+      'repo',
+      '"Fingerprint: `nonexistent`" in:body'
+    );
+
+    expect(result).toHaveLength(0);
+  });
+
+  it('retries once on 403 then throws', async () => {
+    // First call: 403 rate-limited
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      text: () => Promise.resolve('Rate limited'),
+    });
+    // Retry: also 403
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      text: () => Promise.resolve('Rate limited'),
+    });
+
+    await expect(client.searchIssues('owner', 'repo', '"test"')).rejects.toThrow(
+      'GitHub API error: 403'
+    );
+  });
+
+  it('succeeds on retry after 403', async () => {
+    // First call: 403 rate-limited
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      text: () => Promise.resolve('Rate limited'),
+    });
+    // Retry: success
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          total_count: 1,
+          items: [{ number: 42, state: 'open', title: 'Test', body: null, labels: [] }],
+        }),
+    });
+
+    const result = await client.searchIssues('owner', 'repo', '"test"');
+    expect(result).toHaveLength(1);
+    expect(result[0].number).toBe(42);
+  });
+
+  it('properly encodes query parameters', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ total_count: 0, items: [] }),
+    });
+
+    await client.searchIssues('owner', 'repo', '"Fingerprint: `test`" in:body');
+
+    // Check that the second call (search) has the properly encoded URL
+    const searchCall = mockFetch.mock.calls[1];
+    expect(searchCall[0]).toContain('/search/issues?q=');
+    expect(searchCall[0]).toContain(encodeURIComponent('repo:owner/repo is:issue'));
+  });
+
+  it('includes labels in response', async () => {
+    const mockIssues = {
+      total_count: 1,
+      items: [
+        {
+          number: 100,
+          state: 'closed',
+          title: 'Test Issue',
+          body: 'Test body',
+          labels: [{ name: 'cf:error:auto-generated' }, { name: 'cf:muted' }],
+        },
+      ],
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve(mockIssues),
+    });
+
+    const result = await client.searchIssues('owner', 'repo', 'test');
+
+    expect(result[0].labels).toHaveLength(2);
+    expect(result[0].labels[0].name).toBe('cf:error:auto-generated');
+    expect(result[0].labels[1].name).toBe('cf:muted');
+  });
+
+  it('limits results to 5 items', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ total_count: 0, items: [] }),
+    });
+
+    await client.searchIssues('owner', 'repo', 'test');
+
+    const searchCall = mockFetch.mock.calls[1];
+    expect(searchCall[0]).toContain('per_page=5');
+  });
+});