@aaronshaf/ger 0.2.4 → 0.3.1

package/tests/abandon.test.ts

@@ -1,4 +1,11 @@
-import { beforeEach, describe, expect, it, mock } from 'bun:test'
+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 { abandonCommand } from '@/cli/commands/abandon'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
 import type { ChangeInfo } from '@/schemas/gerrit'
 
 const mockChange: ChangeInfo = {
@@ -28,136 +35,196 @@ const mockChange: ChangeInfo = {
   submittable: false,
 }
 
+// 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('abandon command', () => {
-  let mockFetch: ReturnType<typeof mock>
+  let mockConsoleLog: ReturnType<typeof mock>
+  let mockConsoleError: ReturnType<typeof mock>
+
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
 
   beforeEach(() => {
-    // Reset fetch mock for each test
-    mockFetch = mock(() =>
-      Promise.resolve({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(')]}\n{}'),
+    mockConsoleLog = mock(() => {})
+    mockConsoleError = mock(() => {})
+    console.log = mockConsoleLog
+    console.error = mockConsoleError
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  it('should abandon a change with a message', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', async ({ request }) => {
+        const body = (await request.json()) as { message?: string }
+        expect(body.message).toBe('No longer needed')
+        return HttpResponse.text(")]}'\n{}")
       }),
     )
-    global.fetch = mockFetch as unknown as typeof fetch
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('12345', {
+      message: 'No longer needed',
+    }).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('Abandoned change 12345')
+    expect(output).toContain('Test change to abandon')
+    expect(output).toContain('Message: No longer needed')
   })
 
-  it('should call abandon API endpoint with correct parameters', async () => {
-    // Mock successful responses
-    mockFetch
-      .mockResolvedValueOnce({
-        ok: true,
-        text: async () => `)]}'
-{
-  "id": "test-project~master~I123",
-  "project": "test-project",
-  "branch": "master",
-  "change_id": "I123",
-  "subject": "Test change to abandon",
-  "status": "NEW",
-  "_number": 12345
-}`,
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        text: async () => ')]}\n{}',
-      })
-
-    // Note: This is a unit test demonstrating the API calls
-    // Actual integration would require running the full command
-    // which we avoid to prevent hitting production
-
-    // Verify the mock setup
-    const response = await mockFetch('https://test.gerrit.com/a/changes/12345')
-    const text = await response.text()
-    expect(text).toContain('Test change to abandon')
-
-    // Verify abandon endpoint would be called
-    const abandonResponse = await mockFetch('https://test.gerrit.com/a/changes/12345/abandon', {
-      method: 'POST',
-      body: JSON.stringify({ message: 'No longer needed' }),
-    })
-    expect(abandonResponse.ok).toBe(true)
+  it('should abandon a change without a message', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', async ({ request }) => {
+        const body = (await request.json()) as { message?: string }
+        expect(body.message).toBeUndefined()
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
 
-    // Verify calls were made
-    expect(mockFetch).toHaveBeenCalledTimes(2)
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('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('Abandoned change 12345')
+    expect(output).toContain('Test change to abandon')
+    expect(output).not.toContain('Message:')
   })
 
-  it('should handle abandon without message', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      text: async () => ')]}\n{}',
-    })
+  it('should output XML format when --xml flag is used', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', async ({ request }) => {
+        const body = (await request.json()) as { message?: string }
+        expect(body.message).toBe('Abandoning for testing')
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
 
-    const response = await mockFetch('https://test.gerrit.com/a/changes/12345/abandon', {
-      method: 'POST',
-      body: JSON.stringify({}),
-    })
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('12345', {
+      xml: true,
+      message: 'Abandoning for testing',
+    }).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('<abandon_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<change_number>12345</change_number>')
+    expect(output).toContain('<subject><![CDATA[Test change to abandon]]></subject>')
+    expect(output).toContain('<message><![CDATA[Abandoning for testing]]></message>')
+    expect(output).toContain('</abandon_result>')
+  })
 
-    expect(response.ok).toBe(true)
-    expect(mockFetch).toHaveBeenCalledWith('https://test.gerrit.com/a/changes/12345/abandon', {
-      method: 'POST',
-      body: JSON.stringify({}),
-    })
+  it('should output XML format without message when no message provided', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', async () => {
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('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('<abandon_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).not.toContain('<message>')
   })
 
-  it('should handle API errors', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 404,
-      text: async () => 'Change not found',
-    })
+  it('should handle not found errors gracefully', async () => {
+    server.use(
+      http.get('*/a/changes/99999', () => {
+        return HttpResponse.text('Change not found', { status: 404 })
+      }),
+    )
 
-    const response = await mockFetch('https://test.gerrit.com/a/changes/99999/abandon')
-    expect(response.ok).toBe(false)
-    expect(response.status).toBe(404)
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('99999', {
+      message: 'Test message',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
 
-    const errorText = await response.text()
-    expect(errorText).toBe('Change not found')
+    // Should fail when change is not found
+    await expect(Effect.runPromise(program)).rejects.toThrow()
   })
 
-  it('should format message correctly in request body', () => {
-    const testCases = [
-      { input: undefined, expected: {} },
-      { input: '', expected: {} },
-      { input: 'Abandoning this change', expected: { message: 'Abandoning this change' } },
-      { input: 'Multi\nline\nmessage', expected: { message: 'Multi\nline\nmessage' } },
-    ]
-
-    for (const testCase of testCases) {
-      const body = testCase.input ? { message: testCase.input } : {}
-      expect(body).toEqual(testCase.expected)
-    }
+  it('should show error when change ID is not provided', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand(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('Change ID is required')
+    expect(errorOutput).toContain('Usage: ger abandon <change-id>')
   })
 
-  describe('interactive mode API patterns', () => {
-    it('should fetch changes for interactive mode', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        text: async () => `)]}'\n[${JSON.stringify(mockChange)}]`,
-      })
-
-      // Test the API call pattern for interactive mode
-      const response = await mockFetch(
-        'https://test.gerrit.com/a/changes/?q=owner:self+status:open',
-      )
-      const text = await response.text()
-      expect(text).toContain('Test change to abandon')
-    })
+  it('should handle abandon API failure', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockChange)}`)
+      }),
+      http.post('*/a/changes/12345/abandon', () => {
+        return HttpResponse.text('Forbidden', { status: 403 })
+      }),
+    )
 
-    it('should handle empty changes list response', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        text: async () => ")]}'\n[]",
-      })
-
-      const response = await mockFetch(
-        'https://test.gerrit.com/a/changes/?q=owner:self+status:open',
-      )
-      const text = await response.text()
-      const parsed = JSON.parse(text.replace(")]}'\n", ''))
-      expect(parsed).toEqual([])
-    })
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = abandonCommand('12345', {
+      message: 'Test',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
   })
 })

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

@@ -0,0 +1,347 @@
+import { describe, test, expect, beforeAll, afterAll, afterEach } from 'bun:test'
+import { http, HttpResponse } from 'msw'
+import { Effect } from 'effect'
+import { buildStatusCommand } from '@/cli/commands/build-status'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import type { MessageInfo } from '@/schemas/gerrit'
+import {
+  server,
+  capturedStdout,
+  capturedErrors,
+  mockProcessExit,
+  setupBuildStatusTests,
+  teardownBuildStatusTests,
+  resetBuildStatusMocks,
+  createMockConfigLayer,
+} from './helpers/build-status-test-setup'
+
+beforeAll(() => {
+  setupBuildStatusTests()
+})
+
+afterAll(() => {
+  teardownBuildStatusTests()
+})
+
+afterEach(() => {
+  resetBuildStatusMocks()
+})
+
+describe('build-status command - watch mode', () => {
+  test('polls until success state is reached', async () => {
+    let callCount = 0
+
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          callCount++
+
+          let messages: MessageInfo[]
+          if (callCount === 1) {
+            // First call: pending (no build started)
+            messages = []
+          } else if (callCount === 2) {
+            // Second call: running (build started, no verification)
+            messages = [
+              {
+                id: 'msg1',
+                message: 'Build Started',
+                date: '2024-01-15 10:00:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+            ]
+          } else {
+            // Third call: success (verified +1)
+            messages = [
+              {
+                id: 'msg1',
+                message: 'Build Started',
+                date: '2024-01-15 10:00:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+              {
+                id: 'msg2',
+                message: 'Patch Set 1: Verified+1',
+                date: '2024-01-15 10:05:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+            ]
+          }
+
+          return HttpResponse.json(
+            { messages },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1, // Fast polling for tests
+      timeout: 10,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    // Should have multiple outputs (one per poll)
+    expect(capturedStdout.length).toBeGreaterThanOrEqual(3)
+    expect(JSON.parse(capturedStdout[0])).toEqual({ state: 'pending' })
+    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)
+  })
+
+  test('polls until failure state is reached', async () => {
+    let callCount = 0
+
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          callCount++
+
+          let messages: MessageInfo[]
+          if (callCount === 1) {
+            messages = [
+              {
+                id: 'msg1',
+                message: 'Build Started',
+                date: '2024-01-15 10:00:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+            ]
+          } else {
+            messages = [
+              {
+                id: 'msg1',
+                message: 'Build Started',
+                date: '2024-01-15 10:00:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+              {
+                id: 'msg2',
+                message: 'Patch Set 1: Verified-1',
+                date: '2024-01-15 10:05:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+            ]
+          }
+
+          return HttpResponse.json(
+            { messages },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1,
+      timeout: 10,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    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)
+  })
+
+  test('times out after specified duration', async () => {
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          // Always return running state
+          return HttpResponse.json(
+            {
+              messages: [
+                {
+                  id: 'msg1',
+                  message: 'Build Started',
+                  date: '2024-01-15 10:00:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+              ],
+            },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1,
+      timeout: 0.5, // Very short timeout
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    try {
+      await Effect.runPromise(effect)
+    } catch {
+      // Should exit with code 2 for timeout
+      expect(mockProcessExit).toHaveBeenCalledWith(2)
+      expect(capturedErrors.some((e: string) => e.includes('Timeout'))).toBe(true)
+    }
+  })
+
+  test('exit-status flag causes exit 1 on failure', async () => {
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            {
+              messages: [
+                {
+                  id: 'msg1',
+                  message: 'Build Started',
+                  date: '2024-01-15 10:00:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+                {
+                  id: 'msg2',
+                  message: 'Patch Set 1: Verified-1',
+                  date: '2024-01-15 10:05:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+              ],
+            },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1,
+      timeout: 10,
+      exitStatus: true,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    try {
+      await Effect.runPromise(effect)
+    } catch {
+      // Should exit with code 1 for failure when --exit-status is used
+      expect(mockProcessExit).toHaveBeenCalledWith(1)
+    }
+  })
+
+  test('exit-status flag does not affect success state', async () => {
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            {
+              messages: [
+                {
+                  id: 'msg1',
+                  message: 'Build Started',
+                  date: '2024-01-15 10:00:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+                {
+                  id: 'msg2',
+                  message: 'Patch Set 1: Verified+1',
+                  date: '2024-01-15 10:05:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+              ],
+            },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1,
+      timeout: 10,
+      exitStatus: true,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    // Should not call process.exit for success state
+    expect(mockProcessExit).not.toHaveBeenCalled()
+    expect(JSON.parse(capturedStdout[0])).toEqual({ state: 'success' })
+  })
+
+  test('watch mode handles not_found state', async () => {
+    server.use(
+      http.get('*/a/changes/99999', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('99999', {
+      watch: true,
+      interval: 0.1,
+      timeout: 10,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    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)
+  })
+
+  test('without watch flag, behaves as single check', async () => {
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            {
+              messages: [
+                {
+                  id: 'msg1',
+                  message: 'Build Started',
+                  date: '2024-01-15 10:00:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+              ],
+            },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: false,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    // Should only have one output (no polling)
+    expect(capturedStdout.length).toBe(1)
+    expect(JSON.parse(capturedStdout[0])).toEqual({ state: 'running' })
+
+    // Should not have watch mode messages in stderr
+    expect(capturedErrors.some((e: string) => e.includes('Watching build status'))).toBe(false)
+  })
+})