Tests/Unit/CloudJoinFailureTests.swift (4519B)
1import CloudKit
2import Foundation
3import Testing
4
5@testable import Crossmate
6
7@Suite("Cloud join failure handling")
8struct CloudJoinFailureTests {
9 @Test("Accepted-game extraction propagates a per-record error")
10 func acceptedGameRecordPropagatesFailure() throws {
11 let zoneID = CKRecordZone.ID(zoneName: "game-test", ownerName: "_owner")
12 let recordID = CKRecord.ID(recordName: "game-test", zoneID: zoneID)
13 let quotaError = NSError(
14 domain: CKErrorDomain,
15 code: CKError.quotaExceeded.rawValue
16 )
17 let results: [CKRecord.ID: Result<CKRecord, Error>] = [
18 recordID: .failure(quotaError)
19 ]
20
21 do {
22 _ = try SyncEngine.acceptedGameRecord(from: results, recordID: recordID)
23 Issue.record("Expected the record-level CloudKit error")
24 } catch {
25 #expect((error as NSError).domain == CKErrorDomain)
26 #expect((error as NSError).code == CKError.quotaExceeded.rawValue)
27 }
28 }
29
30 @Test("Accepted-game extraction returns the requested record")
31 func acceptedGameRecordReturnsSuccess() throws {
32 let zoneID = CKRecordZone.ID(zoneName: "game-test", ownerName: "_owner")
33 let recordID = CKRecord.ID(recordName: "game-test", zoneID: zoneID)
34 let record = CKRecord(recordType: "Game", recordID: recordID)
35
36 let extracted = try SyncEngine.acceptedGameRecord(
37 from: [recordID: .success(record)],
38 recordID: recordID
39 )
40
41 #expect(extracted?.recordID == recordID)
42 }
43
44 @Test("Join retry policy distinguishes transient and terminal errors")
45 func joinRetryClassification() {
46 let rateLimit = NSError(
47 domain: CKErrorDomain,
48 code: CKError.requestRateLimited.rawValue,
49 userInfo: [CKErrorRetryAfterKey: NSNumber(value: 12.5)]
50 )
51 let quota = NSError(
52 domain: CKErrorDomain,
53 code: CKError.quotaExceeded.rawValue
54 )
55
56 #expect(CloudService.isRetryableJoinError(rateLimit))
57 #expect(CloudService.retryAfter(rateLimit) == 12.5)
58 #expect(CloudService.joinFailureKind(for: rateLimit) == .temporarilyUnavailable)
59 #expect(!CloudService.isRetryableJoinError(quota))
60 #expect(CloudService.joinFailureKind(for: quota) == .unavailable)
61 let acceptedQuota = AcceptedShareError(
62 kind: .unavailable,
63 underlyingError: quota
64 )
65 #expect(acceptedQuota.errorDescription == CloudFailureCopy.quotaJoinBody)
66 }
67
68 @Test("Removed accepted shares retain their distinct outcome")
69 func removedJoinClassification() {
70 for code in [CKError.unknownItem, .zoneNotFound, .userDeletedZone] {
71 let error = NSError(domain: CKErrorDomain, code: code.rawValue)
72 #expect(CloudService.joinFailureKind(for: error) == .removed)
73 }
74 }
75
76 @Test("Only non-retryable Ping errors become terminal")
77 func terminalPingClassification() {
78 let terminal = [CKError.quotaExceeded, .permissionFailure, .zoneNotFound]
79 let retryable = [
80 CKError.networkFailure,
81 .serviceUnavailable,
82 .requestRateLimited,
83 .zoneBusy,
84 .accountTemporarilyUnavailable,
85 ]
86
87 for code in terminal {
88 #expect(SyncEngine.isTerminalPingSaveError(
89 NSError(domain: CKErrorDomain, code: code.rawValue)
90 ))
91 }
92 for code in retryable {
93 #expect(!SyncEngine.isTerminalPingSaveError(
94 NSError(domain: CKErrorDomain, code: code.rawValue)
95 ))
96 }
97
98 let retryAfter = NSError(
99 domain: CKErrorDomain,
100 code: CKError.requestRateLimited.rawValue,
101 userInfo: [CKErrorRetryAfterKey: NSNumber(value: 12.5)]
102 )
103 #expect(SyncEngine.pingSaveRetryDelay(retryAfter) == 12.5)
104 #expect(SyncEngine.pingSaveRetryDelay(
105 NSError(domain: CKErrorDomain, code: CKError.networkFailure.rawValue)
106 ) == 3)
107 #expect(SyncEngine.pingSaveRetryDelay(
108 NSError(domain: CKErrorDomain, code: CKError.quotaExceeded.rawValue)
109 ) == nil)
110 let invitationQuota = SyncEngine.PingOutboxError.deliveryFailed(
111 code: CKError.quotaExceeded.rawValue
112 )
113 #expect(
114 invitationQuota.errorDescription
115 == String(localized: InviteDeliveryFailure.quotaExceeded.body)
116 )
117 }
118}