@aaronshaf/ger 0.3.1 → 0.3.3

package/tests/add-reviewer.test.ts

@@ -0,0 +1,393 @@
+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 { addReviewerCommand } from '@/cli/commands/add-reviewer'
+import { ConfigService } from '@/services/config'
+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('add-reviewer command', () => {
+  let mockConsoleLog: ReturnType<typeof mock>
+  let mockConsoleError: ReturnType<typeof mock>
+
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  beforeEach(() => {
+    mockConsoleLog = mock(() => {})
+    mockConsoleError = mock(() => {})
+    console.log = mockConsoleLog
+    console.error = mockConsoleError
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  it('should add a single reviewer successfully', async () => {
+    server.use(
+      http.post('*/a/changes/12345/reviewers', async ({ request }) => {
+        const body = (await request.json()) as { reviewer: string; state?: string }
+        expect(body.reviewer).toBe('reviewer@example.com')
+        expect(body.state).toBe('REVIEWER')
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            input: 'reviewer@example.com',
+            reviewers: [
+              {
+                _account_id: 2000,
+                name: 'Reviewer User',
+                email: 'reviewer@example.com',
+              },
+            ],
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['reviewer@example.com'], {
+      change: '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).toContain('Added Reviewer User as reviewer')
+  })
+
+  it('should add multiple reviewers successfully', async () => {
+    let callCount = 0
+    server.use(
+      http.post('*/a/changes/12345/reviewers', async ({ request }) => {
+        const body = (await request.json()) as { reviewer: string }
+        callCount++
+        const reviewerName = callCount === 1 ? 'User One' : 'User Two'
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            input: body.reviewer,
+            reviewers: [
+              {
+                _account_id: 2000 + callCount,
+                name: reviewerName,
+                email: body.reviewer,
+              },
+            ],
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['user1@example.com', 'user2@example.com'], {
+      change: '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).toContain('Added User One as reviewer')
+    expect(output).toContain('Added User Two as reviewer')
+    expect(callCount).toBe(2)
+  })
+
+  it('should add as CC when --cc flag is used', async () => {
+    server.use(
+      http.post('*/a/changes/12345/reviewers', async ({ request }) => {
+        const body = (await request.json()) as { reviewer: string; state?: string }
+        expect(body.reviewer).toBe('cc@example.com')
+        expect(body.state).toBe('CC')
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            input: 'cc@example.com',
+            ccs: [
+              {
+                _account_id: 2000,
+                name: 'CC User',
+                email: 'cc@example.com',
+              },
+            ],
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['cc@example.com'], {
+      change: '12345',
+      cc: 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('Added CC User as cc')
+  })
+
+  it('should pass notify option to API', async () => {
+    server.use(
+      http.post('*/a/changes/12345/reviewers', async ({ request }) => {
+        const body = (await request.json()) as { reviewer: string; notify?: string }
+        expect(body.notify).toBe('NONE')
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            input: 'reviewer@example.com',
+            reviewers: [
+              {
+                _account_id: 2000,
+                name: 'Reviewer',
+                email: 'reviewer@example.com',
+              },
+            ],
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['reviewer@example.com'], {
+      change: '12345',
+      notify: 'none',
+    }).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('Added Reviewer as reviewer')
+  })
+
+  it('should handle API error in result', async () => {
+    server.use(
+      http.post('*/a/changes/12345/reviewers', async () => {
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            input: 'nonexistent@example.com',
+            error: 'Account not found: nonexistent@example.com',
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['nonexistent@example.com'], {
+      change: '12345',
+    }).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('Failed to add nonexistent@example.com')
+    expect(errorOutput).toContain('Account not found')
+  })
+
+  it('should show error when change ID is not provided', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['reviewer@example.com'], {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    const result = await Effect.runPromiseExit(program)
+    expect(result._tag).toBe('Failure')
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Change ID is required')
+  })
+
+  it('should show error when no reviewers are provided', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand([], {
+      change: '12345',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    const result = await Effect.runPromiseExit(program)
+    expect(result._tag).toBe('Failure')
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('At least one reviewer is required')
+  })
+
+  it('should output XML format when --xml flag is used', async () => {
+    server.use(
+      http.post('*/a/changes/12345/reviewers', async () => {
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            input: 'reviewer@example.com',
+            reviewers: [
+              {
+                _account_id: 2000,
+                name: 'Reviewer User',
+                email: 'reviewer@example.com',
+              },
+            ],
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['reviewer@example.com'], {
+      change: '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('<add_reviewer_result>')
+    expect(output).toContain('<change_id>12345</change_id>')
+    expect(output).toContain('<state>reviewer</state>')
+    expect(output).toContain('<reviewer status="added">')
+    expect(output).toContain('<input>reviewer@example.com</input>')
+    expect(output).toContain('<name><![CDATA[Reviewer User]]></name>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('</add_reviewer_result>')
+  })
+
+  it('should output XML format for errors when --xml flag is used', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['reviewer@example.com'], {
+      xml: true,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    const result = await Effect.runPromiseExit(program)
+    expect(result._tag).toBe('Failure')
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<add_reviewer_result>')
+    expect(output).toContain('<status>error</status>')
+    expect(output).toContain('<error><![CDATA[Change ID is required')
+    expect(output).toContain('</add_reviewer_result>')
+  })
+
+  it('should handle network errors gracefully', async () => {
+    server.use(
+      http.post('*/a/changes/12345/reviewers', () => {
+        return HttpResponse.text('Internal Server Error', { status: 500 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['reviewer@example.com'], {
+      change: '12345',
+    }).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('Failed to add reviewer@example.com')
+  })
+
+  it('should handle partial success with multiple reviewers', async () => {
+    let callCount = 0
+    server.use(
+      http.post('*/a/changes/12345/reviewers', async ({ request }) => {
+        const body = (await request.json()) as { reviewer: string }
+        callCount++
+        if (callCount === 1) {
+          return HttpResponse.text(
+            `)]}'\n${JSON.stringify({
+              input: body.reviewer,
+              reviewers: [
+                {
+                  _account_id: 2001,
+                  name: 'Valid User',
+                  email: body.reviewer,
+                },
+              ],
+            })}`,
+          )
+        }
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            input: body.reviewer,
+            error: 'Account not found',
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['valid@example.com', 'invalid@example.com'], {
+      change: '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('<status>partial_failure</status>')
+    expect(output).toContain('<reviewer status="added">')
+    expect(output).toContain('<reviewer status="failed">')
+  })
+
+  it('should reject invalid notify option', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['reviewer@example.com'], {
+      change: '12345',
+      notify: 'invalid',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    const result = await Effect.runPromiseExit(program)
+    expect(result._tag).toBe('Failure')
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Invalid notify level: invalid')
+    expect(errorOutput).toContain('Valid values: none, owner, owner_reviewers, all')
+  })
+
+  it('should pass REVIEWER state by default (not CC)', async () => {
+    let receivedState: string | undefined
+    server.use(
+      http.post('*/a/changes/12345/reviewers', async ({ request }) => {
+        const body = (await request.json()) as { reviewer: string; state?: string }
+        receivedState = body.state
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            input: body.reviewer,
+            reviewers: [
+              {
+                _account_id: 2000,
+                name: 'Reviewer',
+                email: body.reviewer,
+              },
+            ],
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = addReviewerCommand(['reviewer@example.com'], {
+      change: '12345',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    expect(receivedState).toBe('REVIEWER')
+  })
+})

package/tests/build-status-watch.test.ts

@@ -92,12 +92,8 @@ describe('build-status command - watch mode', () => {
     expect(JSON.parse(capturedStdout[1])).toEqual({ state: 'running' })
     expect(JSON.parse(capturedStdout[2])).toEqual({ state: 'success' })
 
-    // Should have logged progress to stderr
-    expect(capturedErrors.length).toBeGreaterThan(0)
-    expect(capturedErrors.some((e: string) => e.includes('Watching build status'))).toBe(true)
-    expect(
-      capturedErrors.some((e: string) => e.includes('Build completed with status: success')),
-    ).toBe(true)
+    // Minimalistic output: no stderr messages except on timeout/error
+    expect(capturedErrors.length).toBe(0)
   })
 
   test('polls until failure state is reached', async () => {
@@ -155,9 +151,9 @@ describe('build-status command - watch mode', () => {
 
     expect(capturedStdout.length).toBeGreaterThanOrEqual(2)
     expect(JSON.parse(capturedStdout[capturedStdout.length - 1])).toEqual({ state: 'failure' })
-    expect(
-      capturedErrors.some((e: string) => e.includes('Build completed with status: failure')),
-    ).toBe(true)
+
+    // Minimalistic output: no stderr messages except on timeout/error
+    expect(capturedErrors.length).toBe(0)
   })
 
   test('times out after specified duration', async () => {
@@ -303,9 +299,10 @@ describe('build-status command - watch mode', () => {
 
     expect(capturedStdout.length).toBe(1)
     expect(JSON.parse(capturedStdout[0])).toEqual({ state: 'not_found' })
+
     // 404 errors bypass pollBuildStatus and are handled in error handler
-    // So we get "Watching build status" but not "Build completed" message
-    expect(capturedErrors.some((e: string) => e.includes('Watching build status'))).toBe(true)
+    // Minimalistic output: no stderr messages for not_found state
+    expect(capturedErrors.length).toBe(0)
   })
 
   test('without watch flag, behaves as single check', async () => {

package/tests/build-status.test.ts

@@ -637,4 +637,153 @@ describe('build-status command', () => {
     // Regex should handle extra whitespace
     expect(output).toEqual({ state: 'running' })
   })
+
+  test('ignores verification from older patchset when newer patchset build is running', async () => {
+    // This test replicates the bug scenario:
+    // - PS 3 build started, then PS 4 build started
+    // - PS 3 verification (-1) comes AFTER PS 4 build started
+    // - Should return "running" because PS 4 has no verification yet
+    const messages: MessageInfo[] = [
+      {
+        id: 'msg1',
+        message: 'Build Started https://jenkins.example.com/job/123/',
+        date: '2024-01-15 11:12:00.000000000',
+        _revision_number: 2,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+      {
+        id: 'msg2',
+        message: 'Patch Set 2: Verified -1\n\nBuild Failed',
+        date: '2024-01-15 11:23:00.000000000',
+        _revision_number: 2,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+      {
+        id: 'msg3',
+        message: 'Build Started https://jenkins.example.com/job/456/',
+        date: '2024-01-15 13:57:00.000000000',
+        _revision_number: 3,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+      {
+        id: 'msg4',
+        message: 'Build Started https://jenkins.example.com/job/789/',
+        date: '2024-01-15 14:02:00.000000000',
+        _revision_number: 4,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+      {
+        id: 'msg5',
+        message: 'Patch Set 3: Verified -1\n\nBuild Failed : ABORTED',
+        date: '2024-01-15 14:03:00.000000000',
+        _revision_number: 3,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+    ]
+
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            { messages },
+            {
+              headers: { 'Content-Type': 'application/json' },
+            },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345').pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(createMockConfigLayer()),
+    )
+
+    await Effect.runPromise(effect)
+
+    expect(capturedStdout.length).toBe(1)
+    const output = JSON.parse(capturedStdout[0])
+    // PS 4 build started at 14:02, PS 3 verification at 14:03 should be IGNORED
+    // because it's for a different revision. PS 4 build is still running.
+    expect(output).toEqual({ state: 'running' })
+  })
+
+  test('returns success when verification matches the latest patchset', async () => {
+    const messages: MessageInfo[] = [
+      {
+        id: 'msg1',
+        message: 'Build Started',
+        date: '2024-01-15 10:00:00.000000000',
+        _revision_number: 1,
+        author: {
+          _account_id: 9999,
+          name: 'CI Bot',
+        },
+      },
+      {
+        id: 'msg2',
+        message: 'Build Started',
+        date: '2024-01-15 11:00:00.000000000',
+        _revision_number: 2,
+        author: {
+          _account_id: 9999,
+          name: 'CI Bot',
+        },
+      },
+      {
+        id: 'msg3',
+        message: 'Patch Set 2: Verified+1',
+        date: '2024-01-15 11:15:00.000000000',
+        _revision_number: 2,
+        author: {
+          _account_id: 9999,
+          name: 'CI Bot',
+        },
+      },
+    ]
+
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            { messages },
+            {
+              headers: { 'Content-Type': 'application/json' },
+            },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345').pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(createMockConfigLayer()),
+    )
+
+    await Effect.runPromise(effect)
+
+    expect(capturedStdout.length).toBe(1)
+    const output = JSON.parse(capturedStdout[0])
+    // PS 2 build started at 11:00, PS 2 verification at 11:15 - same revision, success
+    expect(output).toEqual({ state: 'success' })
+  })
 })