| import type { Args, ResultOf } from 'claude-code' |
| import { describe, expect, mock, test, tier } from 'claude-code/testing' |
|
|
| import Limits from '../hooks/limits' |
| import Names from '../hooks/names' |
| import Fixtures from './fixtures' |
|
|
| tier('builtin') |
|
|
| describe('register', () => { |
| test('the start asks nothing of git and registers /diff', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| await $.session.start(Fixtures.SESSION) |
|
|
| expect(world.runs, "no git, as the built-in's start runs none").toEqual([]) |
|
|
| expect(await $.command.run(Fixtures.DIFF), '/diff was registered').toEqual({ |
| text: 'Diff panel shown', |
| }) |
| }) |
|
|
| test("git runs at the built-in's moments and no others", async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| let read = 0 |
|
|
| function spawnedSince(): string[] { |
| const words = world.runs |
| .slice(read) |
| .map(run => Fixtures.gitWordOf(run.argv)) |
| .filter(word => word !== Fixtures.POLL_WORD) |
|
|
| read = world.runs.length |
|
|
| return words |
| } |
|
|
| const edit = () => |
| $.tool.call({ |
| tool: 'Edit', |
| file_path: '/work/app.ts', |
| old_string: '1', |
| new_string: '2', |
| }) |
|
|
| on('tool.call', () => ({ result: 'done' })) |
| on('turn.complete', ($, e) => ({ text: e.answer })) |
| on('command.run', { command: 'clear' }, () => ({})) |
|
|
| await $.session.start(Fixtures.SESSION) |
| await $.ui.render(Fixtures.hintAt(Limits.AUTO_OPEN_MIN_COLUMNS - 1)) |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(spawnedSince(), 'the start and the footer: nothing').toEqual([]) |
|
|
| await edit() |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect( |
| spawnedSince(), |
| 'an edit with no room for a pane: nothing, the width is read first', |
| ).toEqual([]) |
|
|
| await $.command.run(Fixtures.DIFF) |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(spawnedSince(), '/diff: found, then one fetch for the pane').toEqual( |
| [ |
| 'rev-parse --show-toplevel', |
| 'status', |
| 'diff --shortstat', |
| 'diff --numstat', |
| 'ls-files', |
| 'diff -- app.ts', |
| ], |
| ) |
|
|
| await edit() |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(spawnedSince(), 'an edit, the pane open: one fetch').toEqual([ |
| 'diff --shortstat', |
| 'diff --numstat', |
| 'ls-files', |
| 'diff -- app.ts', |
| ]) |
|
|
| await $.tool.call({ tool: 'Bash', command: 'make' }) |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(spawnedSince(), 'a shell command, the pane open: one fetch').toEqual( |
| ['diff --shortstat', 'diff --numstat', 'ls-files', 'diff -- app.ts'], |
| ) |
|
|
| await $.turn.complete({ |
| answer: 'done', |
| durationMs: 1, |
| isAborted: false, |
| turnId: 't1', |
| reason: 'answer', |
| }) |
|
|
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(spawnedSince(), "a turn's end: nothing").toEqual([]) |
|
|
| await $.command.run(Fixtures.DIFF) |
| await edit() |
| await $.tool.call({ tool: 'Bash', command: 'make' }) |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(spawnedSince(), 'the pane closed by hand: nothing').toEqual([]) |
|
|
| await $.command.run(Fixtures.CLEAR) |
| await $.command.run(Fixtures.DIFF) |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(spawnedSince()[0], '/clear forgot the repository').toBe( |
| 'rev-parse --show-toplevel', |
| ) |
| }) |
|
|
| test('/diff whose probe never answers probes once more', async ($, on) => { |
| const probes: (readonly string[])[] = [] |
| const clock = Fixtures.startsSession(on) |
|
|
| on('process.run', async ($, e) => { |
| probes.push(e.argv) |
|
|
| if (probes.length === 1) { |
| await clock.sleep(Limits.GIT_TIMEOUT_MS) |
|
|
| return { deny: Fixtures.GIT_HUNG } |
| } |
|
|
| return { value: Fixtures.NOT_A_REPOSITORY } |
| }) |
|
|
| await $.session.start(Fixtures.SESSION) |
|
|
| const ran = $.command.run(Fixtures.DIFF) |
|
|
| await clock.settle() |
|
|
| expect(probes, "this /diff's probe, unanswered yet").toHaveLength(1) |
|
|
| await clock.advance(Limits.GIT_TIMEOUT_MS) |
|
|
| expect(await ran).toEqual({ |
| text: expect.stringContaining("isn't in a git repository"), |
| }) |
|
|
| expect(probes, 'then one more, which answered').toHaveLength(2) |
| }) |
|
|
| test('two /diff typed together probe the repository once', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| await $.session.start(Fixtures.SESSION) |
|
|
| const [first, second] = await Promise.all([ |
| $.command.run(Fixtures.DIFF), |
| $.command.run(Fixtures.DIFF), |
| ]) |
|
|
| const probes = world.runs.filter(run => |
| run.argv.includes('--show-toplevel'), |
| ) |
|
|
| expect(first.text).toMatch(/^Diff panel (shown|hidden)$/) |
| expect(second.text).toMatch(/^Diff panel (shown|hidden)$/) |
| expect(probes, 'the second joined the probe in flight').toHaveLength(1) |
| }) |
|
|
| test('outside a repository /diff says so, opens nothing', async ($, on) => { |
| const opened: string[] = [] |
|
|
| Fixtures.startsSession(on) |
| on('process.run', () => ({ value: Fixtures.NOT_A_REPOSITORY })) |
|
|
| on('ui.open', ($, e, next) => { |
| opened.push(e.id) |
|
|
| return next(e) |
| }) |
|
|
| await $.session.start(Fixtures.SESSION) |
|
|
| const { text } = await $.command.run(Fixtures.DIFF) |
|
|
| expect(text).toContain("isn't in a git repository") |
| expect(opened).toEqual([]) |
| }) |
|
|
| test('a git that never answers is not "no repository"', async ($, on) => { |
| Fixtures.startsSession(on) |
| on('process.run', () => ({ deny: Fixtures.GIT_HUNG })) |
|
|
| await $.session.start(Fixtures.SESSION) |
|
|
| const { text } = await $.command.run(Fixtures.DIFF) |
|
|
| expect(text).toContain("git didn't answer") |
| }) |
|
|
| test('when the built-in holds /diff, the mod stands down', async ($, on) => { |
| const logged: string[] = [] |
| const runs: Args<'process.run'>[] = [] |
|
|
| mock.clock(on) |
| on('session.start', ($, e) => ({ cwd: e.cwd })) |
| on('command.register', () => ({ deny: Fixtures.BUILTIN_HOLDS })) |
| on('command.run', () => ({ text: 'the built-in /diff ran' })) |
| on('tool.call', () => ({ result: 'edited' })) |
|
|
| on('process.run', ($, e) => { |
| runs.push(e) |
|
|
| return { value: Fixtures.gitIn(e.argv) } |
| }) |
|
|
| on('ui.log', ($, e) => { |
| logged.push(e.text) |
|
|
| return { value: undefined } |
| }) |
|
|
| await $.session.start(Fixtures.SESSION) |
|
|
| expect(await $.command.run(Fixtures.DIFF)).toEqual({ |
| text: 'the built-in /diff ran', |
| }) |
|
|
| await $.tool.call({ |
| tool: 'Edit', |
| file_path: '/work/app.ts', |
| old_string: '1', |
| new_string: '2', |
| }) |
|
|
| expect(logged).toEqual([]) |
| expect(runs, 'idle: no git for /diff or the edit').toEqual([]) |
| }) |
|
|
| test('a refusal the built-in did not cause is said aloud', async ($, on) => { |
| const logged: string[] = [] |
|
|
| mock.clock(on) |
| on('session.start', ($, e) => ({ cwd: e.cwd })) |
|
|
| on('command.register', () => ({ |
| deny: '32 commands are registered already', |
| })) |
|
|
| on('ui.log', ($, e) => { |
| logged.push(e.text) |
|
|
| return { value: undefined } |
| }) |
|
|
| await $.session.start(Fixtures.SESSION) |
|
|
| expect(logged).toEqual([ |
| 'could not register /diff: diff: $.command.register: 32 commands are ' + |
| 'registered already; the diff panel is unavailable this session', |
| ]) |
| }) |
|
|
| test('/diff opens the pane, unfocused, and says so', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| await $.session.start(Fixtures.SESSION) |
|
|
| expect(world.runs, 'the start ran nothing').toEqual([]) |
|
|
| expect(await $.command.run(Fixtures.DIFF)).toEqual({ |
| text: 'Diff panel shown', |
| }) |
|
|
| expect(world.runs[0]?.argv, '/diff found the repository first').toContain( |
| '--show-toplevel', |
| ) |
|
|
| expect(world.opened).toEqual([ |
| { id: 'diff', title: 'Diff', holdToasts: true }, |
| ]) |
|
|
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| const drawn = Fixtures.textOf(await $.ui.render(Fixtures.PANE)) |
|
|
| expect(drawn).toContain('1 file changed') |
| expect(drawn).toContain('app.ts') |
| }) |
|
|
| test('off fullscreen, /diff opens the dialog, focused', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| await $.session.start(Fixtures.SESSION) |
|
|
| expect(await $.command.run(Fixtures.DIALOG_DIFF)).toEqual({}) |
|
|
| expect(world.opened[0]).toEqual({ |
| id: 'diff', |
| title: 'Diff', |
| holdToasts: true, |
| closeOnEscape: true, |
| rows: expect.any(Number), |
| focus: true, |
| }) |
|
|
| expect(await $.command.run(Fixtures.DIALOG_DIFF)).toEqual({ |
| text: 'Diff dialog dismissed', |
| }) |
| }) |
|
|
| test('/diff again closes the pane and says so', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| await $.session.start(Fixtures.SESSION) |
| await $.command.run(Fixtures.DIFF) |
|
|
| expect(await $.command.run(Fixtures.DIFF)).toEqual({ |
| text: 'Diff panel hidden', |
| }) |
|
|
| expect(world.closed.map(pane => pane.id)).toEqual(['diff']) |
| }) |
|
|
| test('a wide terminal opens the pane at the first edit', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| on('tool.call', () => ({ result: 'edited' })) |
|
|
| await $.session.start(Fixtures.SESSION) |
| await $.ui.render(Fixtures.HINT) |
|
|
| await $.tool.call({ |
| tool: 'Edit', |
| file_path: '/work/app.ts', |
| old_string: '1', |
| new_string: '2', |
| }) |
|
|
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(world.opened.map(pane => pane.id)).toEqual(['diff']) |
| }) |
|
|
| test('on the main screen the first edit opens nothing, and /diff still opens the dialog', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| on('tool.call', () => ({ result: 'edited' })) |
|
|
| await $.session.start(Fixtures.SESSION) |
| await $.ui.render(Fixtures.MAIN_SCREEN_HINT) |
|
|
| await $.tool.call({ |
| tool: 'Edit', |
| file_path: '/work/app.ts', |
| old_string: '1', |
| new_string: '2', |
| }) |
|
|
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(world.opened, 'a pane there would be an unasked dialog').toEqual([]) |
| expect(world.runs, 'so nothing was asked of the repository').toEqual([]) |
|
|
| expect(await $.command.run(Fixtures.DIALOG_DIFF)).toEqual({}) |
|
|
| expect( |
| world.opened[0], |
| "the person's /diff opens the dialog, not dismisses one", |
| ).toMatchObject({ id: 'diff', focus: true }) |
| }) |
|
|
| test('a surface that does not say whether it docks a pane opens nothing at the first edit', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| on('tool.call', () => ({ result: 'edited' })) |
|
|
| await $.session.start(Fixtures.SESSION) |
| await $.ui.render(Fixtures.UNSAID_HINT) |
|
|
| await $.tool.call({ |
| tool: 'Edit', |
| file_path: '/work/app.ts', |
| old_string: '1', |
| new_string: '2', |
| }) |
|
|
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(world.opened, 'unknown is not a dock').toEqual([]) |
|
|
| await $.ui.render(Fixtures.HINT) |
|
|
| await $.tool.call({ |
| tool: 'Edit', |
| file_path: '/work/app.ts', |
| old_string: '2', |
| new_string: '3', |
| }) |
|
|
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect( |
| world.opened.map(pane => pane.id), |
| 'once a drawing says the layout docks, the next edit opens it', |
| ).toEqual(['diff']) |
| }) |
|
|
| test('an edit that failed or was refused opens nothing', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| const answers: ResultOf['tool.call'][] = [ |
| { isError: true, result: 'no such text' }, |
| { deny: 'not allowed' }, |
| ] |
|
|
| const edit = () => |
| $.tool.call({ |
| tool: 'Edit', |
| file_path: '/work/app.ts', |
| old_string: '1', |
| new_string: '2', |
| }) |
|
|
| on('tool.call', () => answers.shift() ?? { result: 'edited' }) |
|
|
| await $.session.start(Fixtures.SESSION) |
| await $.ui.render(Fixtures.HINT) |
| await edit() |
| await edit() |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(world.opened, 'neither edit landed').toEqual([]) |
| expect(world.runs, 'so nothing asked after the repository').toEqual([]) |
|
|
| await edit() |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect( |
| world.opened.map(pane => pane.id), |
| 'the third did', |
| ).toEqual(['diff']) |
| }) |
|
|
| test('/clear closes the pane it finds open', async ($, on) => { |
| const world = Fixtures.inRepository(on) |
|
|
| on('command.run', { command: 'clear' }, () => ({})) |
|
|
| await $.session.start(Fixtures.SESSION) |
| await $.command.run(Fixtures.DIFF) |
| await $.command.run(Fixtures.CLEAR) |
|
|
| expect(world.closed.map(pane => pane.id)).toEqual(['diff']) |
| }) |
|
|
| test('ask attaches the hunks on screen and calls no tool', async ($, on) => { |
| const world = Fixtures.inRepository(on, Fixtures.oneSecret()) |
| const called: Args<'tool.call'>[] = [] |
|
|
| on('tool.call', ($, e) => { |
| called.push(e) |
|
|
| return { result: 'called' } |
| }) |
|
|
| on('prompt.submit', ($, e) => ({ text: e.text, context: e.context })) |
|
|
| await $.session.start(Fixtures.WORKTREE_SESSION) |
| await $.command.run(Fixtures.DIFF) |
| await world.clock.advance(Fixtures.SETTLE_MS) |
| await $.ui.render(Fixtures.PANE) |
| await $.ui.press({ plugin: 'diff', key: 'ask:.env' }) |
| await world.clock.settle() |
|
|
| const armed = Fixtures.jsonOf(await $.ui.render(Fixtures.PANE)) |
|
|
| const submitted = await $.prompt.submit(Fixtures.typedPromptOf('why?')) |
|
|
| expect(armed).toContain('asked ✓') |
| expect(called).toEqual([]) |
|
|
| expect(world.statuses.at(-2)).toBe( |
| '.env rides your next prompt (press asked ✓ to drop it)', |
| ) |
|
|
| expect(submitted).toMatchObject({ |
| context: [ |
| 'The user attached the diff of .env from the diff pane to this ' + |
| 'prompt:\n@@ -1 +1 @@\n-KEY=old\n+KEY=new', |
| ], |
| }) |
| }) |
|
|
| test('an ask with no room in the context is dropped', async ($, on) => { |
| const world = Fixtures.inRepository(on, Fixtures.oneSecret()) |
| const full = 'x'.repeat(Limits.PROMPT_CONTEXT_MAX_CHARS) |
| const reached: (readonly string[] | undefined)[] = [] |
|
|
| on('prompt.submit', ($, e) => { |
| reached.push(e.context) |
|
|
| return { text: e.text } |
| }) |
|
|
| await $.session.start(Fixtures.WORKTREE_SESSION) |
| await $.command.run(Fixtures.DIFF) |
| await world.clock.advance(Fixtures.SETTLE_MS) |
| await $.ui.render(Fixtures.PANE) |
| await $.ui.press({ plugin: 'diff', key: 'ask:.env' }) |
| await world.clock.settle() |
|
|
| await $.prompt.submit(Fixtures.typedPromptOf('why?', [full])) |
| await $.prompt.submit(Fixtures.typedPromptOf('and now?')) |
|
|
| expect(reached).toEqual([[full], undefined]) |
|
|
| expect(world.statuses.at(-1)).toBe( |
| ".env's diff did not fit in the prompt and was dropped", |
| ) |
| }) |
|
|
| test('a worktree opens on the base it kept', async ($, on) => { |
| const world = Fixtures.inRepository(on, Fixtures.oneSecret(), { |
| 'base:/main/wt': 'uncommitted', |
| }) |
|
|
| await $.session.start(Fixtures.WORKTREE_SESSION) |
| await $.command.run(Fixtures.DIFF) |
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect( |
| Fixtures.stringsOf(await $.ui.render(Fixtures.PANE)), |
| "the built-in's base line under the header", |
| ).toContain('uncommitted (vs HEAD)') |
| }) |
|
|
| test('no repository is an answer kept until /clear', async ($, on) => { |
| const { 'rev-parse --path-format=absolute': worktree = '', ...notYet } = |
| Fixtures.oneSecret() |
|
|
| const script: Record<string, string> = notYet |
| const world = Fixtures.inRepository(on, script) |
|
|
| const probesOf = () => |
| world.runs.filter(run => run.argv.includes('--show-toplevel')).length |
|
|
| on('command.run', { command: 'clear' }, () => ({})) |
|
|
| await $.session.start(Fixtures.WORKTREE_SESSION) |
|
|
| const before = await $.command.run(Fixtures.DIFF) |
|
|
| script['rev-parse --path-format=absolute'] = worktree |
|
|
| const again = await $.command.run(Fixtures.DIFF) |
| const probesKept = probesOf() |
|
|
| await $.command.run(Fixtures.CLEAR) |
|
|
| const after = await $.command.run(Fixtures.DIFF) |
|
|
| await world.clock.advance(Fixtures.SETTLE_MS) |
| await $.ui.render(Fixtures.PANE) |
|
|
| script['rev-parse --path-format=absolute'] = Fixtures.ELSEWHERE_LINES |
|
|
| const third = $.command.run(Fixtures.DIFF) |
|
|
| await world.clock.advance(Fixtures.SETTLE_MS) |
| await third |
|
|
| expect(before.text).toContain("isn't in a git repository") |
|
|
| expect(again.text, "kept, as the built-in's answer is").toContain( |
| "isn't in a git repository", |
| ) |
|
|
| expect(probesKept, 'one probe answered both').toBe(1) |
| expect(after.text, '/clear forgot it').toBe('Diff panel shown') |
| expect(world.opened[0]?.id).toBe('diff') |
| expect(probesOf(), 'then one more, pinned from there on').toBe(2) |
|
|
| expect( |
| world.runs.some(run => run.argv.includes('--git-dir=/else/.git')), |
| ).toBe(false) |
|
|
| expect( |
| world.runs |
| .filter(run => run.argv.includes('--numstat')) |
| .every(run => run.argv[1] === Fixtures.PINNED_LEAD[1]), |
| ).toBe(true) |
| }) |
|
|
| test('a repository that appears later opens on first edit', async ($, on) => { |
| const { 'rev-parse --path-format=absolute': worktree = '', ...notYet } = |
| Fixtures.oneSecret() |
|
|
| const script: Record<string, string> = notYet |
| const world = Fixtures.inRepository(on, script) |
|
|
| on('tool.call', () => ({ result: 'edited' })) |
|
|
| await $.session.start(Fixtures.WORKTREE_SESSION) |
| await $.ui.render(Fixtures.HINT) |
|
|
| script['rev-parse --path-format=absolute'] = worktree |
|
|
| await $.tool.call({ |
| tool: 'Edit', |
| file_path: '/main/wt/.env', |
| old_string: 'old', |
| new_string: 'new', |
| }) |
|
|
| await world.clock.advance(Fixtures.SETTLE_MS) |
|
|
| expect(world.opened.map(pane => pane.id)).toEqual(['diff']) |
| }) |
|
|
| test('a git that cannot start is an answer, not a timeout', async ($, on) => { |
| const runs: Args<'process.run'>[] = [] |
|
|
| Fixtures.startsSession(on) |
|
|
| on('process.run', ($, e) => { |
| runs.push(e) |
|
|
| return e.argv.includes('--show-toplevel') |
| ? { deny: Fixtures.FAILED_START } |
| : { value: Fixtures.gitIn(e.argv, Fixtures.oneSecret()) } |
| }) |
|
|
| await $.session.start(Fixtures.WORKTREE_SESSION) |
|
|
| const { text } = await $.command.run(Fixtures.DIFF) |
| const probes = runs.filter(run => run.argv.includes('--show-toplevel')) |
|
|
| expect(text).toContain("isn't in a git repository") |
| expect(probes, "this /diff's alone; no retry").toHaveLength(1) |
| }) |
|
|
| test('/diff on a narrow terminal: the resize line', async ($, on) => { |
| const world = Fixtures.inRepository(on, Fixtures.oneSecret()) |
|
|
| await $.session.start(Fixtures.WORKTREE_SESSION) |
|
|
| const narrow = await $.command.run( |
| Fixtures.diffAt(Limits.OPEN_MIN_COLUMNS - 1), |
| ) |
|
|
| const openedNarrow = [...world.opened] |
|
|
| await $.command.run(Fixtures.diffAt(Limits.OPEN_MIN_COLUMNS)) |
|
|
| expect(narrow.text).toContain( |
| 'Resize your terminal to at least 110 columns to show the diff panel', |
| ) |
|
|
| expect(openedNarrow).toEqual([]) |
| expect(world.opened.map(pane => pane.id)).toEqual([Names.PANE_ID]) |
| }) |
| }) |
|
|
