@aaronshaf/ger 0.1.0

package/tests/mine.test.ts

@@ -0,0 +1,318 @@
+import { describe, test, expect, beforeEach } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { mineCommand } from '@/cli/commands/mine'
+import { GerritApiService, type ApiError } from '@/api/gerrit'
+import { generateMockChange } from '@/test-utils/mock-generator'
+import type { ChangeInfo } from '@/schemas/gerrit'
+
+// Mock console.log to capture output
+const mockConsole = {
+  logs: [] as string[],
+  log: function (message: string) {
+    this.logs.push(message)
+  },
+  clear: function () {
+    this.logs = []
+  },
+}
+
+describe('mine command', () => {
+  beforeEach(() => {
+    mockConsole.clear()
+    // Replace console.log for tests
+    global.console.log = mockConsole.log.bind(mockConsole)
+  })
+
+  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',
+      }),
+    ]
+
+    const mockApi = GerritApiService.of({
+      listChanges: (query?: string) => {
+        expect(query).toBe('owner:self status:open')
+        return Effect.succeed(mockChanges)
+      },
+      getChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      postReview: () => Effect.fail(new Error('Not implemented') as ApiError),
+      abandonChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      testConnection: Effect.fail(new Error('Not implemented') as ApiError),
+      getRevision: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFiles: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileContent: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getPatch: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getComments: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getMessages: () => Effect.fail(new Error('Not implemented') as ApiError),
+    })
+
+    await Effect.runPromise(
+      mineCommand({ xml: false }).pipe(Effect.provide(Layer.succeed(GerritApiService, mockApi))),
+    )
+
+    expect(mockConsole.logs.length).toBeGreaterThan(0)
+    expect(mockConsole.logs.some((log) => log.includes('My test change'))).toBe(true)
+    expect(mockConsole.logs.some((log) => log.includes('Another change'))).toBe(true)
+  })
+
+  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',
+      }),
+    ]
+
+    const mockApi = GerritApiService.of({
+      listChanges: (query?: string) => {
+        expect(query).toBe('owner:self status:open')
+        return Effect.succeed(mockChanges)
+      },
+      getChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      postReview: () => Effect.fail(new Error('Not implemented') as ApiError),
+      abandonChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      testConnection: Effect.fail(new Error('Not implemented') as ApiError),
+      getRevision: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFiles: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileContent: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getPatch: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getComments: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getMessages: () => Effect.fail(new Error('Not implemented') as ApiError),
+    })
+
+    await Effect.runPromise(
+      mineCommand({ xml: true }).pipe(Effect.provide(Layer.succeed(GerritApiService, mockApi))),
+    )
+
+    const output = mockConsole.logs.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 () => {
+    const mockApi = GerritApiService.of({
+      listChanges: () => Effect.succeed([]),
+      getChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      postReview: () => Effect.fail(new Error('Not implemented') as ApiError),
+      abandonChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      testConnection: Effect.fail(new Error('Not implemented') as ApiError),
+      getRevision: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFiles: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileContent: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getPatch: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getComments: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getMessages: () => Effect.fail(new Error('Not implemented') as ApiError),
+    })
+
+    await Effect.runPromise(
+      mineCommand({ xml: false }).pipe(Effect.provide(Layer.succeed(GerritApiService, mockApi))),
+    )
+
+    // Mine command returns early for empty results, so no output is expected
+    expect(mockConsole.logs).toEqual([])
+  })
+
+  test('should handle no changes gracefully in XML format', async () => {
+    const mockApi = GerritApiService.of({
+      listChanges: () => Effect.succeed([]),
+      getChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      postReview: () => Effect.fail(new Error('Not implemented') as ApiError),
+      abandonChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      testConnection: Effect.fail(new Error('Not implemented') as ApiError),
+      getRevision: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFiles: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileContent: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getPatch: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getComments: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getMessages: () => Effect.fail(new Error('Not implemented') as ApiError),
+    })
+
+    await Effect.runPromise(
+      mineCommand({ xml: true }).pipe(Effect.provide(Layer.succeed(GerritApiService, mockApi))),
+    )
+
+    const output = mockConsole.logs.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 () => {
+    const mockApi = GerritApiService.of({
+      listChanges: () => Effect.fail(new Error('Network error') as ApiError),
+      getChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      postReview: () => Effect.fail(new Error('Not implemented') as ApiError),
+      abandonChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      testConnection: Effect.fail(new Error('Not implemented') as ApiError),
+      getRevision: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFiles: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileContent: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getPatch: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getComments: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getMessages: () => Effect.fail(new Error('Not implemented') as ApiError),
+    })
+
+    const result = await Effect.runPromise(
+      Effect.either(
+        mineCommand({ xml: false }).pipe(Effect.provide(Layer.succeed(GerritApiService, mockApi))),
+      ),
+    )
+
+    expect(result._tag).toBe('Left')
+    if (result._tag === 'Left') {
+      expect(result.left.message).toBe('Network error')
+    }
+  })
+
+  test('should handle network failures gracefully in XML format', async () => {
+    const mockApi = GerritApiService.of({
+      listChanges: () => Effect.fail(new Error('API error') as ApiError),
+      getChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      postReview: () => Effect.fail(new Error('Not implemented') as ApiError),
+      abandonChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      testConnection: Effect.fail(new Error('Not implemented') as ApiError),
+      getRevision: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFiles: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileContent: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getPatch: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getComments: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getMessages: () => Effect.fail(new Error('Not implemented') as ApiError),
+    })
+
+    const result = await Effect.runPromise(
+      Effect.either(
+        mineCommand({ xml: true }).pipe(Effect.provide(Layer.succeed(GerritApiService, mockApi))),
+      ),
+    )
+
+    expect(result._tag).toBe('Left')
+    if (result._tag === 'Left') {
+      expect(result.left.message).toBe('API error')
+    }
+  })
+
+  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',
+      }),
+    ]
+
+    const mockApi = GerritApiService.of({
+      listChanges: () => Effect.succeed(mockChanges),
+      getChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      postReview: () => Effect.fail(new Error('Not implemented') as ApiError),
+      abandonChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      testConnection: Effect.fail(new Error('Not implemented') as ApiError),
+      getRevision: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFiles: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileContent: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getPatch: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getComments: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getMessages: () => Effect.fail(new Error('Not implemented') as ApiError),
+    })
+
+    await Effect.runPromise(
+      mineCommand({ xml: true }).pipe(Effect.provide(Layer.succeed(GerritApiService, mockApi))),
+    )
+
+    const output = mockConsole.logs.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',
+      }),
+    ]
+
+    const mockApi = GerritApiService.of({
+      listChanges: () => Effect.succeed(mockChanges),
+      getChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      postReview: () => Effect.fail(new Error('Not implemented') as ApiError),
+      abandonChange: () => Effect.fail(new Error('Not implemented') as ApiError),
+      testConnection: Effect.fail(new Error('Not implemented') as ApiError),
+      getRevision: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFiles: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getFileContent: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getPatch: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getDiff: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getComments: () => Effect.fail(new Error('Not implemented') as ApiError),
+      getMessages: () => Effect.fail(new Error('Not implemented') as ApiError),
+    })
+
+    await Effect.runPromise(
+      mineCommand({ xml: false }).pipe(Effect.provide(Layer.succeed(GerritApiService, mockApi))),
+    )
+
+    const output = mockConsole.logs.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/fetch-mock.ts

