@sushanglewis/lincoln 1.5.0 → 1.5.2

package/framework/tools/lincoln-installer/tests/hooks/useSetup.test.tsx

@@ -0,0 +1,213 @@
+import React, { useEffect } from 'react'
+import { Text } from 'ink'
+import { describe, expect, test, vi, afterEach } from 'vitest'
+import { render } from 'ink-testing-library'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { useSetup, type StepResult } from '../../src/hooks/useSetup'
+import * as runSetupModule from '../../src/utils/runSetup'
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+function createProjectDir(): string {
+  const root = mkdtempSync(join(tmpdir(), 'lincoln-'))
+  const scriptsDir = join(root, 'scripts')
+  mkdirSync(scriptsDir)
+  writeFileSync(join(scriptsDir, 'lincoln-setup.py'), '')
+  return root
+}
+
+describe('useSetup', () => {
+  const dirs: string[] = []
+
+  afterEach(() => {
+    for (const dir of dirs) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+    dirs.length = 0
+  })
+
+  test('initial state is idle with no results', () => {
+    function C() {
+      const { isRunning, results } = useSetup()
+      return (
+        <Text>
+          {isRunning ? 'running' : 'idle'}:{results.length}
+        </Text>
+      )
+    }
+    const { lastFrame } = render(<C />)
+    expect(lastFrame()).toBe('idle:0')
+  })
+
+  test('startSetup runs all steps and completes on success', async () => {
+    vi.spyOn(runSetupModule, 'runSetup').mockResolvedValue({
+      success: true,
+      code: 0,
+      stdout: '{"ok":true}',
+      stderr: '',
+    })
+
+    const root = createProjectDir()
+    dirs.push(root)
+    let complete = false
+    let latestResults: StepResult[] = []
+
+    function TestHarness() {
+      const { isRunning, results, startSetup } = useSetup()
+
+      useEffect(() => {
+        startSetup({
+          root,
+          harnesses: ['claude-code'],
+          yes: true,
+          dryRun: false,
+        })
+      }, [])
+
+      useEffect(() => {
+        if (!isRunning && results.length > 0) {
+          complete = true
+        }
+      }, [isRunning, results])
+
+      latestResults = results
+      return <Text>{isRunning ? 'running' : 'idle'}</Text>
+    }
+
+    render(<TestHarness />)
+
+    await vi.waitFor(() => expect(complete).toBe(true), {
+      timeout: 2000,
+    })
+    expect(latestResults.every((r) => r.success)).toBe(true)
+  })
+
+  test('startSetup records failure when a step fails', async () => {
+    vi.spyOn(runSetupModule, 'runSetup').mockResolvedValue({
+      success: false,
+      code: 1,
+      stdout: '',
+      stderr: 'missing dependency',
+    })
+
+    const root = createProjectDir()
+    dirs.push(root)
+    let complete = false
+    let latestResults: StepResult[] = []
+
+    function TestHarness() {
+      const { isRunning, results, startSetup } = useSetup()
+
+      useEffect(() => {
+        startSetup({
+          root,
+          harnesses: [],
+          yes: true,
+          dryRun: false,
+        })
+      }, [])
+
+      useEffect(() => {
+        if (!isRunning && results.length > 0) {
+          complete = true
+        }
+      }, [isRunning, results])
+
+      latestResults = results
+      return <Text>{isRunning ? 'running' : 'idle'}</Text>
+    }
+
+    render(<TestHarness />)
+
+    await vi.waitFor(() => expect(complete).toBe(true), {
+      timeout: 2000,
+    })
+    expect(latestResults[0].success).toBe(false)
+  })
+
+  test('records error when startSetup throws', async () => {
+    vi.spyOn(runSetupModule, 'runSetup').mockRejectedValue(new Error('spawn failed'))
+
+    const root = createProjectDir()
+    dirs.push(root)
+    let capturedError: string | undefined
+
+    function TestHarness() {
+      const { isRunning, error, startSetup } = useSetup()
+
+      useEffect(() => {
+        startSetup({
+          root,
+          harnesses: [],
+          yes: true,
+          dryRun: false,
+        })
+      }, [])
+
+      useEffect(() => {
+        if (!isRunning && error) {
+          capturedError = error
+        }
+      }, [isRunning, error])
+
+      return <Text>{isRunning ? 'running' : 'idle'}</Text>
+    }
+
+    render(<TestHarness />)
+
+    await vi.waitFor(() => expect(capturedError).toBeTruthy(), {
+      timeout: 2000,
+    })
+    expect(capturedError).toContain('spawn failed')
+  })
+
+  test('stops after install-skills fails', async () => {
+    let callCount = 0
+    vi.spyOn(runSetupModule, 'runSetup').mockImplementation(async () => {
+      callCount++
+      if (callCount === 1) {
+        return { success: true, code: 0, stdout: '{"ok":true}', stderr: '' }
+      }
+      return { success: false, code: 1, stdout: '', stderr: 'missing skill' }
+    })
+
+    const root = createProjectDir()
+    dirs.push(root)
+    let complete = false
+    let latestResults: StepResult[] = []
+
+    function TestHarness() {
+      const { isRunning, results, startSetup } = useSetup()
+
+      useEffect(() => {
+        startSetup({
+          root,
+          harnesses: [],
+          yes: true,
+          dryRun: false,
+        })
+      }, [])
+
+      useEffect(() => {
+        if (!isRunning && results.length > 1) {
+          complete = true
+        }
+      }, [isRunning, results])
+
+      latestResults = results
+      return <Text>{isRunning ? 'running' : 'idle'}</Text>
+    }
+
+    render(<TestHarness />)
+
+    await vi.waitFor(() => expect(complete).toBe(true), {
+      timeout: 2000,
+    })
+    expect(latestResults[0].success).toBe(true)
+    expect(latestResults[1].success).toBe(false)
+  })
+})

