@filen/sync 0.2.1 → 0.3.1

package/tests/e2e/state.e2e.test.ts

@@ -0,0 +1,229 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest"
+import type FilenSDK from "@filen/sdk"
+import pathModule from "path"
+import fs from "fs-extra"
+import { E2E_ENABLED, loginTestSDK, teardownTestSDK } from "./harness/account"
+import { withE2EWorld, restartE2EWorld } from "./harness/world"
+import { cycle, settle, expectConverged, allOps, messagesOfType } from "./harness/drive"
+import { snapshotRemoteReal } from "./harness/assert"
+import { writeLocal, rmLocal, renameLocal, existsLocal, uploadRemote } from "./harness/mutations"
+import { DEVICE_ID_VERSION } from "../../src/lib/filesystems/remote"
+
+/**
+ * Phase 3 e2e — state persistence across restarts against the live backend. Proves the on-disk state
+ * (previous trees, deviceId, hashes) survives a process restart / client upgrade and drives correct
+ * incremental syncs: settled trees no-op, and only genuine post-restart changes are transferred.
+ */
+describe.skipIf(!E2E_ENABLED)("E2E — state persistence across restarts", () => {
+	let sdk: FilenSDK
+
+	beforeAll(async () => {
+		sdk = await loginTestSDK()
+	}, 300_000)
+
+	afterAll(async () => {
+		await teardownTestSDK()
+	})
+
+	it("a settled tree no-ops on the first cycle after a restart", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "a")
+			await writeLocal(world, "dir/b.txt", "b")
+			await settle(world)
+
+			await restartE2EWorld(world)
+
+			const messages = await cycle(world, { resetCache: false })
+
+			expect(allOps(messages)).toEqual([])
+			await expectConverged(world)
+		})
+	})
+
+	it("a settled rename no-ops after a restart", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "dir/file.txt", "x")
+			await settle(world)
+			await renameLocal(world, "dir", "dir2")
+			await settle(world)
+
+			await restartE2EWorld(world)
+
+			const messages = await cycle(world, { resetCache: false })
+
+			expect(allOps(messages)).toEqual([])
+			expect((await snapshotRemoteReal(world))["/dir2/file.txt"]).toMatchObject({ type: "file" })
+			await expectConverged(world)
+		})
+	})
+
+	it("a settled deletion no-ops after a restart (no resurrection)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "keep.txt", "k")
+			await writeLocal(world, "gone.txt", "g")
+			await settle(world)
+			await rmLocal(world, "gone.txt")
+			await settle(world)
+
+			await restartE2EWorld(world)
+
+			const messages = await cycle(world, { resetCache: false })
+
+			expect(allOps(messages)).toEqual([])
+			// The deleted file must NOT come back from stale state.
+			expect((await snapshotRemoteReal(world))["/gone.txt"]).toBeUndefined()
+			expect(await existsLocal(world, "gone.txt")).toBe(false)
+		})
+	})
+
+	it("a change made after a restart syncs incrementally (only the change moves)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "existing.txt", "old")
+			await settle(world)
+
+			await restartE2EWorld(world)
+
+			// A brand-new file after the restart...
+			await writeLocal(world, "new-after-restart.txt", "fresh")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/new-after-restart.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/existing.txt"]).toMatchObject({ type: "file" })
+			await expectConverged(world)
+		})
+	})
+
+	it("survives two restarts in a row with no work", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "stable.txt", "s")
+			await settle(world)
+
+			await restartE2EWorld(world)
+			expect(allOps(await cycle(world, { resetCache: false }))).toEqual([])
+
+			await restartE2EWorld(world)
+			expect(allOps(await cycle(world, { resetCache: false }))).toEqual([])
+
+			await expectConverged(world)
+		})
+	})
+
+	it("the deviceId is reused across a restart, keeping the server-side tree cache valid (S2)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "keep.txt", "k")
+			await settle(world)
+
+			const deviceIdPath = pathModule.join(world.dbPath, "deviceId", `v${DEVICE_ID_VERSION}`, world.syncPair.uuid)
+			const before = await fs.readFile(deviceIdPath, { encoding: "utf-8" })
+
+			expect(before.length).toBeGreaterThan(0)
+
+			await restartE2EWorld(world)
+
+			// A regenerated deviceId would invalidate the server's per-device tree cache and force a
+			// re-download storm on every client update — it must survive the restart unchanged.
+			const after = await fs.readFile(deviceIdPath, { encoding: "utf-8" })
+
+			expect(after).toBe(before)
+			expect(allOps(await cycle(world, { resetCache: false }))).toEqual([])
+		})
+	})
+
+	it("a settled sync with large-deletion confirmation enabled raises NO prompt after a restart (S3/BUG-001)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay", requireConfirmationOnLargeDeletion: true }, async world => {
+			await writeLocal(world, "x.txt", "x")
+			await writeLocal(world, "y.txt", "y")
+			await writeLocal(world, "z/w.txt", "w")
+			await settle(world)
+
+			await restartE2EWorld(world)
+
+			// The deletion gate must not misfire when a fresh engine reloads a settled tree: the previous
+			// trees are non-empty and the current trees match them, so nothing looks deleted.
+			const messages = await cycle(world, { resetCache: false })
+
+			expect(messagesOfType(messages, "confirmDeletion")).toEqual([])
+			expect(allOps(messages)).toEqual([])
+			await expectConverged(world)
+		})
+	})
+
+	it("persisted state is the stable v2 line-delimited {prop,data} JSON on disk (S5)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "alpha")
+			await writeLocal(world, "d/b.txt", "bravo")
+			await settle(world)
+
+			const localTreeRaw = await fs.readFile(world.sync.state.previousLocalTreePath, { encoding: "utf-8" })
+			const remoteTreeRaw = await fs.readFile(world.sync.state.previousRemoteTreePath, { encoding: "utf-8" })
+
+			const assertLines = (raw: string): void => {
+				const lines = raw.trim().split("\n").filter(Boolean)
+
+				expect(lines.length).toBeGreaterThan(0)
+
+				for (const line of lines) {
+					const parsed = JSON.parse(line)
+
+					expect(parsed).toHaveProperty("prop")
+					expect(parsed.data).toHaveProperty("path")
+					expect(parsed.data).toHaveProperty("type")
+				}
+			}
+
+			assertLines(localTreeRaw)
+			assertLines(remoteTreeRaw)
+		})
+	})
+
+	// ---- crash / stop mid-run: the persisted base is BEHIND reality on restart ----------------------
+	// The state save runs only after a fully clean cycle, so a kill (or a user stop) mid-run leaves the
+	// on-disk base at the last clean cycle while the fs/remote already moved on. A fresh engine must
+	// re-derive the outstanding work from that stale base and converge — no loss, no resurrection. These
+	// are the live counterparts of mocked Category ZC (which additionally injects a partial-cycle fault).
+
+	it("un-synced changes on BOTH sides survive a restart and converge (crash before the first sync)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "base.txt", "base")
+			await settle(world)
+
+			// Both sides change, then the process dies before any cycle syncs them: the persisted base
+			// still only knows base.txt.
+			await writeLocal(world, "local-only.txt", "L")
+			await uploadRemote(world, "remote-only.txt", "R")
+
+			await restartE2EWorld(world)
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/local-only.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/remote-only.txt"]).toMatchObject({ type: "file" })
+			expect(await existsLocal(world, "local-only.txt")).toBe(true)
+			expect(await existsLocal(world, "remote-only.txt")).toBe(true)
+			await expectConverged(world)
+		})
+	})
+
+	it("an un-synced local rename survives a restart and applies (no resurrection of the old path)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "dir/file.txt", "x")
+			await settle(world)
+
+			// Rename locally, then die before the rename is ever synced — the base still has the old path.
+			await renameLocal(world, "dir", "dir2")
+
+			await restartE2EWorld(world)
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/dir2/file.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/dir/file.txt"]).toBeUndefined()
+			expect(remote["/dir"]).toBeUndefined()
+			await expectConverged(world)
+		})
+	})
+})

