SPB Git

Repository Public

InteropTests.swift 23.9 KB 386 lines swift

1// Cross-client interoperability: a TypeScript device (apps/web/src/core/engine.ts, hosted by Tests/Tools/ts-device.ts)2// and a Swift device (VaultEngine) against the same real server — same account, both directions.3// The account passkey is shared between the two "devices" by exporting / importing the software authenticator's4// credential (private key JWK, credential id, user handle, signature counter).5import CryptoKit6import Foundation7import XCTest8@testable import SharedVaultKit910final class InteropTests: ServerTestCase {11    private var ts: TSHelper { TSHelper.shared }1213    private func args(_ pairs: (String, JSONValue)...) -> JSONValue { .object(JSONObject(pairs)) }1415    /// A TypeScript-created account; returns its recovery key.16    private func tsAccount(_ dev: String, handle: String) async throws -> String {17        try await ts.call("device", args(("dev", .string(dev))))18        let r = try await ts.call("register", args(("dev", .string(dev)), ("handle", .string(handle)), ("invite", .string(try makeInvite()))))19        return try XCTUnwrap(r["recoveryKey"]?.stringValue)20    }2122    /// Enrols a Swift device on the account of TypeScript device `trusted` through pairing approved by the TypeScript device.23    private func swiftJoins(_ trusted: String) async throws -> Dev {24        let auth = SoftwarePasskeys()25        try auth.importCredentials(try await ts.call("exportAuth", args(("dev", .string(trusted)))))26        let d = device(auth: auth, platform: "Swift device")27        let s = try await d.engine.signIn()28        XCTAssertEqual(s, .pending)29        let offer = try await d.engine.startPairing()30        let req = try await ts.call("inspectPairing", args(("dev", .string(trusted)), ("code", .string(offer.code))))31        XCTAssertEqual(req["sas"]?.stringValue, offer.sas, "both clients compute the same 6-digit fingerprint")32        XCTAssertEqual(req["platform"]?.stringValue, "Swift device")33        try await ts.call("approvePairing", args(("dev", .string(trusted)), ("pairingId", try XCTUnwrap(req["pairingId"]))))34        let st = try await d.engine.checkPairing()35        XCTAssertEqual(st, .done)36        // keep the TypeScript authenticator's counter ahead of what Swift just used37        try await ts.call("importAuth", args(("dev", .string(trusted)), ("creds", auth.exportCredentials())))38        return d39    }4041    /// Enrols a TypeScript device on the account of Swift device `trusted` through pairing approved by the Swift device.42    private func tsJoins(_ dev: String, trusted: Dev) async throws {43        try await ts.call("device", args(("dev", .string(dev))))44        try await ts.call("importAuth", args(("dev", .string(dev)), ("creds", trusted.auth.exportCredentials())))45        let s = try await ts.call("signIn", args(("dev", .string(dev))))46        XCTAssertEqual(s, "pending")47        let offer = try await ts.call("startPairing", args(("dev", .string(dev))))48        let req = try await trusted.engine.inspectPairing(code: try XCTUnwrap(offer["code"]?.stringValue))49        XCTAssertEqual(req.sas, offer["sas"]?.stringValue)50        XCTAssertEqual(req.platform, "TS device")51        try await trusted.engine.approvePairing(req)52        let st = try await ts.call("checkPairing", args(("dev", .string(dev))))53        XCTAssertEqual(st, "done")54        try trusted.auth.importCredentials(try await ts.call("exportAuth", args(("dev", .string(dev)))))55    }5657    private func tsGet(_ dev: String, _ vault: String, _ id: String) async throws -> Item? {58        let r = try await ts.call("get", args(("dev", .string(dev)), ("vaultId", .string(vault)), ("id", .string(id))))59        guard let item = r["item"] else { return nil }60        return try SPV1.normalizeItem(item)61    }6263    private func tsSave(_ dev: String, _ vault: String, _ item: Item) async throws -> String {64        try unwrap(try await ts.call("save", args(("dev", .string(dev)), ("vaultId", .string(vault)), ("item", item.jsonValue))).stringValue)65    }6667    private func tsDigest(_ dev: String) async throws -> String { try unwrap(try await ts.call("digest", args(("dev", .string(dev)))).stringValue) }68    private func tsSync(_ dev: String) async throws { try await ts.call("sync", args(("dev", .string(dev)))) }69    private func tsVault(_ dev: String) async throws -> String {70        try unwrap(try await ts.call("vaults", args(("dev", .string(dev))))[0]?["vaultId"]?.stringValue)71    }7273    private func rich(_ title: String) -> Item {74        var it = login(title)75        it.custom = [CustomField(label: "PIN é", value: "12 34", kind: .secret), CustomField(label: "memo", value: "ligne\n2 \u{1F510}", kind: .multiline)]76        it.favorite = true77        it.expiresAt = "2027-01-01"78        it.rotateEveryDays = 9079        it.urls.append(ItemUrl(url: "https://bücher.example/a?b=c", match: .host))80        return it81    }8283    // (1) + (3) + (6): TS account, Swift joins by pairing approved by TS; items, digest, attachments, conflicts.84    func testAccountCreatedByTypeScriptJoinedBySwift() async throws {85        _ = try await tsAccount("x1a", handle: "interop1")86        let v = try await tsVault("x1a")87        let fromTs = try await tsSave("x1a", v, rich("Written by TS"))88        let s = try await swiftJoins("x1a")89        // Swift reads what TypeScript wrote, field for field90        let vaults = await s.engine.vaults()91        XCTAssertEqual(vaults.map(\.vaultId), [v])92        XCTAssertEqual(vaults.first?.meta.name, "Personal")93        let got = try unwrap(await s.engine.get(vaultId: v, id: fromTs)).item94        let expected = try unwrap(try await tsGet("x1a", v, fromTs))95        XCTAssertEqual(got, expected)96        XCTAssertEqual(got.custom.last?.value, "ligne\n2 \u{1F510}")97        // TypeScript reads what Swift writes98        let fromSwift = try await s.engine.saveItem(vaultId: v, item: rich("Written by Swift"))99        try await tsSync("x1a")100        let seenByTs = try unwrap(try await tsGet("x1a", v, fromSwift))101        let mine = try unwrap(await s.engine.get(vaultId: v, id: fromSwift)).item102        XCTAssertEqual(seenByTs, mine)103        var da = try await tsDigest("x1a"), ds = await s.engine.stateDigest()104        XCTAssertEqual(da, ds, "state digests are equal on both clients")105        // both list the two devices as certified106        let devs = try await s.engine.devices()107        XCTAssertEqual(devs.count, 2)108        XCTAssertTrue(devs.allSatisfy(\.verified))109        let tsDevs = try await ts.call("devices", args(("dev", "x1a")))110        XCTAssertEqual(tsDevs.arrayValue?.count, 2)111        XCTAssertEqual(tsDevs.arrayValue?.allSatisfy { $0["verified"] == true }, true)112        XCTAssertEqual(Set(tsDevs.arrayValue?.compactMap { $0["fingerprint"]?.stringValue } ?? []), Set(devs.map(\.fingerprint)))113114        // edits both ways keep the password history and stay in step115        var edit = mine116        edit.fields["password"] = "changed-by-swift"117        try await s.engine.saveItem(vaultId: v, id: fromSwift, item: edit)118        try await tsSync("x1a")119        try await ts.call("save", args(("dev", "x1a"), ("vaultId", .string(v)), ("id", .string(fromSwift)), ("patch", ["notes": "note by TS"])))120        try await s.engine.sync()121        let after = try unwrap(await s.engine.get(vaultId: v, id: fromSwift))122        XCTAssertEqual(after.item.notes, "note by TS")123        XCTAssertEqual(after.item.fields["password"], "changed-by-swift")124        XCTAssertEqual(after.item.passwordHistory.map(\.value), [SECRET_PW])125        XCTAssertEqual(after.rev, 3)126        let history = try await s.engine.history(vaultId: v, id: fromSwift)127        XCTAssertEqual(history.map(\.rev), [2, 1], "Swift decrypts the revisions written by both clients")128129        // (3) attachments both ways130        let payload = SPV1.random(1024 * 1024 + 4321)131        let ref = try await s.engine.upload(vaultId: v, name: "from-swift.bin", mime: "application/octet-stream", data: payload)132        var doc = SPV1.newItem(.document, title: "Swift attachment")133        doc.attachments = [ref]134        let docId = try await s.engine.saveItem(vaultId: v, item: doc)135        try await tsSync("x1a")136        let tsDoc = try unwrap(try await tsGet("x1a", v, docId))137        XCTAssertEqual(tsDoc.attachments, [ref])138        let dl = try await ts.call("download", args(("dev", "x1a"), ("ref", ref.jsonValue)))139        XCTAssertEqual(dl["size"]?.intValue, payload.count)140        XCTAssertEqual(dl["sha256"]?.stringValue, SPV1.b64u(SPV1.sha256(payload)))141        let payload2 = SPV1.random(1024 * 1024 + 99)142        let tsRef = try await ts.call("upload", args(("dev", "x1a"), ("vaultId", .string(v)), ("name", "from-ts.bin"), ("mime", "application/octet-stream"), ("data", .string(payload2.base64EncodedString()))))143        var tsDocItem = SPV1.newItem(.document, title: "TS attachment").jsonValue.objectValue ?? JSONObject()144        tsDocItem["attachments"] = [tsRef]145        let tsDocId = try unwrap(try await ts.call("save", args(("dev", "x1a"), ("vaultId", .string(v)), ("item", .object(tsDocItem)))).stringValue)146        try await s.engine.sync()147        let swiftRef = try unwrap(await s.engine.get(vaultId: v, id: tsDocId)?.item.attachments.first)148        XCTAssertEqual(swiftRef.chunks, 2)149        let downloaded = try await s.engine.download(swiftRef)150        XCTAssertEqual(downloaded, payload2)151152        // (6) conflict: a TypeScript edit against an offline Swift edit → same final state on both153        s.api.offline = true154        var offlineEdit = try unwrap(await s.engine.get(vaultId: v, id: fromTs)).item155        offlineEdit.notes = "edited offline in Swift"156        try await s.engine.saveItem(vaultId: v, id: fromTs, item: offlineEdit)157        try await ts.call("save", args(("dev", "x1a"), ("vaultId", .string(v)), ("id", .string(fromTs)), ("patch", ["notes": "edited online in TS"])))158        s.api.offline = false159        try await s.engine.sync()160        try await tsSync("x1a")161        let swiftList = await s.engine.list()162        let winner = try unwrap(await s.engine.get(vaultId: v, id: fromTs))163        XCTAssertEqual(winner.item.notes, "edited online in TS")164        let copy = try XCTUnwrap(swiftList.first { $0.item.conflictOf == fromTs })165        XCTAssertEqual(copy.item.notes, "edited offline in Swift")166        XCTAssertEqual(copy.item.title, "Written by TS (conflict copy)")167        let tsWinner = try unwrap(try await tsGet("x1a", v, fromTs))168        XCTAssertEqual(tsWinner, winner.item)169        let tsCopy = try unwrap(try await tsGet("x1a", v, copy.recordId))170        XCTAssertEqual(tsCopy, copy.item)171        da = try await tsDigest("x1a"); ds = await s.engine.stateDigest()172        XCTAssertEqual(da, ds)173174        // the mirror image: TypeScript offline, Swift online — TypeScript makes the conflict copy, Swift reads it175        try await ts.call("offline", args(("dev", "x1a"), ("value", true)))176        try await ts.call("save", args(("dev", "x1a"), ("vaultId", .string(v)), ("id", .string(fromSwift)), ("patch", ["notes": "edited offline in TS"])))177        var online = try unwrap(await s.engine.get(vaultId: v, id: fromSwift)).item178        online.notes = "edited online in Swift"179        try await s.engine.saveItem(vaultId: v, id: fromSwift, item: online)180        try await ts.call("offline", args(("dev", "x1a"), ("value", false)))181        try await tsSync("x1a")182        try await s.engine.sync()183        let w2 = try unwrap(await s.engine.get(vaultId: v, id: fromSwift))184        XCTAssertEqual(w2.item.notes, "edited online in Swift")185        let copy2 = try unwrap(await s.engine.list().first { $0.item.conflictOf == fromSwift })186        XCTAssertEqual(copy2.item.notes, "edited offline in TS")187        let tsW2 = try unwrap(try await tsGet("x1a", v, fromSwift))188        XCTAssertEqual(tsW2, w2.item)189        da = try await tsDigest("x1a"); ds = await s.engine.stateDigest()190        XCTAssertEqual(da, ds)191        let h = try await ts.call("health", args(("dev", "x1a")))192        XCTAssertEqual(h["pending"], 0)193        XCTAssertEqual(h["warnings"], [])194        let warnings = await s.engine.syncHealth().warnings195        XCTAssertEqual(warnings, [])196197        // deletion by one client is a tombstone the other authenticates198        try await s.engine.deleteItem(vaultId: v, id: copy.recordId)199        try await tsSync("x1a")200        let deleted = try await tsGet("x1a", v, copy.recordId)201        XCTAssertNil(deleted)202        try await ts.call("deleteItem", args(("dev", "x1a"), ("vaultId", .string(v)), ("id", .string(copy2.recordId))))203        try await s.engine.sync()204        let deleted2 = await s.engine.get(vaultId: v, id: copy2.recordId)205        XCTAssertNil(deleted2)206        da = try await tsDigest("x1a"); ds = await s.engine.stateDigest()207        XCTAssertEqual(da, ds)208    }209210    // (2): Swift account, a TypeScript device joins by pairing approved by Swift; then a key rotation by each side.211    func testAccountCreatedBySwiftJoinedByTypeScript() async throws {212        let (s, recoveryKey) = try await newAccount("interop2", platform: "Swift device")213        let v = try await personal(s)214        let fromSwift = try await s.engine.saveItem(vaultId: v, item: rich("Swift first"))215        try await tsJoins("x2b", trusted: s)216        let tsVaults = try await ts.call("vaults", args(("dev", "x2b")))217        XCTAssertEqual(tsVaults[0]?["name"], "Personal")218        XCTAssertEqual(tsVaults[0]?["vaultId"], .string(v))219        let seen = try unwrap(try await tsGet("x2b", v, fromSwift))220        let mine = try unwrap(await s.engine.get(vaultId: v, id: fromSwift)).item221        XCTAssertEqual(seen, mine)222        let fromTs = try await tsSave("x2b", v, rich("TS second"))223        try await s.engine.sync()224        let got = try unwrap(await s.engine.get(vaultId: v, id: fromTs)).item225        let expected = try unwrap(try await tsGet("x2b", v, fromTs))226        XCTAssertEqual(got, expected)227        var dt = try await tsDigest("x2b"), ds = await s.engine.stateDigest()228        XCTAssertEqual(dt, ds)229        // the TypeScript device unlocks offline from the envelope Swift wrapped for it, and signs in with its device proof230        try await ts.call("lock", args(("dev", "x2b")))231        try await ts.call("unlockOffline", args(("dev", "x2b")))232        try await ts.call("lock", args(("dev", "x2b")))233        let again = try await ts.call("signIn", args(("dev", "x2b")))234        XCTAssertEqual(again, "unlocked")235        try s.auth.importCredentials(try await ts.call("exportAuth", args(("dev", "x2b"))))236237        // vault key rotation by Swift: TypeScript follows to epoch 2 and reads the re-encrypted records238        try await s.engine.rotateVaultKey(vaultId: v, remove: [])239        try await tsSync("x2b")240        let tsAfter = try await ts.call("vaults", args(("dev", "x2b")))241        XCTAssertEqual(tsAfter[0]?["epoch"], 2)242        XCTAssertEqual(try psql("select distinct envelope->>'kid' from records where vault_id = '\(v)'"), "2")243        let reread = try await tsGet("x2b", v, fromSwift)244        XCTAssertEqual(reread, mine)245        // …and by TypeScript: Swift follows to epoch 3246        try await ts.call("rotateVaultKey", args(("dev", "x2b"), ("vaultId", .string(v))))247        try await s.engine.sync()248        let epoch = await s.engine.vaults().first?.epoch249        XCTAssertEqual(epoch, 3)250        let reread2 = await s.engine.get(vaultId: v, id: fromTs)?.item251        XCTAssertEqual(reread2, expected)252        dt = try await tsDigest("x2b"); ds = await s.engine.stateDigest()253        XCTAssertEqual(dt, ds)254255        // backup made by Swift, opened by the TypeScript engine of the same account (and the other way round)256        let backup = try await s.engine.exportBackup()257        let restored = try await ts.call("restoreBackup", args(("dev", "x2b"), ("text", .string(backup))))258        XCTAssertEqual(restored, 2)259        try await s.engine.sync()260        let n = await s.engine.vaults().count261        XCTAssertEqual(n, 2)262        let tsBackup = try unwrap(try await ts.call("exportBackup", args(("dev", "x2b"))).stringValue)263        let opened = try SPV1.openBackup(try SPV1.parseBackup(tsBackup), secret: .recoveryKey(try SPV1.decodeRecoveryKey(recoveryKey)))264        XCTAssertEqual(opened.payload.vaults.count, 2)265266        // account rekey by Swift: the TypeScript device is signed out, signs in again and reads with the new keys267        let rk2 = try await s.engine.rekeyAccount()268        try await ts.call("importAuth", args(("dev", "x2b"), ("creds", s.auth.exportCredentials())))269        try await ts.call("lock", args(("dev", "x2b")))270        let relogin = try await ts.call("signIn", args(("dev", "x2b")))271        XCTAssertEqual(relogin, "unlocked")272        try s.auth.importCredentials(try await ts.call("exportAuth", args(("dev", "x2b"))))273        try await tsSync("x2b")274        let afterRekey = try await tsGet("x2b", v, fromSwift)275        XCTAssertEqual(afterRekey, mine)276        try await s.engine.sync()277        dt = try await tsDigest("x2b"); ds = await s.engine.stateDigest()278        XCTAssertEqual(dt, ds)279        // (5, mirrored) recovery of a Swift-created account on a TypeScript device with the rotated recovery key280        try await ts.call("device", args(("dev", "x2c")))281        try await ts.call("recover", args(("dev", "x2c"), ("handle", "interop2"), ("recoveryKey", .string(rk2))))282        let recovered = try await tsGet("x2c", v, fromSwift)283        XCTAssertEqual(recovered, mine)284    }285286    // (4): relay shares between a TypeScript account and a Swift account, to an account and by link, both directions;287    // plus a shared vault owned by the TypeScript account.288    func testRelayAndSharedVaultBetweenTypeScriptAndSwiftAccounts() async throws {289        _ = try await tsAccount("x3a", handle: "interop3ts")290        let (s, _) = try await newAccount("interop3swift")291        // TS → Swift account292        let recipient = try await ts.call("lookup", args(("dev", "x3a"), ("handle", "interop3swift")))293        let me = try await s.engine.lookupAccount(handle: "interop3swift")294        XCTAssertEqual(recipient["fingerprint"]?.stringValue, me.fingerprint, "both clients compute the same account fingerprint")295        let sid = try unwrap(try await ts.call("shareAccount", args(("dev", "x3a"), ("item", rich("Shared by TS").jsonValue), ("recipient", recipient))).stringValue)296        let received = try await s.engine.shares()297        XCTAssertEqual(received.received.map(\.id), [sid])298        XCTAssertEqual(received.received.first?.senderHandle, "interop3ts")299        let opened = try await s.engine.openShare(id: sid)300        XCTAssertEqual(opened.from, "interop3ts")301        XCTAssertEqual(opened.item.title, "Shared by TS")302        XCTAssertEqual(opened.item.fields["password"], SECRET_PW)303        XCTAssertEqual(opened.item.custom.first?.value, "12 34")304        // TS → link, opened by Swift without an account305        let url = try unwrap(try await ts.call("shareLink", args(("dev", "x3a"), ("item", rich("Link by TS").jsonValue))).stringValue)306        let viaLink = try await VaultEngine.openLinkShare(url: url, transport: device().api)307        XCTAssertEqual(viaLink.title, "Link by TS")308        XCTAssertEqual(viaLink.fields["totp"], "JBSWY3DPEHPK3PXP")309        // Swift → TS account310        let tsAccountInfo = try await s.engine.lookupAccount(handle: "interop3ts")311        let sid2 = try await s.engine.shareWithAccount(item: rich("Shared by Swift"), recipient: tsAccountInfo, expiresInSec: 3600)312        let tsOpened = try await ts.call("openShare", args(("dev", "x3a"), ("id", .string(sid2))))313        XCTAssertEqual(tsOpened["from"], "interop3swift")314        XCTAssertEqual(try SPV1.normalizeItem(try XCTUnwrap(tsOpened["item"])).title, "Shared by Swift")315        XCTAssertEqual(tsOpened["item"]?["fields"]?["password"]?.stringValue, SECRET_PW)316        // Swift → link, opened by TypeScript317        let url2 = try await s.engine.shareByLink(item: rich("Link by Swift"), origin: "https://vault.example", expiresInSec: 3600)318        let tsLink = try await ts.call("openLink", args(("url", .string(url2))))319        XCTAssertEqual(tsLink["title"], "Link by Swift")320321        // shared vault owned by the TypeScript account: Swift is a member (grants issued by TS, owner key pinned by Swift)322        let shared = try unwrap(try await ts.call("createVault", args(("dev", "x3a"), ("name", "Équipe"))).stringValue)323        let inShared = try await tsSave("x3a", shared, rich("In the shared vault"))324        try await ts.call("addMember", args(("dev", "x3a"), ("vaultId", .string(shared)), ("member", recipient), ("role", "editor")))325        try await s.engine.sync()326        let sv = try unwrap(await s.engine.vaults().first { $0.vaultId == shared })327        XCTAssertEqual(sv.meta.name, "Équipe")328        XCTAssertEqual(sv.role, .editor)329        XCTAssertEqual(sv.members.count, 2)330        let item = await s.engine.get(vaultId: shared, id: inShared)331        XCTAssertEqual(item?.item.title, "In the shared vault")332        let added = try await s.engine.saveItem(vaultId: shared, item: rich("Added by the Swift member"))333        try await tsSync("x3a")334        let tsSees = try await tsGet("x3a", shared, added)335        XCTAssertEqual(tsSees?.title, "Added by the Swift member")336        // …and one owned by the Swift account with the TypeScript account as reader, then removed (rotation)337        let mine = try await s.engine.createVault(meta: VaultMeta(name: "Swift shared", kind: .shared))338        let secret = try await s.engine.saveItem(vaultId: mine, item: rich("Owned by Swift"))339        try await s.engine.addMember(vaultId: mine, member: tsAccountInfo, role: .reader)340        try await tsSync("x3a")341        let tsReads = try await tsGet("x3a", mine, secret)342        XCTAssertEqual(tsReads?.title, "Owned by Swift")343        try await s.engine.rotateVaultKey(vaultId: mine, remove: [tsAccountInfo.accountId])344        try await tsSync("x3a")345        let tsVaults = try await ts.call("vaults", args(("dev", "x3a")))346        XCTAssertFalse((tsVaults.arrayValue ?? []).contains { $0["vaultId"]?.stringValue == mine })347    }348349    // (5): recovery of a TypeScript-created account on a fresh Swift device with the recovery key.350    func testRecoveryOfTypeScriptAccountOnSwiftDevice() async throws {351        let recoveryKey = try await tsAccount("x4a", handle: "interop4")352        let v = try await tsVault("x4a")353        let id = try await tsSave("x4a", v, rich("Recovered on Swift"))354        let fresh = device(platform: "Swift replacement")355        try await fresh.engine.recover(handle: "interop4", recoveryKey: recoveryKey)356        let got = try unwrap(await fresh.engine.get(vaultId: v, id: id)).item357        let expected = try unwrap(try await tsGet("x4a", v, id))358        XCTAssertEqual(got, expected)359        let dt = try await tsDigest("x4a"), ds = await fresh.engine.stateDigest()360        XCTAssertEqual(dt, ds)361        // the recovered Swift device is a full device: it writes, adds its own passkey, and rotates the recovery key362        let written = try await fresh.engine.saveItem(vaultId: v, item: rich("After recovery"))363        try await tsSync("x4a")364        let seen = try await tsGet("x4a", v, written)365        XCTAssertEqual(seen?.title, "After recovery")366        try await fresh.engine.addPasskey(label: "swift")367        await fresh.engine.lock()368        let s = try await fresh.engine.signIn()369        XCTAssertEqual(s, .unlocked)370        let rk2 = try await fresh.engine.rotateRecoveryKey()371        try await ts.call("device", args(("dev", "x4b")))372        do {373            try await ts.call("recover", args(("dev", "x4b"), ("handle", "interop4"), ("recoveryKey", .string(recoveryKey))))374            XCTFail("the old recovery key must stop working")375        } catch let e as TSError { XCTAssertEqual(e.status, 401) }376        try await ts.call("recover", args(("dev", "x4b"), ("handle", "interop4"), ("recoveryKey", .string(rk2))))377        let again = try await tsGet("x4b", v, written)378        XCTAssertEqual(again?.title, "After recovery")379        let kinds = try await fresh.engine.audit().map(\.kind)380        XCTAssertTrue(kinds.contains("recovery.started") && kinds.contains("recovery.rotated") && kinds.contains("account.created"))381        let events = try await fresh.engine.audit()382        let ok = await fresh.engine.verifyAuditPage(events)383        XCTAssertTrue(ok, "Swift verifies the audit chain of events produced for both clients")384    }385}386
Files main
Menu

Theme