@aaronshaf/ger 2.0.0 → 2.0.2

package/tests/topic.test.ts

@@ -0,0 +1,443 @@
+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 { topicCommand } from '@/cli/commands/topic'
+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('topic 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()
+  })
+
+  describe('get topic', () => {
+    it('should get topic when one is set', async () => {
+      server.use(
+        http.get('*/a/changes/12345/topic', () => {
+          return HttpResponse.text(`)]}'\n"my-feature"`)
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', undefined, {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      await Effect.runPromise(program)
+
+      const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+      expect(output).toBe('my-feature')
+    })
+
+    it('should show message when no topic is set', async () => {
+      server.use(
+        http.get('*/a/changes/12345/topic', () => {
+          return HttpResponse.text(`)]}'\n""`)
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', undefined, {}).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 topic set')
+    })
+
+    it('should output XML format for get topic', async () => {
+      server.use(
+        http.get('*/a/changes/12345/topic', () => {
+          return HttpResponse.text(`)]}'\n"my-feature"`)
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', undefined, { 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('<topic_result>')
+      expect(output).toContain('<status>success</status>')
+      expect(output).toContain('<action>get</action>')
+      expect(output).toContain('<change_id><![CDATA[12345]]></change_id>')
+      expect(output).toContain('<topic><![CDATA[my-feature]]></topic>')
+      expect(output).toContain('</topic_result>')
+    })
+
+    it('should output XML format when no topic is set', async () => {
+      server.use(
+        http.get('*/a/changes/12345/topic', () => {
+          return HttpResponse.text(`)]}'\n""`)
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', undefined, { 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('<topic />')
+    })
+  })
+
+  describe('set topic', () => {
+    it('should set topic on a change', async () => {
+      server.use(
+        http.put('*/a/changes/12345/topic', async ({ request }) => {
+          const body = await request.json()
+          expect(body).toEqual({ topic: 'my-feature' })
+          return HttpResponse.text(`)]}'\n"my-feature"`)
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', 'my-feature', {}).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('Set topic on change 12345: my-feature')
+    })
+
+    it('should output XML format for set topic', async () => {
+      server.use(
+        http.put('*/a/changes/12345/topic', () => {
+          return HttpResponse.text(`)]}'\n"release-v2"`)
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', 'release-v2', { 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('<topic_result>')
+      expect(output).toContain('<status>success</status>')
+      expect(output).toContain('<action>set</action>')
+      expect(output).toContain('<change_id><![CDATA[12345]]></change_id>')
+      expect(output).toContain('<topic><![CDATA[release-v2]]></topic>')
+      expect(output).toContain('</topic_result>')
+    })
+
+    it('should handle topic with special XML characters', async () => {
+      // Use a topic with XML special chars but no quotes to avoid JSON parsing issues
+      const specialTopic = '<script>alert(1)</script>'
+      server.use(
+        http.put('*/a/changes/12345/topic', () => {
+          // The server echoes the topic back as a quoted JSON string
+          return HttpResponse.text(`)]}'\n"<script>alert(1)</script>"`)
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', specialTopic, { xml: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      await Effect.runPromise(program)
+
+      const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+      // Should be properly wrapped in CDATA
+      expect(output).toContain('<topic><![CDATA[')
+      expect(output).toContain('<script>alert(1)</script>')
+      expect(output).toContain('</topic_result>')
+    })
+
+    it('should handle topic containing CDATA end sequence', async () => {
+      const cdataEndTopic = 'my-feature]]>injection'
+      server.use(
+        http.put('*/a/changes/12345/topic', () => {
+          // Server returns the topic with the CDATA end sequence
+          return HttpResponse.text(`)]}'\n"my-feature]]>injection"`)
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', cdataEndTopic, { xml: true }).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      await Effect.runPromise(program)
+
+      const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+      // The CDATA end sequence should be sanitized by replacing ]]> with ]]&gt;
+      expect(output).toContain('<status>success</status>')
+      // sanitizeCDATA replaces ]]> with ]]&gt; to prevent CDATA injection
+      expect(output).toContain(']]&gt;')
+      // The raw ]]> in the topic content should NOT appear (only the escaped version)
+      expect(output).not.toContain('my-feature]]>injection')
+    })
+  })
+
+  describe('delete topic', () => {
+    it('should delete topic from a change', async () => {
+      server.use(
+        http.delete('*/a/changes/12345/topic', () => {
+          return new HttpResponse(null, { status: 204 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', undefined, { delete: 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('Removed topic from change 12345')
+    })
+
+    it('should output XML format for delete topic', async () => {
+      server.use(
+        http.delete('*/a/changes/12345/topic', () => {
+          return new HttpResponse(null, { status: 204 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', undefined, { delete: true, 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('<topic_result>')
+      expect(output).toContain('<status>success</status>')
+      expect(output).toContain('<action>deleted</action>')
+      expect(output).toContain('<change_id><![CDATA[12345]]></change_id>')
+      expect(output).toContain('</topic_result>')
+    })
+
+    it('should handle deleting non-existent topic', async () => {
+      // Gerrit returns 204 even if there was no topic
+      server.use(
+        http.delete('*/a/changes/12345/topic', () => {
+          return new HttpResponse(null, { status: 204 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', undefined, { delete: 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('Removed topic from change 12345')
+    })
+
+    it('should prioritize --delete over topic argument', async () => {
+      // When both --delete and topic are provided, delete should take precedence
+      server.use(
+        http.delete('*/a/changes/12345/topic', () => {
+          return new HttpResponse(null, { status: 204 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', 'ignored-topic', { delete: 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('Removed topic from change 12345')
+    })
+  })
+
+  describe('error handling', () => {
+    it('should fail when change ID is not provided and not in git repo', async () => {
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand(undefined, undefined, {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      // Should throw because we can't auto-detect from HEAD outside a git repo
+      await expect(Effect.runPromise(program)).rejects.toThrow()
+    })
+
+    it('should fail when empty string change ID is provided and not in git repo', async () => {
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('', undefined, {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      // Should throw because empty string triggers auto-detect which fails outside git repo
+      await expect(Effect.runPromise(program)).rejects.toThrow()
+    })
+
+    it('should fail when whitespace-only change ID is provided and not in git repo', async () => {
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('   ', undefined, {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      // Should throw because whitespace-only triggers auto-detect which fails outside git repo
+      await expect(Effect.runPromise(program)).rejects.toThrow()
+    })
+
+    it('should handle 404 not found error', async () => {
+      server.use(
+        http.get('*/a/changes/99999/topic', () => {
+          return HttpResponse.text('Change not found', { status: 404 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('99999', undefined, {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      await Effect.runPromise(program)
+
+      // 404 for topic endpoint means no topic set, not an error
+      const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+      expect(output).toContain('No topic set')
+    })
+
+    it('should handle 403 forbidden error for set', async () => {
+      server.use(
+        http.put('*/a/changes/12345/topic', () => {
+          return HttpResponse.text('Forbidden', { status: 403 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', 'my-topic', {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      // Should throw/fail
+      await expect(Effect.runPromise(program)).rejects.toThrow()
+    })
+
+    it('should handle 403 forbidden error for delete', async () => {
+      server.use(
+        http.delete('*/a/changes/12345/topic', () => {
+          return HttpResponse.text('Forbidden', { status: 403 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', undefined, { delete: true }).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/topic', () => {
+          return HttpResponse.error()
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('12345', undefined, {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      // Should throw/fail
+      await expect(Effect.runPromise(program)).rejects.toThrow()
+    })
+  })
+
+  describe('Change-ID format support', () => {
+    it('should work with Change-ID format', async () => {
+      server.use(
+        http.get('*/a/changes/If5a3ae8cb5a107e187447802358417f311d0c4b1/topic', () => {
+          return HttpResponse.text(`)]}'\n"feature-branch"`)
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const program = topicCommand('If5a3ae8cb5a107e187447802358417f311d0c4b1', undefined, {}).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      await Effect.runPromise(program)
+
+      const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+      expect(output).toBe('feature-branch')
+    })
+  })
+})

package/tests/unit/commands/install-hook.test.ts

@@ -0,0 +1,258 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from 'bun:test'
+import { Effect, Layer, Exit } from 'effect'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { installHookCommand } from '@/cli/commands/install-hook'
+import { ConfigService } from '@/services/config'
+import { CommitHookService, CommitHookServiceLive } from '@/services/commit-hook'
+import { createMockConfigService } from '../../helpers/config-mock'
+
+// Create MSW server for hook download tests
+const server = setupServer()
+
+// Helper to create mock commit hook service with configurable hasHook
+const createMockCommitHookService = (hookExists: boolean) => ({
+  hasHook: () => Effect.succeed(hookExists),
+  hasChangeId: () => Effect.succeed(true),
+  installHook: () => Effect.void,
+  ensureChangeId: () => Effect.void,
+  amendWithChangeId: () => Effect.void,
+})
+
+describe('install-hook Command', () => {
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  describe('when hook does not exist', () => {
+    test('should call installHook when no hook exists', async () => {
+      let installHookCalled = false
+      const mockService = {
+        hasHook: () => Effect.succeed(false),
+        hasChangeId: () => Effect.succeed(true),
+        installHook: () => {
+          installHookCalled = true
+          return Effect.void
+        },
+        ensureChangeId: () => Effect.void,
+        amendWithChangeId: () => Effect.void,
+      }
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const mockHookLayer = Layer.succeed(CommitHookService, mockService)
+
+      const effect = installHookCommand({}).pipe(
+        Effect.provide(mockHookLayer),
+        Effect.provide(mockConfigLayer),
+      )
+
+      const exit = await Effect.runPromiseExit(effect)
+
+      expect(Exit.isSuccess(exit)).toBe(true)
+      expect(installHookCalled).toBe(true)
+    })
+
+    test('should succeed with XML output when no hook exists', async () => {
+      const mockService = createMockCommitHookService(false)
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const mockHookLayer = Layer.succeed(CommitHookService, mockService)
+
+      const effect = installHookCommand({ xml: true }).pipe(
+        Effect.provide(mockHookLayer),
+        Effect.provide(mockConfigLayer),
+      )
+
+      const exit = await Effect.runPromiseExit(effect)
+
+      expect(Exit.isSuccess(exit)).toBe(true)
+    })
+  })
+
+  describe('when hook already exists', () => {
+    test('should skip installation without --force and return success', async () => {
+      let installHookCalled = false
+      const mockService = {
+        hasHook: () => Effect.succeed(true),
+        hasChangeId: () => Effect.succeed(true),
+        installHook: () => {
+          installHookCalled = true
+          return Effect.void
+        },
+        ensureChangeId: () => Effect.void,
+        amendWithChangeId: () => Effect.void,
+      }
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const mockHookLayer = Layer.succeed(CommitHookService, mockService)
+
+      const effect = installHookCommand({}).pipe(
+        Effect.provide(mockHookLayer),
+        Effect.provide(mockConfigLayer),
+      )
+
+      const exit = await Effect.runPromiseExit(effect)
+
+      expect(Exit.isSuccess(exit)).toBe(true)
+      expect(installHookCalled).toBe(false) // Should NOT call installHook
+    })
+
+    test('should skip installation and succeed with XML output', async () => {
+      const mockService = createMockCommitHookService(true)
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const mockHookLayer = Layer.succeed(CommitHookService, mockService)
+
+      const effect = installHookCommand({ xml: true }).pipe(
+        Effect.provide(mockHookLayer),
+        Effect.provide(mockConfigLayer),
+      )
+
+      const exit = await Effect.runPromiseExit(effect)
+
+      expect(Exit.isSuccess(exit)).toBe(true)
+    })
+
+    test('should reinstall with --force flag', async () => {
+      let installHookCalled = false
+      const mockService = {
+        hasHook: () => Effect.succeed(true),
+        hasChangeId: () => Effect.succeed(true),
+        installHook: () => {
+          installHookCalled = true
+          return Effect.void
+        },
+        ensureChangeId: () => Effect.void,
+        amendWithChangeId: () => Effect.void,
+      }
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const mockHookLayer = Layer.succeed(CommitHookService, mockService)
+
+      const effect = installHookCommand({ force: true }).pipe(
+        Effect.provide(mockHookLayer),
+        Effect.provide(mockConfigLayer),
+      )
+
+      const exit = await Effect.runPromiseExit(effect)
+
+      expect(Exit.isSuccess(exit)).toBe(true)
+      expect(installHookCalled).toBe(true) // Should call installHook with --force
+    })
+  })
+
+  describe('error handling with real service', () => {
+    test('should handle HTTP 404 error', 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 = installHookCommand({ force: true }).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 handle HTTP 500 error', 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 = installHookCommand({ force: true }).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 handle invalid script content', async () => {
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          return HttpResponse.text('<html>Error</html>', { status: 200 })
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      const effect = installHookCommand({ force: true }).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 error', async () => {
+      server.use(
+        http.get('https://test.gerrit.com/tools/hooks/commit-msg', () => {
+          return HttpResponse.error()
+        }),
+      )
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+
+      const effect = installHookCommand({ force: true }).pipe(
+        Effect.provide(CommitHookServiceLive),
+        Effect.provide(mockConfigLayer),
+      )
+
+      const result = await Effect.runPromise(effect).catch((e) => e)
+
+      expect(result).toBeInstanceOf(Error)
+    })
+  })
+
+  describe('service integration', () => {
+    test('should use hasHook from service, not direct function call', async () => {
+      let hasHookCalled = false
+      const mockService = {
+        hasHook: () => {
+          hasHookCalled = true
+          return Effect.succeed(false)
+        },
+        hasChangeId: () => Effect.succeed(true),
+        installHook: () => Effect.void,
+        ensureChangeId: () => Effect.void,
+        amendWithChangeId: () => Effect.void,
+      }
+
+      const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+      const mockHookLayer = Layer.succeed(CommitHookService, mockService)
+
+      const effect = installHookCommand({}).pipe(
+        Effect.provide(mockHookLayer),
+        Effect.provide(mockConfigLayer),
+      )
+
+      await Effect.runPromiseExit(effect)
+
+      expect(hasHookCalled).toBe(true)
+    })
+  })
+})