@aaronshaf/ger 1.2.11 → 2.0.0

package/tests/incoming.test.ts

@@ -0,0 +1,357 @@
+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 { incomingCommand } from '@/cli/commands/incoming'
+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('incoming command', () => {
+  let mockConsoleLog: ReturnType<typeof mock>
+  let mockConsoleError: ReturnType<typeof mock>
+
+  beforeAll(() => {
+    // Start MSW server before all tests
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    // Clean up after all tests
+    server.close()
+  })
+
+  beforeEach(() => {
+    // Reset handlers to defaults before each test
+    server.resetHandlers()
+
+    mockConsoleLog = mock(() => {})
+    mockConsoleError = mock(() => {})
+    console.log = mockConsoleLog
+    console.error = mockConsoleError
+  })
+
+  afterEach(() => {
+    // Clean up after each test
+    server.resetHandlers()
+  })
+
+  it('should fetch and display incoming changes in pretty format', async () => {
+    server.use(
+      http.get('*/a/changes/', ({ request }) => {
+        const url = new URL(request.url)
+        const query = url.searchParams.get('q')
+
+        // Verify the correct query
+        if (query === 'is:open -owner:self -is:wip -is:ignored reviewer:self') {
+          return HttpResponse.text(`)]}'\n[
+            {
+              "id": "team-project~main~I123abc",
+              "_number": 1001,
+              "project": "team-project",
+              "branch": "main",
+              "subject": "Fix critical bug in authentication",
+              "status": "NEW",
+              "change_id": "I123abc",
+              "owner": {
+                "_account_id": 2001,
+                "name": "Alice Developer",
+                "email": "alice@example.com"
+              },
+              "updated": "2024-01-15 10:30:00.000000000"
+            },
+            {
+              "id": "team-project~feature%2Fnew-api~I456def",
+              "_number": 1002,
+              "project": "team-project",
+              "branch": "feature/new-api",
+              "subject": "Add new API endpoint",
+              "status": "NEW",
+              "change_id": "I456def",
+              "owner": {
+                "_account_id": 2002,
+                "name": "Bob Builder",
+                "email": "bob@example.com"
+              },
+              "updated": "2024-01-15 11:00:00.000000000"
+            },
+            {
+              "id": "another-project~main~I789ghi",
+              "_number": 1003,
+              "project": "another-project",
+              "branch": "main",
+              "subject": "Update documentation",
+              "status": "NEW",
+              "change_id": "I789ghi",
+              "owner": {
+                "_account_id": 2003,
+                "name": "Charlie Coder",
+                "email": "charlie@example.com"
+              },
+              "updated": "2024-01-15 09:00:00.000000000"
+            }
+          ]`)
+        }
+        return HttpResponse.json([])
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+    const program = incomingCommand({}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    // Check that changes were displayed
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+
+    // Should not have header since we removed it
+    expect(output).not.toContain('Incoming changes for review')
+
+    // Check project grouping
+    expect(output).toContain('team-project')
+    expect(output).toContain('another-project')
+
+    // Check change details
+    expect(output).toContain('1001')
+    expect(output).toContain('Fix critical bug in authentication')
+    expect(output).toContain('by Alice Developer')
+    expect(output).toContain('1002')
+    expect(output).toContain('Add new API endpoint')
+    expect(output).toContain('by Bob Builder')
+    expect(output).toContain('1003')
+    expect(output).toContain('Update documentation')
+    expect(output).toContain('by Charlie Coder')
+  })
+
+  it('should output XML format when --xml flag is used', async () => {
+    server.use(
+      http.get('*/a/changes/', ({ request }) => {
+        const url = new URL(request.url)
+        const query = url.searchParams.get('q')
+
+        if (query === 'is:open -owner:self -is:wip -is:ignored reviewer:self') {
+          return HttpResponse.text(`)]}'\n[
+            {
+              "id": "xml-project~develop~Ixmltest",
+              "_number": 2001,
+              "project": "xml-project",
+              "branch": "develop",
+              "subject": "XML test change",
+              "status": "NEW",
+              "change_id": "Ixmltest",
+              "owner": {
+                "_account_id": 3001,
+                "name": "XML User",
+                "email": "xml@example.com"
+              },
+              "updated": "2024-01-15 14:00:00.000000000"
+            }
+          ]`)
+        }
+        return HttpResponse.json([])
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+    const program = incomingCommand({ xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    // Check XML output structure
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<incoming_reviews>')
+    expect(output).toContain('<count>1</count>')
+    expect(output).toContain('<changes>')
+    expect(output).toContain('<change>')
+    expect(output).toContain('<number>2001</number>')
+    expect(output).toContain('<subject><![CDATA[XML test change]]></subject>')
+    // Project is now an attribute of project element
+    expect(output).toContain('<project name="xml-project">')
+    expect(output).toContain('<status>NEW</status>')
+    expect(output).toContain('<owner>XML User</owner>')
+    expect(output).toContain('</change>')
+    expect(output).toContain('</changes>')
+    expect(output).toContain('</incoming_reviews>')
+  })
+
+  it('should handle no incoming changes gracefully', async () => {
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text(`)]}'\n[]`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+    const program = incomingCommand({}).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 incoming reviews')
+  })
+
+  it('should handle network failures gracefully', async () => {
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.error()
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+    const program = incomingCommand({}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should handle authentication failures', async () => {
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text('Unauthorized', { status: 401 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+    const program = incomingCommand({}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should properly escape XML special characters', async () => {
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text(`)]}'\n[
+          {
+            "id": "test-project~main~Itest",
+            "_number": 3001,
+            "project": "test<>&\\"project",
+            "branch": "main",
+            "subject": "Fix <script>alert('XSS')</script> & entities",
+            "status": "NEW",
+            "change_id": "I<>&test",
+            "owner": {
+              "_account_id": 4001,
+              "name": "User <>&\\"'",
+              "email": "test@example.com"
+            }
+          }
+        ]`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+    const program = incomingCommand({ xml: true }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    // Subject should be in CDATA
+    expect(output).toContain(
+      "<subject><![CDATA[Fix <script>alert('XSS')</script> & entities]]></subject>",
+    )
+    // Owner name should be preserved in output
+    expect(output).toContain('<owner>User <>&"\'</owner>')
+    // Project and change_id should be in output
+    // Project name should be in the project element attribute
+    expect(output).toContain('<project name="test<>&')
+  })
+
+  it('should group changes by project alphabetically', async () => {
+    server.use(
+      http.get('*/a/changes/', () => {
+        return HttpResponse.text(`)]}'\n[
+          {
+            "id": "zebra-project~main~Izebra",
+            "_number": 4001,
+            "project": "zebra-project",
+            "branch": "main",
+            "subject": "Change in zebra",
+            "status": "NEW",
+            "change_id": "Izebra",
+            "owner": {"_account_id": 5001, "name": "Zoe"}
+          },
+          {
+            "id": "alpha-project~main~Ialpha",
+            "_number": 4002,
+            "project": "alpha-project",
+            "branch": "main",
+            "subject": "Change in alpha",
+            "status": "NEW",
+            "change_id": "Ialpha",
+            "owner": {"_account_id": 5002, "name": "Amy"}
+          },
+          {
+            "id": "beta-project~main~Ibeta",
+            "_number": 4003,
+            "project": "beta-project",
+            "branch": "main",
+            "subject": "Change in beta",
+            "status": "NEW",
+            "change_id": "Ibeta",
+            "owner": {"_account_id": 5003, "name": "Ben"}
+          }
+        ]`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+    const program = incomingCommand({}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+
+    // Find positions of project names in output
+    const alphaPos = output.indexOf('alpha-project')
+    const betaPos = output.indexOf('beta-project')
+    const zebraPos = output.indexOf('zebra-project')
+
+    // Verify alphabetical order
+    expect(alphaPos).toBeLessThan(betaPos)
+    expect(betaPos).toBeLessThan(zebraPos)
+  })
+})

package/tests/init.test.ts

@@ -0,0 +1,70 @@
+import { describe, test, expect } from 'bun:test'
+
+describe('Init Command', () => {
+  describe('token obscuring', () => {
+    test('should obscure short tokens', () => {
+      const obscureToken = (token: string): string => {
+        if (token.length <= 8) return '****'
+        return `${token.substring(0, 4)}****${token.substring(token.length - 4)}`
+      }
+
+      expect(obscureToken('1234')).toBe('****')
+    })
+
+    test('should obscure long tokens', () => {
+      const obscureToken = (token: string): string => {
+        if (token.length <= 8) return '****'
+        return `${token.substring(0, 4)}****${token.substring(token.length - 4)}`
+      }
+
+      expect(obscureToken('verylongpassword123456')).toBe('very****3456')
+    })
+  })
+
+  describe('URL normalization', () => {
+    test('should remove trailing slashes', () => {
+      const url = 'https://gerrit.example.com/'
+      const normalized = url.replace(/\/$/, '')
+      expect(normalized).toBe('https://gerrit.example.com')
+    })
+  })
+
+  describe('input validation', () => {
+    test('should require non-empty host', () => {
+      const host = ''
+      expect(host).toBeFalsy()
+    })
+
+    test('should require non-empty username', () => {
+      const username = ''
+      expect(username).toBeFalsy()
+    })
+
+    test('should require non-empty password', () => {
+      const password = ''
+      expect(password).toBeFalsy()
+    })
+  })
+
+  describe('control characters', () => {
+    test('should handle Ctrl+C', () => {
+      const charCode = '\x03'.charCodeAt(0) // Ctrl+C
+      expect(charCode).toBe(3)
+    })
+
+    test('should handle Enter key', () => {
+      const charCode = '\r'.charCodeAt(0) // Enter
+      expect(charCode).toBe(13)
+    })
+
+    test('should handle backspace', () => {
+      const charCode = '\x7f'.charCodeAt(0) // Backspace
+      expect(charCode).toBe(127)
+    })
+
+    test('should filter printable characters', () => {
+      const charCode = 'a'.charCodeAt(0)
+      expect(charCode >= 32 && charCode <= 126).toBe(true)
+    })
+  })
+})

package/tests/integration/commit-hook.test.ts

@@ -0,0 +1,246 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { ConfigService } from '@/services/config'
+import { CommitHookService, CommitHookServiceLive } from '@/services/commit-hook'
+import { createMockConfigService } from '../helpers/config-mock'
+
+// Sample valid commit-msg hook script
+const VALID_HOOK_SCRIPT = `#!/bin/sh
+# From Gerrit Code Review 3.x
+#
+# Part of Gerrit Code Review (https://www.gerritcodereview.com/)
+
+# Add a Change-Id line to commit messages that don't have one
+add_change_id() {
+  # ... hook implementation
+  echo "Change-Id: I$(git hash-object -t blob /dev/null)"
+}
+
+add_change_id
+`
+
+// Create MSW server for hook download tests
+const server = setupServer()
+
+describe('CommitHookService Integration Tests', () => {
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  describe('installHook', () => {
+    test('should successfully download hook from Gerrit server', async () => {
+      // Setup handler for successful hook download
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          return HttpResponse.text(VALID_HOOK_SCRIPT, { status: 200 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      // Note: We can't fully test installHook without git repo context,
+      // but we can verify the HTTP request is made correctly
+      const effect = Effect.gen(function* () {
+        const service = yield* CommitHookService
+        yield* service.installHook()
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(mockConfigLayer))
+
+      // Run with Effect.exit to capture the result without throwing
+      const exit = await Effect.runPromiseExit(effect)
+
+      // The test verifies the service can be constructed and HTTP fetch succeeds
+      // It will fail with NotGitRepoError because we're not in a git repo,
+      // but it should NOT fail due to HTTP issues
+      if (exit._tag === 'Failure') {
+        const errorStr = String(exit.cause)
+        // Should fail due to git repo issues, not HTTP issues
+        expect(errorStr).not.toContain('Failed to download')
+        expect(errorStr).not.toContain('fetch')
+      }
+    })
+
+    test('should handle 404 error when hook URL is not found', async () => {
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          return HttpResponse.text('Not Found', { status: 404 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      const effect = Effect.gen(function* () {
+        const service = yield* CommitHookService
+        yield* service.installHook()
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(mockConfigLayer))
+
+      const result = await Effect.runPromise(effect).catch((e) => e)
+
+      // Should fail with HookInstallError due to 404
+      expect(result).toBeInstanceOf(Error)
+      expect(String(result)).toContain('Failed to download')
+    })
+
+    test('should handle 500 server error gracefully', async () => {
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          return HttpResponse.text('Internal Server Error', { status: 500 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      const effect = Effect.gen(function* () {
+        const service = yield* CommitHookService
+        yield* service.installHook()
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(mockConfigLayer))
+
+      const result = await Effect.runPromise(effect).catch((e) => e)
+
+      expect(result).toBeInstanceOf(Error)
+      expect(String(result)).toContain('Failed to download')
+    })
+
+    test('should reject invalid hook content (not a script)', async () => {
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          // Return HTML instead of shell script
+          return HttpResponse.text('<html><body>Error page</body></html>', { status: 200 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      const effect = Effect.gen(function* () {
+        const service = yield* CommitHookService
+        yield* service.installHook()
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(mockConfigLayer))
+
+      const result = await Effect.runPromise(effect).catch((e) => e)
+
+      expect(result).toBeInstanceOf(Error)
+      expect(String(result)).toContain('valid script')
+    })
+
+    test('should handle network timeout', async () => {
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', async () => {
+          // Simulate network delay that would cause timeout
+          await new Promise((resolve) => setTimeout(resolve, 100))
+          return HttpResponse.error()
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      const effect = Effect.gen(function* () {
+        const service = yield* CommitHookService
+        yield* service.installHook()
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(mockConfigLayer))
+
+      const result = await Effect.runPromise(effect).catch((e) => e)
+
+      expect(result).toBeInstanceOf(Error)
+    })
+
+    test('should handle host with trailing slash', async () => {
+      // Use a host with trailing slash
+      const configWithTrailingSlash = createMockConfigService({
+        host: 'https://test.gerrit.com/',
+        username: 'testuser',
+        password: 'testpass',
+      })
+
+      server.use(
+        // The trailing slash should be normalized, so this handler should match
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          return HttpResponse.text(VALID_HOOK_SCRIPT, { status: 200 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, configWithTrailingSlash)
+
+      const effect = Effect.gen(function* () {
+        const service = yield* CommitHookService
+        yield* service.installHook()
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(mockConfigLayer))
+
+      // Should not fail due to double slash in URL
+      await Effect.runPromise(effect).catch((e) => {
+        // May fail for git repo reasons, but should not fail for URL issues
+        expect(String(e)).not.toContain('//tools')
+      })
+    })
+  })
+
+  describe('hook script validation', () => {
+    test('should accept sh shebang', async () => {
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          return HttpResponse.text('#!/bin/sh\necho "hook"', { status: 200 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      const effect = Effect.gen(function* () {
+        const service = yield* CommitHookService
+        yield* service.installHook()
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(mockConfigLayer))
+
+      const result = await Effect.runPromise(effect).catch((e) => e)
+
+      // Should not fail with "not a valid script" error
+      expect(String(result)).not.toContain('valid script')
+    })
+
+    test('should accept bash shebang', async () => {
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          return HttpResponse.text('#!/bin/bash\necho "hook"', { status: 200 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      const effect = Effect.gen(function* () {
+        const service = yield* CommitHookService
+        yield* service.installHook()
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(mockConfigLayer))
+
+      const result = await Effect.runPromise(effect).catch((e) => e)
+
+      // Should not fail with "not a valid script" error
+      expect(String(result)).not.toContain('valid script')
+    })
+
+    test('should accept env shebang', async () => {
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          return HttpResponse.text('#!/usr/bin/env sh\necho "hook"', { status: 200 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      const effect = Effect.gen(function* () {
+        const service = yield* CommitHookService
+        yield* service.installHook()
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(mockConfigLayer))
+
+      const result = await Effect.runPromise(effect).catch((e) => e)
+
+      // Should not fail with "not a valid script" error
+      expect(String(result)).not.toContain('valid script')
+    })
+  })
+})