@aaronshaf/ger 0.1.0

package/tests/show.test.ts

@@ -0,0 +1,439 @@
+import { describe, test, expect, beforeAll, afterAll, afterEach, mock } from 'bun:test'
+import { setupServer } from 'msw/node'
+import { http, HttpResponse } from 'msw'
+import { Effect, Layer } from 'effect'
+import { showCommand } from '@/cli/commands/show'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigService } from '@/services/config'
+import { generateMockChange } from '@/test-utils/mock-generator'
+import type { MessageInfo } from '@/schemas/gerrit'
+
+import { createMockConfigService } from './helpers/config-mock'
+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',
+    })
+  }),
+)
+
+// Store captured output
+let capturedLogs: string[] = []
+let capturedErrors: string[] = []
+
+// Mock console.log and console.error
+const mockConsoleLog = mock((...args: any[]) => {
+  capturedLogs.push(args.join(' '))
+})
+const mockConsoleError = mock((...args: any[]) => {
+  capturedErrors.push(args.join(' '))
+})
+
+// Store original console methods
+const originalConsoleLog = console.log
+const originalConsoleError = console.error
+
+beforeAll(() => {
+  server.listen({ onUnhandledRequest: 'bypass' })
+  // @ts-ignore
+  console.log = mockConsoleLog
+  // @ts-ignore
+  console.error = mockConsoleError
+})
+
+afterAll(() => {
+  server.close()
+  console.log = originalConsoleLog
+  console.error = originalConsoleError
+})
+
+afterEach(() => {
+  server.resetHandlers()
+  mockConsoleLog.mockClear()
+  mockConsoleError.mockClear()
+  capturedLogs = []
+  capturedErrors = []
+})
+
+describe('show command', () => {
+  const mockChange = generateMockChange({
+    _number: 12345,
+    change_id: 'I123abc456def',
+    subject: 'Fix authentication bug',
+    status: 'NEW',
+    project: 'test-project',
+    branch: 'main',
+    created: '2024-01-15 10:00:00.000000000',
+    updated: '2024-01-15 12:00:00.000000000',
+    owner: {
+      _account_id: 1001,
+      name: 'John Doe',
+      email: 'john@example.com',
+    },
+  })
+
+  const mockDiff = `--- a/src/auth.js
++++ b/src/auth.js
+@@ -10,7 +10,8 @@ function authenticate(user) {
+   if (!user) {
+-    return false
++    throw new Error('User required')
+   }
++  // Added validation
+   return validateUser(user)
+ }`
+
+  const mockComments = {
+    'src/auth.js': [
+      {
+        id: 'comment1',
+        path: 'src/auth.js',
+        line: 12,
+        message: 'Good improvement!',
+        author: {
+          name: 'Jane Reviewer',
+          email: 'jane@example.com',
+        },
+        updated: '2024-01-15 11:30:00.000000000',
+        unresolved: false,
+      },
+      {
+        id: 'comment2',
+        path: 'src/auth.js',
+        line: 14,
+        message: 'Consider adding JSDoc',
+        author: {
+          name: 'Bob Reviewer',
+          email: 'bob@example.com',
+        },
+        updated: '2024-01-15 11:45:00.000000000',
+        unresolved: true,
+      },
+    ],
+    '/COMMIT_MSG': [
+      {
+        id: 'comment3',
+        path: '/COMMIT_MSG',
+        line: 1,
+        message: 'Clear commit message',
+        author: {
+          name: 'Alice Lead',
+          email: 'alice@example.com',
+        },
+        updated: '2024-01-15 11:00:00.000000000',
+        unresolved: false,
+      },
+    ],
+  }
+
+  const setupMockHandlers = () => {
+    server.use(
+      // Get change details
+      http.get('*/a/changes/:changeId', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      // Get diff (returns base64-encoded content)
+      http.get('*/a/changes/:changeId/revisions/current/patch', () => {
+        return HttpResponse.text(btoa(mockDiff))
+      }),
+      // Get comments
+      http.get('*/a/changes/:changeId/revisions/current/comments', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockComments)}`)
+      }),
+      // Get file diff for context (optional, may fail gracefully)
+      http.get('*/a/changes/:changeId/revisions/current/files/:fileName/diff', () => {
+        return HttpResponse.text(mockDiff)
+      }),
+    )
+  }
+
+  const createMockConfigLayer = () => Layer.succeed(ConfigService, createMockConfigService())
+
+  test('should display comprehensive change information in pretty format', async () => {
+    setupMockHandlers()
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedLogs.join('\n')
+
+    // Check that all sections are present
+    expect(output).toContain('📋 Change 12345: Fix authentication bug')
+    expect(output).toContain('📝 Details:')
+    expect(output).toContain('Project: test-project')
+    expect(output).toContain('Branch: main')
+    expect(output).toContain('Status: NEW')
+    expect(output).toContain('Owner: John Doe')
+    expect(output).toContain('Change-Id: I123abc456def')
+    expect(output).toContain('🔍 Diff:')
+    expect(output).toContain('💬 Inline Comments:')
+
+    // Check diff content is included
+    expect(output).toContain('src/auth.js')
+    expect(output).toContain('authenticate(user)')
+
+    // Check comments are included
+    expect(output).toContain('Good improvement!')
+    expect(output).toContain('Consider adding JSDoc')
+    expect(output).toContain('Clear commit message')
+  })
+
+  test('should output XML format when --xml flag is used', async () => {
+    setupMockHandlers()
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedLogs.join('\n')
+
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<show_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<change>')
+    expect(output).toContain('<id>I123abc456def</id>')
+    expect(output).toContain('<number>12345</number>')
+    expect(output).toContain('<subject><![CDATA[Fix authentication bug]]></subject>')
+    expect(output).toContain('<status>NEW</status>')
+    expect(output).toContain('<project>test-project</project>')
+    expect(output).toContain('<branch>main</branch>')
+    expect(output).toContain('<owner>')
+    expect(output).toContain('<name><![CDATA[John Doe]]></name>')
+    expect(output).toContain('<email>john@example.com</email>')
+    expect(output).toContain('<diff><![CDATA[')
+    expect(output).toContain('<comments>')
+    expect(output).toContain('<count>3</count>')
+    expect(output).toContain('</show_result>')
+  })
+
+  test('should handle API errors gracefully in pretty format', async () => {
+    server.use(
+      http.get('*/a/changes/:changeId', () => {
+        return HttpResponse.json({ error: 'Change not found' }, { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedErrors.join('\n')
+    expect(output).toContain('✗ Failed to fetch change details')
+  })
+
+  test('should handle API errors gracefully in XML format', async () => {
+    server.use(
+      http.get('*/a/changes/:changeId', () => {
+        return HttpResponse.json({ error: 'Change not found' }, { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedLogs.join('\n')
+
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<show_result>')
+    expect(output).toContain('<status>error</status>')
+    expect(output).toContain('<error><![CDATA[')
+    expect(output).toContain('</show_result>')
+  })
+
+  test('should properly escape XML special characters', async () => {
+    const changeWithSpecialChars = generateMockChange({
+      _number: 12345,
+      change_id: 'I123abc456def',
+      subject: 'Fix "quotes" & <tags> in auth',
+      project: 'test-project',
+      branch: 'feature/fix&improve',
+      owner: {
+        _account_id: 1002,
+        name: 'User <with> & "special" chars',
+        email: 'user@example.com',
+      },
+    })
+
+    server.use(
+      http.get('*/a/changes/:changeId', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(changeWithSpecialChars)}`)
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/patch', () => {
+        return HttpResponse.text('diff content')
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/comments', () => {
+        return HttpResponse.text(`)]}'\n{}`)
+      }),
+    )
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedLogs.join('\n')
+
+    expect(output).toContain('<subject><![CDATA[Fix "quotes" & <tags> in auth]]></subject>')
+    expect(output).toContain('<branch>feature/fix&amp;improve</branch>')
+    expect(output).toContain('<name><![CDATA[User <with> & "special" chars]]></name>')
+  })
+
+  test('should handle mixed file and commit message comments', async () => {
+    setupMockHandlers()
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedLogs.join('\n')
+
+    // Should show comments from both files and commit message
+    expect(output).toContain('Good improvement!')
+    expect(output).toContain('Consider adding JSDoc')
+    expect(output).toContain('Clear commit message')
+
+    // Commit message path should be renamed
+    expect(output).toContain('Commit Message')
+    expect(output).not.toContain('/COMMIT_MSG')
+  })
+
+  test('should handle changes with missing optional fields', async () => {
+    const minimalChange = generateMockChange({
+      _number: 12345,
+      change_id: 'I123abc456def',
+      subject: 'Minimal change',
+      status: 'NEW',
+      project: 'test-project',
+      branch: 'main',
+      owner: {
+        _account_id: 1003,
+        email: 'user@example.com',
+      },
+    })
+
+    server.use(
+      http.get('*/a/changes/:changeId', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(minimalChange)}`)
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/patch', () => {
+        return HttpResponse.text('minimal diff')
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/comments', () => {
+        return HttpResponse.text(`)]}'\n{}`)
+      }),
+    )
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedLogs.join('\n')
+
+    expect(output).toContain('📋 Change 12345: Minimal change')
+    expect(output).toContain('Owner: user@example.com') // Should fallback to email
+  })
+
+  test('should display review activity messages', async () => {
+    const mockChange = generateMockChange({
+      _number: 12345,
+      subject: 'Fix authentication bug',
+    })
+
+    const mockMessages: MessageInfo[] = [
+      {
+        id: 'msg1',
+        message: 'Patch Set 2: Code-Review+2',
+        author: { _account_id: 1001, name: 'Jane Reviewer' },
+        date: '2024-01-15 11:30:00.000000000',
+        _revision_number: 2,
+      },
+      {
+        id: 'msg2',
+        message: 'Patch Set 2: Verified+1\\n\\nBuild Successful',
+        author: { _account_id: 1002, name: 'Jenkins Bot' },
+        date: '2024-01-15 11:31:00.000000000',
+        _revision_number: 2,
+      },
+      {
+        id: 'msg3',
+        message: 'Uploaded patch set 1.',
+        author: { _account_id: 1000, name: 'Author' },
+        date: '2024-01-15 11:29:00.000000000',
+        tag: 'autogenerated:gerrit:newPatchSet',
+        _revision_number: 1,
+      },
+    ]
+
+    server.use(
+      http.get('*/a/changes/:changeId', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.text(`)]}'\n${JSON.stringify({ messages: mockMessages })}`)
+        }
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/patch', () => {
+        return HttpResponse.text('diff content')
+      }),
+      http.get('*/a/changes/:changeId/revisions/current/comments', () => {
+        return HttpResponse.text(`)]}'\n{}`)
+      }),
+    )
+
+    const mockConfigLayer = createMockConfigLayer()
+    const program = showCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = capturedLogs.join('\n')
+
+    // Should display review activity section
+    expect(output).toContain('📝 Review Activity:')
+    expect(output).toContain('Jane Reviewer')
+    expect(output).toContain('Code-Review+2')
+    expect(output).toContain('Jenkins Bot')
+    expect(output).toContain('Build Successful')
+
+    // Should filter out autogenerated messages
+    expect(output).not.toContain('Uploaded patch set')
+  })
+})

