crossmate

AppDelegatePushBufferTests.swift (6077B)

---

 import Foundation
 import Testing
 import UIKit
 
 @testable import Crossmate
 
 @Suite("App delegate push buffering")
 @MainActor
 struct AppDelegatePushBufferTests {
     private actor StartupProbe {
         private(set) var started = false
         private(set) var finished = false
         private(set) var callbackReturned = false
         private var continuation: CheckedContinuation<Void, Never>?
         private var resumeRequested = false
 
         func pause() async {
             started = true
             if resumeRequested {
                 finished = true
                 return
             }
             await withCheckedContinuation { continuation = $0 }
             finished = true
         }
 
         func resume() {
             if let continuation {
                 continuation.resume()
                 self.continuation = nil
             } else {
                 resumeRequested = true
             }
         }
 
         func noteCallbackReturned() {
             callbackReturned = true
         }
     }
 
     @Test("An APNs token that beats handler installation is replayed once")
     func tokenReplayedOnce() {
         let delegate = AppDelegate()
         let token = Data([0x01, 0x02, 0x03])
         delegate.application(
             UIApplication.shared,
             didRegisterForRemoteNotificationsWithDeviceToken: token
         )
 
         var received: [Data] = []
         delegate.onAPNsToken = { received.append($0) }
         #expect(received == [token])
 
         // The buffer is consumed by the replay — reinstalling the handler
         // must not deliver the token again.
         delegate.onAPNsToken = { received.append($0) }
         #expect(received == [token])
     }
 
     @Test("The APNs token goes straight through once the handler is installed")
     func tokenDeliveredDirectly() {
         let delegate = AppDelegate()
         var received: [Data] = []
         delegate.onAPNsToken = { received.append($0) }
 
         let token = Data([0x0a, 0x0b])
         delegate.application(
             UIApplication.shared,
             didRegisterForRemoteNotificationsWithDeviceToken: token
         )
         #expect(received == [token])
     }
 
     @Test("A registration failure that beats handler installation is replayed")
     func registrationFailureReplayed() {
         let delegate = AppDelegate()
         delegate.application(
             UIApplication.shared,
             didFailToRegisterForRemoteNotificationsWithError: NSError(domain: "test", code: 3)
         )
 
         var messages: [String] = []
         delegate.onAPNsRegistrationResult = { messages.append($0) }
         #expect(messages.count == 1)
         #expect(messages.first?.contains("FAILED") == true)
     }
 
     @Test("Pre-start remote notifications are buffered, coalesced by source, and drained in order")
     func remoteNotificationsBufferedAndDrained() async {
         let delegate = AppDelegate()
         let firstGame = UUID()
         let secondGame = UUID()
 
         // Two wakes from the same source coalesce to the newer one (which
         // carries the presence deadline); a different game stays a separate
         // entry.
         _ = await delegate.application(UIApplication.shared, didReceiveRemoteNotification: [
             "kind": "presence",
             "gameID": firstGame.uuidString,
             "senderDeviceID": "alice-device",
         ])
         _ = await delegate.application(UIApplication.shared, didReceiveRemoteNotification: [
             "kind": "presence",
             "gameID": firstGame.uuidString,
             "senderDeviceID": "alice-device",
             "presenceUntil": "2026-07-19T10:00:00Z",
         ])
         _ = await delegate.application(UIApplication.shared, didReceiveRemoteNotification: [
             "kind": "presence",
             "gameID": secondGame.uuidString,
             "senderDeviceID": "bob-device",
         ])
 
         var drained: [(gameID: UUID?, presenceUntil: Date?)] = []
         delegate.onRemoteNotification = { _, _, _, gameID, _, _, presenceUntil, _ in
             drained.append((gameID, presenceUntil))
         }
         for _ in 0..<1000 where drained.count < 2 { await Task.yield() }
 
         #expect(drained.count == 2)
         #expect(drained.first?.gameID == firstGame)
         #expect(drained.first?.presenceUntil != nil)
         #expect(drained.last?.gameID == secondGame)
 
         // The buffer is empty after the drain — a later push is delivered
         // directly, not re-queued.
         _ = await delegate.application(UIApplication.shared, didReceiveRemoteNotification: [
             "kind": "presence",
             "gameID": firstGame.uuidString,
             "senderDeviceID": "alice-device",
         ])
         #expect(drained.count == 3)
     }
 
     @Test("A background wake waits for racing startup and the buffered drain")
     func backgroundWakeAwaitsStartupAndDrain() async {
         let delegate = AppDelegate()
         let startup = StartupProbe()
         let gameID = UUID()
         var received: [UUID?] = []
 
         delegate.isInstalledApplicationDelegateForTesting = true
         delegate.startServicesForTesting = {
             await startup.pause()
             delegate.onRemoteNotification = { _, _, _, gameID, _, _, _, _ in
                 received.append(gameID)
             }
         }
 
         let resultTask = Task { @MainActor in
             let result = await delegate.application(UIApplication.shared, didReceiveRemoteNotification: [
                 "kind": "presence",
                 "gameID": gameID.uuidString,
                 "senderDeviceID": "alice-device",
             ])
             await startup.noteCallbackReturned()
             return result
         }
 
         for _ in 0..<1000 where !(await startup.started) { await Task.yield() }
         #expect(await startup.started)
         #expect(!(await startup.finished))
         #expect(!(await startup.callbackReturned))
         #expect(received.isEmpty)
 
         await startup.resume()
         #expect(await resultTask.value == .newData)
         #expect(await startup.finished)
         #expect(received == [gameID])
     }
 }