crossmate

PushClientTests.swift (8623B)

---

 import CryptoKit
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("PushClient registration", .serialized)
 @MainActor
 struct PushClientTests {
     @Test("failed unregister is retried on the next reconcile")
     func failedUnregisterRetries() async throws {
         PushClientURLProtocol.reset()
         PushClientURLProtocol.setHandler { request, deleteAttempt in
             let status: Int
             if request.httpMethod == "DELETE" {
                 status = deleteAttempt == 1 ? 500 : 204
             } else {
                 status = 204
             }
             return HTTPURLResponse(
                 url: request.url!,
                 statusCode: status,
                 httpVersion: nil,
                 headerFields: nil
             )!
         }
         defer { PushClientURLProtocol.reset() }
 
         let client = makeClient()
         let old = PushAddressBinding(address: "old")
         let new = PushAddressBinding(address: "new")
 
         client.testingSetAPNsToken(Data([0x01, 0x02, 0x03]))
         client.testingSetAddresses([old])
         await client.testingReconcile()
         PushClientURLProtocol.resetRequests()
 
         client.testingSetAddresses([new])
         await client.testingReconcile()
 
         #expect(PushClientURLProtocol.deleteAttempts == 1)
 
         PushClientURLProtocol.resetRequests()
         await client.testingReconcile()
 
         #expect(PushClientURLProtocol.deleteAttempts == 1)
     }
 
     @Test("successful unregister advances registration state")
     func successfulUnregisterAdvancesState() async throws {
         PushClientURLProtocol.reset()
         PushClientURLProtocol.setHandler { request, _ in
             HTTPURLResponse(
                 url: request.url!,
                 statusCode: 204,
                 httpVersion: nil,
                 headerFields: nil
             )!
         }
         defer { PushClientURLProtocol.reset() }
 
         let client = makeClient()
         let old = PushAddressBinding(address: "old")
         let new = PushAddressBinding(address: "new")
 
         client.testingSetAPNsToken(Data([0x01, 0x02, 0x03]))
         client.testingSetAddresses([old])
         await client.testingReconcile()
         PushClientURLProtocol.resetRequests()
 
         client.testingSetAddresses([new])
         await client.testingReconcile()
 
         #expect(PushClientURLProtocol.deleteAttempts == 1)
 
         PushClientURLProtocol.resetRequests()
         await client.testingReconcile()
 
         #expect(PushClientURLProtocol.deleteAttempts == 0)
     }
 
     @Test("broadcast payload includes sender name and injected puzzle title")
     func broadcastPayloadCarriesSenderName() async throws {
         PushClientURLProtocol.reset()
         PushClientURLProtocol.setHandler { request, _ in
             let status = request.url?.path == "/publish" ? 200 : 204
             return HTTPURLResponse(
                 url: request.url!,
                 statusCode: status,
                 httpVersion: nil,
                 headerFields: nil
             )!
         }
         defer { PushClientURLProtocol.reset() }
 
         let gameID = UUID(uuidString: "00000000-0000-0000-0000-000000000001")!
         let contentKey = SymmetricKey(data: Data(repeating: 7, count: 32))
         let credentials = GamePushCredentials(
             credID: UUID(uuidString: "00000000-0000-0000-0000-000000000002")!,
             secret: Data(repeating: 3, count: 32).base64URLEncodedString()
         )
         let client = makeClient()
         client.gameCredentialResolver = { _ in credentials }
         client.contentKeyResolver = { _ in contentKey }
 
         await client.publish(
             kind: "nudge",
             gameID: gameID,
             addressees: [],
             title: "Crossmate",
             puzzleTitle: "Saturday Puzzle",
             broadcast: true,
             broadcastPayload: PushPayload(event: .nudge, playerName: "Alice"),
             body: PuzzleNotificationText.nudgeBody(
                 playerName: "Alice",
                 puzzleTitle: "Saturday Puzzle"
             )
         )
 
         let publishRequest = try #require(PushClientURLProtocol.requests.last { $0.url?.path == "/publish" })
         let body = try #require(publishRequest.body)
         let json = try #require(JSONSerialization.jsonObject(with: body) as? [String: Any])
         #expect(json["alertBody"] as? String == PushClient.genericAlertBody)
 
         let encrypted = try #require(json["enc"] as? String)
         let payload = try #require(PushPayloadCipher.open(encrypted, key: contentKey))
         #expect(payload == PushPayload(
             event: .nudge,
             puzzleTitle: "Saturday Puzzle",
             playerName: "Alice"
         ))
     }
 
     private func makeClient() -> PushClient {
         let config = URLSessionConfiguration.ephemeral
         config.protocolClasses = [PushClientURLProtocol.self]
         let session = URLSession(configuration: config)
         return PushClient(
             baseURL: URL(string: "https://push.test")!,
             environment: .sandbox,
             deviceID: "device",
             session: session,
             authorizationHeaders: { _, _, _ in [:] }
         )
     }
 }
 
 private final class PushClientURLProtocol: URLProtocol {
     private static let state = PushClientURLProtocolState()
 
     static var deleteAttempts: Int {
         state.deleteAttempts
     }
 
     static var requests: [PushClientRecordedRequest] {
         state.requests
     }
 
     static func reset() {
         state.reset()
     }
 
     static func resetRequests() {
         state.resetRequests()
     }
 
     static func setHandler(_ handler: @escaping @Sendable (URLRequest, Int) -> HTTPURLResponse) {
         state.setHandler(handler)
     }
 
     override class func canInit(with request: URLRequest) -> Bool {
         true
     }
 
     override class func canonicalRequest(for request: URLRequest) -> URLRequest {
         request
     }
 
     override func startLoading() {
         let response = Self.state.response(for: request)
         client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
         client?.urlProtocol(self, didLoad: Data())
         client?.urlProtocolDidFinishLoading(self)
     }
 
     override func stopLoading() {}
 }
 
 private struct PushClientRecordedRequest: Sendable {
     let url: URL?
     let method: String?
     let body: Data?
 }
 
 private final class PushClientURLProtocolState: @unchecked Sendable {
     private let lock = NSLock()
     private var handler: (@Sendable (URLRequest, Int) -> HTTPURLResponse)?
     private var requestDeleteAttempts = 0
     private var recordedRequests: [PushClientRecordedRequest] = []
 
     var deleteAttempts: Int {
         lock.lock()
         defer { lock.unlock() }
         return requestDeleteAttempts
     }
 
     var requests: [PushClientRecordedRequest] {
         lock.lock()
         defer { lock.unlock() }
         return recordedRequests
     }
 
     func reset() {
         lock.lock()
         handler = nil
         requestDeleteAttempts = 0
         recordedRequests = []
         lock.unlock()
     }
 
     func resetRequests() {
         lock.lock()
         requestDeleteAttempts = 0
         recordedRequests = []
         lock.unlock()
     }
 
     func setHandler(_ next: @escaping @Sendable (URLRequest, Int) -> HTTPURLResponse) {
         lock.lock()
         handler = next
         lock.unlock()
     }
 
     func response(for request: URLRequest) -> HTTPURLResponse {
         let handler: (@Sendable (URLRequest, Int) -> HTTPURLResponse)?
         let deleteAttempt: Int
         lock.lock()
         recordedRequests.append(PushClientRecordedRequest(
             url: request.url,
             method: request.httpMethod,
             body: request.httpBody ?? request.httpBodyStream?.readAllData()
         ))
         if request.httpMethod == "DELETE" {
             requestDeleteAttempts += 1
             deleteAttempt = requestDeleteAttempts
         } else {
             deleteAttempt = 0
         }
         handler = self.handler
         lock.unlock()
 
         return handler?(request, deleteAttempt) ?? HTTPURLResponse(
             url: request.url!,
             statusCode: 204,
             httpVersion: nil,
             headerFields: nil
         )!
     }
 }
 
 private extension InputStream {
     func readAllData() -> Data {
         open()
         defer { close() }
 
         var data = Data()
         var buffer = [UInt8](repeating: 0, count: 4096)
         while hasBytesAvailable {
             let count = read(&buffer, maxLength: buffer.count)
             if count <= 0 { break }
             data.append(buffer, count: count)
         }
         return data
     }
 }