| import fs from 'node:fs/promises'; |
| import os from 'node:os'; |
| import path from 'node:path'; |
| import { execFile } from 'node:child_process'; |
| import { promisify } from 'node:util'; |
| import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; |
| import { |
| stageFiles, |
| StageFilesValidationError, |
| } from '../../../src/services/stage-files-service.js'; |
| import { |
| hasAnyChanges, |
| localBranchExists, |
| popStash, |
| stashChanges, |
| } from '../../../src/services/branch-utils.js'; |
| import { performCheckoutBranch } from '../../../src/services/checkout-branch-service.js'; |
| import { |
| applyOrPop, |
| dropStash, |
| getConflictedFiles, |
| listStash, |
| pushStash, |
| } from '../../../src/services/stash-service.js'; |
| import { getCommitLog } from '../../../src/services/commit-log-service.js'; |
| import { getBranchCommitLog } from '../../../src/services/branch-commit-log-service.js'; |
|
|
| const execFileAsync = promisify(execFile); |
| let repository: string; |
| async function git(...args: string[]) { |
| return ( |
| await execFileAsync('git', args, { |
| cwd: repository, |
| env: { ...process.env, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_SYSTEM: '/dev/null' }, |
| }) |
| ).stdout.trim(); |
| } |
| async function commit(file: string, content: string, message: string) { |
| await fs.writeFile(path.join(repository, file), content); |
| await git('add', '--', file); |
| await git('commit', '-m', message); |
| return git('rev-parse', 'HEAD'); |
| } |
|
|
| beforeEach(async () => { |
| repository = await fs.mkdtemp(path.join(os.tmpdir(), 'git-workflow-contract-')); |
| await git('init', '--initial-branch=main'); |
| await git('config', 'user.name', 'Workflow Test'); |
| await git('config', 'user.email', 'workflow@example.invalid'); |
| await commit('tracked.txt', 'baseline\n', 'Initial commit'); |
| }); |
| afterEach(async () => fs.rm(repository, { recursive: true, force: true })); |
|
|
| describe('real repository staging boundaries', () => { |
| it('stages literal filenames and unstages without deleting user contents', async () => { |
| const filename = '--literal;$(unused).txt'; |
| await fs.writeFile(path.join(repository, filename), 'user content'); |
| await expect(stageFiles(repository, [filename], 'stage')).resolves.toEqual({ |
| operation: 'stage', |
| filesCount: 1, |
| }); |
| expect(await git('diff', '--cached', '--name-only')).toBe(filename); |
| await expect(stageFiles(repository, [filename], 'unstage')).resolves.toEqual({ |
| operation: 'unstage', |
| filesCount: 1, |
| }); |
| expect(await git('diff', '--cached', '--name-only')).toBe(''); |
| expect(await fs.readFile(path.join(repository, filename), 'utf8')).toBe('user content'); |
| }); |
|
|
| it.each(['', ' ', '../outside.txt', '/tmp/outside.txt'])( |
| 'rejects invalid path %j without staging other supplied paths', |
| async (invalid) => { |
| await fs.writeFile(path.join(repository, 'safe.txt'), 'safe'); |
| await expect(stageFiles(repository, ['safe.txt', invalid], 'stage')).rejects.toBeInstanceOf( |
| StageFilesValidationError |
| ); |
| expect(await git('diff', '--cached', '--name-only')).toBe(''); |
| } |
| ); |
|
|
| it('fails clearly for a missing worktree and accepts a canonicalized worktree alias', async () => { |
| await expect( |
| stageFiles(path.join(repository, 'missing'), ['tracked.txt'], 'stage') |
| ).rejects.toThrow('worktreePath does not exist'); |
| const alias = repository + '-alias'; |
| await fs.symlink(repository, alias, 'dir'); |
| try { |
| await fs.writeFile(path.join(repository, 'tracked.txt'), 'changed\n'); |
| await stageFiles(alias, ['tracked.txt'], 'stage'); |
| expect(await git('diff', '--cached', '--name-only')).toBe('tracked.txt'); |
| } finally { |
| await fs.unlink(alias); |
| } |
| }); |
| }); |
|
|
| describe('real branch and stash recovery', () => { |
| it('detects tracked and optional untracked changes while ignoring internal worktree entries only when requested', async () => { |
| expect(await hasAnyChanges(repository)).toBe(false); |
| await fs.mkdir(path.join(repository, '.worktrees')); |
| await fs.writeFile(path.join(repository, '.worktrees', 'untracked'), 'internal'); |
| expect(await hasAnyChanges(repository)).toBe(true); |
| expect(await hasAnyChanges(repository, { excludeWorktreePaths: true })).toBe(false); |
| expect(await hasAnyChanges(repository, { includeUntracked: false })).toBe(false); |
| await fs.writeFile(path.join(repository, 'tracked.txt'), 'changed\n'); |
| expect( |
| await hasAnyChanges(repository, { includeUntracked: false, excludeWorktreePaths: true }) |
| ).toBe(true); |
| expect(await hasAnyChanges(path.join(repository, 'missing'))).toBe(false); |
| }); |
|
|
| it('creates a branch and restores both tracked and untracked edits exactly once', async () => { |
| await fs.writeFile(path.join(repository, 'tracked.txt'), 'uncommitted edit\n'); |
| await fs.writeFile(path.join(repository, 'new.txt'), 'untracked edit\n'); |
| const events = { emit: vi.fn() }; |
| const result = await performCheckoutBranch( |
| repository, |
| 'task/next', |
| 'main', |
| { stashChanges: true }, |
| events as never |
| ); |
| expect(result).toMatchObject({ |
| success: true, |
| result: { |
| previousBranch: 'main', |
| newBranch: 'task/next', |
| stashedChanges: true, |
| hasConflicts: false, |
| }, |
| }); |
| expect(await git('branch', '--show-current')).toBe('task/next'); |
| expect(await fs.readFile(path.join(repository, 'tracked.txt'), 'utf8')).toBe( |
| 'uncommitted edit\n' |
| ); |
| expect(await fs.readFile(path.join(repository, 'new.txt'), 'utf8')).toBe('untracked edit\n'); |
| expect(await git('stash', 'list')).toBe(''); |
| expect(events.emit.mock.calls.filter(([name]) => name === 'switch:pop')).toHaveLength(1); |
| }); |
|
|
| it('preserves edits when branch creation fails and rejects existing or missing base branches', async () => { |
| await fs.writeFile(path.join(repository, 'tracked.txt'), 'preserve me\n'); |
| await expect( |
| performCheckoutBranch(repository, 'bad..branch', undefined, { stashChanges: true }) |
| ).resolves.toMatchObject({ success: false }); |
| expect(await git('branch', '--show-current')).toBe('main'); |
| expect(await fs.readFile(path.join(repository, 'tracked.txt'), 'utf8')).toBe('preserve me\n'); |
| expect(await git('stash', 'list')).toBe(''); |
| await expect(performCheckoutBranch(repository, 'main')).resolves.toMatchObject({ |
| success: false, |
| error: "Branch 'main' already exists", |
| }); |
| await expect(performCheckoutBranch(repository, 'new-branch', 'missing')).resolves.toMatchObject( |
| { success: false, error: "Base branch 'missing' does not exist" } |
| ); |
| expect(await localBranchExists(repository, 'main')).toBe(true); |
| expect(await localBranchExists(repository, 'missing')).toBe(false); |
| }); |
|
|
| it('keeps a conflicting stash available for recovery and reports the conflict files', async () => { |
| await fs.writeFile(path.join(repository, 'tracked.txt'), 'stashed side\n'); |
| expect(await stashChanges(repository, 'recovery fixture')).toBe(true); |
| await commit('tracked.txt', 'committed side\n', 'Competing change'); |
| await expect(popStash(repository)).resolves.toMatchObject({ |
| success: false, |
| hasConflicts: true, |
| }); |
| expect(await getConflictedFiles(repository)).toEqual(['tracked.txt']); |
| expect(await git('stash', 'list')).toContain('recovery fixture'); |
| }); |
|
|
| it('round-trips stash metadata and distinguishes apply from pop and drop', async () => { |
| await expect(pushStash(repository)).resolves.toMatchObject({ success: true, stashed: false }); |
| await expect(listStash(repository)).resolves.toMatchObject({ total: 0, stashes: [] }); |
| await fs.writeFile(path.join(repository, 'tracked.txt'), 'saved edit\n'); |
| await expect( |
| pushStash(repository, { message: ' user recovery ', files: ['tracked.txt'] }) |
| ).resolves.toMatchObject({ |
| success: true, |
| stashed: true, |
| branch: 'main', |
| message: 'user recovery', |
| }); |
| const listed = await listStash(repository); |
| expect(listed.total).toBe(1); |
| expect(listed.stashes[0]).toMatchObject({ index: 0, branch: 'main', files: ['tracked.txt'] }); |
| expect(Number.isFinite(Date.parse(listed.stashes[0].date))).toBe(true); |
| await expect(applyOrPop(repository, 0, {})).resolves.toMatchObject({ |
| success: true, |
| applied: true, |
| operation: 'apply', |
| }); |
| expect(await fs.readFile(path.join(repository, 'tracked.txt'), 'utf8')).toBe('saved edit\n'); |
| expect((await listStash(repository)).total).toBe(1); |
| await git('restore', '--', 'tracked.txt'); |
| await expect(applyOrPop(repository, 0, { pop: true })).resolves.toMatchObject({ |
| success: true, |
| applied: true, |
| operation: 'pop', |
| }); |
| expect((await listStash(repository)).total).toBe(0); |
| await pushStash(repository); |
| await expect(dropStash(repository, 0)).resolves.toMatchObject({ |
| success: true, |
| dropped: true, |
| stashIndex: 0, |
| }); |
| expect((await listStash(repository)).total).toBe(0); |
| await expect(applyOrPop(repository, 5)).resolves.toMatchObject({ success: false }); |
| }); |
| }); |
|
|
| describe('real commit log parsing', () => { |
| it('preserves multiline messages, filenames and branch identity with a bounded result', async () => { |
| const latest = await commit( |
| 'space name.txt', |
| 'content', |
| 'Summary\n\nBody with ---END--- marker\nand another line' |
| ); |
| const log = await getCommitLog(repository, 1); |
| expect(log.branch).toBe('main'); |
| expect(log.total).toBe(1); |
| expect(log.commits[0]).toMatchObject({ |
| hash: latest, |
| subject: 'Summary', |
| body: 'Body with ---END--- marker\nand another line', |
| author: 'Workflow Test', |
| authorEmail: 'workflow@example.invalid', |
| files: ['space name.txt'], |
| }); |
| expect((await getCommitLog(repository, Number.NaN)).total).toBe(2); |
| expect((await getBranchCommitLog(repository, undefined, 0)).total).toBe(1); |
| expect((await getBranchCommitLog(repository, 'main', 999)).branch).toBe('main'); |
| }); |
|
|
| it('deduplicates merge commits and retains files changed against both parents', async () => { |
| await git('checkout', '-b', 'side'); |
| await commit('side.txt', 'side', 'Side change'); |
| await git('checkout', 'main'); |
| await commit('main.txt', 'main', 'Main change'); |
| await git('merge', '--no-ff', 'side', '-m', 'Integration'); |
| const head = await git('rev-parse', 'HEAD'); |
| for (const result of [ |
| await getCommitLog(repository, 100), |
| await getBranchCommitLog(repository, 'main', 100), |
| ]) { |
| expect(result.commits.filter((entry) => entry.hash === head)).toHaveLength(1); |
| expect(result.commits[0].files.sort()).toEqual(['main.txt', 'side.txt']); |
| expect(result.total).toBe(4); |
| } |
| }); |
| }); |
|
|
