@filen/sync 0.2.1 → 0.3.1

package/tests/fakes/fake-cloud.test.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect } from "vitest"
+import { APIError } from "@filen/sdk"
+import { createFakeCloud, type CloudSpec } from "./fake-cloud"
+import { createVirtualFS, type VfsSpec } from "./virtual-fs"
+
+function setup(localSpec: VfsSpec = {}, cloudSpec: CloudSpec = {}) {
+	const vfs = createVirtualFS(localSpec)
+	const cloud = createFakeCloud(cloudSpec, { localFs: vfs.fs })
+
+	return { vfs, cloud, sdk: cloud.sdk, controls: cloud.controls }
+}
+
+describe("fake cloud — tree, cache, tuples", () => {
+	it("returns the root folder with parent 'base' and no files for an empty cloud", async () => {
+		const { sdk, controls } = setup()
+
+		const tree = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1" })
+
+		expect(tree.files).toEqual([])
+		expect(tree.folders).toHaveLength(1)
+		expect(tree.folders[0]![0]).toBe(controls.rootUUID)
+		expect(tree.folders[0]![2]).toBe("base")
+	})
+
+	it("emits the canonical file tuple order [uuid,bucket,region,chunks,parent,metadata,version,n]", async () => {
+		const { vfs, sdk, controls } = setup({ "/src/a.txt": "hello world" })
+
+		const item = await sdk.cloud().uploadLocalFile({ source: "/src/a.txt", parent: controls.rootUUID, name: "a.txt" })
+		const tree = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1", skipCache: true })
+		const fileTuple = tree.files.find(file => file[0] === item.uuid)!
+
+		expect(fileTuple).toBeDefined()
+		expect(fileTuple[0]).toBe(item.uuid) // uuid
+		expect(fileTuple[1]).toBe("filen-1") // bucket
+		expect(fileTuple[2]).toBe("de-1") // region
+		expect(fileTuple[3]).toBe(1) // chunks (11 bytes → 1 chunk)
+		expect(fileTuple[4]).toBe(controls.rootUUID) // parent
+		expect(fileTuple[6]).toBe(2) // version
+
+		expect(item.type).toBe("file")
+
+		const decrypted = await sdk.crypto().decrypt().fileMetadata({ metadata: fileTuple[5] })
+
+		expect(decrypted.name).toBe("a.txt")
+		expect(decrypted.size).toBe("hello world".length)
+
+		if (item.type === "file") {
+			expect(decrypted.key).toBe(item.key)
+		}
+
+		// uploadLocalFile reads the bytes from the injected virtual filesystem.
+		expect(item.size).toBe("hello world".length)
+		void vfs
+	})
+
+	it("honors the per-deviceId revision cache (unchanged → empty, skipCache → full, new device → full)", async () => {
+		const { sdk, controls } = setup()
+
+		await sdk.cloud().createDirectory({ name: "docs", parent: controls.rootUUID })
+
+		// First fetch for device-1 → full tree.
+		const first = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1" })
+		expect(first.folders.length).toBe(2)
+
+		// Nothing changed since device-1 last fetched → empty "unchanged" response.
+		const second = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1" })
+		expect(second.files).toEqual([])
+		expect(second.folders).toEqual([])
+
+		// skipCache always returns the full tree.
+		const skip = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1", skipCache: true })
+		expect(skip.folders.length).toBe(2)
+
+		// A different device has never fetched → full tree.
+		const otherDevice = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-2" })
+		expect(otherDevice.folders.length).toBe(2)
+
+		// A mutation invalidates device-1's cache.
+		await sdk.cloud().createDirectory({ name: "more", parent: controls.rootUUID })
+		const afterChange = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1" })
+		expect(afterChange.folders.length).toBe(3)
+	})
+})
+
+describe("fake cloud — directories, decrypt", () => {
+	it("createDirectory adds a folder tuple and is idempotent by name", async () => {
+		const { sdk, controls } = setup()
+
+		const uuid1 = await sdk.cloud().createDirectory({ name: "docs", parent: controls.rootUUID })
+		const uuid2 = await sdk.cloud().createDirectory({ name: "docs", parent: controls.rootUUID })
+
+		expect(uuid2).toBe(uuid1)
+
+		const tree = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1", skipCache: true })
+		const folderTuple = tree.folders.find(folder => folder[0] === uuid1)!
+
+		expect(folderTuple[2]).toBe(controls.rootUUID)
+
+		const decrypted = await sdk.crypto().decrypt().folderMetadata({ metadata: folderTuple[1] })
+		expect(decrypted.name).toBe("docs")
+	})
+
+	it("decrypt round-trips JSON metadata for files and folders", async () => {
+		const { sdk, controls } = setup({ "/src/note.md": "content" })
+
+		const dirUUID = await sdk.cloud().createDirectory({ name: "folder", parent: controls.rootUUID })
+		const fileItem = await sdk.cloud().uploadLocalFile({ source: "/src/note.md", parent: dirUUID, name: "note.md" })
+		const tree = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1", skipCache: true })
+
+		const folderTuple = tree.folders.find(folder => folder[0] === dirUUID)!
+		const fileTuple = tree.files.find(file => file[0] === fileItem.uuid)!
+
+		expect((await sdk.crypto().decrypt().folderMetadata({ metadata: folderTuple[1] })).name).toBe("folder")
+
+		const fileMeta = await sdk.crypto().decrypt().fileMetadata({ metadata: fileTuple[5] })
+		expect(fileMeta.name).toBe("note.md")
+		expect(fileMeta.mime).toBe("text/markdown")
+	})
+})
+
+describe("fake cloud — case-insensitive uniqueness & versioning", () => {
+	it("errors on a file/folder type clash in either direction", async () => {
+		const { sdk, controls } = setup({ "/src/x": "data" })
+
+		await sdk.cloud().createDirectory({ name: "X", parent: controls.rootUUID })
+
+		await expect(sdk.cloud().uploadLocalFile({ source: "/src/x", parent: controls.rootUUID, name: "x" })).rejects.toThrow()
+
+		const { vfs, sdk: sdk2, controls: controls2 } = setup({ "/src/y": "data" })
+		await sdk2.cloud().uploadLocalFile({ source: "/src/y", parent: controls2.rootUUID, name: "y" })
+		await expect(sdk2.cloud().createDirectory({ name: "Y", parent: controls2.rootUUID })).rejects.toThrow()
+		void vfs
+	})
+
+	it("versions a file on same-name re-upload: a fresh uuid supersedes and the old leaves the tree", async () => {
+		const { vfs, sdk, controls } = setup({ "/src/a.txt": "v1" })
+
+		const first = await sdk.cloud().uploadLocalFile({ source: "/src/a.txt", parent: controls.rootUUID, name: "a.txt" })
+
+		await vfs.fs.writeFile("/src/a.txt", "v2-longer", { encoding: "utf-8" })
+		const second = await sdk.cloud().uploadLocalFile({ source: "/src/a.txt", parent: controls.rootUUID, name: "a.txt" })
+
+		expect(second.uuid).not.toBe(first.uuid)
+
+		const tree = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1", skipCache: true })
+		const matching = tree.files.filter(file => file[4] === controls.rootUUID)
+		expect(matching).toHaveLength(1)
+		expect(matching[0]![0]).toBe(second.uuid)
+
+		// The superseded uuid is gone from the sync perspective.
+		expect((await sdk.api(3).dir().present({ uuid: first.uuid })).present).toBe(false)
+		expect((await sdk.api(3).dir().present({ uuid: second.uuid })).present).toBe(true)
+	})
+})
+
+describe("fake cloud — trash, delete, present", () => {
+	it("reports trashed as present+trash:true and permanently deleted as not present", async () => {
+		const { sdk, controls } = setup({ "/a.txt": "data" }, { "/cloudfile.txt": "x" })
+
+		const node = controls.getByPath("/cloudfile.txt")!
+
+		await sdk.cloud().trashFile({ uuid: node.uuid })
+		expect(await sdk.api(3).dir().present({ uuid: node.uuid })).toEqual({ present: true, trash: true })
+
+		// Trashed nodes drop out of the tree.
+		const tree = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1", skipCache: true })
+		expect(tree.files).toHaveLength(0)
+
+		await sdk.cloud().deleteFile({ uuid: node.uuid })
+		expect(await sdk.api(3).dir().present({ uuid: node.uuid })).toEqual({ present: false, trash: false })
+		void controls
+	})
+
+	it("raises APIError(file_not_found / folder_not_found) on gone uuids", async () => {
+		const { sdk } = setup()
+
+		await expect(sdk.cloud().trashFile({ uuid: "missing" })).rejects.toBeInstanceOf(APIError)
+		await expect(sdk.cloud().deleteFile({ uuid: "missing" })).rejects.toMatchObject({ code: "file_not_found" })
+		await expect(sdk.cloud().deleteDirectory({ uuid: "missing" })).rejects.toMatchObject({ code: "folder_not_found" })
+	})
+})
+
+describe("fake cloud — rename/move overwriteIfExists & fileExists", () => {
+	it("trashes the occupant when overwriteIfExists is set, and throws otherwise", async () => {
+		const { sdk, controls } = setup({}, { "/a.txt": "A", "/b.txt": "B" })
+
+		const a = controls.getByPath("/a.txt")!
+		const b = controls.getByPath("/b.txt")!
+
+		await expect(
+			sdk.cloud().renameFile({ uuid: b.uuid, metadata: { name: "b.txt", size: 1, mime: "x", key: "k", lastModified: 1 }, name: "a.txt" })
+		).rejects.toThrow()
+
+		await sdk.cloud().renameFile({
+			uuid: b.uuid,
+			metadata: { name: "b.txt", size: 1, mime: "x", key: "k", lastModified: 1 },
+			name: "a.txt",
+			overwriteIfExists: true
+		})
+
+		expect((await sdk.api(3).dir().present({ uuid: a.uuid })).trash).toBe(true)
+
+		const tree = await sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1", skipCache: true })
+		expect(tree.files).toHaveLength(1)
+		expect(tree.files[0]![0]).toBe(b.uuid)
+	})
+
+	it("fileExists distinguishes files from directories", async () => {
+		const { sdk, controls } = setup({}, { "/a.txt": "A", "/dir": null })
+
+		const a = controls.getByPath("/a.txt")!
+
+		expect(await sdk.cloud().fileExists({ name: "a.txt", parent: controls.rootUUID })).toEqual({ exists: true, uuid: a.uuid })
+		expect(await sdk.cloud().fileExists({ name: "missing.txt", parent: controls.rootUUID })).toEqual({ exists: false })
+		expect(await sdk.cloud().fileExists({ name: "dir", parent: controls.rootUUID })).toEqual({ exists: false })
+	})
+})
+
+describe("fake cloud — locks, error injection", () => {
+	it("grants an uncontended lock and rejects while held by another holder", async () => {
+		const { sdk } = setup()
+
+		await sdk.user().acquireResourceLock({ resource: "r", lockUUID: "holder-1" })
+		await expect(sdk.user().acquireResourceLock({ resource: "r", lockUUID: "holder-2" })).rejects.toThrow()
+
+		await sdk.user().releaseResourceLock({ resource: "r", lockUUID: "holder-1" })
+		await expect(sdk.user().acquireResourceLock({ resource: "r", lockUUID: "holder-2" })).resolves.toBeUndefined()
+	})
+
+	it("simulates external contention via controls.contendLock", async () => {
+		const { sdk, controls } = setup()
+
+		controls.contendLock("r")
+		await expect(sdk.user().acquireResourceLock({ resource: "r", lockUUID: "me" })).rejects.toThrow()
+
+		controls.releaseLockContention("r")
+		await expect(sdk.user().acquireResourceLock({ resource: "r", lockUUID: "me" })).resolves.toBeUndefined()
+	})
+
+	it("throws an injected error from the named method", async () => {
+		const { sdk, controls } = setup()
+
+		controls.setError("tree", new Error("boom"))
+		await expect(sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1" })).rejects.toThrow("boom")
+
+		controls.clearError("tree")
+		await expect(sdk.api(3).dir().tree({ uuid: controls.rootUUID, deviceId: "device-1" })).resolves.toBeDefined()
+	})
+})
+
+describe("fake cloud — snapshot & external mutators", () => {
+	it("reflects external mutations in the normalized snapshot", async () => {
+		const { controls } = setup({}, { "/keep.txt": "keep" })
+
+		controls.addDir("/photos")
+		controls.addFile("/photos/p.txt", "pixels", { mtimeMs: 1_700_000_000_000 })
+		controls.movePath("/keep.txt", "/photos/kept.txt")
+
+		const snapshot = controls.snapshot()
+
+		expect(snapshot["/photos"]).toEqual({ type: "directory", size: 0, mtimeSec: 0, contentHash: "" })
+		expect(snapshot["/photos/p.txt"]!.type).toBe("file")
+		expect(snapshot["/photos/p.txt"]!.mtimeSec).toBe(1_700_000_000)
+		expect(snapshot["/photos/kept.txt"]!.type).toBe("file")
+		expect(snapshot["/keep.txt"]).toBeUndefined()
+	})
+})