crossmate

FriendZoneTests.swift (7530B)

---

 import CloudKit
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("FriendZone")
 struct FriendZoneTests {
 
     @Test("pairKey is symmetric in its arguments")
     func pairKeySymmetric() {
         let a = "_alice0000000000000000000000000000"
         let b = "_bob00000000000000000000000000000000"
         #expect(FriendZone.pairKey(a, b) == FriendZone.pairKey(b, a))
     }
 
     @Test("pairKey is deterministic across calls")
     func pairKeyDeterministic() {
         let a = "_alice"
         let b = "_bob"
         #expect(FriendZone.pairKey(a, b) == FriendZone.pairKey(a, b))
     }
 
     @Test("pairKey distinguishes different pairs")
     func pairKeyDistinct() {
         #expect(FriendZone.pairKey("_a", "_b") != FriendZone.pairKey("_a", "_c"))
     }
 
     @Test("pairKey is 64 lowercase hex characters")
     func pairKeyShape() {
         let key = FriendZone.pairKey("_a", "_b")
         #expect(key.count == 64)
         #expect(key.allSatisfy { "0123456789abcdef".contains($0) })
     }
 
     @Test("zoneName carries the prefix and is recognised as a friend zone")
     func zoneNameRoundTrip() {
         let key = FriendZone.pairKey("_a", "_b")
         let name = FriendZone.zoneName(pairKey: key)
         #expect(name == "friend-\(key)")
         #expect(FriendZone.isFriendZone(name))
         #expect(!FriendZone.isFriendZone("game-\(UUID().uuidString)"))
         #expect(!FriendZone.isFriendZone("account"))
     }
 
     @Test("owner election is deterministic, asymmetric, and excludes self")
     func ownerElection() {
         let small = "_aaa"
         let large = "_zzz"
         #expect(FriendZone.isOwner(localAuthorID: small, remoteAuthorID: large))
         #expect(!FriendZone.isOwner(localAuthorID: large, remoteAuthorID: small))
         // Exactly one side owns.
         #expect(
             FriendZone.isOwner(localAuthorID: small, remoteAuthorID: large)
                 != FriendZone.isOwner(localAuthorID: large, remoteAuthorID: small)
         )
         // Same user can never be a friend.
         #expect(!FriendZone.isOwner(localAuthorID: small, remoteAuthorID: small))
     }
 
     @Test("inbox and outbox share the pair's zone name but differ by owner")
     func mailboxDerivation() {
         let pairKey = FriendZone.pairKey("_alice", "_bob")
         let inbox = FriendZone.inboxZoneID(pairKey: pairKey)
         let outbox = FriendZone.outboxZoneID(pairKey: pairKey, friendAuthorID: "_bob")
         // Both mailboxes carry the same `friend-<pairKey>` name...
         #expect(inbox.zoneName == FriendZone.zoneName(pairKey: pairKey))
         #expect(outbox.zoneName == inbox.zoneName)
         // ...and are distinguished only by owner: our inbox is ours; the outbox
         // is the friend's inbox, owned by the friend.
         #expect(inbox.ownerName == CKCurrentUserDefaultName)
         #expect(outbox.ownerName == "_bob")
         #expect(inbox != outbox)
     }
 
     @Test("a pair's two mailboxes agree on the zone name that binds them")
     func mailboxSymmetry() {
         let pairKey = FriendZone.pairKey("_alice", "_bob")
         // Alice's outbox to Bob is the zone Bob owns; on Bob's device that same
         // zone is his inbox. They agree on the zone name — the pairwise binding.
         let aliceOutboxToBob = FriendZone.outboxZoneID(pairKey: pairKey, friendAuthorID: "_bob")
         let bobInbox = FriendZone.inboxZoneID(pairKey: pairKey)
         #expect(aliceOutboxToBob.zoneName == bobInbox.zoneName)
     }
 
     @Test("BootstrapPayload round-trips through its string encoding")
     func bootstrapPayloadRoundTrip() {
         let payload = FriendZone.BootstrapPayload(
             friendShareURL: "https://www.icloud.com/share/abc#xyz",
             pairKey: FriendZone.pairKey("_a", "_b"),
             ownerAuthorID: "_a"
         )
         let encoded = payload.encodedString()
         #expect(encoded != nil)
         #expect(FriendZone.BootstrapPayload.decode(encoded) == payload)
     }
 
     @Test("Bootstrap acceptor must be the other member of the pair")
     func bootstrapAcceptorMustBePairMember() {
         let payload = FriendZone.BootstrapPayload(
             friendShareURL: "https://www.icloud.com/share/abc#xyz",
             pairKey: FriendZone.pairKey("_alice", "_bob"),
             ownerAuthorID: "_alice"
         )
 
         #expect(FriendZone.canAcceptBootstrap(payload, localAuthorID: "_bob"))
         #expect(!FriendZone.canAcceptBootstrap(payload, localAuthorID: "_carol"))
         #expect(!FriendZone.canAcceptBootstrap(payload, localAuthorID: "_alice"))
         #expect(!FriendZone.canAcceptBootstrap(payload, localAuthorID: nil))
         #expect(!FriendZone.canAcceptBootstrap(payload, localAuthorID: ""))
     }
 
     @Test("BootstrapPayload.decode tolerates nil and malformed input")
     func bootstrapPayloadDecodeTolerant() {
         #expect(FriendZone.BootstrapPayload.decode(nil) == nil)
         #expect(FriendZone.BootstrapPayload.decode("") == nil)
         #expect(FriendZone.BootstrapPayload.decode("not json") == nil)
         #expect(FriendZone.BootstrapPayload.decode(#"{"friendShareURL":"x"}"#) == nil)
     }
 
     @Test("InvitePayload round-trips through its string encoding")
     func invitePayloadRoundTrip() {
         let payload = FriendZone.InvitePayload(
             gameShareURL: "https://www.icloud.com/share/xyz#abc"
         )
         let encoded = payload.encodedString()
         #expect(encoded != nil)
         #expect(FriendZone.InvitePayload.decode(encoded) == payload)
     }
 
     @Test("InvitePayload round-trips a grid silhouette segment")
     func invitePayloadRoundTripWithSilhouette() {
         let payload = FriendZone.InvitePayload(
             gameShareURL: "https://www.icloud.com/share/xyz#abc",
             gridSilhouette: "sf//AA"
         )
         let decoded = FriendZone.InvitePayload.decode(payload.encodedString())
         #expect(decoded == payload)
         #expect(decoded?.gridSilhouette == "sf//AA")
     }
 
     @Test("InvitePayload round-trips fast-accept game data")
     func invitePayloadRoundTripWithFastAcceptData() {
         let payload = FriendZone.InvitePayload(
             gameShareURL: "https://www.icloud.com/share/xyz#abc",
             gridSilhouette: "sf//AA",
             puzzleSource: "Title: Fast\n\n\nAB\n\n\nA1. _ ~ AB",
             notification: "encoded-notification-credential"
         )
         let decoded = FriendZone.InvitePayload.decode(payload.encodedString())
         #expect(decoded == payload)
         #expect(decoded?.puzzleSource == payload.puzzleSource)
         #expect(decoded?.notification == "encoded-notification-credential")
     }
 
     @Test("InvitePayload from an older sender decodes with a nil silhouette")
     func invitePayloadDecodesLegacyWithoutSilhouette() {
         // Payloads written before the silhouette field omit the key entirely.
         let legacy = #"{"gameShareURL":"https://www.icloud.com/share/xyz"}"#
         let decoded = FriendZone.InvitePayload.decode(legacy)
         #expect(decoded?.gameShareURL == "https://www.icloud.com/share/xyz")
         #expect(decoded?.gridSilhouette == nil)
         #expect(decoded?.puzzleSource == nil)
         #expect(decoded?.notification == nil)
     }
 
     @Test("InvitePayload.decode tolerates nil and malformed input")
     func invitePayloadDecodeTolerant() {
         #expect(FriendZone.InvitePayload.decode(nil) == nil)
         #expect(FriendZone.InvitePayload.decode("") == nil)
         #expect(FriendZone.InvitePayload.decode("garbage") == nil)
         #expect(FriendZone.InvitePayload.decode(#"{"x":1}"#) == nil)
     }
 }