git-chopstick-core 0.1.10 → 0.1.13

package/src/__tests__/integration.test.ts

@@ -4,14 +4,18 @@ import { execSync } from 'child_process'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import {
-  Repository, getStatus, getCommits, getBranches,
+  Repository, getRepositories, getStatus, getWorkingDirectoryChanges, getWorkingDirectoryChangesDetailed, fileChangeSummaryToWorkingDirectoryFile, DiffSelectionType, getCommits, getBranches,
   createCommit, createBranch, deleteLocalBranch, renameBranch,
   getCurrentBranch, getRepositoryType, getRepositorySummary,
   getRemoteUrl, getRemotesFromPath, getAllTags,
   addRemote, removeRemote, setRemoteURL,
   merge, MergeResult,
   rebase, RebaseResult,
-  getStashes, createDesktopStashEntry, popStashEntry,
+  getStashes, getStashesByPath,
+  createDesktopStashEntry, popStashEntry,
+  getTags, getFileAtCommit,
+  getChangedFilesFlat, getChangedFiles,
+  appFileStatusToString, AppFileStatusKind,
 } from '../index.js'
 import {
   setupFixtureRepo, cleanupFixtureRepo, git,
@@ -85,6 +89,116 @@ describe('getStatus', () => {
   })
 })
 