package/tests/e2e/sync.e2e.test.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest"
+import type FilenSDK from "@filen/sdk"
+import { E2E_ENABLED, loginTestSDK, teardownTestSDK } from "./harness/account"
+import { withE2EWorld, restartE2EWorld } from "./harness/world"
+import { cycle, settle, expectConverged, allOps } from "./harness/drive"
+import { snapshotLocalReal, snapshotRemoteReal } from "./harness/assert"
+import { writeLocal, modifyLocal, mkdirLocal, rmLocal, renameLocal, readLocal, uploadRemote, mkdirRemote, existsLocal } from "./harness/mutations"
+
+/**
+ * Phase 3 — real end-to-end against the live SDK + backend. Each case runs a real {@link SyncWorker}
+ * against a fresh `/<uuid>` remote dir and a fresh local tmp dir, then permanently cleans both sides.
+ * All files are tiny (bytes) — this exercises the sync ALGORITHM end-to-end, not transfer throughput.
+ *
+ * Skips entirely when FILEN_TEST_EMAIL / FILEN_TEST_PASSWORD are unset.
+ */
+describe.skipIf(!E2E_ENABLED)("E2E — core sync against live backend", () => {
+	let sdk: FilenSDK
+
+	beforeAll(async () => {
+		sdk = await loginTestSDK()
+	}, 300_000)
+
+	afterAll(async () => {
+		await teardownTestSDK()
+	})
+
+	// ---- twoWay ------------------------------------------------------------------------------------
+
+	it("twoWay: uploads new local files and directories to the remote", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "alpha")
+			await writeLocal(world, "dir/b.txt", "bravo")
+			await mkdirLocal(world, "dir/empty-dir")
+
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/a.txt"]).toMatchObject({ type: "file", size: 5 })
+			expect(remote["/dir"]).toMatchObject({ type: "directory" })
+			expect(remote["/dir/b.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/dir/empty-dir"]).toMatchObject({ type: "directory" })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("twoWay: propagates creation AND deletion of a standalone empty directory", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			// Create a standalone empty directory and let it sync up.
+			await mkdirLocal(world, "empty")
+			await settle(world)
+
+			expect((await snapshotRemoteReal(world))["/empty"]).toMatchObject({ type: "directory" })
+			await expectConverged(world)
+
+			// Deleting the still-empty directory must propagate too — no leaked empty dir on the remote.
+			await rmLocal(world, "empty")
+			await settle(world)
+
+			expect((await snapshotRemoteReal(world))["/empty"]).toBeUndefined()
+			await expectConverged(world)
+		})
+	})
+
+	it("twoWay: downloads new remote files and directories to local", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await uploadRemote(world, "from-cloud.txt", "cloud-content")
+			await mkdirRemote(world, "cloud-dir")
+			await uploadRemote(world, "cloud-dir/nested.txt", "nested")
+
+			await settle(world)
+
+			expect(await existsLocal(world, "from-cloud.txt")).toBe(true)
+			expect(await readLocal(world, "from-cloud.txt")).toBe("cloud-content")
+			expect(await existsLocal(world, "cloud-dir/nested.txt")).toBe(true)
+
+			await expectConverged(world)
+		})
+	})
+
+	it("twoWay: propagates a content modification (same size, different bytes)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "note.txt", "aaaa")
+			await settle(world)
+
+			// Same byte length, different content — size-only checks would miss this; content hash won't.
+			await modifyLocal(world, "note.txt", "bbbb")
+			await settle(world)
+
+			await expectConverged(world)
+
+			const remote = await snapshotRemoteReal(world, { withContent: true })
+			const local = await snapshotLocalReal(world, { withContent: true })
+
+			expect(remote["/note.txt"]!.contentHash).toBe(local["/note.txt"]!.contentHash)
+		})
+	})
+
+	it("twoWay: propagates a local deletion to the remote", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "keep.txt", "keep")
+			await writeLocal(world, "remove-me.txt", "gone")
+			await settle(world)
+
+			await rmLocal(world, "remove-me.txt")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/remove-me.txt"]).toBeUndefined()
+			expect(remote["/keep.txt"]).toMatchObject({ type: "file" })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("twoWay: propagates a rename and a move", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "original.txt", "data")
+			await mkdirLocal(world, "target")
+			await settle(world)
+
+			await renameLocal(world, "original.txt", "renamed.txt")
+			await settle(world)
+			await renameLocal(world, "renamed.txt", "target/renamed.txt")
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/original.txt"]).toBeUndefined()
+			expect(remote["/renamed.txt"]).toBeUndefined()
+			expect(remote["/target/renamed.txt"]).toMatchObject({ type: "file", size: 4 })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("twoWay: syncs a multi-level nested directory tree", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "x/y/z/deep.txt", "deep")
+			await writeLocal(world, "x/y/sibling.txt", "sib")
+			await writeLocal(world, "x/top.txt", "top")
+
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/x/y/z/deep.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/x/y/sibling.txt"]).toMatchObject({ type: "file" })
+			expect(remote["/x/top.txt"]).toMatchObject({ type: "file" })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("twoWay: a 0-byte file syncs (BUG-002)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "empty.txt", "")
+			await writeLocal(world, "nonempty.txt", "x")
+
+			await settle(world)
+
+			const remote = await snapshotRemoteReal(world)
+
+			expect(remote["/empty.txt"]).toMatchObject({ type: "file", size: 0 })
+			expect(remote["/nonempty.txt"]).toMatchObject({ type: "file", size: 1 })
+
+			await expectConverged(world)
+		})
+	})
+
+	it("twoWay: a settled sync does ZERO transfers on the next cycle after a restart (backwards-compat)", async () => {
+		await withE2EWorld({ sdk, mode: "twoWay" }, async world => {
+			await writeLocal(world, "a.txt", "alpha")
+			await writeLocal(world, "dir/b.txt", "bravo")
+			await settle(world)
+
+			await restartE2EWorld(world)
+
+			// Warm-cache path (no resetCache): the reloaded state must see nothing to do.
+			const messages = await cycle(world, { resetCache: false })
+
+			expect(allOps(messages)).toEqual([])
+			await expectConverged(world)
+		})
+	})
+
+	// ---- one-way modes -----------------------------------------------------------------------------
+
+	it("localToCloud: uploads local changes but does NOT pull remote-only files down", async () => {
+		await withE2EWorld({ sdk, mode: "localToCloud" }, async world => {
+			await writeLocal(world, "local-only.txt", "mine")
+			await settle(world)
+
+			// Appears on the remote (push works)...
+			expect((await snapshotRemoteReal(world))["/local-only.txt"]).toMatchObject({ type: "file" })
+
+			// ...but a remote-only file must NOT be downloaded in localToCloud.
+			await uploadRemote(world, "cloud-only.txt", "theirs")
+			await settle(world)
+
+			expect(await existsLocal(world, "cloud-only.txt")).toBe(false)
+		})
+	})
+
+	it("cloudToLocal: downloads remote changes but does NOT push local-only files up", async () => {
+		await withE2EWorld({ sdk, mode: "cloudToLocal" }, async world => {
+			await uploadRemote(world, "cloud-only.txt", "theirs")
+			await settle(world)
+
+			// Pulled down (download works)...
+			expect(await existsLocal(world, "cloud-only.txt")).toBe(true)
+
+			// ...but a local-only file must NOT be uploaded in cloudToLocal.
+			await writeLocal(world, "local-only.txt", "mine")
+			await settle(world)
+
+			expect((await snapshotRemoteReal(world))["/local-only.txt"]).toBeUndefined()
+		})
+	})
+})