Expand coverage for relay, identity, and location flows (#1055)

* Expand coverage for relay, identity, and location flows * Fix macOS SwiftPM CI failures --------- Co-authored-by: jack <jackjackbits@users.noreply.github.com>
2026-07-25 19:45:22 +00:00 · 2026-03-12 12:50:46 -10:00
parent c043cf6354
commit a136b5b7e9
22 changed files with 2926 additions and 164 deletions
@@ -251,7 +251,8 @@ final class BLEService: NSObject {
    init(
        keychain: KeychainManagerProtocol,
        idBridge: NostrIdentityBridge,
-        identityManager: SecureIdentityStateManagerProtocol
+        identityManager: SecureIdentityStateManagerProtocol,
+        initializeBluetoothManagers: Bool = true
    ) {
        self.keychain = keychain
        self.idBridge = idBridge
@@ -294,22 +295,23 @@ final class BLEService: NSObject {
        // Tag BLE queue for re-entrancy detection
        bleQueue.setSpecific(key: bleQueueKey, value: ())

-        // Initialize BLE on background queue to prevent main thread blocking
-        // This prevents app freezes during BLE operations
-        #if os(iOS)
-        let centralOptions: [String: Any] = [
-            CBCentralManagerOptionRestoreIdentifierKey: BLEService.centralRestorationID
-        ]
-        centralManager = CBCentralManager(delegate: self, queue: bleQueue, options: centralOptions)
+        if initializeBluetoothManagers {
+            // Initialize BLE on background queue to prevent main thread blocking.
+            #if os(iOS)
+            let centralOptions: [String: Any] = [
+                CBCentralManagerOptionRestoreIdentifierKey: BLEService.centralRestorationID
+            ]
+            centralManager = CBCentralManager(delegate: self, queue: bleQueue, options: centralOptions)

-        let peripheralOptions: [String: Any] = [
-            CBPeripheralManagerOptionRestoreIdentifierKey: BLEService.peripheralRestorationID
-        ]
-        peripheralManager = CBPeripheralManager(delegate: self, queue: bleQueue, options: peripheralOptions)
-        #else
-        centralManager = CBCentralManager(delegate: self, queue: bleQueue)
-        peripheralManager = CBPeripheralManager(delegate: self, queue: bleQueue)
-        #endif
+            let peripheralOptions: [String: Any] = [
+                CBPeripheralManagerOptionRestoreIdentifierKey: BLEService.peripheralRestorationID
+            ]
+            peripheralManager = CBPeripheralManager(delegate: self, queue: bleQueue, options: peripheralOptions)
+            #else
+            centralManager = CBCentralManager(delegate: self, queue: bleQueue)
+            peripheralManager = CBPeripheralManager(delegate: self, queue: bleQueue)
+            #endif
+        }
        
        // Single maintenance timer for all periodic tasks (dispatch-based for determinism)
        let timer = DispatchSource.makeTimerSource(queue: bleQueue)
@@ -13,6 +13,25 @@ import Combine
 import BitLogger
 import Tor

+protocol GeohashPresenceTimerProtocol: AnyObject {
+    var isValid: Bool { get }
+    func invalidate()
+}
+
+private final class GeohashPresenceTimerAdapter: GeohashPresenceTimerProtocol {
+    private let base: Timer
+
+    init(base: Timer) {
+        self.base = base
+    }
+
+    var isValid: Bool { base.isValid }
+
+    func invalidate() {
+        base.invalidate()
+    }
+}
+
 /// Service that coordinates the broadcasting of presence heartbeats.
 ///
 /// Behavior:
@@ -25,18 +44,27 @@ final class GeohashPresenceService: ObservableObject {
    static let shared = GeohashPresenceService()

    private var subscriptions = Set<AnyCancellable>()
-    private var heartbeatTimer: Timer?
-    private let idBridge = NostrIdentityBridge()
+    private var heartbeatTimer: GeohashPresenceTimerProtocol?
+    private let availableChannelsProvider: () -> [GeohashChannel]
+    private let locationChanges: AnyPublisher<[GeohashChannel], Never>
+    private let torReadyPublisher: AnyPublisher<Void, Never>
+    private let torIsReady: () -> Bool
+    private let torIsForeground: () -> Bool
+    private let deriveIdentity: (String) throws -> NostrIdentity
+    private let relayLookup: (String, Int) -> [String]
+    private let relaySender: (NostrEvent, [String]) -> Void
+    private let sleeper: (UInt64) async -> Void
+    private let scheduleTimer: (TimeInterval, @escaping () -> Void) -> GeohashPresenceTimerProtocol
    
    // MARK: - Constants

    // Loop interval range in seconds
-    private let loopMinInterval: TimeInterval = 40.0
-    private let loopMaxInterval: TimeInterval = 80.0
+    private let loopMinInterval: TimeInterval
+    private let loopMaxInterval: TimeInterval
    
    // Per-broadcast decorrelation delay range in seconds
-    private let burstMinDelay: TimeInterval = 2.0
-    private let burstMaxDelay: TimeInterval = 5.0
+    private let burstMinDelay: TimeInterval
+    private let burstMaxDelay: TimeInterval

    // Privacy: Only broadcast to these levels
    private let allowedPrecisions: Set<Int> = [
@@ -46,6 +74,74 @@ final class GeohashPresenceService: ObservableObject {
    ]

    private init() {
+        let idBridge = NostrIdentityBridge()
+        self.availableChannelsProvider = { LocationStateManager.shared.availableChannels }
+        self.locationChanges = LocationStateManager.shared.$availableChannels.eraseToAnyPublisher()
+        self.torReadyPublisher = NotificationCenter.default.publisher(for: .TorDidBecomeReady)
+            .map { _ in () }
+            .eraseToAnyPublisher()
+        self.torIsReady = { TorManager.shared.isReady }
+        self.torIsForeground = { TorManager.shared.isForeground() }
+        self.deriveIdentity = { try idBridge.deriveIdentity(forGeohash: $0) }
+        self.relayLookup = { geohash, count in
+            GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: count)
+        }
+        self.relaySender = { event, relays in
+            NostrRelayManager.shared.sendEvent(event, to: relays)
+        }
+        self.sleeper = { nanoseconds in
+            try? await Task.sleep(nanoseconds: nanoseconds)
+        }
+        self.scheduleTimer = { interval, action in
+            GeohashPresenceTimerAdapter(
+                base: Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { _ in
+                    action()
+                }
+            )
+        }
+        self.loopMinInterval = 40.0
+        self.loopMaxInterval = 80.0
+        self.burstMinDelay = 2.0
+        self.burstMaxDelay = 5.0
+        setupObservers()
+    }
+
+    internal init(
+        availableChannelsProvider: @escaping () -> [GeohashChannel],
+        locationChanges: AnyPublisher<[GeohashChannel], Never>,
+        torReadyPublisher: AnyPublisher<Void, Never>,
+        torIsReady: @escaping () -> Bool,
+        torIsForeground: @escaping () -> Bool,
+        deriveIdentity: @escaping (String) throws -> NostrIdentity,
+        relayLookup: @escaping (String, Int) -> [String],
+        relaySender: @escaping (NostrEvent, [String]) -> Void,
+        sleeper: @escaping (UInt64) async -> Void = { nanoseconds in try? await Task.sleep(nanoseconds: nanoseconds) },
+        scheduleTimer: @escaping (TimeInterval, @escaping () -> Void) -> GeohashPresenceTimerProtocol = { interval, action in
+            GeohashPresenceTimerAdapter(
+                base: Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { _ in
+                    action()
+                }
+            )
+        },
+        loopMinInterval: TimeInterval = 40.0,
+        loopMaxInterval: TimeInterval = 80.0,
+        burstMinDelay: TimeInterval = 2.0,
+        burstMaxDelay: TimeInterval = 5.0
+    ) {
+        self.availableChannelsProvider = availableChannelsProvider
+        self.locationChanges = locationChanges
+        self.torReadyPublisher = torReadyPublisher
+        self.torIsReady = torIsReady
+        self.torIsForeground = torIsForeground
+        self.deriveIdentity = deriveIdentity
+        self.relayLookup = relayLookup
+        self.relaySender = relaySender
+        self.sleeper = sleeper
+        self.scheduleTimer = scheduleTimer
+        self.loopMinInterval = loopMinInterval
+        self.loopMaxInterval = loopMaxInterval
+        self.burstMinDelay = burstMinDelay
+        self.burstMaxDelay = burstMaxDelay
        setupObservers()
    }
    
@@ -57,7 +153,7 @@ final class GeohashPresenceService: ObservableObject {

    private func setupObservers() {
        // Monitor location channel changes
-        LocationStateManager.shared.$availableChannels
+        locationChanges
            .dropFirst()
            .sink { [weak self] _ in
                self?.handleLocationChange()
@@ -65,28 +161,28 @@ final class GeohashPresenceService: ObservableObject {
            .store(in: &subscriptions)

        // Monitor Tor readiness to kick off heartbeat if it was stalled
-        NotificationCenter.default.publisher(for: .TorDidBecomeReady)
+        torReadyPublisher
            .sink { [weak self] _ in
                self?.handleConnectivityChange()
            }
            .store(in: &subscriptions)
    }

-    private func handleLocationChange() {
+    func handleLocationChange() {
        // When location changes, we trigger an immediate (but slightly delayed) heartbeat
        // to announce presence in the new zone, then reset the loop.
        SecureLogger.debug("Presence: location changed, scheduling update", category: .session)
        heartbeatTimer?.invalidate()
        
        // Small delay to allow location state to settle
-        heartbeatTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: false) { [weak self] _ in
+        heartbeatTimer = scheduleTimer(5.0) { [weak self] in
            Task { @MainActor [weak self] in
                self?.performHeartbeat()
            }
        }
    }
    
-    private func handleConnectivityChange() {
+    func handleConnectivityChange() {
        SecureLogger.debug("Presence: connectivity restored, triggering heartbeat", category: .session)
        // If we were waiting for network, do it now
        if heartbeatTimer == nil || !heartbeatTimer!.isValid {
@@ -94,33 +190,33 @@ final class GeohashPresenceService: ObservableObject {
        }
    }

-    private func scheduleNextHeartbeat() {
+    func scheduleNextHeartbeat() {
        heartbeatTimer?.invalidate()
        let interval = TimeInterval.random(in: loopMinInterval...loopMaxInterval)
-        heartbeatTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { [weak self] _ in
+        heartbeatTimer = scheduleTimer(interval) { [weak self] in
            Task { @MainActor [weak self] in
                self?.performHeartbeat()
            }
        }
    }

-    private func performHeartbeat() {
+    func performHeartbeat() {
        // Always schedule next loop first ensures continuity even if this one fails/skips
        defer { scheduleNextHeartbeat() }

        // 1. Check preconditions
-        guard TorManager.shared.isReady else {
+        guard torIsReady() else {
            SecureLogger.debug("Presence: skipping heartbeat (Tor not ready)", category: .session)
            return
        }
        
        // App must be active (or at least we shouldn't broadcast if in background, usually)
-        if !TorManager.shared.isForeground() {
+        if !torIsForeground() {
            return
        }

        // 2. Get channels
-        let channels = LocationStateManager.shared.availableChannels
+        let channels = availableChannelsProvider()
        guard !channels.isEmpty else { return }

        // 3. Filter and broadcast
@@ -136,16 +232,16 @@ final class GeohashPresenceService: ObservableObject {
                // Random delay for decorrelation
                let delay = TimeInterval.random(in: self.burstMinDelay...self.burstMaxDelay)
                let nanoseconds = UInt64(delay * 1_000_000_000)
-                try? await Task.sleep(nanoseconds: nanoseconds)
+                await self.sleeper(nanoseconds)
                
                self.broadcastPresence(for: channel.geohash)
            }
        }
    }

-    private func broadcastPresence(for geohash: String) {
+    func broadcastPresence(for geohash: String) {
        do {
-            guard let identity = try? idBridge.deriveIdentity(forGeohash: geohash) else {
+            guard let identity = try? deriveIdentity(geohash) else {
                return
            }
            
@@ -155,13 +251,10 @@ final class GeohashPresenceService: ObservableObject {
            )
            
            // Send via RelayManager
-            let targetRelays = GeoRelayDirectory.shared.closestRelays(
-                toGeohash: geohash,
-                count: TransportConfig.nostrGeoRelayCount
-            )
+            let targetRelays = relayLookup(geohash, TransportConfig.nostrGeoRelayCount)
            
            if !targetRelays.isEmpty {
-                NostrRelayManager.shared.sendEvent(event, to: targetRelays)
+                relaySender(event, targetRelays)
                SecureLogger.debug("Presence: sent heartbeat for \(geohash) (pub=\(identity.publicKeyHex.prefix(6))...)", category: .session)
            }
        } catch {
@@ -5,6 +5,82 @@ import Combine
 #if os(iOS) || os(macOS)
 import CoreLocation

+protocol LocationStateManaging: AnyObject {
+    var delegate: CLLocationManagerDelegate? { get set }
+    var desiredAccuracy: CLLocationAccuracy { get set }
+    var distanceFilter: CLLocationDistance { get set }
+    var authorizationStatus: CLAuthorizationStatus { get }
+    func requestWhenInUseAuthorization()
+    func requestLocation()
+    func startUpdatingLocation()
+    func stopUpdatingLocation()
+}
+
+protocol LocationStateGeocoding: AnyObject {
+    func cancelGeocode()
+    func reverseGeocodeLocation(
+        _ location: CLLocation,
+        completionHandler: @escaping ([CLPlacemark]?, Error?) -> Void
+    )
+}
+
+private final class CLLocationManagerAdapter: NSObject, LocationStateManaging {
+    private let base = CLLocationManager()
+
+    var delegate: CLLocationManagerDelegate? {
+        get { base.delegate }
+        set { base.delegate = newValue }
+    }
+
+    var desiredAccuracy: CLLocationAccuracy {
+        get { base.desiredAccuracy }
+        set { base.desiredAccuracy = newValue }
+    }
+
+    var distanceFilter: CLLocationDistance {
+        get { base.distanceFilter }
+        set { base.distanceFilter = newValue }
+    }
+
+    var authorizationStatus: CLAuthorizationStatus {
+        if #available(iOS 14.0, macOS 11.0, *) {
+            return base.authorizationStatus
+        }
+        return CLLocationManager.authorizationStatus()
+    }
+
+    func requestWhenInUseAuthorization() {
+        base.requestWhenInUseAuthorization()
+    }
+
+    func requestLocation() {
+        base.requestLocation()
+    }
+
+    func startUpdatingLocation() {
+        base.startUpdatingLocation()
+    }
+
+    func stopUpdatingLocation() {
+        base.stopUpdatingLocation()
+    }
+}
+
+private final class CLGeocoderAdapter: LocationStateGeocoding {
+    private let base = CLGeocoder()
+
+    func cancelGeocode() {
+        base.cancelGeocode()
+    }
+
+    func reverseGeocodeLocation(
+        _ location: CLLocation,
+        completionHandler: @escaping ([CLPlacemark]?, Error?) -> Void
+    ) {
+        base.reverseGeocodeLocation(location, completionHandler: completionHandler)
+    }
+}
+
 /// Unified manager for location-based channel state including:
 /// - CoreLocation permissions and one-shot location retrieval
 /// - Geohash channel computation from coordinates
@@ -26,8 +102,8 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl

    // MARK: - Private Properties (CoreLocation)

-    private let cl = CLLocationManager()
-    private let geocoder = CLGeocoder()
+    private let cl: LocationStateManaging
+    private let geocoder: LocationStateGeocoding
    private var lastLocation: CLLocation?
    private var refreshTimer: Timer?
    private var isGeocoding: Bool = false
@@ -73,6 +149,8 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl

    private override init() {
        self.storage = .standard
+        self.cl = CLLocationManagerAdapter()
+        self.geocoder = CLGeocoderAdapter()
        super.init()

        // Skip CoreLocation setup in test environments
@@ -92,10 +170,30 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl
    /// Internal initializer for testing with custom storage
    init(storage: UserDefaults) {
        self.storage = storage
+        self.cl = CLLocationManagerAdapter()
+        self.geocoder = CLGeocoderAdapter()
        super.init()
        loadPersistedState()
    }

+    internal init(
+        storage: UserDefaults,
+        locationManager: LocationStateManaging,
+        geocoder: LocationStateGeocoding,
+        shouldInitializeCoreLocation: Bool
+    ) {
+        self.storage = storage
+        self.cl = locationManager
+        self.geocoder = geocoder
+        super.init()
+        loadPersistedState()
+        guard shouldInitializeCoreLocation else { return }
+        cl.delegate = self
+        cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
+        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters
+        initializePermissionState()
+    }
+
    private func loadPersistedState() {
        // Load selected channel
        if let data = storage.data(forKey: selectedChannelKey),
@@ -132,12 +230,7 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl
    }

    private func initializePermissionState() {
-        let status: CLAuthorizationStatus
-        if #available(iOS 14.0, macOS 11.0, *) {
-            status = cl.authorizationStatus
-        } else {
-            status = CLLocationManager.authorizationStatus()
-        }
+        let status = cl.authorizationStatus
        updatePermissionState(from: status)

        // Fall back to persisted teleport state if no location authorization
@@ -156,12 +249,7 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl
    // MARK: - Public API (Permissions & Location)

    func enableLocationChannels() {
-        let status: CLAuthorizationStatus
-        if #available(iOS 14.0, macOS 11.0, *) {
-            status = cl.authorizationStatus
-        } else {
-            status = CLLocationManager.authorizationStatus()
-        }
+        let status = cl.authorizationStatus
        switch status {
        case .notDetermined:
            cl.requestWhenInUseAuthorization()
@@ -3,6 +3,27 @@ import BitLogger
 import Combine
 import Tor

+@MainActor
+protocol NetworkActivationTorControlling: AnyObject {
+    func setAutoStartAllowed(_ allowed: Bool)
+    func startIfNeeded()
+    func shutdownCompletely()
+}
+
+@MainActor
+protocol NetworkActivationRelayControlling: AnyObject {
+    func connect()
+    func disconnect()
+}
+
+protocol NetworkActivationProxyControlling: AnyObject {
+    func setProxyMode(useTor: Bool)
+}
+
+extension TorManager: NetworkActivationTorControlling {}
+extension NostrRelayManager: NetworkActivationRelayControlling {}
+extension TorURLSession: NetworkActivationProxyControlling {}
+
 /// Coordinates when the app is allowed to start Tor and connect to Nostr relays.
 /// Policy: permit start when either location permissions are authorized OR
 /// there exists at least one mutual favorite. Otherwise, do not start.
@@ -17,14 +38,55 @@ final class NetworkActivationService: ObservableObject {
    private var started = false
    private let torPreferenceKey = "networkActivationService.userTorEnabled"
    private var torAutoStartDesired: Bool = false
+    private let storage: UserDefaults
+    private let locationPermissionPublisher: AnyPublisher<LocationChannelManager.PermissionState, Never>
+    private let mutualFavoritesPublisher: AnyPublisher<Set<Data>, Never>
+    private let permissionProvider: () -> LocationChannelManager.PermissionState
+    private let mutualFavoritesProvider: () -> Set<Data>
+    private let torController: NetworkActivationTorControlling
+    private let relayController: NetworkActivationRelayControlling
+    private let proxyController: NetworkActivationProxyControlling
+    private let notificationCenter: NotificationCenter

-    private init() {}
+    private init() {
+        storage = .standard
+        locationPermissionPublisher = LocationChannelManager.shared.$permissionState.eraseToAnyPublisher()
+        mutualFavoritesPublisher = FavoritesPersistenceService.shared.$mutualFavorites.eraseToAnyPublisher()
+        permissionProvider = { LocationChannelManager.shared.permissionState }
+        mutualFavoritesProvider = { FavoritesPersistenceService.shared.mutualFavorites }
+        torController = TorManager.shared
+        relayController = NostrRelayManager.shared
+        proxyController = TorURLSession.shared
+        notificationCenter = .default
+    }
+
+    internal init(
+        storage: UserDefaults,
+        locationPermissionPublisher: AnyPublisher<LocationChannelManager.PermissionState, Never>,
+        mutualFavoritesPublisher: AnyPublisher<Set<Data>, Never>,
+        permissionProvider: @escaping () -> LocationChannelManager.PermissionState,
+        mutualFavoritesProvider: @escaping () -> Set<Data>,
+        torController: NetworkActivationTorControlling,
+        relayController: NetworkActivationRelayControlling,
+        proxyController: NetworkActivationProxyControlling,
+        notificationCenter: NotificationCenter = .default
+    ) {
+        self.storage = storage
+        self.locationPermissionPublisher = locationPermissionPublisher
+        self.mutualFavoritesPublisher = mutualFavoritesPublisher
+        self.permissionProvider = permissionProvider
+        self.mutualFavoritesProvider = mutualFavoritesProvider
+        self.torController = torController
+        self.relayController = relayController
+        self.proxyController = proxyController
+        self.notificationCenter = notificationCenter
+    }

    func start() {
        guard !started else { return }
        started = true

-        if let stored = UserDefaults.standard.object(forKey: torPreferenceKey) as? Bool {
+        if let stored = storage.object(forKey: torPreferenceKey) as? Bool {
            userTorEnabled = stored
        } else {
            userTorEnabled = true
@@ -34,16 +96,16 @@ final class NetworkActivationService: ObservableObject {
        let allowed = basePolicyAllowed()
        activationAllowed = allowed
        torAutoStartDesired = allowed && userTorEnabled
-        TorManager.shared.setAutoStartAllowed(torAutoStartDesired)
+        torController.setAutoStartAllowed(torAutoStartDesired)
        applyTorState(torDesired: torAutoStartDesired)
        if allowed {
-            NostrRelayManager.shared.connect()
+            relayController.connect()
        } else {
-            NostrRelayManager.shared.disconnect()
+            relayController.disconnect()
        }

        // React to location permission changes
-        LocationChannelManager.shared.$permissionState
+        locationPermissionPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.reevaluate()
@@ -51,7 +113,7 @@ final class NetworkActivationService: ObservableObject {
            .store(in: &cancellables)

        // React to mutual favorites changes
-        FavoritesPersistenceService.shared.$mutualFavorites
+        mutualFavoritesPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.reevaluate()
@@ -62,8 +124,8 @@ final class NetworkActivationService: ObservableObject {
    func setUserTorEnabled(_ enabled: Bool) {
        guard enabled != userTorEnabled else { return }
        userTorEnabled = enabled
-        UserDefaults.standard.set(enabled, forKey: torPreferenceKey)
-        NotificationCenter.default.post(
+        storage.set(enabled, forKey: torPreferenceKey)
+        notificationCenter.post(
            name: .TorUserPreferenceChanged,
            object: nil,
            userInfo: ["enabled": enabled]
@@ -82,33 +144,33 @@ final class NetworkActivationService: ObservableObject {
        }
        if statusChanged || torChanged {
            torAutoStartDesired = torDesired
-            TorManager.shared.setAutoStartAllowed(torDesired)
+            torController.setAutoStartAllowed(torDesired)
            applyTorState(torDesired: torDesired)
        }

        if allowed {
            if torChanged {
                // Reset relay sockets when switching transport path (Tor ↔︎ direct)
-                NostrRelayManager.shared.disconnect()
+                relayController.disconnect()
            }
-            NostrRelayManager.shared.connect()
+            relayController.connect()
        } else if statusChanged {
-            NostrRelayManager.shared.disconnect()
+            relayController.disconnect()
        }
    }

    private func basePolicyAllowed() -> Bool {
-        let permOK = LocationChannelManager.shared.permissionState == .authorized
-        let hasMutual = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
+        let permOK = permissionProvider() == .authorized
+        let hasMutual = !mutualFavoritesProvider().isEmpty
        return permOK || hasMutual
    }

    private func applyTorState(torDesired: Bool) {
-        TorURLSession.shared.setProxyMode(useTor: torDesired)
+        proxyController.setProxyMode(useTor: torDesired)
        if torDesired {
-            TorManager.shared.startIfNeeded()
+            torController.startIfNeeded()
        } else {
-            TorManager.shared.shutdownCompletely()
+            torController.shutdownCompletely()
        }
    }
 }
@@ -14,24 +14,103 @@ import UIKit
 import AppKit
 #endif

+protocol NotificationAuthorizing {
+    func requestAuthorization(
+        options: UNAuthorizationOptions,
+        completionHandler: @escaping (Bool, Error?) -> Void
+    )
+}
+
+protocol NotificationRequestDelivering {
+    func add(_ request: UNNotificationRequest)
+}
+
+private final class NotificationCenterAuthorizerAdapter: NotificationAuthorizing {
+    private let center: UNUserNotificationCenter
+
+    init(center: UNUserNotificationCenter) {
+        self.center = center
+    }
+
+    func requestAuthorization(
+        options: UNAuthorizationOptions,
+        completionHandler: @escaping (Bool, Error?) -> Void
+    ) {
+        center.requestAuthorization(options: options, completionHandler: completionHandler)
+    }
+}
+
+private final class NotificationCenterRequestDelivererAdapter: NotificationRequestDelivering {
+    private let center: UNUserNotificationCenter
+
+    init(center: UNUserNotificationCenter) {
+        self.center = center
+    }
+
+    func add(_ request: UNNotificationRequest) {
+        Task {
+            try? await center.add(request)
+        }
+    }
+}
+
+private struct NoopNotificationAuthorizer: NotificationAuthorizing {
+    func requestAuthorization(
+        options: UNAuthorizationOptions,
+        completionHandler: @escaping (Bool, Error?) -> Void
+    ) {
+        completionHandler(false, nil)
+    }
+}
+
+private struct NoopNotificationRequestDeliverer: NotificationRequestDelivering {
+    func add(_ request: UNNotificationRequest) {}
+}
+
 final class NotificationService {
    static let shared = NotificationService()

+    private let isRunningTestsProvider: () -> Bool
+    private let authorizer: NotificationAuthorizing
+    private let requestDeliverer: NotificationRequestDelivering
+
    /// Returns true if running in test environment (XCTest, Swift Testing, or CI)
    private var isRunningTests: Bool {
-        let env = ProcessInfo.processInfo.environment
-        return NSClassFromString("XCTestCase") != nil ||
-               env["XCTestConfigurationFilePath"] != nil ||
-               env["XCTestBundlePath"] != nil ||
-               env["GITHUB_ACTIONS"] != nil ||
-               env["CI"] != nil
+        isRunningTestsProvider()
    }

-    private init() {}
+    private init() {
+        self.isRunningTestsProvider = {
+            let env = ProcessInfo.processInfo.environment
+            return NSClassFromString("XCTestCase") != nil ||
+                   env["XCTestConfigurationFilePath"] != nil ||
+                   env["XCTestBundlePath"] != nil ||
+                   env["GITHUB_ACTIONS"] != nil ||
+                   env["CI"] != nil
+        }
+        if isRunningTestsProvider() {
+            self.authorizer = NoopNotificationAuthorizer()
+            self.requestDeliverer = NoopNotificationRequestDeliverer()
+        } else {
+            let center = UNUserNotificationCenter.current()
+            self.authorizer = NotificationCenterAuthorizerAdapter(center: center)
+            self.requestDeliverer = NotificationCenterRequestDelivererAdapter(center: center)
+        }
+    }
+
+    internal init(
+        isRunningTestsProvider: @escaping () -> Bool,
+        authorizer: NotificationAuthorizing,
+        requestDeliverer: NotificationRequestDelivering
+    ) {
+        self.isRunningTestsProvider = isRunningTestsProvider
+        self.authorizer = authorizer
+        self.requestDeliverer = requestDeliverer
+    }

    func requestAuthorization() {
        guard !isRunningTests else { return }
-        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+        authorizer.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            if granted {
                // Permission granted
            } else {
@@ -64,7 +143,7 @@ final class NotificationService {
            trigger: nil // Deliver immediately
        )

-        UNUserNotificationCenter.current().add(request)
+        requestDeliverer.add(request)
    }
    
    func sendMentionNotification(from sender: String, message: String) {