@aaronshaf/ger 1.2.11 → 2.0.0

package/tests/status.test.ts

@@ -0,0 +1,145 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test'
+
+// Mock console
+const mockConsole = {
+  log: mock(),
+  error: mock(),
+}
+
+// Mock global console
+global.console = mockConsole as any
+
+describe('Status Command', () => {
+  beforeEach(() => {
+    mockConsole.log.mockReset()
+    mockConsole.error.mockReset()
+  })
+
+  afterEach(() => {
+    mock.restore()
+  })
+
+  describe('pretty output format', () => {
+    test('should show success message when connected', () => {
+      console.log('✓ Connected to Gerrit successfully!')
+
+      expect(mockConsole.log).toHaveBeenCalledWith('✓ Connected to Gerrit successfully!')
+    })
+
+    test('should show failure message when connection fails', () => {
+      console.log('✗ Failed to connect to Gerrit')
+      console.log('Please check your credentials and network connection')
+
+      expect(mockConsole.log).toHaveBeenCalledWith('✗ Failed to connect to Gerrit')
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        'Please check your credentials and network connection',
+      )
+    })
+  })
+
+  describe('XML output format', () => {
+    test('should output XML format when connected successfully', () => {
+      console.log('<?xml version="1.0" encoding="UTF-8"?>')
+      console.log('<status_result>')
+      console.log('  <connected>true</connected>')
+      console.log('</status_result>')
+
+      expect(mockConsole.log).toHaveBeenCalledWith('<?xml version="1.0" encoding="UTF-8"?>')
+      expect(mockConsole.log).toHaveBeenCalledWith('<status_result>')
+      expect(mockConsole.log).toHaveBeenCalledWith('  <connected>true</connected>')
+      expect(mockConsole.log).toHaveBeenCalledWith('</status_result>')
+    })
+
+    test('should output XML format when connection fails', () => {
+      console.log('<?xml version="1.0" encoding="UTF-8"?>')
+      console.log('<status_result>')
+      console.log('  <connected>false</connected>')
+      console.log('</status_result>')
+
+      expect(mockConsole.log).toHaveBeenCalledWith('<?xml version="1.0" encoding="UTF-8"?>')
+      expect(mockConsole.log).toHaveBeenCalledWith('<status_result>')
+      expect(mockConsole.log).toHaveBeenCalledWith('  <connected>false</connected>')
+      expect(mockConsole.log).toHaveBeenCalledWith('</status_result>')
+    })
+  })
+
+  describe('option handling', () => {
+    test('should handle xml option correctly', () => {
+      const options: { xml?: boolean } = { xml: true }
+      expect(options.xml).toBe(true)
+    })
+
+    test('should handle undefined xml option correctly', () => {
+      const options = { xml: undefined }
+      expect(options.xml).toBeUndefined()
+    })
+
+    test('should handle missing xml option', () => {
+      const options: { xml?: boolean } = {}
+      expect(options.xml).toBeUndefined()
+    })
+  })
+
+  describe('connection testing', () => {
+    test('should simulate connection success', async () => {
+      const mockTestConnection = mock(() => Promise.resolve(true))
+      const result = await mockTestConnection()
+      expect(result).toBe(true)
+    })
+
+    test('should simulate connection failure', async () => {
+      const mockTestConnection = mock(() => Promise.resolve(false))
+      const result = await mockTestConnection()
+      expect(result).toBe(false)
+    })
+
+    test('should handle connection errors', async () => {
+      const mockTestConnection = mock(() => Promise.reject(new Error('Network error')))
+
+      try {
+        await mockTestConnection()
+      } catch (error: any) {
+        expect(error.message).toBe('Network error')
+      }
+    })
+  })
+
+  describe('console output verification', () => {
+    test('should output exactly the expected XML structure', () => {
+      const expectedXML = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<status_result>',
+        '  <connected>true</connected>',
+        '</status_result>',
+      ]
+
+      expectedXML.forEach((line) => console.log(line))
+
+      const calls = mockConsole.log.mock.calls.map((call) => call[0])
+      expect(calls).toEqual(expectedXML)
+    })
+
+    test('should output exactly one success message in pretty mode', () => {
+      console.log('✓ Connected to Gerrit successfully!')
+
+      expect(mockConsole.log).toHaveBeenCalledTimes(1)
+      expect(mockConsole.log).toHaveBeenCalledWith('✓ Connected to Gerrit successfully!')
+    })
+  })
+
+  describe('status indicators', () => {
+    test('should use checkmark for success', () => {
+      const successIcon = '✓'
+      console.log(`${successIcon} Connected to Gerrit successfully!`)
+
+      expect(mockConsole.log).toHaveBeenCalledWith('✓ Connected to Gerrit successfully!')
+    })
+
+    test('should use X mark for failure', () => {
+      const failureIcon = '✗'
+      console.log(`${failureIcon} Failed to connect to Gerrit`)
+
+      expect(mockConsole.log).toHaveBeenCalledWith('✗ Failed to connect to Gerrit')
+    })
+  })
+})

