@aaronshaf/ger 3.0.2 → 4.0.1

package/tests/tree.test.ts

@@ -0,0 +1,517 @@
+import { describe, test, expect, mock, beforeEach, beforeAll, afterAll, afterEach } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+
+// --- fs / child_process mocks ---
+
+const mockExecSyncImpl = mock((..._args: unknown[]): string => '')
+const mockSpawnSyncImpl = mock((..._args: unknown[]): { status: number; stderr: string } => ({
+  status: 0,
+  stderr: '',
+}))
+const mockExistsSync = mock((..._args: unknown[]): boolean => false)
+const mockMkdirSync = mock((..._args: unknown[]) => undefined)
+const mockReaddirSync = mock((..._args: unknown[]): string[] => [])
+const mockStatSync = mock((..._args: unknown[]) => ({ isDirectory: () => true }))
+
+mock.module('node:child_process', () => ({
+  execSync: mockExecSyncImpl,
+  spawnSync: mockSpawnSyncImpl,
+}))
+mock.module('node:fs', () => ({
+  existsSync: mockExistsSync,
+  mkdirSync: mockMkdirSync,
+  readdirSync: mockReaddirSync,
+  statSync: mockStatSync,
+}))
+
+const inGitRepo = () => {
+  mockExecSyncImpl.mockImplementation((...args: unknown[]): string => {
+    const cmd = args[0] as string
+    if (cmd === 'git rev-parse --git-dir') return '.git'
+    if (cmd === 'git rev-parse --show-toplevel') return '/repo/root'
+    if (cmd === 'git remote -v') return 'origin\thttps://test.gerrit.com/project\t(fetch)\n'
+    return ''
+  })
+}
+
+// --- MSW server for Gerrit API calls ---
+
+const server = setupServer(
+  http.get('*/a/changes/:changeId', () =>
+    HttpResponse.json({
+      id: 'test~master~I123',
+      _number: 12345,
+      change_id: 'I123',
+      project: 'test',
+      branch: 'master',
+      subject: 'Test change',
+      status: 'NEW',
+      created: '2024-01-01 10:00:00.000000000',
+      updated: '2024-01-01 12:00:00.000000000',
+      owner: { _account_id: 1, name: 'User', email: 'u@example.com' },
+      labels: {},
+      work_in_progress: false,
+      submittable: false,
+    }),
+  ),
+  http.get('*/a/changes/:changeId/revisions/:rev/review', () =>
+    HttpResponse.json({ ref: 'refs/changes/45/12345/1', commit: { message: '' } }),
+  ),
+  http.get('*/a/accounts/self', () =>
+    HttpResponse.json({ _account_id: 1, name: 'User', email: 'u@example.com' }),
+  ),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }))
+afterAll(() => server.close())
+
+// ============================================================
+// tree-setup
+// ============================================================
+
+describe('tree-setup', () => {
+  beforeEach(() => {
+    mockExecSyncImpl.mockReset()
+    mockSpawnSyncImpl.mockReset()
+    mockExistsSync.mockReturnValue(false)
+    mockMkdirSync.mockReset()
+  })
+
+  afterEach(() => server.resetHandlers())
+
+  test('exports treeSetupCommand', async () => {
+    const { treeSetupCommand } = await import('@/cli/commands/tree-setup')
+    expect(typeof treeSetupCommand).toBe('function')
+  })
+
+  test('throws when not in a git repo', async () => {
+    const { treeSetupCommand } = await import('@/cli/commands/tree-setup')
+    mockExecSyncImpl.mockImplementation(() => {
+      throw new Error('not a git repo')
+    })
+
+    const mockConfig = createMockConfigService()
+    let threw = false
+    try {
+      await Effect.runPromise(
+        treeSetupCommand('12345', {}).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } catch {
+      threw = true
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('outputs JSON on success', async () => {
+    const { treeSetupCommand } = await import('@/cli/commands/tree-setup')
+    inGitRepo()
+    mockSpawnSyncImpl.mockReturnValue({ status: 0, stderr: '' })
+
+    server.use(
+      http.get('*/a/changes/:changeId/revisions/current/review', () =>
+        HttpResponse.json({
+          ref: 'refs/changes/45/12345/1',
+          commit: { message: 'Test' },
+        }),
+      ),
+    )
+
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (msg: string) => logs.push(msg)
+
+    const mockConfig = createMockConfigService()
+    try {
+      await Effect.runPromise(
+        treeSetupCommand('12345', { json: true }).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } catch {
+      // may fail due to MSW/API; just check function is callable
+    } finally {
+      console.log = originalLog
+    }
+  })
+})
+
+// ============================================================
+// trees
+// ============================================================
+
+describe('trees', () => {
+  beforeEach(() => {
+    mockExecSyncImpl.mockReset()
+    mockSpawnSyncImpl.mockReset()
+  })
+
+  test('throws when not in a git repo', async () => {
+    const { treesCommand } = await import('@/cli/commands/trees')
+    mockExecSyncImpl.mockImplementation(() => {
+      throw new Error('not a git repo')
+    })
+
+    let threw = false
+    try {
+      await Effect.runPromise(treesCommand({}))
+    } catch {
+      threw = true
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('parses porcelain worktree output', () => {
+    const sample = [
+      'worktree /repo/root',
+      'HEAD abc1234',
+      'branch refs/heads/main',
+      '',
+      'worktree /repo/root/.ger/12345',
+      'HEAD def5678',
+      'detached',
+    ].join('\n')
+
+    const blocks = sample.trim().split('\n\n')
+    expect(blocks).toHaveLength(2)
+
+    const second = blocks[1].split('\n')
+    expect(second.some((l) => l === 'detached')).toBe(true)
+    expect(second.find((l) => l.startsWith('worktree '))?.includes('.ger')).toBe(true)
+  })
+
+  test('succeeds with empty ger-managed list', async () => {
+    const { treesCommand } = await import('@/cli/commands/trees')
+    mockExecSyncImpl.mockImplementation((...args: unknown[]): string => {
+      const cmd = args[0] as string
+      if (cmd === 'git rev-parse --git-dir') return '.git'
+      if (cmd === 'git worktree list --porcelain') {
+        return 'worktree /repo/root\nHEAD abc1234\nbranch refs/heads/main\n'
+      }
+      return ''
+    })
+
+    // No ger-managed worktrees — should succeed without throwing
+    await Effect.runPromise(treesCommand({}))
+  })
+
+  test('outputs JSON with ger-managed worktree', async () => {
+    const { treesCommand } = await import('@/cli/commands/trees')
+    mockExecSyncImpl.mockImplementation((...args: unknown[]): string => {
+      const cmd = args[0] as string
+      if (cmd === 'git rev-parse --git-dir') return '.git'
+      if (cmd === 'git worktree list --porcelain') {
+        return 'worktree /repo/root/.ger/12345\nHEAD abc1234\ndetached\n'
+      }
+      return ''
+    })
+
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (msg: string) => logs.push(msg)
+    await Effect.runPromise(treesCommand({ json: true }))
+    console.log = originalLog
+
+    const parsed = JSON.parse(logs[0]) as { status: string; worktrees: unknown[] }
+    expect(parsed.status).toBe('success')
+    expect(parsed.worktrees).toHaveLength(1)
+  })
+})
+
+// ============================================================
+// tree-cleanup
+// ============================================================
+
+describe('tree-cleanup', () => {
+  beforeEach(() => {
+    mockExecSyncImpl.mockReset()
+    mockSpawnSyncImpl.mockReset()
+    mockExistsSync.mockReturnValue(false)
+    mockReaddirSync.mockReturnValue([])
+  })
+
+  test('throws when not in a git repo', async () => {
+    const { treeCleanupCommand } = await import('@/cli/commands/tree-cleanup')
+    mockExecSyncImpl.mockImplementation(() => {
+      throw new Error('not a git repo')
+    })
+
+    let threw = false
+    try {
+      await Effect.runPromise(treeCleanupCommand(undefined, {}))
+    } catch {
+      threw = true
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('throws when specific changeId worktree does not exist', async () => {
+    const { treeCleanupCommand } = await import('@/cli/commands/tree-cleanup')
+    inGitRepo()
+    mockExistsSync.mockReturnValue(false)
+
+    let threw = false
+    try {
+      await Effect.runPromise(treeCleanupCommand('12345', {}))
+    } catch (e) {
+      threw = true
+      expect(String(e)).toContain('No worktree found')
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('succeeds with no ger worktrees to clean', async () => {
+    const { treeCleanupCommand } = await import('@/cli/commands/tree-cleanup')
+    inGitRepo()
+    mockExistsSync.mockReturnValue(false)
+
+    await Effect.runPromise(treeCleanupCommand(undefined, {}))
+  })
+
+  test('removes worktree successfully', async () => {
+    const { treeCleanupCommand } = await import('@/cli/commands/tree-cleanup')
+    inGitRepo()
+
+    mockExistsSync.mockImplementation((...args: unknown[]): boolean => {
+      const p = args[0] as string
+      return p.includes('.ger')
+    })
+    mockReaddirSync.mockReturnValue(['12345'])
+    mockStatSync.mockReturnValue({ isDirectory: () => true })
+    mockSpawnSyncImpl.mockReturnValue({ status: 0, stderr: '' })
+
+    await Effect.runPromise(treeCleanupCommand(undefined, { json: true }))
+    expect(mockSpawnSyncImpl).toHaveBeenCalledWith(
+      'git',
+      expect.arrayContaining(['worktree', 'remove']),
+      expect.anything(),
+    )
+  })
+
+  test('rejects path traversal in change ID', async () => {
+    const { treeCleanupCommand } = await import('@/cli/commands/tree-cleanup')
+    inGitRepo()
+
+    let threw = false
+    try {
+      await Effect.runPromise(treeCleanupCommand('../evil', {}))
+    } catch (e) {
+      threw = true
+      expect(String(e)).toContain('Invalid change ID')
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('rejects mixed alphanumeric change ID', async () => {
+    const { treeCleanupCommand } = await import('@/cli/commands/tree-cleanup')
+    inGitRepo()
+
+    let threw = false
+    try {
+      await Effect.runPromise(treeCleanupCommand('123abc', {}))
+    } catch (e) {
+      threw = true
+      expect(String(e)).toContain('Invalid change ID')
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('does NOT force-remove when --force is omitted', async () => {
+    const { treeCleanupCommand } = await import('@/cli/commands/tree-cleanup')
+    inGitRepo()
+
+    mockExistsSync.mockImplementation((...args: unknown[]): boolean => {
+      const p = args[0] as string
+      return p.includes('.ger')
+    })
+    mockReaddirSync.mockReturnValue(['12345'])
+    mockStatSync.mockReturnValue({ isDirectory: () => true })
+    // Simulate dirty worktree: git worktree remove fails without --force
+    mockSpawnSyncImpl.mockReturnValue({ status: 1, stderr: 'has modifications' })
+
+    await Effect.runPromise(treeCleanupCommand(undefined, {}))
+
+    // Should have called worktree remove WITHOUT --force
+    const calls = mockSpawnSyncImpl.mock.calls as unknown[][]
+    const removeCalls = calls.filter(
+      (c) => Array.isArray(c[1]) && (c[1] as string[]).includes('remove'),
+    )
+    expect(removeCalls.length).toBeGreaterThan(0)
+    for (const call of removeCalls) {
+      expect((call[1] as string[]).includes('--force')).toBe(false)
+    }
+  })
+})
+
+// ============================================================
+// tree-rebase
+// ============================================================
+
+describe('tree-rebase', () => {
+  const mockConfig = createMockConfigService()
+  const originalCwd = process.cwd()
+
+  beforeEach(() => {
+    mockExecSyncImpl.mockReset()
+    mockSpawnSyncImpl.mockReset()
+  })
+
+  afterEach(() => {
+    // Restore cwd in case a test changed it
+    try {
+      process.chdir(originalCwd)
+    } catch {
+      // ignore
+    }
+  })
+
+  const inGerWorktree = () => {
+    mockExecSyncImpl.mockImplementation((...args: unknown[]): string => {
+      const cmd = args[0] as string
+      if (cmd === 'git rev-parse --git-dir') return '.git'
+      // Return a path that looks like a ger worktree
+      if (cmd === 'git rev-parse --show-toplevel') return '/repo/root'
+      if (cmd === 'git remote -v') return 'origin\thttps://test.gerrit.com/project\t(fetch)\n'
+      return ''
+    })
+    // Simulate cwd being inside a ger worktree
+    jest_spyOn_cwd('/repo/root/.ger/12345')
+  }
+
+  // Helper to mock process.cwd()
+  const jest_spyOn_cwd = (fakeCwd: string) => {
+    const original = process.cwd.bind(process)
+    process.cwd = () => fakeCwd
+    return () => {
+      process.cwd = original
+    }
+  }
+
+  test('throws when not in a git repo', async () => {
+    const { treeRebaseCommand } = await import('@/cli/commands/tree-rebase')
+    mockExecSyncImpl.mockImplementation(() => {
+      throw new Error('not a git repo')
+    })
+
+    let threw = false
+    try {
+      await Effect.runPromise(
+        treeRebaseCommand({}).pipe(Effect.provide(Layer.succeed(ConfigService, mockConfig))),
+      )
+    } catch {
+      threw = true
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('throws when not inside a ger worktree', async () => {
+    const { treeRebaseCommand } = await import('@/cli/commands/tree-rebase')
+    // Git repo, but cwd is the repo root (not a .ger worktree)
+    mockExecSyncImpl.mockImplementation((...args: unknown[]): string => {
+      const cmd = args[0] as string
+      if (cmd === 'git rev-parse --git-dir') return '.git'
+      if (cmd === 'git rev-parse --show-toplevel') return '/repo/root'
+      return ''
+    })
+    process.cwd = () => '/repo/root'
+
+    let threw = false
+    try {
+      await Effect.runPromise(
+        treeRebaseCommand({ onto: 'origin/main' }).pipe(
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } catch (e) {
+      threw = true
+      expect(String(e)).toContain('ger-managed worktree')
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('throws when fetch fails', async () => {
+    const { treeRebaseCommand } = await import('@/cli/commands/tree-rebase')
+    inGerWorktree()
+    mockSpawnSyncImpl.mockReturnValue({ status: 1, stderr: 'network error' })
+
+    let threw = false
+    try {
+      await Effect.runPromise(
+        treeRebaseCommand({ onto: 'origin/main' }).pipe(
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } catch (e) {
+      threw = true
+      expect(String(e)).toContain('Failed to fetch')
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('throws when rebase fails', async () => {
+    const { treeRebaseCommand } = await import('@/cli/commands/tree-rebase')
+    inGerWorktree()
+    mockSpawnSyncImpl
+      .mockReturnValueOnce({ status: 0, stderr: '' }) // fetch
+      .mockReturnValueOnce({ status: 1, stderr: 'conflict' }) // rebase
+
+    let threw = false
+    try {
+      await Effect.runPromise(
+        treeRebaseCommand({ onto: 'origin/main' }).pipe(
+          Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+        ),
+      )
+    } catch (e) {
+      threw = true
+      expect(String(e)).toContain('Rebase failed')
+    }
+    expect(threw).toBe(true)
+  })
+
+  test('succeeds and outputs JSON', async () => {
+    const { treeRebaseCommand } = await import('@/cli/commands/tree-rebase')
+    inGerWorktree()
+    mockSpawnSyncImpl.mockReturnValue({ status: 0, stderr: '' })
+
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (msg: string) => logs.push(msg)
+    await Effect.runPromise(
+      treeRebaseCommand({ onto: 'origin/main', json: true }).pipe(
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+    console.log = originalLog
+
+    const parsed = JSON.parse(logs[0]) as { status: string; base: string }
+    expect(parsed.status).toBe('success')
+    expect(parsed.base).toBe('origin/main')
+  })
+
+  test('uses --onto option over auto-detect', async () => {
+    const { treeRebaseCommand } = await import('@/cli/commands/tree-rebase')
+    inGerWorktree()
+    mockSpawnSyncImpl.mockReturnValue({ status: 0, stderr: '' })
+
+    await Effect.runPromise(
+      treeRebaseCommand({ onto: 'origin/feature', json: true }).pipe(
+        Effect.provide(Layer.succeed(ConfigService, mockConfig)),
+      ),
+    )
+
+    expect(mockSpawnSyncImpl).toHaveBeenCalledWith(
+      'git',
+      ['rebase', 'origin/feature'],
+      expect.anything(),
+    )
+  })
+})

package/tests/update.test.ts

@@ -0,0 +1,86 @@
+import { describe, test, expect, mock, spyOn, afterEach } from 'bun:test'
+import { Effect } from 'effect'
+import * as childProcess from 'node:child_process'
+import { updateCommand } from '@/cli/commands/update'
+
+describe('update command', () => {
+  let execSpy: ReturnType<typeof spyOn>
+
+  afterEach(() => {
+    execSpy?.mockRestore()
+    global.fetch = fetch
+  })
+
+  test('skips install when already up to date', async () => {
+    execSpy = spyOn(childProcess, 'execSync').mockImplementation((() =>
+      Buffer.from('')) as unknown as typeof childProcess.execSync)
+    global.fetch = (async () => Response.json({ version: '0.0.0' })) as unknown as typeof fetch
+
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(updateCommand({}))
+    } finally {
+      console.log = origLog
+    }
+
+    expect(logs.join('\n')).toContain('Already up to date')
+    expect(execSpy.mock.calls.length).toBe(0)
+  })
+
+  test('runs bun install when newer version available', async () => {
+    execSpy = spyOn(childProcess, 'execSync').mockImplementation((() =>
+      Buffer.from('')) as unknown as typeof childProcess.execSync)
+    global.fetch = (async () => Response.json({ version: '999.0.0' })) as unknown as typeof fetch
+
+    const logs: string[] = []
+    const origLog = console.log
+    console.log = (...args: unknown[]) => logs.push(String(args[0]))
+
+    try {
+      await Effect.runPromise(updateCommand({}))
+    } finally {
+      console.log = origLog
+    }
+
+    const calls = (execSpy.mock.calls as unknown as [string][]).map(([c]) => c)
+    expect(calls.some((c) => c.includes('bun install -g') && c.includes('@aaronshaf/ger'))).toBe(
+      true,
+    )
+    expect(logs.join('\n')).toContain('updated successfully')
+  })
+
+  test('--skip-pull installs without version check', async () => {
+    execSpy = spyOn(childProcess, 'execSync').mockImplementation((() =>
+      Buffer.from('')) as unknown as typeof childProcess.execSync)
+    const fetchSpy = mock(async () => Response.json({ version: '999.0.0' }))
+    global.fetch = fetchSpy as unknown as typeof fetch
+
+    await Effect.runPromise(updateCommand({ skipPull: true }))
+
+    expect(fetchSpy.mock.calls.length).toBe(0)
+    const calls = (execSpy.mock.calls as unknown as [string][]).map(([c]) => c)
+    expect(calls.some((c) => c.includes('bun install -g'))).toBe(true)
+  })
+
+  test('fails when registry is unreachable', async () => {
+    global.fetch = (async () => {
+      throw new Error('network error')
+    }) as unknown as typeof fetch
+
+    const result = await Effect.runPromise(updateCommand({}).pipe(Effect.either))
+    expect(result._tag).toBe('Left')
+  })
+
+  test('fails when install command fails', async () => {
+    execSpy = spyOn(childProcess, 'execSync').mockImplementation((() => {
+      throw new Error('bun not found')
+    }) as unknown as typeof childProcess.execSync)
+    global.fetch = (async () => Response.json({ version: '999.0.0' })) as unknown as typeof fetch
+
+    const result = await Effect.runPromise(updateCommand({}).pipe(Effect.either))
+    expect(result._tag).toBe('Left')
+  })
+})