@aaronshaf/ger 1.2.11 → 2.0.0

package/tests/interactive-incoming.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, test } from 'bun:test'
+import { incomingCommand } from '@/cli/commands/incoming'
+import { generateMockChange } from '@/test-utils/mock-generator'
+import {
+  getStatusIndicators,
+  getStatusString,
+  getLabelValue,
+  getLabelColor,
+} from '@/utils/status-indicators'
+import { sanitizeUrlSync, getOpenCommand } from '@/utils/shell-safety'
+
+describe('Interactive Incoming Command', () => {
+  test('should create command with interactive option', () => {
+    const command = incomingCommand({ interactive: true })
+    expect(command).toBeDefined()
+  })
+
+  test('should create command with interactive and xml options', () => {
+    const command = incomingCommand({ interactive: true, xml: true })
+    expect(command).toBeDefined()
+  })
+
+  test('should create command without interactive option', () => {
+    const command = incomingCommand({})
+    expect(command).toBeDefined()
+  })
+
+  describe('Status Indicators Utility', () => {
+    test('should generate status indicators for approved change', () => {
+      const change = generateMockChange({
+        labels: {
+          'Code-Review': { approved: { _account_id: 1 }, value: 2 },
+          Verified: { approved: { _account_id: 1 }, value: 1 },
+        },
+      })
+
+      const indicators = getStatusIndicators(change)
+      expect(indicators).toContain('✓')
+      expect(indicators.length).toBeGreaterThan(0)
+    })
+
+    test('should generate status indicators for rejected change', () => {
+      const change = generateMockChange({
+        labels: {
+          'Code-Review': { rejected: { _account_id: 1 }, value: -2 },
+        },
+      })
+
+      const indicators = getStatusIndicators(change)
+      expect(indicators).toContain('✗')
+    })
+
+    test('should generate padded status string', () => {
+      const change = generateMockChange({
+        labels: {
+          'Code-Review': { recommended: { _account_id: 1 }, value: 1 },
+        },
+      })
+
+      const statusString = getStatusString(change, undefined, 8)
+      expect(statusString).toContain('↑')
+      expect(statusString.length).toBe(8)
+    })
+
+    test('should handle empty labels gracefully', () => {
+      const change = generateMockChange({ labels: {} })
+      const indicators = getStatusIndicators(change)
+      expect(indicators).toHaveLength(0)
+    })
+
+    test('should extract label value safely', () => {
+      expect(getLabelValue({ value: 2 })).toBe(2)
+      expect(getLabelValue({ value: -1 })).toBe(-1)
+      expect(getLabelValue({})).toBe(0)
+      expect(getLabelValue(null)).toBe(0)
+      expect(getLabelValue('invalid')).toBe(0)
+    })
+
+    test('should determine label color correctly', () => {
+      expect(getLabelColor(2)).toBe('green')
+      expect(getLabelColor(1)).toBe('green')
+      expect(getLabelColor(0)).toBe('yellow')
+      expect(getLabelColor(-1)).toBe('red')
+      expect(getLabelColor(-2)).toBe('red')
+    })
+  })
+
+  describe('URL Sanitization', () => {
+    test('should sanitize valid HTTPS URLs', () => {
+      const url = 'https://gerrit.example.com/c/project/+/12345'
+      expect(() => sanitizeUrlSync(url)).not.toThrow()
+      expect(sanitizeUrlSync(url)).toBe(url)
+    })
+
+    test('should reject HTTP URLs', () => {
+      const url = 'http://gerrit.example.com/c/project/+/12345'
+      expect(() => sanitizeUrlSync(url)).toThrow('Invalid protocol')
+    })
+
+    test('should reject URLs with dangerous characters', () => {
+      const url = 'https://gerrit.example.com/c/project/+/12345;rm -rf /'
+      expect(() => sanitizeUrlSync(url)).toThrow('dangerous characters')
+    })
+
+    test('should reject malformed URLs', () => {
+      const url = 'not-a-url'
+      expect(() => sanitizeUrlSync(url)).toThrow('Invalid URL format')
+    })
+
+    test('should get correct open command for platform', () => {
+      const originalPlatform = process.platform
+
+      Object.defineProperty(process, 'platform', { value: 'darwin' })
+      expect(getOpenCommand()).toBe('open')
+
+      Object.defineProperty(process, 'platform', { value: 'win32' })
+      expect(getOpenCommand()).toBe('start')
+
+      Object.defineProperty(process, 'platform', { value: 'linux' })
+      expect(getOpenCommand()).toBe('xdg-open')
+
+      // Restore original platform
+      Object.defineProperty(process, 'platform', { value: originalPlatform })
+    })
+  })
+
+  describe('Change Data Processing', () => {
+    test('should handle changes with various label configurations', () => {
+      const changes = [
+        generateMockChange({
+          _number: 1,
+          labels: { 'Code-Review': { value: 2, approved: { _account_id: 1 } } },
+        }),
+        generateMockChange({
+          _number: 2,
+          labels: { 'Code-Review': { value: -1, disliked: { _account_id: 1 } } },
+        }),
+        generateMockChange({
+          _number: 3,
+          labels: {},
+        }),
+      ]
+
+      changes.forEach((change) => {
+        expect(() => getStatusIndicators(change)).not.toThrow()
+        expect(() => getStatusString(change)).not.toThrow()
+      })
+    })
+
+    test('should group changes by project correctly', () => {
+      const changes = [
+        generateMockChange({ project: 'project-a', _number: 1 }),
+        generateMockChange({ project: 'project-b', _number: 2 }),
+        generateMockChange({ project: 'project-a', _number: 3 }),
+      ]
+
+      const grouped = changes.reduce(
+        (acc, change) => {
+          if (!acc[change.project]) {
+            acc[change.project] = []
+          }
+          acc[change.project].push(change)
+          return acc
+        },
+        {} as Record<string, typeof changes>,
+      )
+
+      expect(Object.keys(grouped)).toHaveLength(2)
+      expect(grouped['project-a']).toHaveLength(2)
+      expect(grouped['project-b']).toHaveLength(1)
+    })
+  })
+})