@@ -0,0 +1,139 @@
+import { mock } from 'bun:test'
+import { Schema } from '@effect/schema'
+import { ChangeInfo } from '@/schemas/gerrit'
+import {
+  generateMockAccount,
+  generateMockChange,
+  generateMockFileDiff,
+  generateMockFiles,
+} from '@/test-utils/mock-generator'
+
+// Generate consistent mock data using Effect Schema
+const mockChange = generateMockChange()
+const mockFiles = generateMockFiles()
+const mockDiff = generateMockFileDiff()
+const mockAccount = generateMockAccount()
+
+// Keep the old mockChange definition for now as backup (disabled to fix unused variable)
+// const _mockChange: Schema.Schema.Type<typeof ChangeInfo> = {
+//   id: 'myProject~master~I8473b95934b5732ac55d26311a706c9c2bde9940',
+//   project: 'myProject',
+//   branch: 'master',
+//   change_id: 'I8473b95934b5732ac55d26311a706c9c2bde9940',
+//   subject: 'Implementing new feature',
+//   status: 'NEW',
+//   created: '2023-12-01 10:00:00.000000000',
+//   updated: '2023-12-01 12:00:00.000000000',
+//   _number: 123456,
+//   owner: {
+//     _account_id: 1000000,
+//     name: 'John Doe',
+//     email: 'john.doe@example.com',
+//   },
+//   labels: {},
+//   permitted_labels: {},
+//   removable_reviewers: [],
+//   reviewers: {},
+//   requirements: [],
+// }
+
+export const setupFetchMock = () => {
+  return mock(async (url: string | URL, options?: RequestInit) => {
+    const urlStr = url.toString()
+    const method = options?.method || 'GET'
+
+    // Check authentication
+    const authHeader =
+      options?.headers && 'Authorization' in options.headers
+        ? (options.headers as Record<string, string>).Authorization
+        : undefined
+
+    if (!authHeader || !authHeader.startsWith('Basic ')) {
+      return new Response(`)]}'\n${JSON.stringify({ message: 'Unauthorized' })}`, { status: 401 })
+    }
+
+    // Authentication endpoint
+    if (urlStr.includes('/a/accounts/self')) {
+      return new Response(`)]}'\n${JSON.stringify(mockAccount)}`, { status: 200 })
+    }
+
+    // List changes endpoint (must come before get change endpoint)
+    if (urlStr.includes('/a/changes/?q=')) {
+      return new Response(`)]}'\n${JSON.stringify([mockChange])}`, { status: 200 })
+    }
+
+    // Get change endpoint
+    if (
+      urlStr.includes('/a/changes/') &&
+      method === 'GET' &&
+      !urlStr.includes('/files') &&
+      !urlStr.includes('/diff') &&
+      !urlStr.includes('/patch') &&
+      !urlStr.includes('/review')
+    ) {
+      if (urlStr.includes('notfound')) {
+        return new Response(`)]}'\n${JSON.stringify({ message: 'Not found' })}`, { status: 404 })
+      }
+
+      // Validate response against schema
+      const validated = Schema.decodeUnknownSync(ChangeInfo)(mockChange)
+      return new Response(`)]}'\n${JSON.stringify(validated)}`, { status: 200 })
+    }
+
+    // Get file diff endpoint - must be checked BEFORE other file endpoints
+    if (urlStr.includes('/files/') && urlStr.includes('/diff') && method === 'GET') {
+      return new Response(`)]}'\n${JSON.stringify(mockDiff)}`, { status: 200 })
+    }
+
+    // Get files endpoint (list of files)
+    if (
+      urlStr.includes('/files') &&
+      method === 'GET' &&
+      !urlStr.includes('/diff') &&
+      !urlStr.includes('/content')
+    ) {
+      return new Response(`)]}'\n${JSON.stringify(mockFiles)}`, { status: 200 })
+    }
+
+    // Get file content endpoint
+    if (urlStr.includes('/content') && method === 'GET' && !urlStr.includes('/diff')) {
+      const content =
+        'function main() {\n  console.log("Hello, world!")\n  return process.exit(0)\n}'
+      const base64Content = btoa(content)
+      return new Response(base64Content, { status: 200 })
+    }
+
+    // Get patch endpoint
+    if (urlStr.includes('/patch') && method === 'GET') {
+      const patch = `--- a/src/main.ts
++++ b/src/main.ts
+@@ -1,3 +1,3 @@
+ function main() {
+   console.log("Hello, world!")
+-  return 0
++  return process.exit(0)
+ }`
+      const base64Patch = btoa(patch)
+      return new Response(base64Patch, { status: 200 })
+    }
+
+    // Post review endpoint
+    if (urlStr.includes('/review') && method === 'POST') {
+      return new Response(
+        ")]}'\n" +
+          JSON.stringify({
+            labels: {},
+            ready: true,
+          }),
+        { status: 200 },
+      )
+    }
+
+    // Default 404 for unhandled requests
+    return new Response(`)]}'\n${JSON.stringify({ message: 'Not found' })}`, { status: 404 })
+  })
+}
+
+export const restoreFetch: () => void = () => {
+  // Restore original fetch (Bun handles this automatically after tests)
+}

package/tests/mocks/msw-handlers.ts

@@ -0,0 +1,80 @@
+import { HttpResponse, http } from 'msw'
+import type { CommentInfo } from '@/schemas/gerrit'
+
+export const commentHandlers = [
+  // 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 = [
+  http.get('*/a/changes/:changeId/revisions/:revisionId/comments', () => {
+    return HttpResponse.text(`)]}'\n{}`)
+  }),
+]