@filen/sync 0.2.1 → 0.3.2

package/tests/e2e/conflict.e2e.test.ts

@@ -0,0 +1,261 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest"
+import type FilenSDK from "@filen/sdk"
+import { E2E_ENABLED, loginTestSDK, teardownTestSDK } from "./harness/account"
+import { withE2EWorld } from "./harness/world"
+import { settle, expectConverged } from "./harness/drive"
+import { snapshotRemoteReal } from "./harness/assert"
+import {
+	writeLocal,
+	modifyLocal,
+	rmLocal,
+	renameLocal,
+	readLocal,
+	uploadRemote,
+	deleteRemote,
+	renameRemote,
+	setLocalMtime,
+	existsLocal
+} from "./harness/mutations"
+
+/**
+ * Phase 3 e2e — twoWay conflict resolution against the live backend (both sides changed since the last
+ * sync). The mtime helper makes the local side deterministically newer where "newest wins" applies.
+ */
+describe.skipIf(!E2E_ENABLED)("E2E — twoWay conflict resolution", () => {
+	let sdk: FilenSDK
+
+	beforeAll(async () => {
+		sdk = await loginTestSDK()
+	}, 300_000)
+
+	afterAll(async () => {
+		await teardownTestSDK()
+	})
+
+	it("both sides create the same path; the newer (local) copy wins", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			// Local copy stamped clearly-newer than the remote upload that follows.
+			await modifyLocal(world, "c.txt", "LOCAL-WINS")
+			await uploadRemote(world, "c.txt", "remote-loses")
+
+			await settle(world)
+
+			await expectConverged(world)
+			expect(await readLocal(world, "c.txt")).toBe("LOCAL-WINS")
+		})
+	})
+
+	it("local modify vs remote delete: the newer local modification wins, resurrected (E2E-OBS-001)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "f.txt", "v1")
+			await settle(world)
+
+			// The local copy is edited (content changed) while the remote deletes it. Per newer-modify-wins
+			// the local modification survives the deletion: the file is re-uploaded (resurrected) remotely
+			// and kept locally with the local content, rather than being removed on both sides.
+			await modifyLocal(world, "f.txt", "v2-modified")
+			await deleteRemote(world, "f.txt")
+
+			await settle(world)
+
+			await expectConverged(world)
+			expect(await existsLocal(world, "f.txt")).toBe(true)
+			expect(await readLocal(world, "f.txt")).toBe("v2-modified")
+			expect((await snapshotRemoteReal(world))["/f.txt"]).toMatchObject({ type: "file" })
+		})
+	})
+
+	it("local delete vs remote-unchanged: the delete propagates", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "g.txt", "data")
+			await settle(world)
+
+			await rmLocal(world, "g.txt")
+
+			await settle(world)
+
+			expect((await snapshotRemoteReal(world))["/g.txt"]).toBeUndefined()
+			await expectConverged(world)
+		})
+	})
+
+	it("remote modify vs local delete: the newer remote modification wins, resurrected (F7)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "h.txt", "v1")
+			await settle(world)
+
+			// Symmetric to the local-modify-vs-remote-delete case: the local copy is deleted while the remote
+			// modifies it (a new version). The newer modification wins on EITHER side, so the file survives.
+			await rmLocal(world, "h.txt")
+			await uploadRemote(world, "h.txt", "REMOTE-MODIFIED")
+
+			await settle(world)
+
+			await expectConverged(world)
+			expect(await existsLocal(world, "h.txt")).toBe(true)
+			expect(await readLocal(world, "h.txt")).toBe("REMOTE-MODIFIED")
+		})
+	})
+
+	it("rename + in-place modify in one beat keeps the new name AND the new content (F1)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "original-content")
+			await settle(world)
+
+			// Rename, then immediately overwrite the renamed file before the next sync. The rename must not
+			// mask the content change — the remote ends with the NEW bytes under the new name.
+			await renameLocal(world, "a.txt", "b.txt")
+			await writeLocal(world, "b.txt", "BRAND-NEW-CONTENT")
+
+			await settle(world)
+
+			await expectConverged(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/a.txt"]).toBeUndefined()
+			expect(remote["/b.txt"]).toMatchObject({ type: "file" })
+			expect(await readLocal(world, "b.txt")).toBe("BRAND-NEW-CONTENT")
+		})
+	})
+
+	// --- Conflict-matrix parity with mocked Category Y (the trickiest rename-vs-other-side cases) ---
+
+	it("add(local) vs add(remote) same path, remote newer → the remote copy wins (Y2)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "addboth.txt", "LOCAL-OLDER")
+			// Age the local copy so the remote upload that follows is unambiguously newer.
+			await setLocalMtime(world, "addboth.txt", Date.now() - 60_000)
+			await uploadRemote(world, "addboth.txt", "REMOTE-NEWER")
+
+			await settle(world)
+
+			await expectConverged(world)
+			expect(await readLocal(world, "addboth.txt")).toBe("REMOTE-NEWER")
+		})
+	})
+
+	it("delete(local) vs delete(remote) same path → converges to empty, no error (Y3)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "doomed.txt", "bye")
+			await settle(world)
+
+			await rmLocal(world, "doomed.txt")
+			await deleteRemote(world, "doomed.txt")
+
+			await settle(world)
+
+			await expectConverged(world)
+			expect((await snapshotRemoteReal(world))["/doomed.txt"]).toBeUndefined()
+			expect(await existsLocal(world, "doomed.txt")).toBe(false)
+		})
+	})
+
+	it("rename(local a→b) vs delete(remote a) → converges to {b}, data preserved (Y7)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "data")
+			await settle(world)
+
+			await renameLocal(world, "a.txt", "b.txt")
+			await deleteRemote(world, "a.txt")
+
+			await settle(world)
+
+			await expectConverged(world)
+			const remote = await snapshotRemoteReal(world)
+			expect(remote["/a.txt"]).toBeUndefined()
+			expect(remote["/b.txt"]).toMatchObject({ type: "file" })
+			expect(await existsLocal(world, "b.txt")).toBe(true)
+		})
+	})
+
+	it("rename(local a→b) vs modify(remote a) → converges keeping BOTH a and b (Y8)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "orig")
+			await settle(world)
+
+			await renameLocal(world, "a.txt", "b.txt")
+			await uploadRemote(world, "a.txt", "REMOTE-MOD")
+
+			await settle(world)
+
+			await expectConverged(world)
+			const remote = await snapshotRemoteReal(world)
+			expect(remote["/a.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/b.txt"]).toMatchObject({ type: "file" })
+			expect(await readLocal(world, "a.txt")).toBe("REMOTE-MOD")
+			expect(await readLocal(world, "b.txt")).toBe("orig")
+		})
+	})
+
+	it("rename(local a→X) vs rename(remote a→Y) → converges keeping BOTH X and Y (Y9)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "data")
+			await settle(world)
+
+			await renameLocal(world, "a.txt", "local-name.txt")
+			await renameRemote(world, "a.txt", "remote-name.txt")
+
+			await settle(world)
+
+			await expectConverged(world)
+			const remote = await snapshotRemoteReal(world)
+			expect(remote["/local-name.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/remote-name.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/a.txt"]).toBeUndefined()
+		})
+	})
+
+	it("rename(remote a→b) vs delete(local a) → converges to {b}, data preserved (Y10)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "data")
+			await settle(world)
+
+			await renameRemote(world, "a.txt", "b.txt")
+			await rmLocal(world, "a.txt")
+
+			await settle(world)
+
+			await expectConverged(world)
+			const remote = await snapshotRemoteReal(world)
+			expect(remote["/a.txt"]).toBeUndefined()
+			expect(remote["/b.txt"]).toMatchObject({ type: "file" })
+		})
+	})
+
+	it("rename(remote a→b) vs modify(local a) → converges keeping BOTH a and b (Y11)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "orig")
+			await settle(world)
+
+			await renameRemote(world, "a.txt", "b.txt")
+			await modifyLocal(world, "a.txt", "LOCAL-MOD")
+
+			await settle(world)
+
+			await expectConverged(world)
+			const remote = await snapshotRemoteReal(world)
+			expect(remote["/a.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/b.txt"]).toMatchObject({ type: "file" })
+			expect(await readLocal(world, "a.txt")).toBe("LOCAL-MOD")
+			expect(await readLocal(world, "b.txt")).toBe("orig")
+		})
+	})
+
+	it("delete(local a) + add(remote b) in one cycle → both applied, converges (Y12)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "data")
+			await settle(world)
+
+			await rmLocal(world, "a.txt")
+			await uploadRemote(world, "b.txt", "new-remote")
+
+			await settle(world)
+
+			await expectConverged(world)
+			const remote = await snapshotRemoteReal(world)
+			expect(remote["/a.txt"]).toBeUndefined()
+			expect(remote["/b.txt"]).toMatchObject({ type: "file" })
+		})
+	})
+})

