@mentra/bluetooth-sdk 3.4.0-dev.996 → 3.4.0-dev.998

package/ios/Tests/MentraLivePairingAdvertisementTests.swift

@@ -1,8 +1,57 @@
+import CoreBluetooth
 import Foundation
 @testable import MentraBluetoothSDK
 import XCTest
 
 final class MentraLivePairingAdvertisementTests: XCTestCase {
+    func testKnownConnectUsesThePeripheralFoundDuringPairing() {
+        XCTAssertEqual(
+            MentraLiveKnownConnectRoute.decide(
+                bluetoothPoweredOn: false,
+                hasCachedPeripheral: true,
+                hasSavedIdentifier: true,
+                systemConnectedMatch: true
+            ),
+            .waitForPower
+        )
+        XCTAssertEqual(
+            MentraLiveKnownConnectRoute.decide(
+                bluetoothPoweredOn: true,
+                hasCachedPeripheral: true,
+                hasSavedIdentifier: true,
+                systemConnectedMatch: false
+            ),
+            .cachedPeripheral
+        )
+        XCTAssertEqual(
+            MentraLiveKnownConnectRoute.decide(
+                bluetoothPoweredOn: true,
+                hasCachedPeripheral: false,
+                hasSavedIdentifier: true,
+                systemConnectedMatch: false
+            ),
+            .savedIdentifier
+        )
+        XCTAssertEqual(
+            MentraLiveKnownConnectRoute.decide(
+                bluetoothPoweredOn: true,
+                hasCachedPeripheral: false,
+                hasSavedIdentifier: false,
+                systemConnectedMatch: true
+            ),
+            .alreadyConnected
+        )
+        XCTAssertEqual(
+            MentraLiveKnownConnectRoute.decide(
+                bluetoothPoweredOn: true,
+                hasCachedPeripheral: false,
+                hasSavedIdentifier: false,
+                systemConnectedMatch: false
+            ),
+            .scan
+        )
+    }
+
     func testConnectedPairingRecoveryRequiresExplicitPendingTarget() {
         XCTAssertFalse(
             MentraLivePendingPairingTarget.matches(
@@ -139,6 +188,188 @@ final class MentraLivePairingAdvertisementTests: XCTestCase {
         }
     }
 
+    func testCapabilityFlagDoesNotConfirmOwnership() {
+        XCTAssertFalse(MentraLiveConnectionAttemptPolicy.pairingInfoConfirmsOwner(ownerCommitted: false))
+        XCTAssertTrue(MentraLiveConnectionAttemptPolicy.pairingInfoConfirmsOwner(ownerCommitted: true))
+    }
+
+    func testStaleIosBondPromptsOnceUntilTheCooldownPasses() {
+        typealias Policy = MentraLiveConnectionAttemptPolicy
+        XCTAssertTrue(
+            Policy.shouldPromptToForgetStaleIosBond(peerRemovedPairingInformation: true, promptedAt: 0, now: 100)
+        )
+        XCTAssertFalse(
+            Policy.shouldPromptToForgetStaleIosBond(peerRemovedPairingInformation: true, promptedAt: 90, now: 100)
+        )
+        XCTAssertTrue(
+            Policy.shouldPromptToForgetStaleIosBond(
+                peerRemovedPairingInformation: true,
+                promptedAt: 100,
+                now: 100 + Policy.staleIosBondPromptCooldownSeconds
+            )
+        )
+        XCTAssertFalse(
+            Policy.shouldPromptToForgetStaleIosBond(peerRemovedPairingInformation: false, promptedAt: 0, now: 100)
+        )
+    }
+
+    func testOnlySecureFirmwareOutsideExplicitPairingRejectsAnOwner() {
+        typealias Policy = MentraLiveConnectionAttemptPolicy
+        XCTAssertTrue(Policy.isOwnerRejection(isAuthFailure: true, explicitPairing: false, secureFirmware: true))
+        XCTAssertFalse(Policy.isOwnerRejection(isAuthFailure: true, explicitPairing: true, secureFirmware: true))
+        XCTAssertFalse(Policy.isOwnerRejection(isAuthFailure: true, explicitPairing: false, secureFirmware: false))
+        XCTAssertFalse(Policy.isOwnerRejection(isAuthFailure: false, explicitPairing: false, secureFirmware: true))
+    }
+
+    func testASingleRejectionDoesNotStandDown() {
+        var streak = MentraLiveOwnerRejectionStreak()
+        XCTAssertFalse(streak.record(nowMs: 0))
+    }
+
+    func testQuickRejectionsWaitForTheStreakToSpanAboutAMinute() {
+        var streak = MentraLiveOwnerRejectionStreak()
+        XCTAssertFalse(streak.record(nowMs: 0))
+        XCTAssertFalse(streak.record(nowMs: 3_000))
+        // Third attempt, but a glasses reboot also rejects for a few seconds.
+        XCTAssertFalse(streak.record(nowMs: 8_000))
+        XCTAssertFalse(streak.record(nowMs: 24_000))
+        XCTAssertTrue(streak.record(nowMs: MentraLiveOwnerRejectionStreak.minSpanMs))
+    }
+
+    func testASuccessfulSessionEndsTheStreak() {
+        var streak = MentraLiveOwnerRejectionStreak()
+        _ = streak.record(nowMs: 0)
+        _ = streak.record(nowMs: 10_000)
+        streak.reset()
+        XCTAssertFalse(streak.record(nowMs: 50_000))
+        XCTAssertFalse(streak.record(nowMs: 60_000))
+    }
+
+    func testRejectionsFarApartAreNotOneStreak() {
+        var streak = MentraLiveOwnerRejectionStreak()
+        _ = streak.record(nowMs: 0)
+        _ = streak.record(nowMs: 10_000)
+        _ = streak.record(nowMs: 20_000)
+        let later = 20_000 + MentraLiveOwnerRejectionStreak.streakGapMs + 1
+        XCTAssertFalse(streak.record(nowMs: later))
+        XCTAssertFalse(streak.record(nowMs: later + 10_000))
+        XCTAssertFalse(streak.record(nowMs: later + 20_000))
+    }
+
+    func testOneAttemptReportingTwiceCountsOnce() {
+        var streak = MentraLiveOwnerRejectionStreak()
+        let span = MentraLiveOwnerRejectionStreak.minSpanMs
+        // didFailToConnect then didDisconnect for each of two attempts.
+        XCTAssertFalse(streak.record(nowMs: 0))
+        XCTAssertFalse(streak.record(nowMs: 400))
+        XCTAssertFalse(streak.record(nowMs: span))
+        XCTAssertFalse(streak.record(nowMs: span + 400))
+        // A genuine third attempt completes the streak.
+        XCTAssertTrue(streak.record(nowMs: span + 10_000))
+    }
+
+    func testAutomaticReconnectStandsDownWhileTheSavedGlassesAdvertisePairingMode() {
+        typealias Policy = MentraLiveConnectionAttemptPolicy
+        XCTAssertTrue(Policy.shouldStandDownInsteadOfReconnect(
+            pairingMode: true, savedGlasses: true, explicitPairing: false
+        ))
+        XCTAssertFalse(Policy.shouldStandDownInsteadOfReconnect(
+            pairingMode: true, savedGlasses: true, explicitPairing: true
+        ))
+        XCTAssertFalse(Policy.shouldStandDownInsteadOfReconnect(
+            pairingMode: false, savedGlasses: true, explicitPairing: false
+        ))
+        XCTAssertFalse(Policy.shouldStandDownInsteadOfReconnect(
+            pairingMode: true, savedGlasses: false, explicitPairing: false
+        ))
+    }
+
+    func testPauseIsTheWindowPlusTheCloseMarginWithNo300sClamp() {
+        typealias Policy = MentraLiveConnectionAttemptPolicy
+        XCTAssertEqual(Policy.yieldMs(windowMs: 120_000), 150_000)
+        XCTAssertEqual(Policy.yieldMs(windowMs: 900_000), 930_000)
+        XCTAssertEqual(Policy.yieldMs(windowMs: 5_000), 35_000)
+        // A missing window falls back to the spec default, not to a floor.
+        XCTAssertEqual(Policy.yieldMs(windowMs: 0), 150_000)
+        XCTAssertEqual(Policy.yieldMs(windowMs: -1), 150_000)
+    }
+
+    func testARestartedAppKeepsOnlyALiveDeadlineWithinThePersistedPause() {
+        typealias Policy = MentraLiveConnectionAttemptPolicy
+        let now = 1_000_000
+        let pause = 150_000
+        XCTAssertEqual(Policy.persistedYieldRemainingMs(untilWallMs: 0, nowWallMs: now, pauseMs: pause), 0)
+        XCTAssertEqual(Policy.persistedYieldRemainingMs(untilWallMs: now + 50_000, nowWallMs: now, pauseMs: pause), 50_000)
+        XCTAssertEqual(Policy.persistedYieldRemainingMs(untilWallMs: now - 1, nowWallMs: now, pauseMs: pause), 0)
+        XCTAssertEqual(Policy.persistedYieldRemainingMs(untilWallMs: now + pause, nowWallMs: now, pauseMs: pause), pause)
+        // Longer than the pause persisted with it: a clock jump, not a deadline.
+        XCTAssertEqual(Policy.persistedYieldRemainingMs(untilWallMs: now + pause + 1, nowWallMs: now, pauseMs: pause), 0)
+        // A long window is not clamped to the old 300 s bound.
+        XCTAssertEqual(
+            Policy.persistedYieldRemainingMs(untilWallMs: now + 600_000, nowWallMs: now, pauseMs: 930_000),
+            600_000
+        )
+        XCTAssertEqual(Policy.persistedYieldRemainingMs(untilWallMs: now + 10, nowWallMs: now, pauseMs: 0), 0)
+    }
+
+    func testPairSelectGoesOnlyWithAnExplicitAttemptToSecureGlasses() {
+        typealias Policy = MentraLiveConnectionAttemptPolicy
+        XCTAssertTrue(Policy.shouldSendPairSelect(explicitPairing: true, securePairingTarget: true))
+        XCTAssertFalse(Policy.shouldSendPairSelect(explicitPairing: false, securePairingTarget: true))
+        XCTAssertFalse(Policy.shouldSendPairSelect(explicitPairing: true, securePairingTarget: false))
+        XCTAssertFalse(Policy.shouldSendPairSelect(explicitPairing: false, securePairingTarget: false))
+    }
+
+    func testParkedSecureReadinessAlwaysHasABondWaitDeadline() {
+        typealias Policy = MentraLiveConnectionAttemptPolicy
+        // glasses_ready parks exactly when the attempt is explicit and the target secure; the
+        // wait must then always run so the pair cannot hang.
+        XCTAssertTrue(Policy.shouldRunSecurePairingWait(explicitPairing: true, securePairingTarget: true))
+        XCTAssertFalse(Policy.shouldRunSecurePairingWait(explicitPairing: false, securePairingTarget: true))
+        XCTAssertFalse(Policy.shouldRunSecurePairingWait(explicitPairing: true, securePairingTarget: false))
+    }
+
+    func testTheStaleBondCodeMatchesTheAppContract() {
+        XCTAssertEqual(MentraLiveConnectionAttemptPolicy.iosForgetPairingCode, "ios_forget_pairing")
+    }
+
+    func testAuthFailureClassifierCoversError14AndInsufficientSecurityOnly() {
+        XCTAssertTrue(MentraLive.isPairingAuthFailure(
+            NSError(domain: CBErrorDomain, code: CBError.peerRemovedPairingInformation.rawValue)
+        ))
+        XCTAssertTrue(MentraLive.isPairingAuthFailure(
+            NSError(domain: CBATTErrorDomain, code: CBATTError.insufficientAuthentication.rawValue)
+        ))
+        XCTAssertTrue(MentraLive.isPairingAuthFailure(
+            NSError(domain: CBATTErrorDomain, code: CBATTError.insufficientEncryption.rawValue)
+        ))
+        // A plain remote disconnect (the glasses' 0x14 refusal) and timeouts are not.
+        XCTAssertFalse(MentraLive.isPairingAuthFailure(
+            NSError(domain: CBErrorDomain, code: CBError.peripheralDisconnected.rawValue)
+        ))
+        XCTAssertFalse(MentraLive.isPairingAuthFailure(
+            NSError(domain: CBErrorDomain, code: CBError.connectionTimeout.rawValue)
+        ))
+        XCTAssertFalse(MentraLive.isPairingAuthFailure(nil))
+    }
+
+    func testReadsTheOwnerChangedFlagAndWindowIdFromTheV4Trailer() {
+        var payload = securePayload(pairingFlag: 0)
+        payload[2 + 7] = 0x01 | 0x04
+        payload[2 + 12] = 9
+        let result = MentraLivePairingAdvertisement.parse(coreBluetoothManufacturerData: payload)
+        XCTAssertEqual(result?.ownerChanged, true)
+        XCTAssertEqual(result?.pairingGeneration, 9)
+        XCTAssertEqual(result?.pairingMode, false)
+    }
+
+    func testOwnerChangedIsFalseWithoutTheFlag() {
+        let result = MentraLivePairingAdvertisement.parse(
+            coreBluetoothManufacturerData: securePayload(pairingFlag: 1)
+        )
+        XCTAssertEqual(result?.ownerChanged, false)
+    }
+
     private func legacyPayload() -> Data {
         var data = Data(repeating: 0, count: 29)
         data[0] = 0x22
@@ -157,4 +388,100 @@ final class MentraLivePairingAdvertisementTests: XCTestCase {
         data[2 + 11] = 0x50
         return data
     }
+
+    func testAPacketWithoutTheTrailerRightAfterOneWithItIsPartialNotLegacy() {
+        let t0 = 1_000_000
+        XCTAssertTrue(
+            MentraLiveDiscoveryPolicy.isPartialAdvertisement(secureCapable: false, lastSecureTrailerAtMs: t0, nowMs: t0 + 500)
+        )
+        XCTAssertTrue(
+            MentraLiveDiscoveryPolicy.isPartialAdvertisement(
+                secureCapable: false, lastSecureTrailerAtMs: t0, nowMs: t0 + MentraLiveDiscoveryPolicy.secureTrailerMemoryMs
+            )
+        )
+        XCTAssertFalse(
+            MentraLiveDiscoveryPolicy.isPartialAdvertisement(secureCapable: false, lastSecureTrailerAtMs: nil, nowMs: t0),
+            "legacy firmware never carries the trailer and is still listed as pairable"
+        )
+        XCTAssertFalse(
+            MentraLiveDiscoveryPolicy.isPartialAdvertisement(secureCapable: true, lastSecureTrailerAtMs: t0, nowMs: t0 + 500)
+        )
+        XCTAssertFalse(
+            MentraLiveDiscoveryPolicy.isPartialAdvertisement(secureCapable: true, lastSecureTrailerAtMs: nil, nowMs: t0)
+        )
+    }
+
+    func testTheSecureTrailerMemoryIsTenSeconds() {
+        XCTAssertEqual(MentraLiveDiscoveryPolicy.secureTrailerMemoryMs, 10_000)
+    }
+
+    func testARolledBackUnitListsAsLegacyOnceTheShortMemoryExpires() {
+        var memory = MentraLiveSecureTrailerMemory()
+        let unit = UUID()
+        let t0 = 5_000_000
+        memory.recordSecureTrailer(unit, nowMs: t0)
+        XCTAssertTrue(memory.isPartialAdvertisement(unit, secureCapable: false, nowMs: t0 + 2_000))
+        // Rolled back to legacy firmware: no trailer any more. After the memory it is legacy.
+        XCTAssertFalse(memory.isPartialAdvertisement(unit, secureCapable: false, nowMs: t0 + 10_001))
+        XCTAssertFalse(memory.hasRecentSecureTrailer(unit, nowMs: t0 + 10_001))
+    }
+
+    func testASameNamedLegacyUnitIsNotHidden() {
+        var memory = MentraLiveSecureTrailerMemory()
+        let secureUnit = UUID()
+        let legacyUnitWithTheSameName = UUID()
+        let t0 = 5_000_000
+        memory.recordSecureTrailer(secureUnit, nowMs: t0)
+        XCTAssertTrue(memory.isPartialAdvertisement(secureUnit, secureCapable: false, nowMs: t0 + 100))
+        XCTAssertFalse(memory.isPartialAdvertisement(legacyUnitWithTheSameName, secureCapable: false, nowMs: t0 + 100))
+    }
+
+    func testForgetClearsTheSecureTrailerMemory() {
+        var memory = MentraLiveSecureTrailerMemory()
+        let unit = UUID()
+        memory.recordSecureTrailer(unit, nowMs: 1_000)
+        memory.clear()
+        XCTAssertFalse(memory.isPartialAdvertisement(unit, secureCapable: false, nowMs: 1_100))
+    }
+
+    func testSecurePairingTargetFollowsOnlyTheSelectedRow() {
+        typealias Policy = MentraLiveConnectionAttemptPolicy
+        XCTAssertTrue(Policy.isSecurePairingTarget(selectedCapability: true, securePairingInfoThisSession: false))
+        XCTAssertFalse(
+            Policy.isSecurePairingTarget(selectedCapability: false, securePairingInfoThisSession: true),
+            "a row listed as legacy stays legacy"
+        )
+        XCTAssertFalse(Policy.isSecurePairingTarget(selectedCapability: nil, securePairingInfoThisSession: false))
+        XCTAssertTrue(
+            Policy.isSecurePairingTarget(selectedCapability: nil, securePairingInfoThisSession: true),
+            "an unknown row follows this session's secure pairing_info"
+        )
+    }
+
+    func testGlassesReadyReadinessForEachTargetCapability() {
+        typealias Policy = MentraLiveConnectionAttemptPolicy
+        func readiness(
+            explicit: Bool = true, row: Bool?, securePairingInfo: Bool = false, confirmed: Bool = false
+        ) -> Policy.Readiness {
+            Policy.readinessAtGlassesReady(
+                explicitPairing: explicit,
+                selectedCapability: row,
+                securePairingInfoThisSession: securePairingInfo,
+                securePairingConfirmed: confirmed
+            )
+        }
+        // Automatic reconnect never waits.
+        XCTAssertEqual(readiness(explicit: false, row: nil), .ready)
+        XCTAssertEqual(readiness(explicit: false, row: true), .ready)
+        // Known rows.
+        XCTAssertEqual(readiness(row: false), .ready)
+        XCTAssertEqual(readiness(row: true), .awaitOwnerCommit)
+        XCTAssertEqual(readiness(row: true, confirmed: true), .ready)
+        // Unknown row: wait (bounded) for pairing_info unless one already decided it.
+        XCTAssertEqual(readiness(row: nil), .awaitPairingInfo)
+        XCTAssertEqual(readiness(row: nil, securePairingInfo: true), .awaitOwnerCommit)
+        XCTAssertEqual(readiness(row: nil, securePairingInfo: true, confirmed: true), .ready)
+        XCTAssertEqual(Policy.unknownCapabilityPairingInfoWaitMs, 5_000)
+        XCTAssertEqual(Policy.secureFirmwareRefreshMs, 15_000)
+    }
 }