mirror of
https://gitea.toothfairyai.com/ToothFairyAI/tf_code.git
synced 2026-03-31 22:32:28 +00:00
32e6bcae3b
This ensures unicode and special characters in filenames are displayed correctly when generating diff patches, allowing proper file detection and revert operations
995 lines
30 KiB
TypeScript
995 lines
30 KiB
TypeScript
import { test, expect } from "bun:test"
|
|
import { $ } from "bun"
|
|
import { Snapshot } from "../../src/snapshot"
|
|
import { Instance } from "../../src/project/instance"
|
|
import { tmpdir } from "../fixture/fixture"
|
|
|
|
async function bootstrap() {
|
|
return tmpdir({
|
|
git: true,
|
|
init: async (dir) => {
|
|
const unique = Math.random().toString(36).slice(2)
|
|
const aContent = `A${unique}`
|
|
const bContent = `B${unique}`
|
|
await Bun.write(`${dir}/a.txt`, aContent)
|
|
await Bun.write(`${dir}/b.txt`, bContent)
|
|
await $`git add .`.cwd(dir).quiet()
|
|
await $`git commit --no-gpg-sign -m init`.cwd(dir).quiet()
|
|
return {
|
|
aContent,
|
|
bContent,
|
|
}
|
|
},
|
|
})
|
|
}
|
|
|
|
test("tracks deleted files correctly", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await $`rm ${tmp.path}/a.txt`.quiet()
|
|
|
|
expect((await Snapshot.patch(before!)).files).toContain(`${tmp.path}/a.txt`)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("revert should remove new files", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/new.txt`, "NEW")
|
|
|
|
await Snapshot.revert([await Snapshot.patch(before!)])
|
|
|
|
expect(await Bun.file(`${tmp.path}/new.txt`).exists()).toBe(false)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("revert in subdirectory", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await $`mkdir -p ${tmp.path}/sub`.quiet()
|
|
await Bun.write(`${tmp.path}/sub/file.txt`, "SUB")
|
|
|
|
await Snapshot.revert([await Snapshot.patch(before!)])
|
|
|
|
expect(await Bun.file(`${tmp.path}/sub/file.txt`).exists()).toBe(false)
|
|
// Note: revert currently only removes files, not directories
|
|
// The empty subdirectory will remain
|
|
},
|
|
})
|
|
})
|
|
|
|
test("multiple file operations", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await $`rm ${tmp.path}/a.txt`.quiet()
|
|
await Bun.write(`${tmp.path}/c.txt`, "C")
|
|
await $`mkdir -p ${tmp.path}/dir`.quiet()
|
|
await Bun.write(`${tmp.path}/dir/d.txt`, "D")
|
|
await Bun.write(`${tmp.path}/b.txt`, "MODIFIED")
|
|
|
|
await Snapshot.revert([await Snapshot.patch(before!)])
|
|
|
|
expect(await Bun.file(`${tmp.path}/a.txt`).text()).toBe(tmp.extra.aContent)
|
|
expect(await Bun.file(`${tmp.path}/c.txt`).exists()).toBe(false)
|
|
// Note: revert currently only removes files, not directories
|
|
// The empty directory will remain
|
|
expect(await Bun.file(`${tmp.path}/b.txt`).text()).toBe(tmp.extra.bContent)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("empty directory handling", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await $`mkdir ${tmp.path}/empty`.quiet()
|
|
|
|
expect((await Snapshot.patch(before!)).files.length).toBe(0)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("binary file handling", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/image.png`, new Uint8Array([0x89, 0x50, 0x4e, 0x47]))
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
expect(patch.files).toContain(`${tmp.path}/image.png`)
|
|
|
|
await Snapshot.revert([patch])
|
|
expect(await Bun.file(`${tmp.path}/image.png`).exists()).toBe(false)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("symlink handling", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await $`ln -s ${tmp.path}/a.txt ${tmp.path}/link.txt`.quiet()
|
|
|
|
expect((await Snapshot.patch(before!)).files).toContain(`${tmp.path}/link.txt`)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("large file handling", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/large.txt`, "x".repeat(1024 * 1024))
|
|
|
|
expect((await Snapshot.patch(before!)).files).toContain(`${tmp.path}/large.txt`)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("nested directory revert", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await $`mkdir -p ${tmp.path}/level1/level2/level3`.quiet()
|
|
await Bun.write(`${tmp.path}/level1/level2/level3/deep.txt`, "DEEP")
|
|
|
|
await Snapshot.revert([await Snapshot.patch(before!)])
|
|
|
|
expect(await Bun.file(`${tmp.path}/level1/level2/level3/deep.txt`).exists()).toBe(false)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("special characters in filenames", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/file with spaces.txt`, "SPACES")
|
|
await Bun.write(`${tmp.path}/file-with-dashes.txt`, "DASHES")
|
|
await Bun.write(`${tmp.path}/file_with_underscores.txt`, "UNDERSCORES")
|
|
|
|
const files = (await Snapshot.patch(before!)).files
|
|
expect(files).toContain(`${tmp.path}/file with spaces.txt`)
|
|
expect(files).toContain(`${tmp.path}/file-with-dashes.txt`)
|
|
expect(files).toContain(`${tmp.path}/file_with_underscores.txt`)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("revert with empty patches", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
// Should not crash with empty patches
|
|
expect(Snapshot.revert([])).resolves.toBeUndefined()
|
|
|
|
// Should not crash with patches that have empty file lists
|
|
expect(Snapshot.revert([{ hash: "dummy", files: [] }])).resolves.toBeUndefined()
|
|
},
|
|
})
|
|
})
|
|
|
|
test("patch with invalid hash", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
// Create a change
|
|
await Bun.write(`${tmp.path}/test.txt`, "TEST")
|
|
|
|
// Try to patch with invalid hash - should handle gracefully
|
|
const patch = await Snapshot.patch("invalid-hash-12345")
|
|
expect(patch.files).toEqual([])
|
|
expect(patch.hash).toBe("invalid-hash-12345")
|
|
},
|
|
})
|
|
})
|
|
|
|
test("revert non-existent file", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
// Try to revert a file that doesn't exist in the snapshot
|
|
// This should not crash
|
|
expect(
|
|
Snapshot.revert([
|
|
{
|
|
hash: before!,
|
|
files: [`${tmp.path}/nonexistent.txt`],
|
|
},
|
|
]),
|
|
).resolves.toBeUndefined()
|
|
},
|
|
})
|
|
})
|
|
|
|
test("unicode filenames", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
const unicodeFiles = [
|
|
{ path: `${tmp.path}/文件.txt`, content: "chinese content" },
|
|
{ path: `${tmp.path}/🚀rocket.txt`, content: "emoji content" },
|
|
{ path: `${tmp.path}/café.txt`, content: "accented content" },
|
|
{ path: `${tmp.path}/файл.txt`, content: "cyrillic content" },
|
|
]
|
|
|
|
for (const file of unicodeFiles) {
|
|
await Bun.write(file.path, file.content)
|
|
}
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
expect(patch.files.length).toBe(4)
|
|
|
|
for (const file of unicodeFiles) {
|
|
expect(patch.files).toContain(file.path)
|
|
}
|
|
|
|
await Snapshot.revert([patch])
|
|
|
|
for (const file of unicodeFiles) {
|
|
expect(await Bun.file(file.path).exists()).toBe(false)
|
|
}
|
|
},
|
|
})
|
|
})
|
|
|
|
test("unicode filenames modification and restore", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const chineseFile = `${tmp.path}/文件.txt`
|
|
const cyrillicFile = `${tmp.path}/файл.txt`
|
|
|
|
await Bun.write(chineseFile, "original chinese")
|
|
await Bun.write(cyrillicFile, "original cyrillic")
|
|
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(chineseFile, "modified chinese")
|
|
await Bun.write(cyrillicFile, "modified cyrillic")
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
expect(patch.files).toContain(chineseFile)
|
|
expect(patch.files).toContain(cyrillicFile)
|
|
|
|
await Snapshot.revert([patch])
|
|
|
|
expect(await Bun.file(chineseFile).text()).toBe("original chinese")
|
|
expect(await Bun.file(cyrillicFile).text()).toBe("original cyrillic")
|
|
},
|
|
})
|
|
})
|
|
|
|
test("unicode filenames in subdirectories", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await $`mkdir -p "${tmp.path}/目录/подкаталог"`.quiet()
|
|
const deepFile = `${tmp.path}/目录/подкаталог/文件.txt`
|
|
await Bun.write(deepFile, "deep unicode content")
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
expect(patch.files).toContain(deepFile)
|
|
|
|
await Snapshot.revert([patch])
|
|
expect(await Bun.file(deepFile).exists()).toBe(false)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("very long filenames", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
const longName = "a".repeat(200) + ".txt"
|
|
const longFile = `${tmp.path}/${longName}`
|
|
|
|
await Bun.write(longFile, "long filename content")
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
expect(patch.files).toContain(longFile)
|
|
|
|
await Snapshot.revert([patch])
|
|
expect(await Bun.file(longFile).exists()).toBe(false)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("hidden files", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/.hidden`, "hidden content")
|
|
await Bun.write(`${tmp.path}/.gitignore`, "*.log")
|
|
await Bun.write(`${tmp.path}/.config`, "config content")
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
expect(patch.files).toContain(`${tmp.path}/.hidden`)
|
|
expect(patch.files).toContain(`${tmp.path}/.gitignore`)
|
|
expect(patch.files).toContain(`${tmp.path}/.config`)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("nested symlinks", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await $`mkdir -p ${tmp.path}/sub/dir`.quiet()
|
|
await Bun.write(`${tmp.path}/sub/dir/target.txt`, "target content")
|
|
await $`ln -s ${tmp.path}/sub/dir/target.txt ${tmp.path}/sub/dir/link.txt`.quiet()
|
|
await $`ln -s ${tmp.path}/sub ${tmp.path}/sub-link`.quiet()
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
expect(patch.files).toContain(`${tmp.path}/sub/dir/link.txt`)
|
|
expect(patch.files).toContain(`${tmp.path}/sub-link`)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("file permissions and ownership changes", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
// Change permissions multiple times
|
|
await $`chmod 600 ${tmp.path}/a.txt`.quiet()
|
|
await $`chmod 755 ${tmp.path}/a.txt`.quiet()
|
|
await $`chmod 644 ${tmp.path}/a.txt`.quiet()
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
// Note: git doesn't track permission changes on existing files by default
|
|
// Only tracks executable bit when files are first added
|
|
expect(patch.files.length).toBe(0)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("circular symlinks", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
// Create circular symlink
|
|
await $`ln -s ${tmp.path}/circular ${tmp.path}/circular`.quiet().nothrow()
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
expect(patch.files.length).toBeGreaterThanOrEqual(0) // Should not crash
|
|
},
|
|
})
|
|
})
|
|
|
|
test("gitignore changes", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/.gitignore`, "*.ignored")
|
|
await Bun.write(`${tmp.path}/test.ignored`, "ignored content")
|
|
await Bun.write(`${tmp.path}/normal.txt`, "normal content")
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
|
|
// Should track gitignore itself
|
|
expect(patch.files).toContain(`${tmp.path}/.gitignore`)
|
|
// Should track normal files
|
|
expect(patch.files).toContain(`${tmp.path}/normal.txt`)
|
|
// Should not track ignored files (git won't see them)
|
|
expect(patch.files).not.toContain(`${tmp.path}/test.ignored`)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("concurrent file operations during patch", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
// Start creating files
|
|
const createPromise = (async () => {
|
|
for (let i = 0; i < 10; i++) {
|
|
await Bun.write(`${tmp.path}/concurrent${i}.txt`, `concurrent${i}`)
|
|
// Small delay to simulate concurrent operations
|
|
await new Promise((resolve) => setTimeout(resolve, 1))
|
|
}
|
|
})()
|
|
|
|
// Get patch while files are being created
|
|
const patchPromise = Snapshot.patch(before!)
|
|
|
|
await createPromise
|
|
const patch = await patchPromise
|
|
|
|
// Should capture some or all of the concurrent files
|
|
expect(patch.files.length).toBeGreaterThanOrEqual(0)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("snapshot state isolation between projects", async () => {
|
|
// Test that different projects don't interfere with each other
|
|
await using tmp1 = await bootstrap()
|
|
await using tmp2 = await bootstrap()
|
|
|
|
await Instance.provide({
|
|
directory: tmp1.path,
|
|
fn: async () => {
|
|
const before1 = await Snapshot.track()
|
|
await Bun.write(`${tmp1.path}/project1.txt`, "project1 content")
|
|
const patch1 = await Snapshot.patch(before1!)
|
|
expect(patch1.files).toContain(`${tmp1.path}/project1.txt`)
|
|
},
|
|
})
|
|
|
|
await Instance.provide({
|
|
directory: tmp2.path,
|
|
fn: async () => {
|
|
const before2 = await Snapshot.track()
|
|
await Bun.write(`${tmp2.path}/project2.txt`, "project2 content")
|
|
const patch2 = await Snapshot.patch(before2!)
|
|
expect(patch2.files).toContain(`${tmp2.path}/project2.txt`)
|
|
|
|
// Ensure project1 files don't appear in project2
|
|
expect(patch2.files).not.toContain(`${tmp1?.path}/project1.txt`)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("patch detects changes in secondary worktree", async () => {
|
|
await using tmp = await bootstrap()
|
|
const worktreePath = `${tmp.path}-worktree`
|
|
await $`git worktree add ${worktreePath} HEAD`.cwd(tmp.path).quiet()
|
|
|
|
try {
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
expect(await Snapshot.track()).toBeTruthy()
|
|
},
|
|
})
|
|
|
|
await Instance.provide({
|
|
directory: worktreePath,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
const worktreeFile = `${worktreePath}/worktree.txt`
|
|
await Bun.write(worktreeFile, "worktree content")
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
expect(patch.files).toContain(worktreeFile)
|
|
},
|
|
})
|
|
} finally {
|
|
await $`git worktree remove --force ${worktreePath}`.cwd(tmp.path).quiet().nothrow()
|
|
await $`rm -rf ${worktreePath}`.quiet()
|
|
}
|
|
})
|
|
|
|
test("revert only removes files in invoking worktree", async () => {
|
|
await using tmp = await bootstrap()
|
|
const worktreePath = `${tmp.path}-worktree`
|
|
await $`git worktree add ${worktreePath} HEAD`.cwd(tmp.path).quiet()
|
|
|
|
try {
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
expect(await Snapshot.track()).toBeTruthy()
|
|
},
|
|
})
|
|
const primaryFile = `${tmp.path}/worktree.txt`
|
|
await Bun.write(primaryFile, "primary content")
|
|
|
|
await Instance.provide({
|
|
directory: worktreePath,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
const worktreeFile = `${worktreePath}/worktree.txt`
|
|
await Bun.write(worktreeFile, "worktree content")
|
|
|
|
const patch = await Snapshot.patch(before!)
|
|
await Snapshot.revert([patch])
|
|
|
|
expect(await Bun.file(worktreeFile).exists()).toBe(false)
|
|
},
|
|
})
|
|
|
|
expect(await Bun.file(primaryFile).text()).toBe("primary content")
|
|
} finally {
|
|
await $`git worktree remove --force ${worktreePath}`.cwd(tmp.path).quiet().nothrow()
|
|
await $`rm -rf ${worktreePath}`.quiet()
|
|
await $`rm -f ${tmp.path}/worktree.txt`.quiet()
|
|
}
|
|
})
|
|
|
|
test("diff reports worktree-only/shared edits and ignores primary-only", async () => {
|
|
await using tmp = await bootstrap()
|
|
const worktreePath = `${tmp.path}-worktree`
|
|
await $`git worktree add ${worktreePath} HEAD`.cwd(tmp.path).quiet()
|
|
|
|
try {
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
expect(await Snapshot.track()).toBeTruthy()
|
|
},
|
|
})
|
|
|
|
await Instance.provide({
|
|
directory: worktreePath,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${worktreePath}/worktree-only.txt`, "worktree diff content")
|
|
await Bun.write(`${worktreePath}/shared.txt`, "worktree edit")
|
|
await Bun.write(`${tmp.path}/shared.txt`, "primary edit")
|
|
await Bun.write(`${tmp.path}/primary-only.txt`, "primary change")
|
|
|
|
const diff = await Snapshot.diff(before!)
|
|
expect(diff).toContain("worktree-only.txt")
|
|
expect(diff).toContain("shared.txt")
|
|
expect(diff).not.toContain("primary-only.txt")
|
|
},
|
|
})
|
|
} finally {
|
|
await $`git worktree remove --force ${worktreePath}`.cwd(tmp.path).quiet().nothrow()
|
|
await $`rm -rf ${worktreePath}`.quiet()
|
|
await $`rm -f ${tmp.path}/shared.txt`.quiet()
|
|
await $`rm -f ${tmp.path}/primary-only.txt`.quiet()
|
|
}
|
|
})
|
|
|
|
test("track with no changes returns same hash", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const hash1 = await Snapshot.track()
|
|
expect(hash1).toBeTruthy()
|
|
|
|
// Track again with no changes
|
|
const hash2 = await Snapshot.track()
|
|
expect(hash2).toBe(hash1!)
|
|
|
|
// Track again
|
|
const hash3 = await Snapshot.track()
|
|
expect(hash3).toBe(hash1!)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diff function with various changes", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
// Make various changes
|
|
await $`rm ${tmp.path}/a.txt`.quiet()
|
|
await Bun.write(`${tmp.path}/new.txt`, "new content")
|
|
await Bun.write(`${tmp.path}/b.txt`, "modified content")
|
|
|
|
const diff = await Snapshot.diff(before!)
|
|
expect(diff).toContain("a.txt")
|
|
expect(diff).toContain("b.txt")
|
|
expect(diff).toContain("new.txt")
|
|
},
|
|
})
|
|
})
|
|
|
|
test("restore function", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
// Make changes
|
|
await $`rm ${tmp.path}/a.txt`.quiet()
|
|
await Bun.write(`${tmp.path}/new.txt`, "new content")
|
|
await Bun.write(`${tmp.path}/b.txt`, "modified")
|
|
|
|
// Restore to original state
|
|
await Snapshot.restore(before!)
|
|
|
|
expect(await Bun.file(`${tmp.path}/a.txt`).exists()).toBe(true)
|
|
expect(await Bun.file(`${tmp.path}/a.txt`).text()).toBe(tmp.extra.aContent)
|
|
expect(await Bun.file(`${tmp.path}/new.txt`).exists()).toBe(true) // New files should remain
|
|
expect(await Bun.file(`${tmp.path}/b.txt`).text()).toBe(tmp.extra.bContent)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("revert should not delete files that existed but were deleted in snapshot", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const snapshot1 = await Snapshot.track()
|
|
expect(snapshot1).toBeTruthy()
|
|
|
|
await $`rm ${tmp.path}/a.txt`.quiet()
|
|
|
|
const snapshot2 = await Snapshot.track()
|
|
expect(snapshot2).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/a.txt`, "recreated content")
|
|
|
|
const patch = await Snapshot.patch(snapshot2!)
|
|
expect(patch.files).toContain(`${tmp.path}/a.txt`)
|
|
|
|
await Snapshot.revert([patch])
|
|
|
|
expect(await Bun.file(`${tmp.path}/a.txt`).exists()).toBe(false)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("revert preserves file that existed in snapshot when deleted then recreated", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
await Bun.write(`${tmp.path}/existing.txt`, "original content")
|
|
|
|
const snapshot = await Snapshot.track()
|
|
expect(snapshot).toBeTruthy()
|
|
|
|
await $`rm ${tmp.path}/existing.txt`.quiet()
|
|
await Bun.write(`${tmp.path}/existing.txt`, "recreated")
|
|
await Bun.write(`${tmp.path}/newfile.txt`, "new")
|
|
|
|
const patch = await Snapshot.patch(snapshot!)
|
|
expect(patch.files).toContain(`${tmp.path}/existing.txt`)
|
|
expect(patch.files).toContain(`${tmp.path}/newfile.txt`)
|
|
|
|
await Snapshot.revert([patch])
|
|
|
|
expect(await Bun.file(`${tmp.path}/newfile.txt`).exists()).toBe(false)
|
|
expect(await Bun.file(`${tmp.path}/existing.txt`).exists()).toBe(true)
|
|
expect(await Bun.file(`${tmp.path}/existing.txt`).text()).toBe("original content")
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diffFull with new file additions", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/new.txt`, "new content")
|
|
|
|
const after = await Snapshot.track()
|
|
expect(after).toBeTruthy()
|
|
|
|
const diffs = await Snapshot.diffFull(before!, after!)
|
|
expect(diffs.length).toBe(1)
|
|
|
|
const newFileDiff = diffs[0]
|
|
expect(newFileDiff.file).toBe("new.txt")
|
|
expect(newFileDiff.before).toBe("")
|
|
expect(newFileDiff.after).toBe("new content")
|
|
expect(newFileDiff.additions).toBe(1)
|
|
expect(newFileDiff.deletions).toBe(0)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diffFull with file modifications", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/b.txt`, "modified content")
|
|
|
|
const after = await Snapshot.track()
|
|
expect(after).toBeTruthy()
|
|
|
|
const diffs = await Snapshot.diffFull(before!, after!)
|
|
expect(diffs.length).toBe(1)
|
|
|
|
const modifiedFileDiff = diffs[0]
|
|
expect(modifiedFileDiff.file).toBe("b.txt")
|
|
expect(modifiedFileDiff.before).toBe(tmp.extra.bContent)
|
|
expect(modifiedFileDiff.after).toBe("modified content")
|
|
expect(modifiedFileDiff.additions).toBeGreaterThan(0)
|
|
expect(modifiedFileDiff.deletions).toBeGreaterThan(0)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diffFull with file deletions", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await $`rm ${tmp.path}/a.txt`.quiet()
|
|
|
|
const after = await Snapshot.track()
|
|
expect(after).toBeTruthy()
|
|
|
|
const diffs = await Snapshot.diffFull(before!, after!)
|
|
expect(diffs.length).toBe(1)
|
|
|
|
const removedFileDiff = diffs[0]
|
|
expect(removedFileDiff.file).toBe("a.txt")
|
|
expect(removedFileDiff.before).toBe(tmp.extra.aContent)
|
|
expect(removedFileDiff.after).toBe("")
|
|
expect(removedFileDiff.additions).toBe(0)
|
|
expect(removedFileDiff.deletions).toBe(1)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diffFull with multiple line additions", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/multi.txt`, "line1\nline2\nline3")
|
|
|
|
const after = await Snapshot.track()
|
|
expect(after).toBeTruthy()
|
|
|
|
const diffs = await Snapshot.diffFull(before!, after!)
|
|
expect(diffs.length).toBe(1)
|
|
|
|
const multiDiff = diffs[0]
|
|
expect(multiDiff.file).toBe("multi.txt")
|
|
expect(multiDiff.before).toBe("")
|
|
expect(multiDiff.after).toBe("line1\nline2\nline3")
|
|
expect(multiDiff.additions).toBe(3)
|
|
expect(multiDiff.deletions).toBe(0)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diffFull with addition and deletion", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/added.txt`, "added content")
|
|
await $`rm ${tmp.path}/a.txt`.quiet()
|
|
|
|
const after = await Snapshot.track()
|
|
expect(after).toBeTruthy()
|
|
|
|
const diffs = await Snapshot.diffFull(before!, after!)
|
|
expect(diffs.length).toBe(2)
|
|
|
|
const addedFileDiff = diffs.find((d) => d.file === "added.txt")
|
|
expect(addedFileDiff).toBeDefined()
|
|
expect(addedFileDiff!.before).toBe("")
|
|
expect(addedFileDiff!.after).toBe("added content")
|
|
expect(addedFileDiff!.additions).toBe(1)
|
|
expect(addedFileDiff!.deletions).toBe(0)
|
|
|
|
const removedFileDiff = diffs.find((d) => d.file === "a.txt")
|
|
expect(removedFileDiff).toBeDefined()
|
|
expect(removedFileDiff!.before).toBe(tmp.extra.aContent)
|
|
expect(removedFileDiff!.after).toBe("")
|
|
expect(removedFileDiff!.additions).toBe(0)
|
|
expect(removedFileDiff!.deletions).toBe(1)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diffFull with multiple additions and deletions", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/multi1.txt`, "line1\nline2\nline3")
|
|
await Bun.write(`${tmp.path}/multi2.txt`, "single line")
|
|
await $`rm ${tmp.path}/a.txt`.quiet()
|
|
await $`rm ${tmp.path}/b.txt`.quiet()
|
|
|
|
const after = await Snapshot.track()
|
|
expect(after).toBeTruthy()
|
|
|
|
const diffs = await Snapshot.diffFull(before!, after!)
|
|
expect(diffs.length).toBe(4)
|
|
|
|
const multi1Diff = diffs.find((d) => d.file === "multi1.txt")
|
|
expect(multi1Diff).toBeDefined()
|
|
expect(multi1Diff!.additions).toBe(3)
|
|
expect(multi1Diff!.deletions).toBe(0)
|
|
|
|
const multi2Diff = diffs.find((d) => d.file === "multi2.txt")
|
|
expect(multi2Diff).toBeDefined()
|
|
expect(multi2Diff!.additions).toBe(1)
|
|
expect(multi2Diff!.deletions).toBe(0)
|
|
|
|
const removedADiff = diffs.find((d) => d.file === "a.txt")
|
|
expect(removedADiff).toBeDefined()
|
|
expect(removedADiff!.additions).toBe(0)
|
|
expect(removedADiff!.deletions).toBe(1)
|
|
|
|
const removedBDiff = diffs.find((d) => d.file === "b.txt")
|
|
expect(removedBDiff).toBeDefined()
|
|
expect(removedBDiff!.additions).toBe(0)
|
|
expect(removedBDiff!.deletions).toBe(1)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diffFull with no changes", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
const after = await Snapshot.track()
|
|
expect(after).toBeTruthy()
|
|
|
|
const diffs = await Snapshot.diffFull(before!, after!)
|
|
expect(diffs.length).toBe(0)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diffFull with binary file changes", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/binary.bin`, new Uint8Array([0x00, 0x01, 0x02, 0x03]))
|
|
|
|
const after = await Snapshot.track()
|
|
expect(after).toBeTruthy()
|
|
|
|
const diffs = await Snapshot.diffFull(before!, after!)
|
|
expect(diffs.length).toBe(1)
|
|
|
|
const binaryDiff = diffs[0]
|
|
expect(binaryDiff.file).toBe("binary.bin")
|
|
expect(binaryDiff.before).toBe("")
|
|
},
|
|
})
|
|
})
|
|
|
|
test("diffFull with whitespace changes", async () => {
|
|
await using tmp = await bootstrap()
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
await Bun.write(`${tmp.path}/whitespace.txt`, "line1\nline2")
|
|
const before = await Snapshot.track()
|
|
expect(before).toBeTruthy()
|
|
|
|
await Bun.write(`${tmp.path}/whitespace.txt`, "line1\n\nline2\n")
|
|
|
|
const after = await Snapshot.track()
|
|
expect(after).toBeTruthy()
|
|
|
|
const diffs = await Snapshot.diffFull(before!, after!)
|
|
expect(diffs.length).toBe(1)
|
|
|
|
const whitespaceDiff = diffs[0]
|
|
expect(whitespaceDiff.file).toBe("whitespace.txt")
|
|
expect(whitespaceDiff.additions).toBeGreaterThan(0)
|
|
},
|
|
})
|
|
})
|