package/tests/submit.test.ts

@@ -0,0 +1,316 @@
+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 { submitCommand } from '@/cli/commands/submit'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+import type { ChangeInfo } from '@/schemas/gerrit'
+
+const mockSubmittableChange: ChangeInfo = {
+  id: 'test-project~master~I123',
+  _number: 12345,
+  change_id: 'I123',
+  project: 'test-project',
+  branch: 'master',
+  subject: 'Test change ready to submit',
+  status: 'NEW',
+  created: '2024-01-01 10:00:00.000000000',
+  updated: '2024-01-01 12:00:00.000000000',
+  owner: {
+    _account_id: 1000,
+    name: 'Test User',
+    email: 'test@example.com',
+  },
+  labels: {
+    'Code-Review': {
+      value: 2,
+      approved: {
+        _account_id: 1001,
+        name: 'Reviewer',
+        email: 'reviewer@example.com',
+      },
+    },
+    Verified: {
+      value: 1,
+      approved: {
+        _account_id: 1002,
+        name: 'CI Bot',
+        email: 'ci@example.com',
+      },
+    },
+  },
+  work_in_progress: false,
+  submittable: true,
+}
+
+const mockNotSubmittableChange: ChangeInfo = {
+  ...mockSubmittableChange,
+  submittable: false,
+  labels: {
+    'Code-Review': {
+      value: 0,
+    },
+    Verified: {
+      value: 0,
+    },
+  },
+}
+
+const mockWipChange: ChangeInfo = {
+  ...mockSubmittableChange,
+  submittable: false,
+  work_in_progress: true,
+}
+
+const mockSubmitResponse = {
+  status: 'MERGED' as const,
+  change_id: 'I123',
+}
+
+// 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('submit 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 submit a submittable change', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockSubmittableChange)}`)
+      }),
+      http.post('*/a/changes/12345/submit', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockSubmitResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand('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('Submitted change 12345')
+    expect(output).toContain('Test change ready to submit')
+    expect(output).toContain('Status: MERGED')
+  })
+
+  it('should output XML format when --xml flag is used', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockSubmittableChange)}`)
+      }),
+      http.post('*/a/changes/12345/submit', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockSubmitResponse)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand('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('<submit_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<change_number>12345</change_number>')
+    expect(output).toContain('<subject><![CDATA[Test change ready to submit]]></subject>')
+    expect(output).toContain('<submit_status>MERGED</submit_status>')
+    expect(output).toContain('</submit_result>')
+  })
+
+  it('should reject change that is not submittable', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockNotSubmittableChange)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand('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('Change 12345 cannot be submitted')
+    expect(errorOutput).toContain('Reasons:')
+    expect(errorOutput).toContain('Missing Code-Review+2 approval')
+    expect(errorOutput).toContain('Missing Verified+1 approval')
+  })
+
+  it('should reject change that is work in progress', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockWipChange)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand('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('Change 12345 cannot be submitted')
+    expect(errorOutput).toContain('work-in-progress')
+  })
+
+  it('should output XML format for non-submittable change', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockNotSubmittableChange)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand('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('<submit_result>')
+    expect(output).toContain('<status>error</status>')
+    expect(output).toContain('<submittable>false</submittable>')
+    expect(output).toContain('<reasons>')
+    expect(output).toContain('<reason><![CDATA[Missing Code-Review+2 approval]]></reason>')
+    expect(output).toContain('</reasons>')
+  })
+
+  it('should handle not found errors gracefully', async () => {
+    server.use(
+      http.get('*/a/changes/99999', () => {
+        return HttpResponse.text('Change not found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand('99999', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Should fail when change is not found
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should show error when change ID is not provided', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand(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 submit <change-id>')
+  })
+
+  it('should handle submit API failure', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockSubmittableChange)}`)
+      }),
+      http.post('*/a/changes/12345/submit', () => {
+        return HttpResponse.text('Merge conflict detected', { status: 409 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should handle network errors', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.error()
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should handle API permission errors', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockSubmittableChange)}`)
+      }),
+      http.post('*/a/changes/12345/submit', () => {
+        return HttpResponse.text('Forbidden', { status: 403 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = submitCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+})

package/tests/unit/commands/push.test.ts

@@ -0,0 +1,194 @@
+import { test, expect, describe } from 'bun:test'
+import { buildPushRefspec, validateEmails, PushError } from '@/cli/commands/push'
+
+describe('Push Command', () => {
+  describe('buildPushRefspec', () => {
+    test('should build basic refspec without options', () => {
+      const refspec = buildPushRefspec('master', {})
+      expect(refspec).toBe('refs/for/master')
+    })
+
+    test('should build refspec with topic', () => {
+      const refspec = buildPushRefspec('master', { topic: 'my-feature' })
+      expect(refspec).toBe('refs/for/master%topic=my-feature')
+    })
+
+    test('should URL-encode topic with special characters', () => {
+      const refspec = buildPushRefspec('master', { topic: 'feature/auth-fix' })
+      expect(refspec).toBe('refs/for/master%topic=feature%2Fauth-fix')
+    })
+
+    test('should build refspec with wip flag', () => {
+      const refspec = buildPushRefspec('master', { wip: true })
+      expect(refspec).toBe('refs/for/master%wip')
+    })
+
+    test('should build refspec with draft flag (alias for wip)', () => {
+      const refspec = buildPushRefspec('master', { draft: true })
+      expect(refspec).toBe('refs/for/master%wip')
+    })
+
+    test('should build refspec with ready flag', () => {
+      const refspec = buildPushRefspec('master', { ready: true })
+      expect(refspec).toBe('refs/for/master%ready')
+    })
+
+    test('should build refspec with private flag', () => {
+      const refspec = buildPushRefspec('master', { private: true })
+      expect(refspec).toBe('refs/for/master%private')
+    })
+
+    test('should build refspec with single reviewer', () => {
+      const refspec = buildPushRefspec('master', { reviewer: ['alice@example.com'] })
+      expect(refspec).toBe('refs/for/master%r=alice@example.com')
+    })
+
+    test('should build refspec with multiple reviewers', () => {
+      const refspec = buildPushRefspec('master', {
+        reviewer: ['alice@example.com', 'bob@example.com'],
+      })
+      expect(refspec).toBe('refs/for/master%r=alice@example.com,r=bob@example.com')
+    })
+
+    test('should build refspec with single cc', () => {
+      const refspec = buildPushRefspec('master', { cc: ['manager@example.com'] })
+      expect(refspec).toBe('refs/for/master%cc=manager@example.com')
+    })
+
+    test('should build refspec with multiple ccs', () => {
+      const refspec = buildPushRefspec('master', {
+        cc: ['manager@example.com', 'lead@example.com'],
+      })
+      expect(refspec).toBe('refs/for/master%cc=manager@example.com,cc=lead@example.com')
+    })
+
+    test('should build refspec with single hashtag', () => {
+      const refspec = buildPushRefspec('master', { hashtag: ['bugfix'] })
+      expect(refspec).toBe('refs/for/master%hashtag=bugfix')
+    })
+
+    test('should build refspec with multiple hashtags', () => {
+      const refspec = buildPushRefspec('master', { hashtag: ['bugfix', 'urgent'] })
+      expect(refspec).toBe('refs/for/master%hashtag=bugfix,hashtag=urgent')
+    })
+
+    test('should URL-encode hashtags with special characters', () => {
+      const refspec = buildPushRefspec('master', { hashtag: ['release/v1.0'] })
+      expect(refspec).toBe('refs/for/master%hashtag=release%2Fv1.0')
+    })
+
+    test('should build refspec with multiple options combined', () => {
+      const refspec = buildPushRefspec('main', {
+        topic: 'auth-refactor',
+        reviewer: ['alice@example.com'],
+        cc: ['manager@example.com'],
+        wip: true,
+        hashtag: ['security'],
+      })
+      expect(refspec).toBe(
+        'refs/for/main%topic=auth-refactor,wip,r=alice@example.com,cc=manager@example.com,hashtag=security',
+      )
+    })
+
+    test('should handle different branch names', () => {
+      expect(buildPushRefspec('main', {})).toBe('refs/for/main')
+      expect(buildPushRefspec('develop', {})).toBe('refs/for/develop')
+      expect(buildPushRefspec('feature/my-branch', {})).toBe('refs/for/feature/my-branch')
+      expect(buildPushRefspec('release/v1.0', {})).toBe('refs/for/release/v1.0')
+    })
+
+    test('should preserve order of parameters', () => {
+      // The order should be: topic, wip, ready, private, reviewers, ccs, hashtags
+      const refspec = buildPushRefspec('master', {
+        hashtag: ['tag1'],
+        reviewer: ['r@example.com'],
+        topic: 'topic1',
+        wip: true,
+        cc: ['cc@example.com'],
+        private: true,
+      })
+      // Order in the code: topic, wip, ready, private, reviewer, cc, hashtag
+      expect(refspec).toBe(
+        'refs/for/master%topic=topic1,wip,private,r=r@example.com,cc=cc@example.com,hashtag=tag1',
+      )
+    })
+
+    test('should handle empty arrays gracefully', () => {
+      const refspec = buildPushRefspec('master', {
+        reviewer: [],
+        cc: [],
+        hashtag: [],
+      })
+      expect(refspec).toBe('refs/for/master')
+    })
+
+    test('should not add wip twice when both wip and draft are true', () => {
+      const refspec = buildPushRefspec('master', { wip: true, draft: true })
+      // Both wip and draft set the wip flag, but we check wip first, so only one 'wip' should appear
+      expect(refspec).toBe('refs/for/master%wip')
+    })
+  })
+
+  describe('validateEmails', () => {
+    test('should accept valid email addresses', () => {
+      expect(() => validateEmails(['user@example.com'], 'reviewer')).not.toThrow()
+      expect(() => validateEmails(['alice@company.org'], 'cc')).not.toThrow()
+      expect(() => validateEmails(['test.user@sub.domain.com'], 'reviewer')).not.toThrow()
+    })
+
+    test('should accept multiple valid emails', () => {
+      expect(() =>
+        validateEmails(['user1@example.com', 'user2@example.com'], 'reviewer'),
+      ).not.toThrow()
+    })
+
+    test('should accept undefined', () => {
+      expect(() => validateEmails(undefined, 'reviewer')).not.toThrow()
+    })
+
+    test('should accept empty array', () => {
+      expect(() => validateEmails([], 'reviewer')).not.toThrow()
+    })
+
+    test('should reject email without @', () => {
+      expect(() => validateEmails(['userexample.com'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should reject email without domain', () => {
+      expect(() => validateEmails(['user@'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should reject email without user', () => {
+      expect(() => validateEmails(['@example.com'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should reject email with spaces', () => {
+      expect(() => validateEmails(['user @example.com'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should reject plain username', () => {
+      expect(() => validateEmails(['username'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should include field name in error message', () => {
+      try {
+        validateEmails(['invalid'], 'reviewer')
+        expect(true).toBe(false) // Should not reach here
+      } catch (e) {
+        expect(e).toBeInstanceOf(PushError)
+        expect((e as PushError).message).toContain('reviewer')
+        expect((e as PushError).message).toContain('invalid')
+      }
+    })
+
+    test('should fail on first invalid email in array', () => {
+      try {
+        validateEmails(['valid@example.com', 'invalid', 'another@example.com'], 'cc')
+        expect(true).toBe(false)
+      } catch (e) {
+        expect(e).toBeInstanceOf(PushError)
+        expect((e as PushError).message).toContain('invalid')
+      }
+    })
+  })
+})