mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-07-25 02:05:19 +00:00
Gateway mode: opt-in mesh↔Nostr uplink for geohash channels
An opt-in "internet gateway" toggle lets one connected phone bridge the local geohash channel for mesh-only peers: signed kind-20000 events ride a new nostrCarrier (0x28) packet — directed to the gateway for uplink, broadcast with TTL for downlink — with Schnorr verification at every hop, CourierStore-style quotas, and explicit loop-prevention rules. - BitFoundation: MessageType.nostrCarrier = 0x28 - NostrCarrierPacket: 2-byte-length TLV codec (direction, geohash, signed event JSON), 16 KiB cap, tolerant decoder - GatewayService: closure-injected policy layer — verify gates (sig, kind, #g tag, age, size), uplink quotas (10/min/depositor rate limit, offline queue of 20 total / 5 per depositor, drop-oldest, flush on reconnect), downlink budget (30/min, bounded drop-oldest backlog), bounded loop-prevention ID sets - BLEService: runtime capability bits (advertise .gateway only while the toggle is on, re-announce on change), signed directed uplink sends, carrier ingress with depositor signature verification - Mesh-only senders uplink automatically from sendGeohash when no relay is connected and a reachable peer advertises .gateway; once-per- channel "sent via mesh gateway" notice - UI: gateway toggle beside the Tor toggle, globe header indicator, VoiceOver labels, xcstrings entries Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
jack
@@ -0,0 +1,96 @@
|
||||
//
|
||||
// NostrCarrierPacketTests.swift
|
||||
// bitchat
|
||||
//
|
||||
// This is free and unencumbered software released into the public domain.
|
||||
// For more information, see <https://unlicense.org>
|
||||
//
|
||||
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import bitchat
|
||||
|
||||
@Suite("Nostr carrier packet TLV")
|
||||
struct NostrCarrierPacketTests {
|
||||
private func makeEvent(geohash: String = "u4pruy", content: String = "hello mesh") throws -> NostrEvent {
|
||||
let identity = try NostrIdentity.generate()
|
||||
return try NostrProtocol.createEphemeralGeohashEvent(
|
||||
content: content,
|
||||
geohash: geohash,
|
||||
senderIdentity: identity,
|
||||
nickname: "tester"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("round-trips both directions with the signed event intact")
|
||||
func roundTrip() throws {
|
||||
let event = try makeEvent()
|
||||
for direction in [NostrCarrierPacket.Direction.toGateway, .fromGateway] {
|
||||
let packet = try #require(NostrCarrierPacket(direction: direction, geohash: "u4pruy", event: event))
|
||||
let encoded = try #require(packet.encode())
|
||||
let decoded = try #require(NostrCarrierPacket.decode(encoded))
|
||||
|
||||
#expect(decoded == packet)
|
||||
#expect(decoded.direction == direction)
|
||||
#expect(decoded.geohash == "u4pruy")
|
||||
|
||||
// The carried event survives byte-exact: same ID, and the
|
||||
// signature still verifies after the mesh hop.
|
||||
let carried = try #require(decoded.event())
|
||||
#expect(carried.id == event.id)
|
||||
#expect(carried.sig == event.sig)
|
||||
#expect(carried.isValidSignature())
|
||||
}
|
||||
}
|
||||
|
||||
@Test("rejects an oversized event at construction and at decode")
|
||||
func oversizedRejected() throws {
|
||||
let oversized = Data(repeating: 0x7B, count: NostrCarrierPacket.maxEventJSONBytes + 1)
|
||||
#expect(NostrCarrierPacket(direction: .toGateway, geohash: "u4pruy", eventJSON: oversized) == nil)
|
||||
|
||||
// Hand-build the TLV bytes to bypass the initializer's cap.
|
||||
var data = Data([0x01, 0x00, 0x01, NostrCarrierPacket.Direction.toGateway.rawValue])
|
||||
let geohash = Data("u4pruy".utf8)
|
||||
data.append(contentsOf: [0x02, 0x00, UInt8(geohash.count)])
|
||||
data.append(geohash)
|
||||
data.append(contentsOf: [0x03, UInt8((oversized.count >> 8) & 0xFF), UInt8(oversized.count & 0xFF)])
|
||||
data.append(oversized)
|
||||
#expect(NostrCarrierPacket.decode(data) == nil)
|
||||
}
|
||||
|
||||
@Test("rejects an over-length or empty geohash")
|
||||
func geohashBoundsEnforced() throws {
|
||||
let event = try makeEvent()
|
||||
#expect(NostrCarrierPacket(direction: .toGateway, geohash: "", event: event) == nil)
|
||||
#expect(NostrCarrierPacket(direction: .toGateway, geohash: String(repeating: "u", count: 13), event: event) == nil)
|
||||
#expect(NostrCarrierPacket(direction: .toGateway, geohash: String(repeating: "u", count: 12), event: event) != nil)
|
||||
}
|
||||
|
||||
@Test("skips unknown TLVs for forward compatibility")
|
||||
func unknownTLVSkipped() throws {
|
||||
let event = try makeEvent()
|
||||
let packet = try #require(NostrCarrierPacket(direction: .fromGateway, geohash: "u4pruy", event: event))
|
||||
var encoded = try #require(packet.encode())
|
||||
// Append an unknown TLV (type 0x7F, 2-byte value).
|
||||
encoded.append(contentsOf: [0x7F, 0x00, 0x02, 0xDE, 0xAD])
|
||||
let decoded = try #require(NostrCarrierPacket.decode(encoded))
|
||||
#expect(decoded == packet)
|
||||
}
|
||||
|
||||
@Test("rejects truncated and missing-field payloads")
|
||||
func malformedRejected() throws {
|
||||
let event = try makeEvent()
|
||||
let packet = try #require(NostrCarrierPacket(direction: .toGateway, geohash: "u4pruy", event: event))
|
||||
let encoded = try #require(packet.encode())
|
||||
|
||||
// Truncation anywhere inside the last TLV fails cleanly.
|
||||
#expect(NostrCarrierPacket.decode(encoded.dropLast(1)) == nil)
|
||||
#expect(NostrCarrierPacket.decode(encoded.prefix(4)) == nil)
|
||||
#expect(NostrCarrierPacket.decode(Data()) == nil)
|
||||
|
||||
// Direction TLV alone (missing geohash and event) fails.
|
||||
#expect(NostrCarrierPacket.decode(Data([0x01, 0x00, 0x01, 0x01])) == nil)
|
||||
// Unknown direction value fails.
|
||||
#expect(NostrCarrierPacket.decode(Data([0x01, 0x00, 0x01, 0x77])) == nil)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,453 @@
|
||||
//
|
||||
// GatewayServiceTests.swift
|
||||
// bitchat
|
||||
//
|
||||
// This is free and unencumbered software released into the public domain.
|
||||
// For more information, see <https://unlicense.org>
|
||||
//
|
||||
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import bitchat
|
||||
|
||||
@Suite("Gateway mode policy")
|
||||
@MainActor
|
||||
struct GatewayServiceTests {
|
||||
private static let geohash = "u4pruy"
|
||||
|
||||
/// Closure-injected harness around `GatewayService` recording every
|
||||
/// side effect, with a controllable clock and relay connectivity.
|
||||
@MainActor
|
||||
private final class Fixture {
|
||||
private final class ClockBox {
|
||||
var now = Date()
|
||||
}
|
||||
|
||||
var relaysConnected = true
|
||||
var currentGeohash: String? = GatewayServiceTests.geohash
|
||||
var gatewayPeers: [PeerID] = []
|
||||
var sendToGatewaySucceeds = true
|
||||
|
||||
private(set) var published: [(event: NostrEvent, geohash: String)] = []
|
||||
private(set) var broadcasts: [Data] = []
|
||||
private(set) var injected: [NostrEvent] = []
|
||||
private(set) var uplinkSends: [(payload: Data, peer: PeerID)] = []
|
||||
private(set) var enabledChanges: [Bool] = []
|
||||
|
||||
private let clock = ClockBox()
|
||||
let defaults: UserDefaults
|
||||
let service: GatewayService
|
||||
|
||||
init(enabled: Bool = true, suite: String = "GatewayServiceTests-\(UUID().uuidString)") {
|
||||
defaults = UserDefaults(suiteName: suite)!
|
||||
defaults.removePersistentDomain(forName: suite)
|
||||
let clock = clock
|
||||
service = GatewayService(defaults: defaults) { clock.now }
|
||||
service.publishToRelays = { [weak self] event, geohash in
|
||||
self?.published.append((event, geohash))
|
||||
}
|
||||
service.broadcastToMesh = { [weak self] payload in
|
||||
self?.broadcasts.append(payload)
|
||||
}
|
||||
service.sendToGatewayPeer = { [weak self] payload, peer in
|
||||
guard let self, self.sendToGatewaySucceeds else { return false }
|
||||
self.uplinkSends.append((payload, peer))
|
||||
return true
|
||||
}
|
||||
service.availableGatewayPeers = { [weak self] in self?.gatewayPeers ?? [] }
|
||||
service.relaysConnected = { [weak self] in self?.relaysConnected ?? false }
|
||||
service.currentGeohash = { [weak self] in self?.currentGeohash }
|
||||
service.injectInbound = { [weak self] event in self?.injected.append(event) }
|
||||
service.onEnabledChanged = { [weak self] enabled in self?.enabledChanges.append(enabled) }
|
||||
if enabled {
|
||||
service.setEnabled(true)
|
||||
}
|
||||
}
|
||||
|
||||
func advance(_ seconds: TimeInterval) {
|
||||
clock.now = clock.now.addingTimeInterval(seconds)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: Event helpers
|
||||
|
||||
private func makeEvent(
|
||||
geohash: String = GatewayServiceTests.geohash,
|
||||
content: String = "hello \(UUID().uuidString.prefix(8))"
|
||||
) throws -> NostrEvent {
|
||||
let identity = try NostrIdentity.generate()
|
||||
return try NostrProtocol.createEphemeralGeohashEvent(
|
||||
content: content,
|
||||
geohash: geohash,
|
||||
senderIdentity: identity,
|
||||
nickname: "tester"
|
||||
)
|
||||
}
|
||||
|
||||
/// A copy of `event` with tampered content but the original ID and
|
||||
/// signature — what a forging gateway or mesh peer would produce.
|
||||
private func forge(_ event: NostrEvent) throws -> NostrEvent {
|
||||
let dict: [String: Any] = [
|
||||
"id": event.id,
|
||||
"pubkey": event.pubkey,
|
||||
"created_at": event.created_at,
|
||||
"kind": event.kind,
|
||||
"tags": event.tags,
|
||||
"content": event.content + " (tampered)",
|
||||
"sig": event.sig ?? ""
|
||||
]
|
||||
return try NostrEvent(from: dict)
|
||||
}
|
||||
|
||||
private func carrierPayload(
|
||||
_ event: NostrEvent,
|
||||
direction: NostrCarrierPacket.Direction = .toGateway,
|
||||
geohash: String = GatewayServiceTests.geohash
|
||||
) throws -> Data {
|
||||
let packet = try #require(NostrCarrierPacket(direction: direction, geohash: geohash, event: event))
|
||||
return try #require(packet.encode())
|
||||
}
|
||||
|
||||
private func deposit(
|
||||
_ event: NostrEvent,
|
||||
into fixture: Fixture,
|
||||
from depositor: PeerID = PeerID(str: "1122334455667788"),
|
||||
geohash: String = GatewayServiceTests.geohash
|
||||
) throws {
|
||||
let payload = try carrierPayload(event, direction: .toGateway, geohash: geohash)
|
||||
fixture.service.handleMeshCarrier(payload, from: depositor, directedToUs: true)
|
||||
}
|
||||
|
||||
// MARK: - Uplink verification gates
|
||||
|
||||
@Test("publishes a verified deposit to the geo relays")
|
||||
func verifiedDepositPublished() throws {
|
||||
let fixture = Fixture()
|
||||
let event = try makeEvent()
|
||||
try deposit(event, into: fixture)
|
||||
|
||||
#expect(fixture.published.count == 1)
|
||||
#expect(fixture.published.first?.event.id == event.id)
|
||||
#expect(fixture.published.first?.geohash == Self.geohash)
|
||||
// Viewing the same geohash: the carried message shows on our own timeline.
|
||||
#expect(fixture.injected.map(\.id) == [event.id])
|
||||
}
|
||||
|
||||
@Test("rejects a forged signature")
|
||||
func forgedSignatureRejected() throws {
|
||||
let fixture = Fixture()
|
||||
let forged = try forge(try makeEvent())
|
||||
try deposit(forged, into: fixture)
|
||||
|
||||
#expect(fixture.published.isEmpty)
|
||||
#expect(fixture.injected.isEmpty)
|
||||
}
|
||||
|
||||
@Test("rejects wrong kind, geohash mismatch, and stale events")
|
||||
func structuralGates() throws {
|
||||
let fixture = Fixture()
|
||||
|
||||
// Wrong kind (kind-1 text note instead of kind-20000 ephemeral).
|
||||
let identity = try NostrIdentity.generate()
|
||||
let note = try NostrProtocol.createGeohashTextNote(
|
||||
content: "note",
|
||||
geohash: Self.geohash,
|
||||
senderIdentity: identity
|
||||
)
|
||||
try deposit(note, into: fixture)
|
||||
#expect(fixture.published.isEmpty)
|
||||
|
||||
// Carrier geohash disagreeing with the event's #g tag.
|
||||
let mismatched = try makeEvent(geohash: "9q8yyk")
|
||||
try deposit(mismatched, into: fixture, geohash: Self.geohash)
|
||||
#expect(fixture.published.isEmpty)
|
||||
|
||||
// Stale event (beyond accepted clock skew).
|
||||
let stale = try makeEvent()
|
||||
fixture.advance(GatewayService.Limits.maxEventAgeSeconds + 60)
|
||||
try deposit(stale, into: fixture)
|
||||
#expect(fixture.published.isEmpty)
|
||||
}
|
||||
|
||||
@Test("does nothing while the toggle is off")
|
||||
func disabledGatewayIgnoresDeposits() throws {
|
||||
let fixture = Fixture(enabled: false)
|
||||
try deposit(try makeEvent(), into: fixture)
|
||||
#expect(fixture.published.isEmpty)
|
||||
#expect(fixture.service.queuedUplinks.isEmpty)
|
||||
|
||||
fixture.service.rebroadcastRelayEvent(try makeEvent(), geohash: Self.geohash)
|
||||
#expect(fixture.broadcasts.isEmpty)
|
||||
}
|
||||
|
||||
// MARK: - Uplink quotas and rate limit
|
||||
|
||||
@Test("rate-limits deposits per depositor per minute")
|
||||
func uplinkRateLimit() throws {
|
||||
let fixture = Fixture()
|
||||
let depositor = PeerID(str: "aabbccddeeff0011")
|
||||
|
||||
for _ in 0..<GatewayService.Limits.uplinkEventsPerMinutePerDepositor {
|
||||
try deposit(try makeEvent(), into: fixture, from: depositor)
|
||||
}
|
||||
#expect(fixture.published.count == GatewayService.Limits.uplinkEventsPerMinutePerDepositor)
|
||||
|
||||
// One over budget inside the window: dropped.
|
||||
try deposit(try makeEvent(), into: fixture, from: depositor)
|
||||
#expect(fixture.published.count == GatewayService.Limits.uplinkEventsPerMinutePerDepositor)
|
||||
|
||||
// Another depositor is unaffected.
|
||||
try deposit(try makeEvent(), into: fixture, from: PeerID(str: "0011223344556677"))
|
||||
#expect(fixture.published.count == GatewayService.Limits.uplinkEventsPerMinutePerDepositor + 1)
|
||||
|
||||
// The window slides.
|
||||
fixture.advance(61)
|
||||
try deposit(try makeEvent(), into: fixture, from: depositor)
|
||||
#expect(fixture.published.count == GatewayService.Limits.uplinkEventsPerMinutePerDepositor + 2)
|
||||
}
|
||||
|
||||
@Test("bounds the offline uplink queue per depositor and in total, evicting oldest")
|
||||
func uplinkQueueQuotas() throws {
|
||||
let fixture = Fixture()
|
||||
fixture.relaysConnected = false
|
||||
|
||||
let depositorA = PeerID(str: "1111111111111111")
|
||||
var firstFromA: NostrEvent?
|
||||
for i in 0..<(GatewayService.Limits.maxQueuedUplinksPerDepositor + 1) {
|
||||
let event = try makeEvent()
|
||||
if i == 0 { firstFromA = event }
|
||||
try deposit(event, into: fixture, from: depositorA)
|
||||
}
|
||||
// The sixth deposit from the same depositor is rejected.
|
||||
#expect(fixture.service.queuedUplinks.count == GatewayService.Limits.maxQueuedUplinksPerDepositor)
|
||||
|
||||
// Fill the global queue with other depositors.
|
||||
var filler = GatewayService.Limits.maxQueuedUplinksPerDepositor
|
||||
var suffix = 2
|
||||
while filler < GatewayService.Limits.maxQueuedUplinks {
|
||||
let depositor = PeerID(str: String(repeating: "\(suffix)", count: 16))
|
||||
for _ in 0..<GatewayService.Limits.maxQueuedUplinksPerDepositor {
|
||||
try deposit(try makeEvent(), into: fixture, from: depositor)
|
||||
}
|
||||
filler += GatewayService.Limits.maxQueuedUplinksPerDepositor
|
||||
suffix += 1
|
||||
}
|
||||
#expect(fixture.service.queuedUplinks.count == GatewayService.Limits.maxQueuedUplinks)
|
||||
|
||||
// One more from a fresh depositor evicts the oldest queued deposit.
|
||||
let newest = try makeEvent()
|
||||
try deposit(newest, into: fixture, from: PeerID(str: "9999999999999999"))
|
||||
#expect(fixture.service.queuedUplinks.count == GatewayService.Limits.maxQueuedUplinks)
|
||||
#expect(fixture.service.queuedUplinks.contains { $0.event.id == newest.id })
|
||||
#expect(!fixture.service.queuedUplinks.contains { $0.event.id == firstFromA?.id })
|
||||
|
||||
// Relay connectivity returning flushes the queue.
|
||||
fixture.relaysConnected = true
|
||||
fixture.service.flushQueuedUplinks()
|
||||
#expect(fixture.published.count == GatewayService.Limits.maxQueuedUplinks)
|
||||
#expect(fixture.service.queuedUplinks.isEmpty)
|
||||
}
|
||||
|
||||
@Test("absorbs repeat deposits of the same event")
|
||||
func repeatDepositAbsorbed() throws {
|
||||
let fixture = Fixture()
|
||||
let event = try makeEvent()
|
||||
try deposit(event, into: fixture)
|
||||
try deposit(event, into: fixture, from: PeerID(str: "8877665544332211"))
|
||||
#expect(fixture.published.count == 1)
|
||||
}
|
||||
|
||||
// MARK: - Loop prevention
|
||||
|
||||
@Test("never re-publishes or re-carries an event learned from a fromGateway broadcast")
|
||||
func meshCarriedNeverRepublished() throws {
|
||||
let fixture = Fixture()
|
||||
let event = try makeEvent()
|
||||
let broadcast = try carrierPayload(event, direction: .fromGateway)
|
||||
|
||||
// Another gateway rebroadcast this event onto the mesh; we saw it.
|
||||
fixture.service.handleMeshCarrier(broadcast, from: PeerID(str: "8877665544332211"), directedToUs: false)
|
||||
#expect(fixture.injected.map(\.id) == [event.id])
|
||||
|
||||
// Rule: a deposit of the same event must never be published…
|
||||
try deposit(event, into: fixture)
|
||||
#expect(fixture.published.isEmpty)
|
||||
|
||||
// …a relay echo of it must never be rebroadcast (we'd loop it back)…
|
||||
fixture.service.rebroadcastRelayEvent(event, geohash: Self.geohash)
|
||||
#expect(fixture.broadcasts.isEmpty)
|
||||
|
||||
// …and it must never be re-uplinked from this device.
|
||||
fixture.relaysConnected = false
|
||||
fixture.gatewayPeers = [PeerID(str: "8877665544332211")]
|
||||
#expect(!fixture.service.uplinkViaMesh(event: event, geohash: Self.geohash))
|
||||
#expect(fixture.uplinkSends.isEmpty)
|
||||
}
|
||||
|
||||
@Test("rebroadcasts a relay event at most once, absorbing echoes")
|
||||
func relayEventRebroadcastOnce() throws {
|
||||
let fixture = Fixture()
|
||||
let event = try makeEvent()
|
||||
|
||||
fixture.service.rebroadcastRelayEvent(event, geohash: Self.geohash)
|
||||
fixture.service.rebroadcastRelayEvent(event, geohash: Self.geohash)
|
||||
#expect(fixture.broadcasts.count == 1)
|
||||
|
||||
// The rebroadcast payload decodes as a fromGateway carrier for the
|
||||
// same signed event.
|
||||
let payload = try #require(fixture.broadcasts.first)
|
||||
let decoded = try #require(NostrCarrierPacket.decode(payload))
|
||||
#expect(decoded.direction == .fromGateway)
|
||||
#expect(decoded.event()?.id == event.id)
|
||||
}
|
||||
|
||||
@Test("a forged broadcast cannot poison the loop-prevention set")
|
||||
func forgedBroadcastDoesNotPoison() throws {
|
||||
let fixture = Fixture()
|
||||
let event = try makeEvent()
|
||||
let forgedPayload = try carrierPayload(try forge(event), direction: .fromGateway)
|
||||
|
||||
fixture.service.handleMeshCarrier(forgedPayload, from: PeerID(str: "8877665544332211"), directedToUs: false)
|
||||
#expect(fixture.injected.isEmpty)
|
||||
|
||||
// The genuine event still uplinks: the forged copy (sharing its ID)
|
||||
// was rejected before the mesh-carried marking.
|
||||
try deposit(event, into: fixture)
|
||||
#expect(fixture.published.map(\.event.id) == [event.id])
|
||||
}
|
||||
|
||||
// MARK: - Downlink bandwidth guard
|
||||
|
||||
@Test("caps mesh rebroadcasts per minute, queueing with drop-oldest")
|
||||
func downlinkBudget() throws {
|
||||
let fixture = Fixture()
|
||||
let overBudget = GatewayService.Limits.downlinkEventsPerMinute + 5
|
||||
|
||||
var events: [NostrEvent] = []
|
||||
for _ in 0..<overBudget {
|
||||
let event = try makeEvent()
|
||||
events.append(event)
|
||||
fixture.service.rebroadcastRelayEvent(event, geohash: Self.geohash)
|
||||
}
|
||||
#expect(fixture.broadcasts.count == GatewayService.Limits.downlinkEventsPerMinute)
|
||||
|
||||
// Once the window slides, the next relay event drains the backlog too.
|
||||
fixture.advance(61)
|
||||
fixture.service.rebroadcastRelayEvent(try makeEvent(), geohash: Self.geohash)
|
||||
#expect(fixture.broadcasts.count == overBudget + 1)
|
||||
}
|
||||
|
||||
// MARK: - Receiver downlink handling
|
||||
|
||||
@Test("injects a carried event once, even when broadcast twice")
|
||||
func downlinkInjectedOnce() throws {
|
||||
let fixture = Fixture(enabled: false) // receivers need no toggle
|
||||
let event = try makeEvent()
|
||||
let payload = try carrierPayload(event, direction: .fromGateway)
|
||||
|
||||
fixture.service.handleMeshCarrier(payload, from: PeerID(str: "8877665544332211"), directedToUs: false)
|
||||
fixture.service.handleMeshCarrier(payload, from: PeerID(str: "7766554433221100"), directedToUs: false)
|
||||
#expect(fixture.injected.map(\.id) == [event.id])
|
||||
}
|
||||
|
||||
@Test("only injects events for the geohash channel being viewed")
|
||||
func downlinkChannelScoped() throws {
|
||||
let fixture = Fixture(enabled: false)
|
||||
fixture.currentGeohash = "9q8yyk"
|
||||
let event = try makeEvent()
|
||||
let payload = try carrierPayload(event, direction: .fromGateway)
|
||||
|
||||
fixture.service.handleMeshCarrier(payload, from: PeerID(str: "8877665544332211"), directedToUs: false)
|
||||
#expect(fixture.injected.isEmpty)
|
||||
}
|
||||
|
||||
@Test("a directed fromGateway or broadcast toGateway carrier is malformed and dropped")
|
||||
func directionMisuseDropped() throws {
|
||||
let fixture = Fixture()
|
||||
let event = try makeEvent()
|
||||
|
||||
let downlink = try carrierPayload(event, direction: .fromGateway)
|
||||
fixture.service.handleMeshCarrier(downlink, from: PeerID(str: "8877665544332211"), directedToUs: true)
|
||||
#expect(fixture.injected.isEmpty)
|
||||
|
||||
let uplink = try carrierPayload(event, direction: .toGateway)
|
||||
fixture.service.handleMeshCarrier(uplink, from: PeerID(str: "8877665544332211"), directedToUs: false)
|
||||
#expect(fixture.published.isEmpty)
|
||||
}
|
||||
|
||||
// MARK: - Mesh-only sender uplink
|
||||
|
||||
@Test("uplinks via a mesh gateway only when relays are down and a gateway exists")
|
||||
func uplinkViaMeshConditions() throws {
|
||||
let fixture = Fixture(enabled: false)
|
||||
let gatewayPeer = PeerID(str: "8877665544332211")
|
||||
let event = try makeEvent()
|
||||
|
||||
// Relays working: no mesh uplink.
|
||||
fixture.relaysConnected = true
|
||||
fixture.gatewayPeers = [gatewayPeer]
|
||||
#expect(!fixture.service.uplinkViaMesh(event: event, geohash: Self.geohash))
|
||||
|
||||
// Relays down, no gateway around: no mesh uplink.
|
||||
fixture.relaysConnected = false
|
||||
fixture.gatewayPeers = []
|
||||
#expect(!fixture.service.uplinkViaMesh(event: event, geohash: Self.geohash))
|
||||
|
||||
// Relays down and a gateway peer advertised: uplink goes out.
|
||||
fixture.gatewayPeers = [gatewayPeer]
|
||||
#expect(fixture.service.uplinkViaMesh(event: event, geohash: Self.geohash))
|
||||
#expect(fixture.uplinkSends.count == 1)
|
||||
#expect(fixture.uplinkSends.first?.peer == gatewayPeer)
|
||||
|
||||
let sentPayload = try #require(fixture.uplinkSends.first?.payload)
|
||||
let sent = try #require(NostrCarrierPacket.decode(sentPayload))
|
||||
#expect(sent.direction == .toGateway)
|
||||
#expect(sent.geohash == Self.geohash)
|
||||
#expect(sent.event()?.id == event.id)
|
||||
|
||||
// A failed transport hand-off reports false.
|
||||
fixture.sendToGatewaySucceeds = false
|
||||
#expect(!fixture.service.uplinkViaMesh(event: try makeEvent(), geohash: Self.geohash))
|
||||
}
|
||||
|
||||
// MARK: - Toggle
|
||||
|
||||
@Test("persists the toggle and reports changes")
|
||||
func togglePersistsAndNotifies() throws {
|
||||
let suite = "GatewayServiceTests-\(UUID().uuidString)"
|
||||
let fixture = Fixture(enabled: false, suite: suite)
|
||||
#expect(!fixture.service.isEnabled)
|
||||
|
||||
fixture.service.setEnabled(true)
|
||||
#expect(fixture.enabledChanges == [true])
|
||||
// Setting the same value again is a no-op.
|
||||
fixture.service.setEnabled(true)
|
||||
#expect(fixture.enabledChanges == [true])
|
||||
|
||||
// A fresh service over the same defaults restores the toggle.
|
||||
let revived = GatewayService(defaults: UserDefaults(suiteName: suite)!)
|
||||
#expect(revived.isEnabled)
|
||||
|
||||
fixture.service.setEnabled(false)
|
||||
#expect(fixture.enabledChanges == [true, false])
|
||||
fixture.defaults.removePersistentDomain(forName: suite)
|
||||
}
|
||||
|
||||
@Test("disabling the toggle drops queued work")
|
||||
func disableClearsQueues() throws {
|
||||
let fixture = Fixture()
|
||||
fixture.relaysConnected = false
|
||||
try deposit(try makeEvent(), into: fixture)
|
||||
#expect(fixture.service.queuedUplinks.count == 1)
|
||||
|
||||
fixture.service.setEnabled(false)
|
||||
#expect(fixture.service.queuedUplinks.isEmpty)
|
||||
|
||||
// Nothing to flush after re-enabling.
|
||||
fixture.service.setEnabled(true)
|
||||
fixture.relaysConnected = true
|
||||
fixture.service.flushQueuedUplinks()
|
||||
#expect(fixture.published.isEmpty)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user