@aaronshaf/ger 1.2.10 → 2.0.0

package/tests/restore.test.ts

@@ -0,0 +1,237 @@
+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 { restoreCommand } from '@/cli/commands/restore'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+import type { ChangeInfo } from '@/schemas/gerrit'
+
+const mockChange: ChangeInfo = {
+  id: 'test-project~master~I123',
+  _number: 12345,
+  change_id: 'I123',
+  project: 'test-project',
+  branch: 'master',
+  subject: 'Test change to restore',
+  status: 'ABANDONED',
+  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: 0,
+    },
+    Verified: {
+      value: 0,
+    },
+  },
+  work_in_progress: false,
+  submittable: false,
+}
+
+const mockRestoredChange: ChangeInfo = {
+  ...mockChange,
+  status: 'NEW',
+}
+
+// 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('restore 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 restore a change with a message', async () => {
+    server.use(
+      http.post('*/a/changes/12345/restore', async ({ request }) => {
+        const body = (await request.json()) as { message?: string }
+        expect(body.message).toBe('Restoring this change')
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockRestoredChange)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = restoreCommand('12345', {
+      message: 'Restoring this change',
+    }).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('Restored change 12345')
+    expect(output).toContain('Test change to restore')
+    expect(output).toContain('Message: Restoring this change')
+  })
+
+  it('should restore a change without a message', async () => {
+    server.use(
+      http.post('*/a/changes/12345/restore', async ({ request }) => {
+        const body = (await request.json()) as { message?: string }
+        expect(body.message).toBeUndefined()
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockRestoredChange)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = restoreCommand('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('Restored change 12345')
+    expect(output).toContain('Test change to restore')
+    expect(output).not.toContain('Message:')
+  })
+
+  it('should output XML format when --xml flag is used', async () => {
+    server.use(
+      http.post('*/a/changes/12345/restore', async ({ request }) => {
+        const body = (await request.json()) as { message?: string }
+        expect(body.message).toBe('Restoring for testing')
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockRestoredChange)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = restoreCommand('12345', {
+      xml: true,
+      message: 'Restoring for testing',
+    }).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('<restore_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<change_number>12345</change_number>')
+    expect(output).toContain('<subject><![CDATA[Test change to restore]]></subject>')
+    expect(output).toContain('<message><![CDATA[Restoring for testing]]></message>')
+    expect(output).toContain('</restore_result>')
+  })
+
+  it('should output XML format without message when no message provided', async () => {
+    server.use(
+      http.post('*/a/changes/12345/restore', async () => {
+        return HttpResponse.text(`)]}'\n${JSON.stringify(mockRestoredChange)}`)
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = restoreCommand('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('<restore_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).not.toContain('<message>')
+  })
+
+  it('should handle not found errors gracefully', async () => {
+    server.use(
+      http.post('*/a/changes/99999/restore', () => {
+        return HttpResponse.text('Change not found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = restoreCommand('99999', {
+      message: 'Test message',
+    }).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 = restoreCommand(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 restore <change-id>')
+  })
+
+  it('should handle restore API failure', async () => {
+    server.use(
+      http.post('*/a/changes/12345/restore', () => {
+        return HttpResponse.text('Forbidden', { status: 403 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = restoreCommand('12345', {
+      message: 'Test',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should handle changes that are already active', async () => {
+    server.use(
+      http.post('*/a/changes/12345/restore', () => {
+        return HttpResponse.text('Change is already active', { status: 409 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = restoreCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+})

package/tests/review.test.ts

@@ -0,0 +1,135 @@
+import { describe, test, expect, beforeEach, afterEach, spyOn } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { GitWorktreeService, WorktreeCreationError } from '@/services/git-worktree'
+
+describe('Review Command - Focused Tests', () => {
+  let consoleSpy: any
+
+  beforeEach(() => {
+    consoleSpy = {
+      log: spyOn(console, 'log').mockImplementation(() => {}),
+      error: spyOn(console, 'error').mockImplementation(() => {}),
+    }
+  })
+
+  afterEach(() => {
+    consoleSpy.log.mockRestore()
+    consoleSpy.error.mockRestore()
+  })
+
+  test('should integrate GitWorktreeService with review workflow', async () => {
+    // Mock Git Worktree Service
+    const mockGitService = {
+      validatePreconditions: () => Effect.succeed(undefined),
+      createWorktree: (changeId: string) =>
+        Effect.succeed({
+          path: `/tmp/test-worktree-${changeId}`,
+          changeId,
+          originalCwd: '/test/current',
+          timestamp: Date.now(),
+          pid: process.pid,
+        }),
+      fetchAndCheckoutPatchset: () => Effect.succeed(undefined),
+      cleanup: () => Effect.succeed(undefined),
+      getChangedFiles: () => Effect.succeed(['src/main.ts', 'tests/main.test.ts']),
+    }
+
+    // Test the complete GitWorktreeService workflow
+    const result = await Effect.runPromise(
+      Effect.gen(function* () {
+        const service = yield* GitWorktreeService
+
+        // Test precondition validation
+        yield* service.validatePreconditions()
+
+        // Test worktree creation
+        const worktree = yield* service.createWorktree('12345')
+        expect(worktree.changeId).toBe('12345')
+        expect(worktree.path).toContain('12345')
+        expect(worktree.originalCwd).toBe('/test/current')
+
+        // Test patchset fetch
+        yield* service.fetchAndCheckoutPatchset(worktree)
+
+        // Test getting changed files
+        const files = yield* service.getChangedFiles()
+        expect(files).toEqual(['src/main.ts', 'tests/main.test.ts'])
+
+        // Test cleanup
+        yield* service.cleanup(worktree)
+
+        return { success: true, worktree, files }
+      }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockGitService))),
+    )
+
+    // Verify the workflow completed successfully
+    expect(result.success).toBe(true)
+    expect(result.worktree.path).toContain('12345')
+    expect(result.files).toHaveLength(2)
+    expect(result.files).toEqual(['src/main.ts', 'tests/main.test.ts'])
+  })
+
+  test('should handle concurrent worktree scenarios with unique paths', async () => {
+    const mockGitService = {
+      validatePreconditions: () => Effect.succeed(undefined),
+      createWorktree: (changeId: string) =>
+        Effect.succeed({
+          path: `/tmp/test-worktree-${changeId}-${Date.now()}-${process.pid}`,
+          changeId,
+          originalCwd: process.cwd(),
+          timestamp: Date.now(),
+          pid: process.pid,
+        }),
+      fetchAndCheckoutPatchset: () => Effect.succeed(undefined),
+      cleanup: () => Effect.succeed(undefined),
+      getChangedFiles: () => Effect.succeed(['test.ts']),
+    }
+
+    // Simulate concurrent worktree creation
+    const [result1, result2] = await Promise.all([
+      Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* GitWorktreeService
+          return yield* service.createWorktree('change-1')
+        }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockGitService))),
+      ),
+      Effect.runPromise(
+        Effect.gen(function* () {
+          const service = yield* GitWorktreeService
+          return yield* service.createWorktree('change-2')
+        }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockGitService))),
+      ),
+    ])
+
+    // Verify both worktrees have unique paths
+    expect(result1.path).not.toBe(result2.path)
+    expect(result1.changeId).toBe('change-1')
+    expect(result2.changeId).toBe('change-2')
+  })
+
+  test('should handle error scenarios in worktree operations', async () => {
+    const failingGitService = {
+      validatePreconditions: () =>
+        Effect.fail(new WorktreeCreationError({ message: 'Git repository validation failed' })),
+      createWorktree: () =>
+        Effect.fail(new WorktreeCreationError({ message: 'Worktree creation failed' })),
+      fetchAndCheckoutPatchset: () =>
+        Effect.fail(new WorktreeCreationError({ message: 'Patchset fetch failed' })),
+      cleanup: () => Effect.succeed(undefined), // Cleanup should never fail
+      getChangedFiles: () => Effect.fail(new WorktreeCreationError({ message: 'Git diff failed' })),
+    }
+
+    // Test validation failure
+    const validationResult = await Effect.runPromiseExit(
+      Effect.gen(function* () {
+        const service = yield* GitWorktreeService
+        yield* service.validatePreconditions()
+      }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, failingGitService))),
+    )
+
+    expect(validationResult._tag).toBe('Failure')
+    if (validationResult._tag === 'Failure') {
+      expect(String(validationResult.cause)).toContain('Git repository validation failed')
+    }
+  })
+})