package/framework/tools/lincoln-installer/tests/update.test.tsx

@@ -0,0 +1,108 @@
+import { describe, expect, test, vi, afterEach } from 'vitest'
+import * as updateReleaseModule from '../src/utils/updateRelease'
+
+vi.mock('ink', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('ink')>()
+  return {
+    ...actual,
+    render: vi.fn(),
+  }
+})
+
+describe('updateMain', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  test('prints help and exits zero for --help', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const { render: mockedRender } = await import('ink')
+    const { updateMain } = await import('../src/update')
+    await updateMain(['--help'])
+    expect(errorSpy).not.toHaveBeenCalled()
+    expect(process.exitCode).not.toBe(1)
+    expect(mockedRender).toHaveBeenCalled()
+    const element = (mockedRender as unknown as ReturnType<typeof vi.fn>).mock.calls[0][0]
+    expect(element.props.args.help).toBe(true)
+  })
+
+  test('prints JSON result for --no-tui --format json', async () => {
+    vi.spyOn(updateReleaseModule, 'updateRelease').mockResolvedValue({
+      success: true,
+      fromVersion: '1.2.0',
+      toVersion: '1.3.0',
+      updated: ['README.md'],
+      preserved: ['.context'],
+    })
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    const { updateMain } = await import('../src/update')
+    await updateMain(['--root', '/tmp/proj', '--no-tui', '--format', 'json'])
+
+    expect(logSpy).toHaveBeenCalled()
+    const output = JSON.parse(logSpy.mock.calls[0][0] as string)
+    expect(output.success).toBe(true)
+    expect(output.toVersion).toBe('1.3.0')
+  })
+
+  test('prints human result for --no-tui --format human', async () => {
+    vi.spyOn(updateReleaseModule, 'updateRelease').mockResolvedValue({
+      success: true,
+      fromVersion: '1.2.0',
+      toVersion: '1.3.0',
+      updated: ['README.md'],
+      preserved: ['.context'],
+      backupDir: '/tmp/.context/lincoln-update-backup',
+    })
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    const { updateMain } = await import('../src/update')
+    await updateMain(['--root', '/tmp/proj', '--no-tui', '--format', 'human'])
+
+    expect(logSpy).toHaveBeenCalled()
+    const output = logSpy.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Update available')
+    expect(output).toContain('README.md')
+    expect(output).toContain('Preserved user data')
+  })
+
+  test('prints error for invalid argument', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const { updateMain } = await import('../src/update')
+    await updateMain(['--unknown'])
+    expect(errorSpy).toHaveBeenCalled()
+  })
+
+  test('rejects invalid repository slug', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const { updateMain } = await import('../src/update')
+    await updateMain(['--repo', 'invalid'])
+    expect(errorSpy).toHaveBeenCalled()
+    expect(process.exitCode).toBe(1)
+  })
+
+  test('renders TUI by default', async () => {
+    const { render: mockedRender } = await import('ink')
+    const { updateMain } = await import('../src/update')
+    await updateMain(['--root', '/tmp/proj'])
+    expect(mockedRender).toHaveBeenCalled()
+    const element = (mockedRender as unknown as ReturnType<typeof vi.fn>).mock.calls[0][0]
+    expect(element.props.args.noTui).toBe(false)
+  })
+
+  test('prints human result for failed update', async () => {
+    vi.spyOn(updateReleaseModule, 'updateRelease').mockResolvedValue({
+      success: false,
+      updated: [],
+      preserved: [],
+      error: 'network error',
+    })
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    const { updateMain } = await import('../src/update')
+    await updateMain(['--root', '/tmp/proj', '--no-tui', '--format', 'human'])
+
+    expect(logSpy).toHaveBeenCalled()
+    expect(logSpy.mock.calls[0][0]).toContain('network error')
+  })
+})

