@aaronshaf/ger 1.2.11 → 2.0.0

package/tests/open.test.ts

@@ -0,0 +1,233 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { http, HttpResponse } from 'msw'
+import { setupServer } from 'msw/node'
+import { Layer } from 'effect'
+import { Effect } from 'effect'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { openCommand } from '@/cli/commands/open'
+import { ConfigService } from '@/services/config'
+
+import { createMockConfigService } from './helpers/config-mock'
+// Mock child_process.exec
+const mockExec = mock()
+mock.module('node:child_process', () => ({
+  exec: mockExec,
+}))
+
+const server = setupServer()
+
+beforeAll(() => {
+  server.listen()
+})
+
+beforeEach(() => {
+  mockExec.mockClear()
+})
+
+afterAll(() => {
+  server.close()
+})
+
+describe('open command', () => {
+  test('should open change URL in browser', async () => {
+    // Mock the exec function to simulate successful browser opening
+    mockExec.mockImplementation((cmd: string, callback: (error: null) => void) => {
+      expect(cmd).toMatch(
+        /^(open|start|xdg-open) "https:\/\/gerrit\.example\.com\/c\/test-project\/\+\/12345"$/,
+      )
+      callback(null)
+    })
+
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            id: 'test-project~main~I1234567890abcdef',
+            project: 'test-project',
+            branch: 'main',
+            change_id: 'I1234567890abcdef',
+            subject: 'Test change',
+            status: 'NEW',
+            _number: 12345,
+            owner: {
+              _account_id: 1000000,
+              name: 'Test User',
+              email: 'test@example.com',
+            },
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(
+      ConfigService,
+      createMockConfigService({
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass',
+      }),
+    )
+
+    const consoleSpy = mock(() => {})
+    const originalLog = console.log
+    console.log = consoleSpy
+
+    const program = openCommand('12345').pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    console.log = originalLog
+
+    expect(mockExec).toHaveBeenCalledTimes(1)
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Opened: https://gerrit.example.com/c/test-project/+/12345',
+    )
+  })
+
+  test('should handle URLs and extract change number', async () => {
+    mockExec.mockImplementation((cmd: string, callback: (error: null) => void) => {
+      expect(cmd).toMatch(
+        /^(open|start|xdg-open) "https:\/\/gerrit\.example\.com\/c\/test-project\/\+\/12345"$/,
+      )
+      callback(null)
+    })
+
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            id: 'test-project~main~I1234567890abcdef',
+            project: 'test-project',
+            branch: 'main',
+            change_id: 'I1234567890abcdef',
+            subject: 'Test change',
+            status: 'NEW',
+            _number: 12345,
+            owner: {
+              _account_id: 1000000,
+              name: 'Test User',
+            },
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(
+      ConfigService,
+      createMockConfigService({
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass',
+      }),
+    )
+
+    const consoleSpy = mock(() => {})
+    const originalLog = console.log
+    console.log = consoleSpy
+
+    // Test with a full Gerrit URL
+    const program = openCommand('https://gerrit.example.com/c/test-project/+/12345').pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    console.log = originalLog
+
+    expect(mockExec).toHaveBeenCalledTimes(1)
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Opened: https://gerrit.example.com/c/test-project/+/12345',
+    )
+  })
+
+  test('should handle invalid change ID', async () => {
+    const mockConfigLayer = Layer.succeed(
+      ConfigService,
+      createMockConfigService({
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass',
+      }),
+    )
+
+    // Use an empty string which is truly invalid according to isValidChangeId
+    const program = openCommand('').pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('Invalid change ID: ')
+  })
+
+  test('should handle API errors gracefully', async () => {
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.json({ error: 'Change not found' }, { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(
+      ConfigService,
+      createMockConfigService({
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass',
+      }),
+    )
+
+    const program = openCommand('12345').pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  test('should handle browser opening errors', async () => {
+    mockExec.mockImplementation((cmd: string, callback: (error: Error) => void) => {
+      callback(new Error('Browser not found'))
+    })
+
+    server.use(
+      http.get('*/a/changes/12345', () => {
+        return HttpResponse.text(
+          `)]}'\n${JSON.stringify({
+            id: 'test-project~main~I1234567890abcdef',
+            project: 'test-project',
+            branch: 'main',
+            change_id: 'I1234567890abcdef',
+            subject: 'Test change',
+            status: 'NEW',
+            _number: 12345,
+            owner: {
+              _account_id: 1000000,
+              name: 'Test User',
+            },
+          })}`,
+        )
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(
+      ConfigService,
+      createMockConfigService({
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass',
+      }),
+    )
+
+    const program = openCommand('12345').pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await expect(Effect.runPromise(program)).rejects.toThrow(
+      'Failed to open URL: Browser not found',
+    )
+  })
+})

package/tests/projects.test.ts

@@ -0,0 +1,259 @@
+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 { projectsCommand } from '@/cli/commands/projects'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+
+const mockProjects = {
+  'project-a': {
+    id: 'project-a',
+    name: 'project-a',
+    parent: 'All-Projects',
+    state: 'ACTIVE' as const,
+  },
+  'project-b': {
+    id: 'project-b',
+    name: 'project-b',
+    parent: 'All-Projects',
+    state: 'ACTIVE' as const,
+  },
+  'test-project': {
+    id: 'test-project',
+    name: 'test-project',
+    parent: 'All-Projects',
+    state: 'ACTIVE' as const,
+  },
+}
+
+// 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('projects 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 list all projects', async () => {
+    server.use(
+      http.get('*/a/projects/', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockProjects)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = projectsCommand({}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    // Projects should be sorted alphabetically
+    expect(output).toContain('project-a')
+    expect(output).toContain('project-b')
+    expect(output).toContain('test-project')
+
+    // Check that they appear in alphabetical order
+    const lines = output.split('\n').filter((line) => line.trim())
+    expect(lines[0]).toBe('project-a')
+    expect(lines[1]).toBe('project-b')
+    expect(lines[2]).toBe('test-project')
+  })
+
+  it('should list projects with pattern filter', async () => {
+    server.use(
+      http.get('*/a/projects/', ({ request }) => {
+        const url = new URL(request.url)
+        const pattern = url.searchParams.get('p')
+        expect(pattern).toBe('test-*')
+
+        // Return filtered projects
+        const filtered = {
+          'test-project': mockProjects['test-project'],
+        }
+        return HttpResponse.text(`)]}'\n${JSON.stringify(filtered)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = projectsCommand({ pattern: 'test-*' }).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('test-project')
+    expect(output).not.toContain('project-a')
+    expect(output).not.toContain('project-b')
+  })
+
+  it('should output XML format when --xml flag is used', async () => {
+    server.use(
+      http.get('*/a/projects/', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockProjects)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = projectsCommand({ 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('<projects_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<projects>')
+    expect(output).toContain('<project>')
+    expect(output).toContain('<id>project-a</id>')
+    expect(output).toContain('<name>project-a</name>')
+    expect(output).toContain('<parent>All-Projects</parent>')
+    expect(output).toContain('<state>ACTIVE</state>')
+    expect(output).toContain('</project>')
+    expect(output).toContain('</projects>')
+    expect(output).toContain('</projects_result>')
+  })
+
+  it('should handle empty results', async () => {
+    server.use(
+      http.get('*/a/projects/', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify({})}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = projectsCommand({}).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('No projects found')
+  })
+
+  it('should handle empty results with XML format', async () => {
+    server.use(
+      http.get('*/a/projects/', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify({})}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = projectsCommand({ 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('<projects_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<projects />')
+  })
+
+  it('should handle network errors gracefully', async () => {
+    server.use(
+      http.get('*/a/projects/', () => {
+        return HttpResponse.error()
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = projectsCommand({}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should handle API errors', async () => {
+    server.use(
+      http.get('*/a/projects/', () => {
+        return HttpResponse.text('Forbidden', { status: 403 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = projectsCommand({}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should handle projects without parent or state', async () => {
+    const minimalProjects = {
+      'minimal-project': {
+        id: 'minimal-project',
+        name: 'minimal-project',
+      },
+    }
+
+    server.use(
+      http.get('*/a/projects/', () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(minimalProjects)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = projectsCommand({ 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('<id>minimal-project</id>')
+    expect(output).toContain('<name>minimal-project</name>')
+    expect(output).not.toContain('<parent>')
+    expect(output).not.toContain('<state>')
+  })
+})