@aaronshaf/ger 3.0.2 → 4.0.1

package/tests/analyze.test.ts

@@ -0,0 +1,197 @@
+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 { analyzeCommand } from '@/cli/commands/analyze'
+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: 'Test change',
+  status: 'MERGED',
+  created: '2025-01-15 10:00:00.000000000',
+  updated: '2025-01-15 12:00:00.000000000',
+  submitted: '2025-01-15 12:00:00.000000000',
+  owner: { _account_id: 1001, name: 'Alice Smith', email: 'alice@example.com' },
+  ...overrides,
+})
+
+const mockChanges: ChangeInfo[] = [
+  makeChange({
+    _number: 1,
+    project: 'repo-a',
+    owner: { _account_id: 1, name: 'Alice', email: 'alice@x.com' },
+  }),
+  makeChange({
+    _number: 2,
+    project: 'repo-a',
+    owner: { _account_id: 1, name: 'Alice', email: 'alice@x.com' },
+  }),
+  makeChange({
+    _number: 3,
+    project: 'repo-b',
+    owner: { _account_id: 2, name: 'Bob', email: 'bob@x.com' },
+    submitted: '2025-02-10 10:00:00.000000000',
+  }),
+]
+
+const server = setupServer(
+  http.get('*/a/accounts/self', () =>
+    HttpResponse.json({ _account_id: 1, name: 'User', email: 'u@example.com' }),
+  ),
+  http.get('*/a/changes/', () => HttpResponse.json(mockChanges)),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }))
+afterAll(() => server.close())
+afterEach(() => server.resetHandlers())
+
+const mockConfig = createMockConfigService()
+
+describe('analyze command', () => {
+  test('runs without error and outputs terminal UI', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(' '))
+
+    try {
+      await Effect.runPromise(
+        analyzeCommand({}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const output = logs.join('\n')
+    expect(output).toContain('repo-a')
+    expect(output).toContain('Alice')
+  })
+
+  test('outputs JSON', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(' '))
+
+    try {
+      await Effect.runPromise(
+        analyzeCommand({ json: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const jsonStr = logs.find((l) => l.startsWith('{'))
+    expect(jsonStr).toBeDefined()
+    const parsed = JSON.parse(jsonStr as string) as { totalMerged: number }
+    expect(parsed.totalMerged).toBe(3)
+  })
+
+  test('outputs XML', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(' '))
+
+    try {
+      await Effect.runPromise(
+        analyzeCommand({ xml: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const output = logs.join('\n')
+    expect(output).toContain('<analytics>')
+    expect(output).toContain('<total_merged>3</total_merged>')
+  })
+
+  test('outputs markdown', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(' '))
+
+    try {
+      await Effect.runPromise(
+        analyzeCommand({ markdown: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const output = logs.join('\n')
+    expect(output).toContain('# Contribution Analytics')
+    expect(output).toContain('| Repository | Count |')
+  })
+
+  test('outputs CSV', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(' '))
+
+    try {
+      await Effect.runPromise(
+        analyzeCommand({ csv: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const output = logs.join('\n')
+    expect(output).toContain('section,key,count')
+    expect(output).toContain('repo,"repo-a",2')
+  })
+
+  test('filters by repo via query', async () => {
+    let capturedUrl = ''
+    server.use(
+      http.get('*/a/changes/', ({ request }) => {
+        capturedUrl = request.url
+        return HttpResponse.json([mockChanges[0]])
+      }),
+    )
+
+    await Effect.runPromise(
+      analyzeCommand({ repo: 'my-repo', json: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    expect(capturedUrl).toContain('project%3Amy-repo')
+  })
+
+  test('fails gracefully when API returns error', async () => {
+    server.use(http.get('*/a/changes/', () => HttpResponse.json({}, { status: 500 })))
+
+    const result = await Effect.runPromise(
+      analyzeCommand({}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        Effect.either,
+      ),
+    )
+
+    expect(result._tag).toBe('Left')
+  })
+})

package/tests/cherry.test.ts

@@ -0,0 +1,208 @@
+import { describe, test, expect, beforeAll, afterAll, afterEach, mock, spyOn } from 'bun:test'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { Effect, Layer } from 'effect'
+import { cherryCommand } from '@/cli/commands/cherry'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+import type { ChangeInfo, RevisionInfo } from '@/schemas/gerrit'
+import * as childProcess from 'node:child_process'
+import type { SpawnSyncReturns } from 'node:child_process'
+
+const mockChange: ChangeInfo = {
+  id: 'test-project~main~I123',
+  _number: 12345,
+  project: 'test-project',
+  branch: 'main',
+  change_id: 'I123',
+  subject: 'Test cherry-pick change',
+  status: 'NEW',
+  created: '2024-01-15 10:00:00.000000000',
+  updated: '2024-01-15 10:00:00.000000000',
+}
+
+const mockRevision: RevisionInfo = {
+  _number: 1,
+  ref: 'refs/changes/45/12345/1',
+  created: '2024-01-15 10:00:00.000000000',
+  uploader: { _account_id: 1000, name: 'Test User', email: 'test@example.com' },
+}
+
+const server = setupServer(
+  http.get('*/a/accounts/self', ({ request }) => {
+    const auth = request.headers.get('Authorization')
+    if (!auth?.startsWith('Basic ')) return HttpResponse.text('Unauthorized', { status: 401 })
+    return HttpResponse.json({ _account_id: 1000, name: 'Test User', email: 'test@example.com' })
+  }),
+  http.get('*/a/changes/12345', () => HttpResponse.json(mockChange)),
+  http.get('*/a/changes/12345/revisions/current', () => HttpResponse.json(mockRevision)),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }))
+afterAll(() => server.close())
+
+const mockConfig = createMockConfigService({
+  host: 'https://test.gerrit.com',
+  username: 'testuser',
+  password: 'testpass',
+})
+
+describe('cherry command', () => {
+  let mockExecSync: ReturnType<typeof spyOn>
+  let mockSpawnSync: ReturnType<typeof spyOn>
+
+  afterEach(() => {
+    server.resetHandlers()
+    mockExecSync?.mockRestore()
+    mockSpawnSync?.mockRestore()
+  })
+
+  const setupGitMocks = (spawnOverrides: { failFetch?: boolean; failCherry?: boolean } = {}) => {
+    mockExecSync = spyOn(childProcess, 'execSync').mockImplementation(((command: string) => {
+      if (command.includes('rev-parse --git-dir')) return Buffer.from('.git')
+      if (command.includes('remote -v'))
+        return Buffer.from('origin\thttps://test.gerrit.com/project\t(fetch)\n')
+      return Buffer.from('')
+    }) as typeof childProcess.execSync)
+
+    mockSpawnSync = spyOn(childProcess, 'spawnSync').mockImplementation(((
+      _cmd: string,
+      args: string[],
+    ) => {
+      const isCherry = args.includes('cherry-pick')
+      if (isCherry && spawnOverrides.failCherry) {
+        return {
+          status: 1,
+          stderr: Buffer.from('conflict during cherry-pick'),
+        } as unknown as SpawnSyncReturns<Buffer>
+      }
+      if (!isCherry && spawnOverrides.failFetch) {
+        return {
+          status: 1,
+          stderr: Buffer.from('fetch failed'),
+        } as unknown as SpawnSyncReturns<Buffer>
+      }
+      return { status: 0, stderr: Buffer.from('') } as unknown as SpawnSyncReturns<Buffer>
+    }) as typeof childProcess.spawnSync)
+  }
+
+  test('cherry-picks a change successfully', async () => {
+    setupGitMocks()
+
+    await Effect.runPromise(
+      cherryCommand('12345', {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    const spawnCalls = mockSpawnSync.mock.calls as unknown as [string, string[]][]
+    expect(spawnCalls.some(([, args]) => args.includes('fetch'))).toBe(true)
+    expect(
+      spawnCalls.some(([, args]) => args.includes('cherry-pick') && args.includes('FETCH_HEAD')),
+    ).toBe(true)
+    expect(spawnCalls.some(([, args]) => args.includes('cherry-pick') && args.includes('-n'))).toBe(
+      false,
+    )
+  })
+
+  test('cherry-picks with --no-commit flag', async () => {
+    setupGitMocks()
+
+    await Effect.runPromise(
+      cherryCommand('12345', { noCommit: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    const spawnCalls = mockSpawnSync.mock.calls as unknown as [string, string[]][]
+    expect(spawnCalls.some(([, args]) => args.includes('cherry-pick') && args.includes('-n'))).toBe(
+      true,
+    )
+  })
+
+  test('parses 12345/3 patchset syntax', async () => {
+    setupGitMocks()
+
+    server.use(
+      http.get('*/a/changes/12345/revisions/3', () =>
+        HttpResponse.json({ ...mockRevision, _number: 3, ref: 'refs/changes/45/12345/3' }),
+      ),
+    )
+
+    await Effect.runPromise(
+      cherryCommand('12345/3', {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    const spawnCalls = mockSpawnSync.mock.calls as unknown as [string, string[]][]
+    expect(spawnCalls.some(([, args]) => args.includes('refs/changes/45/12345/3'))).toBe(true)
+  })
+
+  test('fails when not in a git repo', async () => {
+    mockExecSync = spyOn(childProcess, 'execSync').mockImplementation((() => {
+      throw new Error('not a git repo')
+    }) as typeof childProcess.execSync)
+
+    const result = await Effect.runPromise(
+      cherryCommand('12345', {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        Effect.either,
+      ),
+    )
+    expect(result._tag).toBe('Left')
+  })
+
+  test('fails when change not found', async () => {
+    setupGitMocks()
+    server.use(http.get('*/a/changes/99999', () => HttpResponse.json({}, { status: 404 })))
+
+    const result = await Effect.runPromise(
+      cherryCommand('99999', {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        Effect.either,
+      ),
+    )
+    expect(result._tag).toBe('Left')
+  })
+
+  test('fails when git cherry-pick fails', async () => {
+    setupGitMocks({ failCherry: true })
+
+    let threw = false
+    try {
+      await Effect.runPromise(
+        cherryCommand('12345', {}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } catch (e) {
+      threw = true
+      expect(String(e)).toContain('Cherry-pick failed')
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('uses --remote option when provided', async () => {
+    setupGitMocks()
+
+    await Effect.runPromise(
+      cherryCommand('12345', { remote: 'upstream' }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    const spawnCalls = mockSpawnSync.mock.calls as unknown as [string, string[]][]
+    expect(spawnCalls.some(([, args]) => args.includes('fetch') && args.includes('upstream'))).toBe(
+      true,
+    )
+  })
+})

package/tests/failures.test.ts

@@ -0,0 +1,212 @@
+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 { failuresCommand } from '@/cli/commands/failures'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+
+const JENKINS_URL = 'https://jenkins.inst-ci.net/job/Canvas/job/main/123//build-summary-report/'
+
+const makeMessage = (id: string, message: string, authorName = 'Test User') => ({
+  id,
+  message,
+  date: '2025-01-15 10:00:00.000000000',
+  author: { _account_id: 1, name: authorName, email: 'test@example.com' },
+})
+
+const makeMessagesResponse = (messages: ReturnType<typeof makeMessage>[]) => ({
+  messages,
+})
+
+const defaultMessages = [
+  makeMessage('m1', 'Build started', 'Service Cloud Jenkins'),
+  makeMessage(
+    'm2',
+    `Patch Set 1: Verified-1\n\nBuild failed. See ${JENKINS_URL}`,
+    'Service Cloud Jenkins',
+  ),
+]
+
+const server = setupServer(
+  http.get('*/a/accounts/self', () =>
+    HttpResponse.json({ _account_id: 1, name: 'User', email: 'u@example.com' }),
+  ),
+  http.get('*/a/changes/12345', () => HttpResponse.json(makeMessagesResponse(defaultMessages))),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }))
+afterAll(() => server.close())
+afterEach(() => server.resetHandlers())
+
+const mockConfig = createMockConfigService()
+
+describe('failures command', () => {
+  test('outputs the Jenkins failure URL', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        failuresCommand('12345', {}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    expect(logs.join('\n')).toContain(JENKINS_URL)
+  })
+
+  test('outputs JSON with url field', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        failuresCommand('12345', { 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; url: string }
+    expect(parsed.status).toBe('found')
+    expect(parsed.url).toBe(JENKINS_URL)
+  })
+
+  test('outputs XML with url element', async () => {
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        failuresCommand('12345', { xml: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    const output = logs.join('\n')
+    expect(output).toContain('<failures>')
+    expect(output).toContain(`<url>${JENKINS_URL}</url>`)
+  })
+
+  test('ignores messages not from Service Cloud Jenkins', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () =>
+        HttpResponse.json(
+          makeMessagesResponse([
+            makeMessage('m1', `Verified-1\n\nFailed: ${JENKINS_URL}`, 'Some Other Bot'),
+          ]),
+        ),
+      ),
+    )
+
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        failuresCommand('12345', {}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    expect(logs.join('\n')).not.toContain(JENKINS_URL)
+    expect(logs.join('\n')).toContain('No build failure links found')
+  })
+
+  test('ignores Service Cloud Jenkins messages without Verified-1', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () =>
+        HttpResponse.json(
+          makeMessagesResponse([
+            makeMessage('m1', `Build started: ${JENKINS_URL}`, 'Service Cloud Jenkins'),
+          ]),
+        ),
+      ),
+    )
+
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        failuresCommand('12345', {}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    expect(logs.join('\n')).not.toContain(JENKINS_URL)
+    expect(logs.join('\n')).toContain('No build failure links found')
+  })
+
+  test('returns most recent failure when multiple exist', async () => {
+    const NEWER_URL = 'https://jenkins.inst-ci.net/job/Canvas/job/main/456//build-summary-report/'
+    server.use(
+      http.get('*/a/changes/12345', () =>
+        HttpResponse.json(
+          makeMessagesResponse([
+            makeMessage('m1', `Verified-1\n\nFailed: ${JENKINS_URL}`, 'Service Cloud Jenkins'),
+            makeMessage('m2', `Verified-1\n\nFailed: ${NEWER_URL}`, 'Service Cloud Jenkins'),
+          ]),
+        ),
+      ),
+    )
+
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(
+        failuresCommand('12345', {}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } finally {
+      console.log = origLog
+    }
+
+    expect(logs.join('\n')).toContain(NEWER_URL)
+    expect(logs.join('\n')).not.toContain(JENKINS_URL)
+  })
+
+  test('fails when change not found', async () => {
+    server.use(http.get('*/a/changes/99999', () => HttpResponse.json({}, { status: 404 })))
+
+    const result = await Effect.runPromise(
+      failuresCommand('99999', {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        Effect.either,
+      ),
+    )
+
+    expect(result._tag).toBe('Left')
+  })
+})

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),
 })