@aaronshaf/ger 3.0.1 → 4.0.0

package/tests/files.test.ts

@@ -0,0 +1,223 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, mock } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { filesCommand } from '@/cli/commands/files'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+
+const mockFilesResponse = {
+  '/COMMIT_MSG': { status: 'A' as const, lines_inserted: 10 },
+  'src/foo.ts': { status: 'M' as const, lines_inserted: 5, lines_deleted: 2 },
+  'src/bar.ts': { status: 'A' as const, lines_inserted: 20 },
+  'src/old.ts': { status: 'D' as const, lines_deleted: 30 },
+}
+
+const server = setupServer(
+  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('files command', () => {
+  let mockConsoleLog: ReturnType<typeof mock>
+  let mockConsoleError: ReturnType<typeof mock>
+  let mockProcessExit: ReturnType<typeof mock>
+
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  beforeEach(() => {
+    mockConsoleLog = mock(() => {})
+    mockConsoleError = mock(() => {})
+    mockProcessExit = mock(() => {})
+    console.log = mockConsoleLog
+    console.error = mockConsoleError
+    process.exit = mockProcessExit as unknown as typeof process.exit
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  it('should list changed files with plain output', async () => {
+    server.use(
+      http.get('*/a/changes/12345/revisions/current/files', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockFilesResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).not.toContain('/COMMIT_MSG')
+    expect(output).toContain('M src/foo.ts')
+    expect(output).toContain('A src/bar.ts')
+    expect(output).toContain('D src/old.ts')
+  })
+
+  it('should output JSON format', async () => {
+    server.use(
+      http.get('*/a/changes/12345/revisions/current/files', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockFilesResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('12345', { json: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    const parsed = JSON.parse(output) as { status: string; change_id: string; files: unknown[] }
+    expect(parsed.status).toBe('success')
+    expect(parsed.change_id).toBe('12345')
+    expect(parsed.files).toBeArray()
+    const paths = (parsed.files as Array<{ path: string }>).map((f) => f.path)
+    expect(paths).not.toContain('/COMMIT_MSG')
+    expect(paths).toContain('src/foo.ts')
+  })
+
+  it('should output XML format', async () => {
+    server.use(
+      http.get('*/a/changes/12345/revisions/current/files', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockFilesResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('12345', { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<files_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<change_id><![CDATA[12345]]></change_id>')
+    expect(output).toContain('<path><![CDATA[src/foo.ts]]></path>')
+    expect(output).not.toContain('/COMMIT_MSG')
+    expect(output).toContain('</files_result>')
+  })
+
+  it('should handle empty files response (only magic files)', async () => {
+    server.use(
+      http.get('*/a/changes/12345/revisions/current/files', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify({ '/COMMIT_MSG': { status: 'A' } })}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).not.toContain('/COMMIT_MSG')
+  })
+
+  it('should exit 1 on API error', async () => {
+    server.use(
+      http.get('*/a/changes/99999/revisions/current/files', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('99999', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Error:')
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+
+  it('should exit 1 and output XML on API error with --xml', async () => {
+    server.use(
+      http.get('*/a/changes/99999/revisions/current/files', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('99999', { xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<files_result>')
+    expect(output).toContain('<status>error</status>')
+    expect(output).toContain('</files_result>')
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+
+  it('should exit 1 and output JSON on API error with --json', async () => {
+    server.use(
+      http.get('*/a/changes/99999/revisions/current/files', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand('99999', { json: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    const parsed = JSON.parse(output) as { status: string; error: string }
+    expect(parsed.status).toBe('error')
+    expect(typeof parsed.error).toBe('string')
+    expect(parsed.error.length).toBeGreaterThan(0)
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+
+  it('should exit 1 when no change-id and HEAD has no Change-Id', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = filesCommand(undefined, {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Error:')
+    expect(errorOutput).toContain('No Change-ID found in HEAD commit')
+    expect(mockProcessExit.mock.calls[0][0]).toBe(1)
+  })
+})

package/tests/helpers/config-mock.ts

@@ -10,6 +10,7 @@ export const createMockConfigService = (
     password: 'testpass',
   },
   aiConfig: AiConfig = { autoDetect: true },
+  retriggerComment?: string,
 ): ConfigServiceImpl => ({
   getCredentials: Effect.succeed(credentials),
   saveCredentials: () => Effect.succeed(undefined as void),
@@ -22,6 +23,9 @@ export const createMockConfigService = (
     password: credentials.password,
     aiTool: aiConfig.tool,
     aiAutoDetect: aiConfig.autoDetect ?? true,
+    retriggerComment,
   } as AppConfig),
   saveFullConfig: () => Effect.succeed(undefined as void),
+  getRetriggerComment: Effect.succeed(retriggerComment),
+  saveRetriggerComment: () => Effect.succeed(undefined as void),
 })

package/tests/list.test.ts

@@ -0,0 +1,220 @@
+import { describe, test, expect, beforeAll, afterAll, afterEach } from 'bun:test'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { Effect, Layer } from 'effect'
+import { listCommand } from '@/cli/commands/list'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+import type { ChangeInfo } from '@/schemas/gerrit'
+
+const makeChange = (overrides: Partial<ChangeInfo> = {}): ChangeInfo => ({
+  id: 'project~main~I123',
+  _number: 12345,
+  project: 'my-project',
+  branch: 'main',
+  change_id: 'I123',
+  subject: 'Fix the important thing',
+  status: 'NEW',
+  created: '2025-01-15 10:00:00.000000000',
+  updated: '2025-01-15 12:00:00.000000000',
+  owner: { _account_id: 1, name: 'Alice', email: 'alice@x.com' },
+  ...overrides,
+})
+
+const mockChanges: ChangeInfo[] = [
+  makeChange({ _number: 1, subject: 'First change' }),
+  makeChange({
+    _number: 2,
+    subject: 'Second change with Code-Review',
+    labels: { 'Code-Review': { approved: { _account_id: 1 }, value: 2 } },
+  }),
+  makeChange({
+    _number: 3,
+    subject: 'Third change rejected',
+    labels: { 'Code-Review': { rejected: { _account_id: 2 }, value: -2 } },
+  }),
+]
+
+const server = setupServer(
+  http.get('*/a/accounts/self', () =>
+    HttpResponse.json({ _account_id: 1, name: 'Alice', email: 'alice@x.com' }),
+  ),
+  http.get('*/a/changes/', () => HttpResponse.json(mockChanges)),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }))
+afterAll(() => server.close())
+afterEach(() => server.resetHandlers())
+
+const mockConfig = createMockConfigService()
+
+describe('list command', () => {
+  test('renders table with header and rows', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        listCommand({}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const output = logs.join('\n')
+    expect(output).toContain('Change')
+    expect(output).toContain('Subject')
+    expect(output).toContain('CR')
+    expect(output).toContain('Verified')
+    expect(output).toContain('1')
+    expect(output).toContain('First change')
+  })
+
+  test('outputs JSON', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        listCommand({ json: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const parsed = JSON.parse(logs.join('')) as { status: string; count: number }
+    expect(parsed.status).toBe('success')
+    expect(parsed.count).toBe(3)
+  })
+
+  test('outputs XML', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        listCommand({ xml: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const output = logs.join('\n')
+    expect(output).toContain('<changes count="3">')
+    expect(output).toContain('<number>1</number>')
+  })
+
+  test('--detailed shows per-change info', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        listCommand({ detailed: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const output = logs.join('\n')
+    expect(output).toContain('Change:')
+    expect(output).toContain('Subject:')
+    expect(output).toContain('Project:')
+  })
+
+  test('--limit caps results', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        listCommand({ limit: 1, json: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const parsed = JSON.parse(logs.join('')) as { count: number }
+    expect(parsed.count).toBe(1)
+  })
+
+  test('--status passes query to API', async () => {
+    let capturedUrl = ''
+    server.use(
+      http.get('*/a/changes/', ({ request }) => {
+        capturedUrl = decodeURIComponent(request.url)
+        return HttpResponse.json([])
+      }),
+    )
+
+    await Effect.runPromise(
+      listCommand({ status: 'merged' }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    expect(capturedUrl).toContain('status:merged')
+  })
+
+  test('--reviewer uses reviewer query', async () => {
+    let capturedUrl = ''
+    server.use(
+      http.get('*/a/changes/', ({ request }) => {
+        capturedUrl = decodeURIComponent(request.url)
+        return HttpResponse.json([])
+      }),
+    )
+
+    await Effect.runPromise(
+      listCommand({ reviewer: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    expect(capturedUrl).toContain('reviewer:')
+  })
+
+  test('shows empty message when no changes', async () => {
+    server.use(http.get('*/a/changes/', () => HttpResponse.json([])))
+
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        listCommand({}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    expect(logs.join('\n')).toContain('No changes found')
+  })
+})

package/tests/retrigger.test.ts

@@ -0,0 +1,159 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, mock } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigService } from '@/services/config'
+import { retriggerCommand } from '@/cli/commands/retrigger'
+import { createMockConfigService } from './helpers/config-mock'
+
+// Mock @inquirer/prompts so tests don't block on stdin
+const mockInput = mock(async () => 'trigger-build')
+mock.module('@inquirer/prompts', () => ({ input: mockInput }))
+
+const server = setupServer(
+  http.get('*/a/accounts/self', () =>
+    HttpResponse.json({ _account_id: 1, name: 'User', email: 'u@example.com' }),
+  ),
+  http.post('*/a/changes/:changeId/revisions/current/review', () => HttpResponse.json({})),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }))
+afterAll(() => server.close())
+
+describe('retrigger command', () => {
+  let mockConsoleLog: ReturnType<typeof mock>
+  let mockConsoleError: ReturnType<typeof mock>
+
+  beforeEach(() => {
+    mockConsoleLog = mock()
+    mockConsoleError = mock()
+    console.log = mockConsoleLog
+    console.error = mockConsoleError
+    mockInput.mockReset()
+    mockInput.mockResolvedValue('trigger-build')
+    server.resetHandlers()
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  it('posts the retrigger comment when change-id is explicit and comment is configured', async () => {
+    const mockConfig = createMockConfigService(undefined, undefined, '__TRIGGER__')
+
+    await Effect.runPromise(
+      retriggerCommand('12345', {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    // Should print success
+    expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('✓'))
+  })
+
+  it('posts to the given change-id', async () => {
+    const mockConfig = createMockConfigService(undefined, undefined, '__TRIGGER__')
+
+    let postedChangeId = ''
+    server.use(
+      http.post('*/a/changes/:changeId/revisions/current/review', ({ params }) => {
+        postedChangeId = params.changeId as string
+        return HttpResponse.json({})
+      }),
+    )
+
+    await Effect.runPromise(
+      retriggerCommand('67890', {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    expect(postedChangeId).toBe('67890')
+  })
+
+  it('prompts for retrigger comment when not configured, then saves it', async () => {
+    let savedComment = ''
+    const mockConfig: ReturnType<typeof createMockConfigService> = {
+      ...createMockConfigService(),
+      getRetriggerComment: Effect.succeed(undefined),
+      saveRetriggerComment: (comment: string) => {
+        savedComment = comment
+        return Effect.succeed(undefined as void)
+      },
+    }
+
+    mockInput.mockResolvedValue('my-trigger-comment')
+
+    await Effect.runPromise(
+      retriggerCommand('12345', {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    expect(mockInput).toHaveBeenCalled()
+    expect(savedComment).toBe('my-trigger-comment')
+  })
+
+  it('throws when prompted comment is empty', async () => {
+    const mockConfig: ReturnType<typeof createMockConfigService> = {
+      ...createMockConfigService(),
+      getRetriggerComment: Effect.succeed(undefined),
+      saveRetriggerComment: () => Effect.succeed(undefined as void),
+    }
+
+    mockInput.mockResolvedValue('   ')
+
+    let threw = false
+    try {
+      await Effect.runPromise(
+        retriggerCommand('12345', {}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } catch (e) {
+      threw = true
+      expect(String(e)).toContain('cannot be empty')
+    }
+    expect(threw).toBe(true)
+  })
+
+  it('outputs JSON on success', async () => {
+    const mockConfig = createMockConfigService(undefined, undefined, '__TRIGGER__')
+
+    const logs: string[] = []
+    console.log = (msg: string) => logs.push(msg)
+
+    await Effect.runPromise(
+      retriggerCommand('12345', { json: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    const parsed = JSON.parse(logs[0]) as { status: string; change_id: string }
+    expect(parsed.status).toBe('success')
+    expect(parsed.change_id).toBe('12345')
+  })
+
+  it('outputs XML on success', async () => {
+    const mockConfig = createMockConfigService(undefined, undefined, '__TRIGGER__')
+
+    const logs: string[] = []
+    console.log = (msg: string) => logs.push(msg)
+
+    await Effect.runPromise(
+      retriggerCommand('12345', { xml: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    expect(logs.join('\n')).toContain('<retrigger>')
+    expect(logs.join('\n')).toContain('<status>success</status>')
+  })
+})