package/framework/tools/lincoln-installer/tests/utils/detectHarness.test.ts

@@ -0,0 +1,40 @@
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, expect, test, afterEach } from 'vitest'
+import { detectHarnesses } from '../../src/utils/detectHarness'
+
+describe('detectHarnesses', () => {
+  let root: string
+
+  afterEach(() => {
+    if (root) rmSync(root, { recursive: true, force: true })
+  })
+
+  function setupRoot() {
+    root = mkdtempSync(join(tmpdir(), 'lincoln-'))
+    return root
+  }
+
+  test('detects project-level claude-code harness', () => {
+    setupRoot()
+    mkdirSync(join(root, '.claude'))
+    const harnesses = detectHarnesses(root, root)
+    const claude = harnesses.find((h) => h.id === 'claude-code')
+    expect(claude?.installed).toBe(true)
+  })
+
+  test('detects project-level codex harness', () => {
+    setupRoot()
+    mkdirSync(join(root, '.codex'))
+    const harnesses = detectHarnesses(root, root)
+    const codex = harnesses.find((h) => h.id === 'codex')
+    expect(codex?.installed).toBe(true)
+  })
+
+  test('marks undetected harnesses as not installed', () => {
+    setupRoot()
+    const harnesses = detectHarnesses(root, root)
+    expect(harnesses.every((h) => !h.installed)).toBe(true)
+  })
+})

package/framework/tools/lincoln-installer/tests/utils/runSetup.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from 'vitest'
+import { runSetup, parseJsonOutput } from '../../src/utils/runSetup'
+
+describe('runSetup', () => {
+  test('runs a successful command and captures stdout', async () => {
+    const result = await runSetup({ root: process.cwd(), command: 'node', args: ['-e', 'console.log("ok")'] })
+    expect(result.success).toBe(true)
+    expect(result.code).toBe(0)
+    expect(result.stdout.trim()).toBe('ok')
+  })
+
+  test('returns failure for non-zero exit', async () => {
+    const result = await runSetup({ root: process.cwd(), command: 'node', args: ['-e', 'process.exit(1)'] })
+    expect(result.success).toBe(false)
+    expect(result.code).toBe(1)
+  })
+
+  test('returns error when command is missing', async () => {
+    const result = await runSetup({ root: process.cwd(), command: 'this-command-does-not-exist-12345', args: [] })
+    expect(result.success).toBe(false)
+    expect(result.error).toBeTruthy()
+  })
+})
+
+describe('parseJsonOutput', () => {
+  test('parses single JSON line', () => {
+    expect(parseJsonOutput('{"ok":true}')).toEqual({ ok: true })
+  })
+
+  test('parses last JSON line from mixed output', () => {
+    expect(parseJsonOutput('log line\n{"ok":true}')).toEqual({ ok: true })
+  })
+
+  test('returns undefined for empty output', () => {
+    expect(parseJsonOutput('')).toBeUndefined()
+  })
+
+  test('returns undefined for invalid JSON', () => {
+    expect(parseJsonOutput('not json')).toBeUndefined()
+  })
+
+  test('returns undefined for whitespace-only output', () => {
+    expect(parseJsonOutput('   ')).toBeUndefined()
+  })
+})