+describe('getWorkingDirectoryChanges', () => {
+  it('returns flattened changes for a repo with modified files', async () => {
+    // Modify an existing file and create a new (untracked) one
+    writeFileSync(join(repoPath, 'README.md'), 'modified content')
+    writeFileSync(join(repoPath, 'new-file.txt'), 'new content')
+
+    const changes = await getWorkingDirectoryChanges(repo)
+
+    expect(changes.length).toBeGreaterThanOrEqual(2)
+
+    const modified = changes.find(c => c.path === 'README.md')
+    expect(modified).toBeTruthy()
+    expect(modified!.status).toBe('modified')
+    expect(modified!.oldPath).toBeUndefined()
+
+    const untracked = changes.find(c => c.path === 'new-file.txt')
+    expect(untracked).toBeTruthy()
+    // Unstaged new files show as 'untracked' (not 'added' — that requires staging)
+    expect(untracked!.status).toBe('untracked')
+
+    // Clean up
+    git(repoPath, 'checkout -- README.md')
+    execSync(`rm -f ${join(repoPath, 'new-file.txt')}`)
+  })
+
+  it('throws for a non-repo path', async () => {
+    const nonRepoPath = mkdtempSync(join(tmpdir(), 'gcctest-nonrepo-'))
+    await expect(
+      getWorkingDirectoryChanges(new Repository(nonRepoPath))
+    ).rejects.toThrow()
+    execSync(`rm -rf ${nonRepoPath}`)
+  })
+
+  it('includes oldPath for renamed files', async () => {
+    // Use an existing tracked file to avoid creating a commit
+    git(repoPath, 'mv README.md readme-backup.md')
+
+    const changes = await getWorkingDirectoryChanges(repo)
+    const renamed = changes.find(c => c.path === 'readme-backup.md')
+    expect(renamed).toBeTruthy()
+    expect(renamed!.status).toBe('renamed')
+    expect(renamed!.oldPath).toBe('README.md')
+
+    // Clean up: reverse the rename
+    git(repoPath, 'mv readme-backup.md README.md')
+  })
+})
+
+describe('getWorkingDirectoryChangesDetailed', () => {
+  it('includes selectionType and selection for each file', async () => {
+    // Modify an existing file
+    writeFileSync(join(repoPath, 'README.md'), 'detailed test')
+
+    const changes = await getWorkingDirectoryChangesDetailed(repo)
+
+    expect(changes.length).toBeGreaterThanOrEqual(1)
+
+    const modified = changes.find(c => c.path === 'README.md')
+    expect(modified).toBeTruthy()
+    expect(modified!.status).toBe('modified')
+    expect(modified!.selectionType).toBe(DiffSelectionType.All)
+    expect(modified!.selection).toBeTruthy()
+    // DiffSelection should report the file as fully selected
+    expect(modified!.selection.isSelected(0)).toBe(true)
+
+    // Clean up
+    git(repoPath, 'checkout -- README.md')
+  })
+
+  it('round-trips through fileChangeSummaryToWorkingDirectoryFile', async () => {
+    // Create a file and stage it so it appears as 'added'
+    writeFileSync(join(repoPath, 'stage-test.txt'), 'stage me')
+    git(repoPath, 'add stage-test.txt')
+
+    const changes = await getWorkingDirectoryChangesDetailed(repo)
+    const added = changes.find(c => c.path === 'stage-test.txt')
+    expect(added).toBeTruthy()
+    expect(added!.status).toBe('added')
+
+    // Round-trip back to WorkingDirectoryFileChange
+    const wdfc = fileChangeSummaryToWorkingDirectoryFile(added!)
+    expect(wdfc.path).toBe('stage-test.txt')
+    expect(wdfc.selection.getSelectionType()).toBe(DiffSelectionType.All)
+    // Verify the status was properly reconstructed
+    expect(wdfc.status.kind).toBe(AppFileStatusKind.New)
+
+    // Clean up: unstage and remove
+    git(repoPath, 'reset HEAD -- stage-test.txt')
+    execSync(`rm -f ${join(repoPath, 'stage-test.txt')}`)
+  })
+
+  it('preserves oldPath through round-trip for renamed files', async () => {
+    git(repoPath, 'mv README.md readme-backup.md')
+
+    const changes = await getWorkingDirectoryChangesDetailed(repo)
+    const renamed = changes.find(c => c.path === 'readme-backup.md')
+    expect(renamed).toBeTruthy()
+    expect(renamed!.oldPath).toBe('README.md')
+
+    // Round-trip
+    const wdfc = fileChangeSummaryToWorkingDirectoryFile(renamed!)
+    expect(wdfc.path).toBe('readme-backup.md')
+    expect(wdfc.status.kind).toBe(AppFileStatusKind.Renamed)
+    expect((wdfc.status as any).oldPath).toBe('README.md')
+
+    // Clean up: reverse the rename
+    git(repoPath, 'mv readme-backup.md README.md')
+  })
+})
+
 describe('getCommits', () => {
   it('returns commits in order (fixture has 6 commits reachable from main)', async () => {
     const commits = await getCommits(repo, 'HEAD', 10)
@@ -160,6 +274,181 @@ describe('Tag operations', () => {
     expect(tags.size).toBeGreaterThanOrEqual(1)
     expect(tags.has('v0.1.0')).toBe(true)
   })
+
+  it('getTags returns the same tags as getAllTags', async () => {
+    const tags = await getTags(repoPath)
+    expect(tags.length).toBeGreaterThanOrEqual(1)
+
+    const v010 = tags.find(t => t.name === 'v0.1.0')
+    expect(v010).toBeTruthy()
+    expect(v010!.sha).toMatch(/^[a-f0-9]{40}$/)
+
+    // Verify consistency with getAllTags
+    const allTags = await getAllTags(repo)
+    expect(tags.length).toBe(allTags.size)
+    for (const t of tags) {
+      expect(allTags.get(t.name)).toBe(t.sha)
+    }
+  })
+
+  it('getTags returns empty array for a tag-less repo', async () => {
+    const noTagPath = mkdtempSync(join(tmpdir(), 'gcctest-notags-'))
+    execSync(`git init ${noTagPath}`, { stdio: 'pipe' })
+    execSync(
+      `git -C ${noTagPath} commit --allow-empty -m 'init'`,
+      { stdio: 'pipe' }
+    )
+    const tags = await getTags(noTagPath)
+    expect(tags).toEqual([])
+    execSync(`rm -rf ${noTagPath}`)
+  })
+
+  it('getTags returns empty array for a non-repo path', async () => {
+    const nonRepoPath = mkdtempSync(join(tmpdir(), 'gcctest-nonrepo-'))
+    const tags = await getTags(nonRepoPath)
+    expect(tags).toEqual([])
+    execSync(`rm -rf ${nonRepoPath}`)
+  })
+})
+
+describe('getFileAtCommit', () => {
+  it('reads README.md at HEAD', async () => {
+    const content = await getFileAtCommit(repoPath, 'HEAD', 'README.md')
+    expect(content).toContain('# Test Repo')
+  })
+
+  it('reads a file at the initial commit', async () => {
+    const commits = await getCommits(repo, 'HEAD', 10)
+    const initialSha = commits[commits.length - 1].sha
+    const content = await getFileAtCommit(repoPath, initialSha, 'README.md')
+    expect(content).toContain('# Test Repo')
+  })
+
+  it('reads src/index.js at a commit where it exists', async () => {
+    // The second commit adds src/index.js with 'console.log("hi")'
+    const commits = await getCommits(repo, 'HEAD', 10)
+    // Second-to-last commit has the initial version
+    const secondCommit = commits[commits.length - 2].sha
+    const content = await getFileAtCommit(repoPath, secondCommit, 'src/index.js')
+    expect(content.trim()).toBe('console.log("hi")')
+  })
+
+  it('throws for a file that does not exist at the given commit', async () => {
+    await expect(
+      getFileAtCommit(repoPath, 'HEAD', 'nonexistent-file.txt')
+    ).rejects.toThrow()
+  })
+})
+
+describe('getChangedFilesFlat', () => {
+  it('returns flat file changes for the merge commit', async () => {
+    const commits = await getCommits(repo, 'HEAD', 10)
+    // The merge commit merged feature/one (which added feature-one.txt)
+    const mergeSha = commits[0].sha
+    const flat = await getChangedFilesFlat(repo, mergeSha)
+
+    expect(flat.length).toBeGreaterThanOrEqual(1)
+
+    // Each entry should have path and statusKind
+    for (const f of flat) {
+      expect(f).toHaveProperty('path')
+      expect(f).toHaveProperty('statusKind')
+      expect(Object.values(AppFileStatusKind)).toContain(f.statusKind)
+      // oldPath should only be present for Renamed/Copied files
+      if (f.statusKind === AppFileStatusKind.Renamed || f.statusKind === AppFileStatusKind.Copied) {
+        expect(f.oldPath).toBeTruthy()
+      } else {
+        expect(f.oldPath).toBeUndefined()
+      }
+    }
+  })
+
+  it('matches structure from getChangedFiles', async () => {
+    const commits = await getCommits(repo, 'HEAD', 10)
+    const mergeSha = commits[0].sha
+
+    const [flat, full] = await Promise.all([
+      getChangedFilesFlat(repo, mergeSha),
+      getChangedFiles(repo, mergeSha),
+    ])
+
+    expect(flat.length).toBe(full.files.length)
+
+    for (let i = 0; i < flat.length; i++) {
+      expect(flat[i].path).toBe(full.files[i].path)
+      expect(flat[i].statusKind).toBe(full.files[i].status.kind)
+
+      if (
+        full.files[i].status.kind === AppFileStatusKind.Renamed ||
+        full.files[i].status.kind === AppFileStatusKind.Copied
+      ) {
+        expect(flat[i].oldPath).toBe(full.files[i].status.oldPath)
+      }
+    }
+  })
+
+  it('throws for an unborn HEAD', async () => {
+    const unbornPath = mkdtempSync(join(tmpdir(), 'gcctest-unborn-'))
+    execSync(`git init ${unbornPath}`, { stdio: 'pipe' })
+    const unbornRepo = new Repository(unbornPath, 1)
+    // Cannot get changed files for a commit that doesn't exist
+    await expect(
+      getChangedFilesFlat(unbornRepo, 'HEAD')
+    ).rejects.toThrow()
+    execSync(`rm -rf ${unbornPath}`)
+  })
+})
+
+describe('getStashesByPath', () => {
+  it('returns empty stashes when no stash exists', async () => {
+    const result = await getStashesByPath(repoPath)
+    expect(result.desktopEntries).toEqual([])
+    expect(result.stashEntryCount).toBe(0)
+  })
+
+  it('returns same result as getStashes after creating a stash', async () => {
+    // Create a working directory change
+    writeFileSync(join(repoPath, 'stash-by-path-test.txt'), 'stash me')
+    git(repoPath, 'add stash-by-path-test.txt')
+
+    await createDesktopStashEntry(repo, 'main', [], null)
+
+    const byPath = await getStashesByPath(repoPath)
+    const byRepo = await getStashes(repo)
+
+    expect(byPath.desktopEntries.length).toBe(byRepo.desktopEntries.length)
+    expect(byPath.stashEntryCount).toBe(byRepo.stashEntryCount)
+
+    // Verify the entry has expected fields
+    const entry = byPath.desktopEntries[0]
+    expect(entry.branchName).toBe('main')
+    expect(entry.stashSha).toMatch(/^[a-f0-9]{40}$/)
+
+    // Clean up: pop the stash, unstage, and remove the test file
+    await popStashEntry(repo, entry.stashSha)
+    git(repoPath, 'reset HEAD -- stash-by-path-test.txt')
+    execSync(`rm -f ${join(repoPath, 'stash-by-path-test.txt')}`)
+  })
+
+  it('returns empty for a non-repo path', async () => {
+    const nonRepoPath = mkdtempSync(join(tmpdir(), 'gcctest-nonrepo-'))
+    const result = await getStashesByPath(nonRepoPath)
+    expect(result.desktopEntries).toEqual([])
+    expect(result.stashEntryCount).toBe(0)
+    execSync(`rm -rf ${nonRepoPath}`)
+  })
+})
+
+describe('appFileStatusToString', () => {
+  it('maps each status kind to a human-readable string', () => {
+    expect(appFileStatusToString({ kind: AppFileStatusKind.New })).toBe('Added')
+    expect(appFileStatusToString({ kind: AppFileStatusKind.Modified })).toBe('Modified')
+    expect(appFileStatusToString({ kind: AppFileStatusKind.Deleted })).toBe('Deleted')
+    expect(appFileStatusToString({ kind: AppFileStatusKind.Renamed })).toBe('Renamed')
+    expect(appFileStatusToString({ kind: AppFileStatusKind.Copied })).toBe('Copied')
+    expect(appFileStatusToString({ kind: AppFileStatusKind.Conflicted })).toBe('Conflicted')
+    expect(appFileStatusToString({ kind: AppFileStatusKind.Untracked })).toBe('Untracked')
+  })
 })
 
 describe('getRepositorySummary', () => {
@@ -240,6 +529,89 @@ describe('getRemotesFromPath', () => {
   })
 })
 
+describe('getRepositories', () => {
+  it('discovers the root repo when scanning from repo path', async () => {
+    // Scan the fixture repo — should find it at the root
+    const repos = await getRepositories(repoPath)
+    expect(repos.length).toBeGreaterThanOrEqual(1)
+
+    const root = repos.find(r => r.path === repoPath)
+    expect(root).toBeTruthy()
+    // The fixture is created in a temp dir, so name will be the temp dir name
+    expect(root!.path).toBe(repoPath)
+  })
+
+  it('finds nested repos in a monorepo-style layout', async () => {
+    const monorepoRoot = mkdtempSync(join(tmpdir(), 'gcctest-monorepo-'))
+    execSync(`git init ${monorepoRoot}`, { stdio: 'pipe' })
+    execSync(`git -C ${monorepoRoot} commit --allow-empty -m 'init'`, { stdio: 'pipe' })
+
+    const pkgA = join(monorepoRoot, 'packages', 'pkg-a')
+    const pkgB = join(monorepoRoot, 'packages', 'pkg-b')
+    execSync(`mkdir -p ${pkgA} ${pkgB}`)
+    execSync(`git init ${pkgA}`, { stdio: 'pipe' })
+    execSync(`git -C ${pkgA} commit --allow-empty -m 'init pkg-a'`, { stdio: 'pipe' })
+    execSync(`git init ${pkgB}`, { stdio: 'pipe' })
+    execSync(`git -C ${pkgB} commit --allow-empty -m 'init pkg-b'`, { stdio: 'pipe' })
+
+    const repos = await getRepositories(monorepoRoot)
+    expect(repos.length).toBe(3)
+
+    const paths = repos.map(r => r.path).sort()
+    expect(paths).toContain(monorepoRoot)
+    expect(paths).toContain(pkgA)
+    expect(paths).toContain(pkgB)
+
+    execSync(`rm -rf ${monorepoRoot}`)
+  })
+
+  it('skips node_modules directories', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'gcctest-skips-'))
+    execSync(`git init ${root}`, { stdio: 'pipe' })
+    execSync(`git -C ${root} commit --allow-empty -m 'init'`, { stdio: 'pipe' })
+
+    const nm = join(root, 'node_modules', 'some-lib')
+    execSync(`mkdir -p ${nm}`)
+    execSync(`git init ${nm}`, { stdio: 'pipe' })
+    execSync(`git -C ${nm} commit --allow-empty -m 'dep'`, { stdio: 'pipe' })
+
+    const repos = await getRepositories(root)
+    expect(repos.length).toBe(1)
+    expect(repos[0].path).toBe(root)
+
+    execSync(`rm -rf ${root}`)
+  })
+
+  it('obeys the depth limit', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'gcctest-depth-'))
+    execSync(`git init ${root}`, { stdio: 'pipe' })
+    execSync(`git -C ${root} commit --allow-empty -m 'init'`, { stdio: 'pipe' })
+
+    const deep = join(root, 'a', 'b', 'c')
+    execSync(`mkdir -p ${deep}`)
+    execSync(`git init ${deep}`, { stdio: 'pipe' })
+    execSync(`git -C ${deep} commit --allow-empty -m 'deep'`, { stdio: 'pipe' })
+
+    // With depth 2, should not find the deep repo
+    const repos = await getRepositories(root, { depth: 2 })
+    expect(repos.length).toBe(1)
+    expect(repos[0].path).toBe(root)
+
+    // With depth -1 (unlimited), should find the deep repo
+    const reposDeep = await getRepositories(root, { depth: -1 })
+    expect(reposDeep.length).toBe(2)
+
+    execSync(`rm -rf ${root}`)
+  })
+
+  it('returns empty array for a non-repo path', async () => {
+    const nonRepoPath = mkdtempSync(join(tmpdir(), 'gcctest-nonrepo-'))
+    const repos = await getRepositories(nonRepoPath)
+    expect(repos).toEqual([])
+    execSync(`rm -rf ${nonRepoPath}`)
+  })
+})
+
 describe('addRemote', () => {
   it('adds a new remote and returns it', async () => {
     const remote = await addRemote(repo, 'upstream', 'https://github.com/upstream/repo.git')