package/tests/e2e/edge.e2e.test.ts

@@ -0,0 +1,339 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest"
+import type FilenSDK from "@filen/sdk"
+import { E2E_ENABLED, loginTestSDK, teardownTestSDK } from "./harness/account"
+import { withE2EWorld } from "./harness/world"
+import { cycle, settle, expectConverged, transferKinds } from "./harness/drive"
+import { snapshotRemoteReal, snapshotLocalReal } from "./harness/assert"
+import {
+	writeLocal,
+	mkdirLocal,
+	rmLocal,
+	renameLocal,
+	uploadRemote,
+	existsLocal,
+	renameRemoteDir,
+	deleteRemote,
+	modifyLocal,
+	readLocal
+} from "./harness/mutations"
+
+/**
+ * Phase 3 e2e — structural and naming edge cases against the live backend. Heavy on directory
+ * renames/moves (the delta-collapse path, BUG-004) and unusual names. All tiny files.
+ */
+describe.skipIf(!E2E_ENABLED)("E2E — structural & naming edge cases", () => {
+	let sdk: FilenSDK
+
+	beforeAll(async () => {
+		sdk = await loginTestSDK()
+	}, 300_000)
+
+	afterAll(async () => {
+		await teardownTestSDK()
+	})
+
+	it("renames a directory and carries its children (collapse to one parent op)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "parent/a.txt", "a")
+			await writeLocal(world, "parent/sub/b.txt", "b")
+			await settle(world)
+
+			await renameLocal(world, "parent", "parent2")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/parent"]).toBeUndefined()
+			expect(remote["/parent2/a.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/parent2/sub/b.txt"]).toMatchObject({ type: "file" })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("renames a parent dir AND a child within it in one beat (BUG-004 composition)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "p/child.txt", "x")
+			await settle(world)
+
+			// Parent rename + child rename composed in a single cycle.
+			await renameLocal(world, "p", "p2")
+			await renameLocal(world, "p2/child.txt", "p2/child2.txt")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/p"]).toBeUndefined()
+			expect(remote["/p2/child.txt"]).toBeUndefined()
+			expect(remote["/p2/child2.txt"]).toMatchObject({ type: "file" })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("moves a subtree into another directory", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "src/inner/file.txt", "data")
+			await mkdirLocal(world, "dest")
+			await settle(world)
+
+			await renameLocal(world, "src", "dest/src")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/src"]).toBeUndefined()
+			expect(remote["/dest/src/inner/file.txt"]).toMatchObject({ type: "file" })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("deletes an entire directory tree", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "tree/a.txt", "a")
+			await writeLocal(world, "tree/deep/b.txt", "b")
+			await writeLocal(world, "keep.txt", "k")
+			await settle(world)
+
+			await rmLocal(world, "tree")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/tree"]).toBeUndefined()
+			expect(remote["/tree/a.txt"]).toBeUndefined()
+			expect(remote["/tree/deep/b.txt"]).toBeUndefined()
+			expect(remote["/keep.txt"]).toMatchObject({ type: "file" })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("syncs files with spaces, unicode, and emoji in their names", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a file with spaces.txt", "1")
+			await writeLocal(world, "ünïcödé/naïve café.txt", "2")
+			await writeLocal(world, "emoji 🚀 rocket.txt", "3")
+
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/a file with spaces.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/ünïcödé/naïve café.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/emoji 🚀 rocket.txt"]).toMatchObject({ type: "file" })
+
+			await expectConverged(world)
+		})
+	})
+
+	// E2E-BUG-001 (FIXED): a same-path type change (file -> directory). The delta engine now attributes
+	// the change against the last-synced base, deletes the stale-type remote item, then creates the new
+	// type — the phase-ordered runner guarantees the delete lands before the create.
+	it("replaces a file with a directory of the same name", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "thing", "i am a file")
+			await settle(world)
+
+			await rmLocal(world, "thing")
+			await writeLocal(world, "thing/inside.txt", "now a dir")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/thing"]).toMatchObject({ type: "directory" })
+			expect(remote["/thing/inside.txt"]).toMatchObject({ type: "file" })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("replaces a directory (with children) with a file of the same name", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "thing/a.txt", "child a")
+			await writeLocal(world, "thing/b.txt", "child b")
+			await settle(world)
+
+			await rmLocal(world, "thing")
+			await writeLocal(world, "thing", "now a file")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/thing"]).toMatchObject({ type: "file" })
+			expect(remote["/thing/a.txt"]).toBeUndefined()
+			expect(remote["/thing/b.txt"]).toBeUndefined()
+
+			await expectConverged(world)
+		})
+	})
+
+	it("syncs a deeply nested tree", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "l1/l2/l3/l4/l5/deep.txt", "deep")
+			await settle(world)
+
+			expect((await snapshotRemoteReal(world))["/l1/l2/l3/l4/l5/deep.txt"]).toMatchObject({ type: "file" })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("syncs many files in a single directory", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			for (let i = 0; i < 20; i++) {
+				await writeLocal(world, `bulk/file-${i}.txt`, `content-${i}`)
+			}
+
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			for (let i = 0; i < 20; i++) {
+				expect(remote[`/bulk/file-${i}.txt`]).toMatchObject({ type: "file" })
+			}
+
+			await expectConverged(world)
+		})
+	})
+
+	it("moves a file from one directory to another", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "from/doc.txt", "data")
+			await mkdirLocal(world, "to")
+			await settle(world)
+
+			await renameLocal(world, "from/doc.txt", "to/doc.txt")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/from/doc.txt"]).toBeUndefined()
+			expect(remote["/to/doc.txt"]).toMatchObject({ type: "file", size: 4 })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("merges independent additions from both sides (twoWay, no conflict)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "local-add.txt", "local")
+			await uploadRemote(world, "remote-add.txt", "remote")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/local-add.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/remote-add.txt"]).toMatchObject({ type: "file" })
+			expect(await existsLocal(world, "local-add.txt")).toBe(true)
+			expect(await existsLocal(world, "remote-add.txt")).toBe(true)
+
+			await expectConverged(world)
+		})
+	})
+
+	it("a settled directory rename does no further work after the move", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "dir/a.txt", "a")
+			await settle(world)
+			await renameLocal(world, "dir", "dir-renamed")
+			await settle(world)
+
+			// One more cycle must be a complete no-op (no leftover per-child churn).
+			const messages = await cycle(world)
+
+			expect(transferKinds(messages)).toEqual([])
+			await expectConverged(world)
+		})
+	})
+
+	it("case-insensitive name collision: only one variant survives and the sync converges (F11)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			// The backend is case-insensitive per parent, so two names differing only in case collide. The
+			// collision is created on the REMOTE (a case-sensitive local FS isn't guaranteed on the test host)
+			// and synced down — the live counterpart of mocked F11.
+			await uploadRemote(world, "Report.txt", "one")
+			await uploadRemote(world, "report.txt", "two")
+
+			// The backend kept exactly one of the two case variants.
+			const remoteAfterUpload = await snapshotRemoteReal(world)
+			const survivingRemote = ["/Report.txt", "/report.txt"].filter(path => remoteAfterUpload[path] !== undefined)
+
+			expect(survivingRemote).toHaveLength(1)
+
+			// The sync converges without crashing or churning; the local side ends matching the single copy.
+			await settle(world)
+			await expectConverged(world)
+
+			expect(Object.keys(await snapshotLocalReal(world))).toHaveLength(1)
+		})
+	})
+
+	// Cross-side directory rename + concurrent child change (BUG-A / BUG-B): a folder renamed on one side
+	// while a file inside it is edited/deleted on the OTHER side. Before the rename-aware rebase the rename
+	// relocated the subtree while a stale same-path op clobbered the change (data loss) or resurrected a
+	// deletion. Live mirror of the mocked ZB suite.
+	describe("cross-side directory rename + concurrent child change", () => {
+		it("a local dir rename + a remote child edit keeps the remote edit (BUG-A)", async () => {
+			await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+				await mkdirLocal(world, "dir")
+				await writeLocal(world, "dir/child.txt", "old")
+				await writeLocal(world, "dir/sibling.txt", "sib")
+				await settle(world)
+				await expectConverged(world)
+
+				// One device renames the folder; another edits a file still at the old path, same window.
+				await renameLocal(world, "dir", "dir2")
+				await uploadRemote(world, "dir/child.txt", "REMOTE-EDITED-NEW-CONTENT")
+
+				await settle(world)
+				await expectConverged(world)
+
+				expect(await readLocal(world, "dir2/child.txt")).toBe("REMOTE-EDITED-NEW-CONTENT")
+				const remote = await snapshotRemoteReal(world)
+				expect(remote["/dir2/child.txt"]).toMatchObject({ size: "REMOTE-EDITED-NEW-CONTENT".length })
+				expect(remote["/dir/child.txt"]).toBeUndefined()
+			})
+		})
+
+		it("a remote dir rename + a local child edit keeps the local edit (BUG-A symmetric)", async () => {
+			await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+				await mkdirLocal(world, "dir")
+				await writeLocal(world, "dir/child.txt", "old")
+				await settle(world)
+				await expectConverged(world)
+
+				await renameRemoteDir(world, "dir", "dir2")
+				await modifyLocal(world, "dir/child.txt", "LOCAL-EDITED-NEW-CONTENT")
+
+				await settle(world)
+				await expectConverged(world)
+
+				const remote = await snapshotRemoteReal(world)
+				expect(remote["/dir2/child.txt"]).toMatchObject({ size: "LOCAL-EDITED-NEW-CONTENT".length })
+			})
+		})
+
+		it("a local dir rename + a remote child delete does not resurrect the child (BUG-B)", async () => {
+			await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+				await mkdirLocal(world, "dir")
+				await writeLocal(world, "dir/child.txt", "old")
+				await writeLocal(world, "dir/keep.txt", "k")
+				await settle(world)
+				await expectConverged(world)
+
+				await renameLocal(world, "dir", "dir2")
+				await deleteRemote(world, "dir/child.txt")
+
+				await settle(world)
+				await expectConverged(world)
+
+				expect(await existsLocal(world, "dir2/child.txt")).toBe(false)
+				const remote = await snapshotRemoteReal(world)
+				expect(remote["/dir2/child.txt"]).toBeUndefined()
+				expect(remote["/dir2/keep.txt"]).toMatchObject({ size: "k".length })
+			})
+		})
+	})
+})