adoor 0.1.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (41) hide show
  1. package/CHANGELOG.md +4 -0
  2. package/README.md +2 -2
  3. package/dist/adoor.mjs +105 -84
  4. package/native/LICENSE +662 -0
  5. package/native/README.md +12 -0
  6. package/native/darwin/ADoorService.app/Contents/Info.plist +57 -0
  7. package/native/darwin/ADoorService.app/Contents/MacOS/ADoorService +0 -0
  8. package/native/darwin/ADoorService.app/Contents/PkgInfo +1 -0
  9. package/native/darwin/ADoorService.app/Contents/_CodeSignature/CodeResources +123 -0
  10. package/native/darwin/ADoorService.app/Contents/embedded.provisionprofile +0 -0
  11. package/native/source/Package.swift +6 -0
  12. package/native/source/sdk/LICENSE +21 -0
  13. package/native/source/sdk/Package.swift +14 -0
  14. package/native/source/sdk/Sources/ADoor/AdoorClient.swift +270 -0
  15. package/native/source/sdk/Sources/ADoor/AdoorError.swift +60 -0
  16. package/native/source/sdk/Sources/ADoor/Changes.swift +202 -0
  17. package/native/source/sdk/Sources/ADoor/DesktopSessionState.swift +73 -0
  18. package/native/source/sdk/Sources/ADoor/DeviceFlow.swift +70 -0
  19. package/native/source/sdk/Sources/ADoor/FolderCatalog.swift +49 -0
  20. package/native/source/sdk/Sources/ADoor/JSONValue.swift +70 -0
  21. package/native/source/sdk/Sources/ADoor/LocalStore.swift +474 -0
  22. package/native/source/sdk/Sources/ADoor/Models.swift +146 -0
  23. package/native/source/sdk/Sources/ADoor/MountModel.swift +896 -0
  24. package/native/source/sdk/Sources/ADoor/OAuth.swift +225 -0
  25. package/native/source/sdk/Sources/ADoor/Provider.swift +211 -0
  26. package/native/source/sdk/Sources/ADoor/Storage.swift +41 -0
  27. package/native/source/sdk/Sources/ADoor/SyncTree.swift +501 -0
  28. package/native/source/sdk/Sources/ADoor/Trash.swift +283 -0
  29. package/native/source/sdk/Tests/ADoorTests/ADoorTests.swift +182 -0
  30. package/native/source/sdk/Tests/ADoorTests/DesktopSessionStateTests.swift +46 -0
  31. package/native/source/sdk/Tests/ADoorTests/MountTests.swift +560 -0
  32. package/native/source/sdk/Tests/ADoorTests/RegressionTests.swift +360 -0
  33. package/native/source/service/DesktopSession.swift +241 -0
  34. package/native/source/service/DeviceClient.swift +53 -0
  35. package/native/source/service/Domains.swift +182 -0
  36. package/native/source/service/FolderRefresh.swift +37 -0
  37. package/native/source/service/KeychainStore.swift +74 -0
  38. package/native/source/service/LocalSessionSocket.swift +142 -0
  39. package/native/source/service/ServiceMain.swift +14 -0
  40. package/native/source/service/ServiceMounts.swift +34 -0
  41. package/package.json +12 -3