package/tests/unit/schemas/gerrit.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test } from 'bun:test'
+import { Schema } from '@effect/schema'
+import { CommentInput, GerritCredentials } from '@/schemas/gerrit'
+
+describe('Gerrit Schemas', () => {
+  describe('GerritCredentials', () => {
+    test('should validate valid credentials', () => {
+      const validCredentials = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+      }
+
+      const result = Schema.decodeUnknownSync(GerritCredentials)(validCredentials)
+      expect(result).toEqual(validCredentials)
+    })
+
+    test('should reject invalid URL', () => {
+      const invalidCredentials = {
+        host: 'not-a-url',
+        username: 'testuser',
+        password: 'testpass123',
+      }
+
+      expect(() => {
+        Schema.decodeUnknownSync(GerritCredentials)(invalidCredentials)
+      }).toThrow()
+    })
+
+    test('should reject empty username', () => {
+      const invalidCredentials = {
+        host: 'https://gerrit.example.com',
+        username: '',
+        password: 'testpass123',
+      }
+
+      expect(() => {
+        Schema.decodeUnknownSync(GerritCredentials)(invalidCredentials)
+      }).toThrow()
+    })
+
+    test('should reject empty password', () => {
+      const invalidCredentials = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: '',
+      }
+
+      expect(() => {
+        Schema.decodeUnknownSync(GerritCredentials)(invalidCredentials)
+      }).toThrow()
+    })
+  })
+
+  describe('CommentInput', () => {
+    test('should validate valid comment input', () => {
+      const validComment = {
+        message: 'This is a test comment',
+        unresolved: true,
+      }
+
+      const result = Schema.decodeUnknownSync(CommentInput)(validComment)
+      expect(result).toEqual(validComment)
+    })
+
+    test('should validate comment without unresolved flag', () => {
+      const validComment = {
+        message: 'This is a test comment',
+      }
+
+      const result = Schema.decodeUnknownSync(CommentInput)(validComment)
+      expect(result).toEqual(validComment)
+    })
+
+    test('should reject empty message', () => {
+      const invalidComment = {
+        message: '',
+      }
+
+      expect(() => {
+        Schema.decodeUnknownSync(CommentInput)(invalidComment)
+      }).toThrow()
+    })
+  })
+})