package/tests/mine.test.ts

@@ -0,0 +1,285 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { mineCommand } from '@/cli/commands/mine'
+import { ConfigService } from '@/services/config'
+import { generateMockChange } from '@/test-utils/mock-generator'
+import type { ChangeInfo } from '@/schemas/gerrit'
+import { createMockConfigService } from './helpers/config-mock'
+
+// Create MSW server
+const server = setupServer(
+  // Default handler for auth check
+  http.get('*/a/accounts/self', ({ request }) => {
+    const auth = request.headers.get('Authorization')
+    if (!auth || !auth.startsWith('Basic ')) {
+      return HttpResponse.text('Unauthorized', { status: 401 })
+    }
+    return HttpResponse.json({
+      _account_id: 1000,
+      name: 'Test User',
+      email: 'test@example.com',
+    })
+  }),
+)
+
+describe('mine command', () => {
+  let mockConsoleLog: ReturnType<typeof mock>
+
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  beforeEach(() => {
+    mockConsoleLog = mock(() => {})
+    console.log = mockConsoleLog
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  test('should fetch and display my changes in pretty format', async () => {
+    const mockChanges: ChangeInfo[] = [
+      generateMockChange({
+        _number: 12345,
+        subject: 'My test change',
+        project: 'test-project',
+        branch: 'main',
+        status: 'NEW',
+      }),
+      generateMockChange({
+        _number: 12346,
+        subject: 'Another change',
+        project: 'test-project-2',
+        branch: 'develop',
+        status: 'MERGED',
+      }),
+    ]
+
+    server.use(
+      http.get('*/a/changes/', ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('q')).toBe('owner:self status:open')
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChanges)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    await Effect.runPromise(
+      mineCommand({ xml: false }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      ),
+    )
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output.length).toBeGreaterThan(0)
+    expect(output).toContain('My test change')
+    expect(output).toContain('Another change')
+  })
+
+  test('should output XML format when --xml flag is used', async () => {
+    const mockChanges: ChangeInfo[] = [
+      generateMockChange({
+        _number: 12345,
+        subject: 'Test change',
+        project: 'test-project',
+        branch: 'main',
+        status: 'NEW',
+      }),
+    ]
+
+    server.use(
+      http.get('*/a/changes/', ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('q')).toBe('owner:self status:open')
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChanges)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    await Effect.runPromise(
+      mineCommand({ xml: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      ),
+    )
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<changes count="1">')
+    expect(output).toContain('<change>')
+    expect(output).toContain('<number>12345</number>')
+    expect(output).toContain('<subject><![CDATA[Test change]]></subject>')
+    expect(output).toContain('<project>test-project</project>')
+    expect(output).toContain('<branch>main</branch>')
+    expect(output).toContain('<status>NEW</status>')
+    expect(output).toContain('</change>')
+    expect(output).toContain('</changes>')
+  })
+
+  test('should handle no changes gracefully', async () => {
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text(")]}'\n[]")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    await Effect.runPromise(
+      mineCommand({ xml: false }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      ),
+    )
+
+    // Mine command returns early for empty results, so no output is expected
+    expect(mockConsoleLog.mock.calls).toEqual([])
+  })
+
+  test('should handle no changes gracefully in XML format', async () => {
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text(")]}'\n[]")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    await Effect.runPromise(
+      mineCommand({ xml: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      ),
+    )
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<changes count="0">')
+    expect(output).toContain('</changes>')
+  })
+
+  test('should handle network failures gracefully', async () => {
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text('Network error', { status: 500 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const result = await Effect.runPromise(
+      Effect.either(
+        mineCommand({ xml: false }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(mockConfigLayer),
+        ),
+      ),
+    )
+
+    expect(result._tag).toBe('Left')
+  })
+
+  test('should handle network failures gracefully in XML format', async () => {
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text('API error', { status: 500 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const result = await Effect.runPromise(
+      Effect.either(
+        mineCommand({ xml: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(mockConfigLayer),
+        ),
+      ),
+    )
+
+    expect(result._tag).toBe('Left')
+  })
+
+  test('should properly escape XML special characters', async () => {
+    const mockChanges: ChangeInfo[] = [
+      generateMockChange({
+        _number: 12345,
+        subject: 'Test with <special> & "characters"',
+        project: 'test-project',
+        branch: 'feature/test&update',
+        status: 'NEW',
+      }),
+    ]
+
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChanges)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    await Effect.runPromise(
+      mineCommand({ xml: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      ),
+    )
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    // CDATA sections should preserve special characters
+    expect(output).toContain('<![CDATA[Test with <special> & "characters"]]>')
+    expect(output).toContain('<branch>feature/test&update</branch>')
+  })
+
+  test('should display changes with proper grouping by project', async () => {
+    const mockChanges: ChangeInfo[] = [
+      generateMockChange({
+        _number: 12345,
+        subject: 'Change in project A',
+        project: 'project-a',
+        branch: 'main',
+        status: 'NEW',
+      }),
+      generateMockChange({
+        _number: 12346,
+        subject: 'Change in project B',
+        project: 'project-b',
+        branch: 'main',
+        status: 'NEW',
+      }),
+      generateMockChange({
+        _number: 12347,
+        subject: 'Another change in project A',
+        project: 'project-a',
+        branch: 'develop',
+        status: 'MERGED',
+      }),
+    ]
+
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChanges)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    await Effect.runPromise(
+      mineCommand({ xml: false }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      ),
+    )
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Change in project A')
+    expect(output).toContain('Change in project B')
+    expect(output).toContain('Another change in project A')
+    expect(output).toContain('project-a')
+    expect(output).toContain('project-b')
+  })
+})

package/tests/mocks/msw-handlers.ts

@@ -0,0 +1,80 @@
+import { HttpResponse, http, type HttpHandler } from 'msw'
+import type { CommentInfo } from '@/schemas/gerrit'
+
+export const commentHandlers: HttpHandler[] = [
+  // Comments endpoint
+  http.get('*/a/changes/:changeId/revisions/:revisionId/comments', () => {
+    const mockComments: Record<string, CommentInfo[]> = {
+      '/COMMIT_MSG': [
+        {
+          id: 'comment1',
+          message: 'Please update the commit message',
+          author: {
+            name: 'Reviewer 1',
+            email: 'reviewer1@example.com',
+            _account_id: 1001,
+          },
+          updated: '2024-01-15 10:30:00.000000000',
+          unresolved: true,
+          line: 3,
+        },
+      ],
+      'src/main.ts': [
+        {
+          id: 'comment2',
+          message: 'Consider using a more descriptive variable name',
+          author: {
+            name: 'Reviewer 2',
+            email: 'reviewer2@example.com',
+            _account_id: 1002,
+          },
+          updated: '2024-01-15 11:45:00.000000000',
+          unresolved: false,
+          line: 42,
+        },
+        {
+          id: 'comment3',
+          message: 'This could be simplified',
+          author: {
+            name: 'Reviewer 1',
+            _account_id: 1001,
+          },
+          updated: '2024-01-15 12:00:00.000000000',
+          line: 67,
+        },
+      ],
+    }
+
+    return HttpResponse.text(`)]}'\n${JSON.stringify(mockComments)}`)
+  }),
+
+  // File diff endpoint
+  http.get('*/a/changes/:changeId/revisions/:revisionId/files/:filePath/diff', () => {
+    const mockDiff = {
+      content: [
+        {
+          ab: ['function calculateTotal(items) {', '  let total = 0;'],
+        },
+        {
+          b: [
+            '  // TODO: Add validation',
+            '  for (const item of items) {',
+            '    total += item.price * item.quantity;',
+            '  }',
+          ],
+        },
+        {
+          ab: ['  return total;', '}'],
+        },
+      ],
+    }
+
+    return HttpResponse.text(`)]}'\n${JSON.stringify(mockDiff)}`)
+  }),
+]
+
+export const emptyCommentsHandlers: HttpHandler[] = [
+  http.get('*/a/changes/:changeId/revisions/:revisionId/comments', () => {
+    return HttpResponse.text(`)]}'\n{}`)
+  }),
+]