@@ -0,0 +1,560 @@
1
+ import XCTest
2
+ import Foundation
3
+ @testable import ADoor
4
+
5
+ final class MountTests: XCTestCase {
6
+ func testRenameReceiptPreservesFileMetadataAndDirectoryKind() throws {
7
+ let id = UUID()
8
+ for kind: NodeKind in [.file, .directory] {
9
+ let original = NodeAttr(id: id, name: "before", kind: kind, size: 4096, generation: 7,
10
+ mode: 0o755, mtime: Date(), contentId: nil)
11
+ let receipt = try FileJSON.node(.object(["id": .string(id.uuidString), "name": .string("after"), "generation": .number(8)]))
12
+ let result = try ProviderMap.renamed(original, receipt: receipt, parent: "destination")
13
+ XCTAssertEqual(result.name, "after")
14
+ XCTAssertEqual(result.generation, 8)
15
+ XCTAssertEqual(result.size, 4096)
16
+ XCTAssertEqual(result.isDirectory, kind == .directory)
17
+ XCTAssertEqual(result.parent, "destination")
18
+ }
19
+ }
20
+
21
+ func testExcludesNeverLeaveTheMac() {
22
+ XCTAssertTrue(MountExcludes.excluded(".git/config"))
23
+ XCTAssertTrue(MountExcludes.excluded("app/.env"))
24
+ XCTAssertTrue(MountExcludes.excluded("web/node_modules/left-pad/index.js"))
25
+ XCTAssertFalse(MountExcludes.excluded("notes/monday.txt"))
26
+ }
27
+
28
+ func testBlockCacheDropsTheOldestSlot() {
29
+ var cache = BlockCache(capacity: 2)
30
+ cache.set("a", Data("one".utf8))
31
+ cache.set("b", Data("two".utf8))
32
+ cache.set("c", Data("three".utf8))
33
+ XCTAssertNil(cache.get("a"))
34
+ XCTAssertEqual(cache.get("c"), Data("three".utf8))
35
+ }
36
+
37
+ func testLeaseStaysLocalUntilTheServerOffersOne() {
38
+ var machine = LeaseMachine()
39
+ let now = Date(timeIntervalSince1970: 1_700_000_000)
40
+ machine.begin(.unsupported, now: now)
41
+ XCTAssertEqual(machine.phase, .localOnly)
42
+ machine.begin(.held(id: "lease-1", ttl: 10), now: now)
43
+ XCTAssertEqual(machine.phase, .held(id: "lease-1", renewAfter: now.addingTimeInterval(5)))
44
+ XCTAssertFalse(machine.needsRenewal(now: now.addingTimeInterval(4)))
45
+ XCTAssertTrue(machine.needsRenewal(now: now.addingTimeInterval(5)))
46
+ machine.resume(.denied, now: now)
47
+ XCTAssertEqual(machine.phase, .denied)
48
+ }
49
+
50
+ func testPackMatchesTheSliceLayout() {
51
+ let body = Data(repeating: 0x61, count: MountLayout.inlineBytes + 1)
52
+ let packed = FilePacker.pack(body)
53
+ XCTAssertEqual(packed?.size, body.count)
54
+ XCTAssertEqual(packed?.contentSha.count, 64)
55
+ XCTAssertEqual(packed?.manifestHex.count, 64)
56
+ XCTAssertEqual(packed?.objects.count, 2)
57
+ XCTAssertNil(FilePacker.pack(Data("small".utf8)))
58
+ }
59
+
60
+ func testRegistryOmitsCredentials() throws {
61
+ let record = MountRecord(
62
+ id: "mount-1", server: "https://files.example", workspace: "demo", space: "general", remotePath: "/Notes",
63
+ localPath: "/Users/me/Notes", readOnly: false, access: "read-write", state: "mounted", sync: "current")
64
+ let data = try MountRegistry.encode(MountBook(mounts: [record]))
65
+ let json = try JSONSerialization.jsonObject(with: data) as? [String: Any]
66
+ XCTAssertEqual(json?["version"] as? Int, 1)
67
+ let mounts = json?["mounts"] as? [[String: Any]]
68
+ XCTAssertEqual(mounts?.first?["workspace"] as? String, "demo")
69
+ XCTAssertEqual(mounts?.first?["space"] as? String, "general")
70
+ XCTAssertNil(mounts?.first?["token"])
71
+ XCTAssertFalse(String(decoding: data, as: UTF8.self).contains("ps_profile_token"))
72
+ }
73
+
74
+ func testMountTargetAndProviderDomain() throws {
75
+ XCTAssertEqual(try MountTarget.parse("general").remotePath, "/")
76
+ XCTAssertEqual(try MountTarget.parse("general/Notes").space, "general")
77
+ XCTAssertEqual(try MountTarget.parse("general/Notes").remotePath, "/Notes")
78
+ XCTAssertEqual(try MountTarget.parse("general/Notes/2026").remotePath, "/Notes/2026")
79
+ XCTAssertThrowsError(try MountTarget.parse("general/../secret"))
80
+ XCTAssertThrowsError(try MountTarget.parse(""))
81
+ let domain = DomainName.make(home: "/Users/me", workspace: "demo", space: "general", scope: "Notes")
82
+ XCTAssertEqual(domain.cloudPath, "/Users/me/Library/CloudStorage/ADoor-demo general Notes")
83
+ XCTAssertFalse(domain.cloudPath.contains("ps_profile_token"))
84
+ XCTAssertFalse(domain.identifier.contains("Bearer"))
85
+ try ServerOrigin.validate(URL(string: "https://files.example")!)
86
+ try ServerOrigin.validate(URL(string: "http://127.0.0.1:4317")!)
87
+ XCTAssertThrowsError(try ServerOrigin.validate(URL(string: "http://example.com")!))
88
+ XCTAssertThrowsError(try ServerOrigin.validate(URL(string: "https://files.example/notes")!))
89
+ XCTAssertThrowsError(try ServerOrigin.validate(URL(string: "https://user:secret@files.example")!))
90
+ }
91
+
92
+ func testDemoDeskShowsAccessAndDeletedFiles() {
93
+ var desk = MountDesk.demo()
94
+ XCTAssertEqual(desk.menuStatus.label, "1 conflict")
95
+ XCTAssertEqual(desk.visibleSpaces.map(\.name), ["Field notes", "General"])
96
+ XCTAssertEqual(desk.visibleFolders.map(\.name), ["Notes", "Receipts"])
97
+ XCTAssertEqual(desk.folders[0].access.readLabel, "Read")
98
+ XCTAssertEqual(desk.folders[0].access.writeLabel, "Write")
99
+ XCTAssertEqual(desk.visibleFolders[1].access.writeLabel, "No write")
100
+ desk.select(space: "general-demo")
101
+ XCTAssertEqual(desk.visibleFolders.map(\.name), ["Inbox"])
102
+ desk.select(workspace: "studio")
103
+ XCTAssertEqual(desk.visibleSpaces.map(\.name), ["General"])
104
+ XCTAssertEqual(desk.visibleFolders.map(\.name), ["Clips"])
105
+ desk.select(workspace: "demo")
106
+ XCTAssertEqual(desk.selectedFolder?.name, "Notes")
107
+ let listed: JSONValue = [
108
+ "workspaces": [
109
+ ["id": "demo", "name": "Demo", "slug": "demo", "current": true],
110
+ ["id": "studio", "name": "Studio", "slug": "studio"]
111
+ ]
112
+ ]
113
+ XCTAssertEqual(FolderCatalog.workspaces(from: listed).map(\.slug), ["demo", "studio"])
114
+ let spaces: JSONValue = ["spaces": [["id": "space-1", "name": "General", "slug": "general"], ["id": "old", "name": "Old", "archived": true]]]
115
+ XCTAssertEqual(FolderCatalog.spaces(from: spaces, workspaceID: "demo").map(\.slug), ["general"])
116
+ XCTAssertEqual(KeychainPlacement.record()["accessible"], "kSecAttrAccessibleWhenUnlockedThisDeviceOnly")
117
+ XCTAssertEqual(desk.recoveryNote, "Files can be recovered for 30 days.")
118
+ XCTAssertEqual(desk.deleted.map(\.who), ["Ada Lovelace", "This Mac"])
119
+ desk.showDeleted()
120
+ desk.toggleDeleted("old-budget")
121
+ desk.toggleDeleted("scratch-note")
122
+ desk.restored(["old-budget", "scratch-note"])
123
+ XCTAssertTrue(desk.deleted.isEmpty)
124
+ XCTAssertEqual(desk.activity.first?.title, "2 files")
125
+ XCTAssertEqual(desk.activity.first?.detail, "Restored")
126
+ desk = MountDesk.demo()
127
+ desk.resolve(conflictId: "conflict-budget", keep: .mine)
128
+ XCTAssertEqual(desk.activity.first?.detail, "Kept your copy")
129
+ XCTAssertEqual(desk.folders[0].sync, .current)
130
+ }
131
+
132
+ func testDeletedListNamesWhoAndWhen() throws {
133
+ let json: JSONValue = [
134
+ "retentionDays": 30,
135
+ "entries": [[
136
+ "id": "old-budget",
137
+ "name": "old-budget.txt",
138
+ "kind": "file",
139
+ "deletedBy": "Ada Lovelace",
140
+ "deletedAt": "2026-11-12T12:00:00Z",
141
+ "purgeAfter": "2026-12-12T12:00:00Z"
142
+ ]]
143
+ ]
144
+ let folder = try FileJSON.deleted(json)
145
+ XCTAssertEqual(folder.files.first?.who, "Ada Lovelace")
146
+ XCTAssertEqual(folder.files.first?.name, "old-budget.txt")
147
+ XCTAssertEqual(folder.retentionDays, 30)
148
+ XCTAssertEqual(DeletedFolder.note(days: folder.retentionDays), "Files can be recovered for 30 days.")
149
+ let broken: JSONValue = ["entries": [["id": "x", "name": "a.txt", "deletedAt": "2026-11-12T12:00:00Z"]]]
150
+ XCTAssertThrowsError(try FileJSON.deleted(broken))
151
+ }
152
+
153
+ func testUnavailableTrashNamesTheMissingOperation() async {
154
+ let trash = UnavailableFileTrash()
155
+ do {
156
+ _ = try await trash.listDeleted(spaceId: "space", folderId: "folder")
157
+ XCTFail("list should fail")
158
+ } catch let error as AdoorError {
159
+ XCTAssertEqual(error.code, "ENDPOINT_UNAVAILABLE")
160
+ XCTAssertTrue(error.message.contains("fs.list_deleted"))
161
+ } catch {
162
+ XCTFail("Unexpected error")
163
+ }
164
+ }
165
+
166
+ func testDeviceFlowRedactsTheDeviceCode() throws {
167
+ let origin = URL(string: "https://files.example")!
168
+ let json: JSONValue = [
169
+ "deviceCode": "device_secret_value_0123456789",
170
+ "userCode": "BCDF-GHJK",
171
+ "approvalUrl": "https://files.example/#device/1",
172
+ "expiresAt": "2026-11-19T03:00:00.000Z",
173
+ "interval": 2
174
+ ]
175
+ let start = try DeviceFlow.parseStart(json, origin: origin)
176
+ XCTAssertEqual(start.userCode, "BCDF-GHJK")
177
+ XCTAssertFalse(DeviceFlow.redacted(start).contains("device_secret_value"))
178
+ XCTAssertThrowsError(try DeviceFlow.parseStart(json, origin: URL(string: "https://example.test")!))
179
+ let approved = try DeviceFlow.parsePoll(["status": "approved", "token": "ps_issued_token"])
180
+ XCTAssertEqual(approved, .approved(token: "ps_issued_token"))
181
+ XCTAssertThrowsError(try DeviceFlow.parsePoll(["status": "approved"]))
182
+ }
183
+
184
+ func testTreeKeepsExcludedNamesAndWritesAConflictCopy() async throws {
185
+ let remote = FakeRemote()
186
+ let tree = SyncTree(spaceId: "space", readOnly: false, remote: remote, bytes: remote, cacheSlots: 2)
187
+ try await tree.open(path: "/")
188
+ let root = await tree.rootIdentifier()
189
+ _ = try await tree.create(root, name: ".git", data: Data("local".utf8))
190
+ XCTAssertEqual(remote.writes, 0)
191
+ let created = try await tree.create(root, name: "hello.txt", data: Data("hello".utf8))
192
+ XCTAssertEqual(remote.writes, 1)
193
+ _ = try await tree.write(created.id, offset: 0, data: Data("local".utf8))
194
+ remote.conflict = true
195
+ let saved = try await tree.commit(created.id)
196
+ XCTAssertEqual(saved.generation, 2)
197
+ let copies = await tree.conflictCopies()
198
+ XCTAssertEqual(copies.first?.originalName, "hello.txt")
199
+ XCTAssertEqual(copies.first?.localBytes, Data("local".utf8))
200
+ remote.conflict = false
201
+ try await tree.resolve(copies[0].id, keep: .mine)
202
+ XCTAssertEqual(remote.replaced, Data("local".utf8))
203
+ let after = await tree.conflictCopies()
204
+ XCTAssertTrue(after.isEmpty)
205
+ remote.failAccess = true
206
+ do { _ = try await tree.attributes(created.id) } catch let error as TreeError { XCTAssertEqual(error, .access) }
207
+ remote.failAccess = false
208
+ remote.stats = 0
209
+ _ = try await tree.attributes(created.id)
210
+ XCTAssertGreaterThan(remote.stats, 0)
211
+ }
212
+
213
+ func testSmallReadsStayInlineAndLargeReadsAskForARange() async throws {
214
+ let remote = FakeRemote()
215
+ let tree = SyncTree(spaceId: "space", readOnly: false, remote: remote, bytes: remote)
216
+ try await tree.open(path: "/")
217
+ let root = await tree.rootIdentifier()
218
+ let small = try await tree.create(root, name: "note.txt", data: Data("note".utf8))
219
+ remote.reads = 0
220
+ remote.ranges = 0
221
+ let text = try await tree.read(small.id, offset: 0, count: 4)
222
+ XCTAssertEqual(text, Data("note".utf8))
223
+ XCTAssertEqual(remote.reads, 1)
224
+ XCTAssertEqual(remote.ranges, 0)
225
+ remote.large = Data(repeating: 7, count: MountLayout.inlineBytes + 8)
226
+ let big = try await tree.lookup(root, name: "big.bin")
227
+ _ = try await tree.read(big.id, offset: 0, count: 4)
228
+ XCTAssertEqual(remote.ranges, 1)
229
+ }
230
+
231
+ func testProviderItemMappingPagesAndStaleGeneration() {
232
+ let file = NodeAttr(
233
+ id: UUID(uuidString: "22222222-2222-2222-2222-222222222222")!, name: "hello.txt", kind: .file,
234
+ size: 5, generation: 4, mode: 0o644, mtime: Date(timeIntervalSince1970: 0))
235
+ let folder = NodeAttr(
236
+ id: UUID(uuidString: "33333333-3333-3333-3333-333333333333")!, name: "Notes", kind: .directory,
237
+ size: 0, generation: 1, mode: 0o755, mtime: Date(timeIntervalSince1970: 0))
238
+ let mapped = ProviderMap.item(file, parent: ProviderMap.root, phase: .downloaded)
239
+ XCTAssertEqual(mapped.name, "hello.txt")
240
+ XCTAssertFalse(mapped.isDirectory)
241
+ XCTAssertTrue(mapped.isDownloaded)
242
+ XCTAssertEqual(mapped.contentVersion, Data([0, 0, 0, 0, 0, 0, 0, 4]))
243
+ let syncing = ProviderMap.item(folder, parent: ProviderMap.root, phase: .syncing)
244
+ XCTAssertTrue(syncing.isDirectory)
245
+ XCTAssertTrue(syncing.isSyncing)
246
+ let failed = ProviderMap.item(file, parent: ProviderMap.root, phase: .error, message: "The server rejected the generation.")
247
+ XCTAssertTrue(failed.hasError)
248
+ XCTAssertEqual(failed.message, "The server rejected the generation.")
249
+ let entries = [file, folder, file]
250
+ let first = ProviderPages.window(entries: entries, parent: ProviderMap.root, cursor: nil, limit: 2, phase: .downloaded)
251
+ XCTAssertEqual(first.items.map(\.name), ["hello.txt", "Notes"])
252
+ XCTAssertEqual(first.nextCursor, "2")
253
+ let second = ProviderPages.window(entries: entries, parent: ProviderMap.root, cursor: first.nextCursor, limit: 2, phase: .downloaded)
254
+ XCTAssertEqual(second.items.count, 1)
255
+ XCTAssertNil(second.nextCursor)
256
+ let remote = RemotePage(directoryId: folder.id, entries: [file], nextCursor: "page-2")
257
+ XCTAssertEqual(ProviderPages.remote(remote, parent: folder.idString, phase: .downloaded).nextCursor, "page-2")
258
+ let stored = GenerationGate.plan(expected: 4, server: 4, name: "hello.txt", identity: "abcd")
259
+ XCTAssertEqual(stored, .store(expectedGeneration: 4))
260
+ let stale = GenerationGate.plan(expected: 4, server: 9, name: "hello.txt", identity: "abcd")
261
+ XCTAssertEqual(stale, .conflict(copyName: ConflictName.make(original: "hello.txt", id: "abcd"), serverGeneration: 9))
262
+ if case .store = stale { XCTFail("A stale generation was stored.") }
263
+ let domain = DomainName.make(home: "/Users/me", workspace: "demo", space: "general", scope: "Notes")
264
+ XCTAssertEqual(domain.cloudPath, "/Users/me/Library/CloudStorage/ADoor-demo general Notes")
265
+ XCTAssertFalse(domain.identifier.contains("/"))
266
+ XCTAssertEqual(DomainName.parse(domain.identifier)?.scope, "Notes")
267
+ let nested = DomainName.make(home: "/Users/me", workspace: "demo", space: "general", scope: "Notes/2026")
268
+ XCTAssertFalse(nested.identifier.contains("/"))
269
+ XCTAssertEqual(DomainName.parse(nested.identifier)?.scope, "Notes/2026")
270
+ XCTAssertFalse(domain.identifier.contains("ps_"))
271
+ XCTAssertFalse(domain.cloudPath.contains("token"))
272
+ XCTAssertEqual(MacBackend.choose(platformDarwin: false), .linuxFuse)
273
+ XCTAssertEqual(MacBackend.choose(platformDarwin: true), .fileProvider)
274
+ let wake = EnumeratorWake.forChange(FileChange(cursor: "3", inodeId: file.idString, type: "changed"))
275
+ XCTAssertEqual(wake.containers, ["workingSet", file.idString])
276
+ XCTAssertEqual(FinderPhase.phase(for: .current).label, "Downloaded")
277
+ XCTAssertEqual(FinderPhase.phase(for: .syncing).label, "Syncing")
278
+ XCTAssertEqual(FinderPhase.phase(for: .conflict), .downloaded)
279
+ XCTAssertEqual(FinderPhase.phase(for: .offline), .error)
280
+ XCTAssertEqual(FinderPhase.phase(for: .offline).label, "Couldn't reach the server")
281
+ XCTAssertNotEqual(FinderPhase.phase(for: .conflict).label, "Error")
282
+ XCTAssertNil(VersionGeneration.decode(Data()))
283
+ XCTAssertNil(VersionGeneration.decode(Data(repeating: 255, count: 8)))
284
+ XCTAssertEqual(VersionGeneration.decode(mapped.contentVersion), 4)
285
+ XCTAssertNotEqual(VersionGeneration.decode(mapped.contentVersion), 9)
286
+ let space = "11111111-1111-1111-1111-111111111111"
287
+ let mounted = DomainName.make(home: "/Users/me", workspace: "demo", space: space, scope: "Notes", label: "general")
288
+ XCTAssertEqual(DomainName.parse(mounted.identifier)?.space, space)
289
+ XCTAssertEqual(mounted.cloudPath, "/Users/me/Library/CloudStorage/ADoor-demo general Notes")
290
+ XCTAssertFalse(mounted.identifier.contains("general"))
291
+ XCTAssertThrowsError(try ProviderAccess(userInfo: [DomainFlag.readOnly: true]).requireWrite()) { error in
292
+ XCTAssertEqual(error as? TreeError, .readOnly)
293
+ }
294
+ XCTAssertNoThrow(try ProviderAccess(userInfo: [:]).requireWrite())
295
+ let locked = DomainName.make(
296
+ home: "/Users/me", workspace: "demo", space: space, scope: "Notes", label: "general", readOnly: true)
297
+ let lockedInfo = ProviderAccess.userInfo(identifier: locked.identifier, stored: [:])
298
+ XCTAssertEqual(DomainName.parse(locked.identifier)?.space, space)
299
+ XCTAssertTrue(DomainName.parse(locked.identifier)?.readOnly == true)
300
+ XCTAssertThrowsError(try ProviderAccess(userInfo: lockedInfo).requireWrite()) { error in
301
+ XCTAssertEqual(error as? TreeError, .readOnly)
302
+ }
303
+ let openInfo = ProviderAccess.userInfo(identifier: mounted.identifier, stored: [:])
304
+ XCTAssertNoThrow(try ProviderAccess(userInfo: openInfo).requireWrite())
305
+ let marked = ProviderAccess.userInfo(identifier: mounted.identifier, stored: [DomainFlag.readOnly: true])
306
+ XCTAssertThrowsError(try ProviderAccess(userInfo: marked).requireWrite()) { error in
307
+ XCTAssertEqual(error as? TreeError, .readOnly)
308
+ }
309
+ }
310
+
311
+ func testKeepMineWritesTheInodeTheUserSaw() async throws {
312
+ let remote = FakeRemote()
313
+ let tree = SyncTree(spaceId: "space", readOnly: false, remote: remote, bytes: remote)
314
+ try await tree.open(path: "/")
315
+ let root = await tree.rootIdentifier()
316
+ let created = try await tree.create(root, name: "hello.txt", data: Data("hello".utf8))
317
+ _ = try await tree.write(created.id, offset: 0, data: Data("local".utf8))
318
+ remote.conflict = true
319
+ _ = try await tree.commit(created.id)
320
+ let copies = await tree.conflictCopies()
321
+ let seen = try XCTUnwrap(copies.first)
322
+ XCTAssertEqual(seen.inodeId, created.id.uuidString.lowercased())
323
+ XCTAssertEqual(seen.baseGeneration, 2)
324
+ remote.rename(created.id, to: "server.txt")
325
+ remote.bump(created.id, generation: 7, data: Data("newer".utf8))
326
+ let twin = remote.plant(name: "hello.txt", generation: 7, data: Data("other".utf8))
327
+ _ = try await tree.directory(root)
328
+ do {
329
+ try await tree.resolve(seen.id, keep: .mine)
330
+ XCTFail("a different file was kept")
331
+ } catch let error as TreeError {
332
+ XCTAssertEqual(error, .conflict)
333
+ }
334
+ XCTAssertEqual(remote.lastInode, created.id.uuidString.lowercased())
335
+ XCTAssertEqual(remote.lastGeneration, seen.baseGeneration)
336
+ XCTAssertEqual(remote.bytes(created.id), Data("newer".utf8))
337
+ XCTAssertEqual(remote.bytes(twin), Data("other".utf8))
338
+ let remaining = await tree.conflictCopies()
339
+ XCTAssertEqual(remaining.map(\.inodeId), [seen.inodeId])
340
+ }
341
+
342
+ func testDeleteUsesTheGenerationTheUserSaw() async throws {
343
+ let remote = FakeRemote()
344
+ remote.seedHello()
345
+ let tree = SyncTree(spaceId: "space", readOnly: false, remote: remote, bytes: remote)
346
+ try await tree.open(path: "/")
347
+ let root = await tree.rootIdentifier()
348
+ remote.bump(remote.hello, generation: 6, data: Data("kept".utf8))
349
+ do {
350
+ try await tree.remove(root, name: "hello.txt", expectedGeneration: 1)
351
+ XCTFail("a newer file was deleted")
352
+ } catch let error as TreeError {
353
+ XCTAssertEqual(error, .conflict)
354
+ }
355
+ XCTAssertEqual(remote.bytes(remote.hello), Data("kept".utf8))
356
+ XCTAssertTrue(remote.removals.isEmpty)
357
+ try await tree.remove(root, name: "hello.txt", expectedGeneration: 6)
358
+ XCTAssertNil(remote.bytes(remote.hello))
359
+ XCTAssertEqual(remote.removals.map(\.inode), [remote.helloKey])
360
+ XCTAssertEqual(remote.removals.map(\.generation), [6])
361
+ }
362
+
363
+ func testReadOnlyMountRefusesWrites() async throws {
364
+ let remote = FakeRemote()
365
+ remote.seedHello()
366
+ let tree = SyncTree(spaceId: "space", readOnly: true, remote: remote, bytes: remote)
367
+ try await tree.open(path: "/")
368
+ let root = await tree.rootIdentifier()
369
+ do {
370
+ try await tree.remove(root, name: "hello.txt", expectedGeneration: 1)
371
+ XCTFail("a read-only mount deleted a file")
372
+ } catch let error as TreeError {
373
+ XCTAssertEqual(error, .readOnly)
374
+ }
375
+ XCTAssertTrue(remote.removals.isEmpty)
376
+ XCTAssertEqual(remote.bytes(remote.hello), Data("hello".utf8))
377
+ }
378
+ }
379
+
380
+ private final class FakeRemote: FileRemote, FileBytePlane, @unchecked Sendable {
381
+ let root = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
382
+ let hello = UUID(uuidString: "22222222-2222-2222-2222-222222222222")!
383
+ let big = UUID(uuidString: "33333333-3333-3333-3333-333333333333")!
384
+ var writes = 0
385
+ var reads = 0
386
+ var ranges = 0
387
+ var stats = 0
388
+ var conflict = false
389
+ var failAccess = false
390
+ var replaced = Data()
391
+ var lastInode: String?
392
+ var lastGeneration = -1
393
+ var removals: [(inode: String, generation: Int)] = []
394
+ var helloKey: String { key(hello) }
395
+ var large = Data() {
396
+ didSet {
397
+ items[key(big)] = Item(name: "big.bin", data: large, generation: 1, kind: .file, content: "abc")
398
+ }
399
+ }
400
+ private var items: [String: Item] = [:]
401
+
402
+ init() {
403
+ items[key(root)] = Item(name: "space", data: Data(), generation: 1, kind: .directory, content: nil)
404
+ }
405
+
406
+ func seedHello() {
407
+ items[key(hello)] = Item(name: "hello.txt", data: Data("hello".utf8), generation: 1, kind: .file, content: nil)
408
+ }
409
+
410
+ func bump(_ id: UUID, generation: Int, data: Data) {
411
+ guard var item = items[key(id)] else { return }
412
+ item.generation = generation
413
+ item.data = data
414
+ items[key(id)] = item
415
+ }
416
+
417
+ func rename(_ id: UUID, to name: String) {
418
+ guard var item = items[key(id)] else { return }
419
+ item.name = name
420
+ items[key(id)] = item
421
+ }
422
+
423
+ func plant(name: String, generation: Int, data: Data) -> UUID {
424
+ let id = UUID()
425
+ items[key(id)] = Item(name: name, data: data, generation: generation, kind: .file, content: nil)
426
+ return id
427
+ }
428
+
429
+ func bytes(_ id: UUID) -> Data? { items[key(id)]?.data }
430
+
431
+ func stat(spaceId: String, path: String?, inodeId: String?) async throws -> NodeAttr {
432
+ _ = spaceId
433
+ stats += 1
434
+ if failAccess { throw AdoorError(code: "UNAUTHORIZED", message: "Sign in again.", status: 401) }
435
+ if path == "/" { return node(root) }
436
+ guard let inodeId, let item = items[inodeId] else { throw TreeError.notFound }
437
+ return node(UUID(uuidString: inodeId)!, item)
438
+ }
439
+
440
+ func list(spaceId: String, inodeId: String, cursor: String?) async throws -> RemotePage {
441
+ _ = spaceId
442
+ _ = cursor
443
+ guard inodeId == key(root) else { throw TreeError.notFound }
444
+ let entries = items.compactMap { id, item -> NodeAttr? in
445
+ guard id != key(root), item.kind == .file else { return nil }
446
+ return node(UUID(uuidString: id)!, item)
447
+ }.sorted { $0.name < $1.name }
448
+ return RemotePage(directoryId: root, entries: entries, nextCursor: nil)
449
+ }
450
+
451
+ func readInline(spaceId: String, inodeId: String) async throws -> Data {
452
+ _ = spaceId
453
+ reads += 1
454
+ guard let item = items[inodeId], item.kind == .file else { throw TreeError.notFound }
455
+ return item.data
456
+ }
457
+
458
+ func writeInline(
459
+ spaceId: String, path: String?, name: String?, inodeId: String?, bytes: Data,
460
+ expectedGeneration: Int?, idempotencyKey: String
461
+ ) async throws -> NodeAttr {
462
+ _ = spaceId
463
+ _ = path
464
+ _ = idempotencyKey
465
+ writes += 1
466
+ if let inodeId {
467
+ lastInode = inodeId
468
+ lastGeneration = expectedGeneration ?? -1
469
+ guard var item = items[inodeId] else { throw TreeError.notFound }
470
+ if conflict {
471
+ conflict = false
472
+ item.generation += 1
473
+ item.data = Data("server".utf8)
474
+ items[inodeId] = item
475
+ throw AdoorError(code: "CONFLICT", message: "The file changed.", status: 409)
476
+ }
477
+ guard expectedGeneration == item.generation else { throw TreeError.conflict }
478
+ item.data = bytes
479
+ items[inodeId] = item
480
+ replaced = bytes
481
+ return node(UUID(uuidString: inodeId)!, item)
482
+ }
483
+ let id = UUID()
484
+ let item = Item(name: name ?? "file", data: bytes, generation: 1, kind: .file, content: nil)
485
+ items[key(id)] = item
486
+ return node(id, item)
487
+ }
488
+
489
+ func mkdir(spaceId: String, parentId: String, name: String) async throws -> NodeAttr {
490
+ _ = spaceId
491
+ _ = parentId
492
+ let id = UUID()
493
+ let item = Item(name: name, data: Data(), generation: 1, kind: .directory, content: nil)
494
+ items[key(id)] = item
495
+ return node(id, item)
496
+ }
497
+
498
+ func rename(spaceId: String, inodeId: String, name: String, expectedGeneration: Int, parentId: String?) async throws -> NodeAttr {
499
+ _ = spaceId
500
+ _ = parentId
501
+ guard var item = items[inodeId], item.generation == expectedGeneration else { throw TreeError.conflict }
502
+ item.name = name
503
+ items[inodeId] = item
504
+ return node(UUID(uuidString: inodeId)!, item)
505
+ }
506
+
507
+ func remove(spaceId: String, inodeId: String, expectedGeneration: Int) async throws {
508
+ _ = spaceId
509
+ guard let item = items[inodeId], item.generation == expectedGeneration else { throw TreeError.conflict }
510
+ removals.append((inode: inodeId, generation: expectedGeneration))
511
+ items.removeValue(forKey: inodeId)
512
+ }
513
+
514
+ func commitSlices(
515
+ spaceId: String, inodeId: String?, path: String?, name: String?, expectedGeneration: Int?, packed: PackedFile
516
+ ) async throws -> NodeAttr {
517
+ _ = spaceId
518
+ _ = path
519
+ _ = expectedGeneration
520
+ writes += 1
521
+ let id = UUID(uuidString: inodeId ?? "") ?? UUID()
522
+ let item = Item(name: name ?? "file", data: Data(count: packed.size), generation: 1, kind: .file, content: nil)
523
+ items[key(id)] = item
524
+ return node(id, item)
525
+ }
526
+
527
+ func readRange(spaceId: String, inodeId: String, offset: Int, length: Int) async throws -> Data {
528
+ _ = spaceId
529
+ ranges += 1
530
+ guard let item = items[inodeId] else { throw TreeError.notFound }
531
+ let end = min(item.data.count, offset + length)
532
+ guard offset < end else { return Data() }
533
+ return item.data.subdata(in: offset..<end)
534
+ }
535
+
536
+ func putSlice(spaceId: String, sha256: String, body: Data) async throws {
537
+ _ = spaceId
538
+ _ = sha256
539
+ _ = body
540
+ }
541
+
542
+ private func key(_ id: UUID) -> String { id.uuidString.lowercased() }
543
+
544
+ private func node(_ id: UUID) -> NodeAttr { node(id, items[key(id)]!) }
545
+
546
+ private func node(_ id: UUID, _ item: Item) -> NodeAttr {
547
+ let mode = item.kind == .directory ? 0o755 : 0o644
548
+ return NodeAttr(
549
+ id: id, name: item.name, kind: item.kind, size: item.data.count, generation: item.generation,
550
+ mode: mode, mtime: Date(timeIntervalSince1970: 0), contentId: item.content)
551
+ }
552
+ }
553
+
554
+ private struct Item {
555
+ var name: String
556
+ var data: Data
557
+ var generation: Int
558
+ var kind: NodeKind
559
+ var content: String?
560
+ }