package/tests/unit/test-utils/mock-generator.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  generateMockAccount,
+  generateMockChange,
+  generateMockFileDiff,
+  generateMockFiles,
+} from '@/test-utils/mock-generator'
+
+describe('Mock Generator', () => {
+  describe('generateMockChange', () => {
+    test('should generate a complete mock change object', () => {
+      const change = generateMockChange()
+
+      expect(change).toMatchObject({
+        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 15:30:00.000000000',
+        insertions: 25,
+        deletions: 3,
+        _number: 12345,
+        owner: {
+          _account_id: 1000096,
+          name: 'John Developer',
+          email: 'john@example.com',
+          username: 'jdeveloper',
+        },
+      })
+    })
+
+    test('should apply overrides to mock change', () => {
+      const overrides = {
+        subject: 'Custom subject',
+        status: 'MERGED' as const,
+        insertions: 100,
+      }
+
+      const change = generateMockChange(overrides)
+
+      expect(change.subject).toBe('Custom subject')
+      expect(change.status).toBe('MERGED')
+      expect(change.insertions).toBe(100)
+      // Original values should remain for non-overridden fields
+      expect(change.project).toBe('myProject')
+      expect(change.deletions).toBe(3)
+    })
+
+    test('should handle partial owner overrides', () => {
+      const overrides = {
+        owner: {
+          _account_id: 999,
+          name: 'Custom Developer',
+          email: 'custom@example.com',
+          username: 'customdev',
+        },
+      }
+
+      const change = generateMockChange(overrides)
+
+      expect(change.owner).toEqual(overrides.owner)
+    })
+  })
+
+  describe('generateMockFiles', () => {
+    test('should generate mock file info objects', () => {
+      const files = generateMockFiles()
+
+      expect(Object.keys(files)).toContain('src/main.ts')
+      expect(Object.keys(files)).toContain('tests/main.test.ts')
+
+      expect(files['src/main.ts']).toMatchObject({
+        status: 'M',
+        lines_inserted: 15,
+        lines_deleted: 3,
+        size_delta: 120,
+        size: 1200,
+      })
+
+      expect(files['tests/main.test.ts']).toMatchObject({
+        status: 'A',
+        lines_inserted: 45,
+        lines_deleted: 0,
+        size_delta: 450,
+        size: 450,
+      })
+    })
+
+    test('should return consistent file structure', () => {
+      const files1 = generateMockFiles()
+      const files2 = generateMockFiles()
+
+      expect(Object.keys(files1)).toEqual(Object.keys(files2))
+      expect(files1['src/main.ts']).toEqual(files2['src/main.ts'])
+    })
+  })
+
+  describe('generateMockFileDiff', () => {
+    test('should generate mock file diff content', () => {
+      const diff = generateMockFileDiff()
+
+      expect(diff).toMatchObject({
+        content: [
+          {
+            ab: ['function main() {', '  console.log("Hello, world!")'],
+          },
+          {
+            a: ['  return 0'],
+            b: ['  return process.exit(0)'],
+          },
+          {
+            ab: ['}'],
+          },
+        ],
+        change_type: 'MODIFIED',
+        diff_header: ['--- a/src/main.ts', '+++ b/src/main.ts'],
+      })
+    })
+
+    test('should have consistent structure', () => {
+      const diff1 = generateMockFileDiff()
+      const diff2 = generateMockFileDiff()
+
+      expect(diff1.change_type).toBe('MODIFIED')
+      expect(diff2.change_type).toBe('MODIFIED')
+      expect(diff1.content.length).toBe(diff2.content.length)
+      expect(diff1.diff_header).toEqual(['--- a/src/main.ts', '+++ b/src/main.ts'])
+      expect(diff2.diff_header).toEqual(['--- a/src/main.ts', '+++ b/src/main.ts'])
+    })
+  })
+
+  describe('generateMockAccount', () => {
+    test('should generate mock account object', () => {
+      const account = generateMockAccount()
+
+      expect(account).toMatchObject({
+        _account_id: 1000096,
+        name: 'Test User',
+        email: 'test@example.com',
+        username: 'testuser',
+      })
+    })
+
+    test('should return consistent account data', () => {
+      const account1 = generateMockAccount()
+      const account2 = generateMockAccount()
+
+      expect(account1).toEqual(account2)
+    })
+  })
+})