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.
- package/CHANGELOG.md +4 -0
- package/README.md +2 -2
- package/dist/adoor.mjs +105 -84
- package/native/LICENSE +662 -0
- package/native/README.md +12 -0
- package/native/darwin/ADoorService.app/Contents/Info.plist +57 -0
- package/native/darwin/ADoorService.app/Contents/MacOS/ADoorService +0 -0
- package/native/darwin/ADoorService.app/Contents/PkgInfo +1 -0
- package/native/darwin/ADoorService.app/Contents/_CodeSignature/CodeResources +123 -0
- package/native/darwin/ADoorService.app/Contents/embedded.provisionprofile +0 -0
- package/native/source/Package.swift +6 -0
- package/native/source/sdk/LICENSE +21 -0
- package/native/source/sdk/Package.swift +14 -0
- package/native/source/sdk/Sources/ADoor/AdoorClient.swift +270 -0
- package/native/source/sdk/Sources/ADoor/AdoorError.swift +60 -0
- package/native/source/sdk/Sources/ADoor/Changes.swift +202 -0
- package/native/source/sdk/Sources/ADoor/DesktopSessionState.swift +73 -0
- package/native/source/sdk/Sources/ADoor/DeviceFlow.swift +70 -0
- package/native/source/sdk/Sources/ADoor/FolderCatalog.swift +49 -0
- package/native/source/sdk/Sources/ADoor/JSONValue.swift +70 -0
- package/native/source/sdk/Sources/ADoor/LocalStore.swift +474 -0
- package/native/source/sdk/Sources/ADoor/Models.swift +146 -0
- package/native/source/sdk/Sources/ADoor/MountModel.swift +896 -0
- package/native/source/sdk/Sources/ADoor/OAuth.swift +225 -0
- package/native/source/sdk/Sources/ADoor/Provider.swift +211 -0
- package/native/source/sdk/Sources/ADoor/Storage.swift +41 -0
- package/native/source/sdk/Sources/ADoor/SyncTree.swift +501 -0
- package/native/source/sdk/Sources/ADoor/Trash.swift +283 -0
- package/native/source/sdk/Tests/ADoorTests/ADoorTests.swift +182 -0
- package/native/source/sdk/Tests/ADoorTests/DesktopSessionStateTests.swift +46 -0
- package/native/source/sdk/Tests/ADoorTests/MountTests.swift +560 -0
- package/native/source/sdk/Tests/ADoorTests/RegressionTests.swift +360 -0
- package/native/source/service/DesktopSession.swift +241 -0
- package/native/source/service/DeviceClient.swift +53 -0
- package/native/source/service/Domains.swift +182 -0
- package/native/source/service/FolderRefresh.swift +37 -0
- package/native/source/service/KeychainStore.swift +74 -0
- package/native/source/service/LocalSessionSocket.swift +142 -0
- package/native/source/service/ServiceMain.swift +14 -0
- package/native/source/service/ServiceMounts.swift +34 -0
- 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
|
+
}
|