Add tests for AppMessageHandler

ios/PacketTunnel/PacketTunnelProvider/BlockedStateErrorMapper.swift

@@ -57,6 +57,10 @@ struct BlockedStateErrorMapper: BlockedStateErrorMapperProtocol {
             // packet tunnel provider.
             return .tunnelAdapter
 
+        case is PublicKeyError:
+            // Returned when there is an endpoint but its public key is invalid.
+            return .invalidPublicKey
+
         default:
             // Everything else in case we introduce new errors and forget to handle them.
             return .unknown

ios/PacketTunnelCore/Actor/ConfigurationBuilder.swift

@@ -13,29 +13,44 @@ import struct WireGuardKitTypes.IPAddressRange
 import class WireGuardKitTypes.PrivateKey
 import class WireGuardKitTypes.PublicKey
 
+/// Error returned when there is an endpoint but its public key is invalid.
+public struct PublicKeyError: LocalizedError {
+    let endpoint: MullvadEndpoint
+
+    public var errorDescription: String? {
+        "Public key is invalid, endpoint: \(endpoint)"
+    }
+}
+
 /// Struct building tunnel adapter configuration.
 struct ConfigurationBuilder {
     var privateKey: PrivateKey
     var interfaceAddresses: [IPAddressRange]
     var dns: SelectedDNSServers?
     var endpoint: MullvadEndpoint?
 
-    func makeConfiguration() -> TunnelAdapterConfiguration {
+    func makeConfiguration() throws -> TunnelAdapterConfiguration {
         return TunnelAdapterConfiguration(
             privateKey: privateKey,
             interfaceAddresses: interfaceAddresses,
             dns: dnsServers,
-            peer: peer
+            peer: try peer
         )
     }
 
     private var peer: TunnelPeer? {
-        guard let endpoint else { return nil }
+        get throws {
+            guard let endpoint else { return nil }
 
-        return TunnelPeer(
-            endpoint: .ipv4(endpoint.ipv4Relay),
-            publicKey: PublicKey(rawValue: endpoint.publicKey)!
-        )
+            guard let publicKey = PublicKey(rawValue: endpoint.publicKey) else {
+                throw PublicKeyError(endpoint: endpoint)
+            }
+
+            return TunnelPeer(
+                endpoint: .ipv4(endpoint.ipv4Relay),
+                publicKey: publicKey
+            )
+        }
     }
 
     private var dnsServers: [IPAddress] {

ios/PacketTunnelCore/Actor/Actor+KeyPolicy.swift → ios/PacketTunnelCore/Actor/PacketTunnelActor+KeyPolicy.swift

@@ -108,7 +108,7 @@ extension PacketTunnelActor {
             guard let self else { return }
 
             // Wait for key to propagate across relays.
-            try await Task.sleepUsingContinuousClock(for: timings.wgKeyPropagationDelay)
+//            try await Task.sleepUsingContinuousClock(for: timings.wgKeyPropagationDelay)
 
             // Enqueue task to change key policy.
             commandChannel.send(.switchKey)
@@ -159,7 +159,7 @@ extension PacketTunnelActor {
     /**
      Internal helper that transitions key policy from `.usePrior` to `.useCurrent`.
 
-     - Parameter keyPolicy: a reference to key policy hend either in connection state or blocked state struct.
+     - Parameter keyPolicy: a reference to key policy held either in connection state or blocked state struct.
      - Returns: `true` when the policy was modified, otherwise `false`.
      */
     private func setCurrentKeyPolicy(_ keyPolicy: inout KeyPolicy) -> Bool {

ios/PacketTunnelCore/Actor/Actor+Public.swift → ios/PacketTunnelCore/Actor/PacketTunnelActor+Public.swift

@@ -1,5 +1,5 @@
 //
-//  Actor+Public.swift
+//  PacketTunnelActor+Public.swift
 //  PacketTunnelCore
 //
 //  Created by pronebird on 27/09/2023.

ios/PacketTunnelCore/Actor/Actor.swift → ios/PacketTunnelCore/Actor/PacketTunnelActor.swift

@@ -1,5 +1,5 @@
 //
-//  Actor.swift
+//  PacketTunnelActor.swift
 //  PacketTunnel
 //
 //  Created by pronebird on 30/06/2023.

ios/PacketTunnelCore/Actor/State+Extensions.swift

@@ -7,6 +7,7 @@
 //
 
 import Foundation
+import MullvadTypes
 import class WireGuardKitTypes.PrivateKey
 
 extension State {
@@ -36,6 +37,50 @@ extension State {
         }
     }
 
+    var packetTunnelStatus: PacketTunnelStatus {
+        var status = PacketTunnelStatus()
+
+        switch self {
+        case let .connecting(connState),
+            let .connected(connState),
+            let .reconnecting(connState),
+            let .disconnecting(connState):
+            switch connState.networkReachability {
+            case .reachable:
+                status.isNetworkReachable = true
+            case .unreachable:
+                status.isNetworkReachable = false
+            case .undetermined:
+                // TODO: fix me
+                status.isNetworkReachable = true
+            }
+
+            status.numberOfFailedAttempts = connState.connectionAttemptCount
+            status.tunnelRelay = connState.selectedRelay.packetTunnelRelay
+
+        case .disconnected, .initial:
+            break
+
+        case let .error(blockedState):
+            status.blockedStateReason = blockedState.reason
+        }
+
+        return status
+    }
+
+    public var relayConstraints: RelayConstraints? {
+        switch self {
+        case let .connecting(connState), let .connected(connState), let .reconnecting(connState):
+            return connState.relayConstraints
+
+        case let .error(blockedState):
+            return blockedState.relayConstraints
+
+        case .initial, .disconnecting, .disconnected:
+            return nil
+        }
+    }
+
     // MARK: - Logging
 
     func logFormat() -> String {
@@ -105,7 +150,7 @@ extension BlockedStateReason {
             return true
 
         case .noRelaysSatisfyingConstraints, .readSettings, .invalidAccount, .deviceRevoked, .tunnelAdapter, .unknown,
-             .deviceLoggedOut, .outdatedSchema:
+                .deviceLoggedOut, .outdatedSchema, .invalidPublicKey:
             return false
         }
     }

ios/PacketTunnelCore/Actor/State.swift

@@ -55,7 +55,11 @@ import class WireGuardKitTypes.PrivateKey
  `.connecting`, `.reconnecting`, `.error` can be interrupted if the tunnel is requested to stop, which should segue actor towards `.disconnected` state.
 
  */
-public enum State {
+public enum State: Equatable {
+    public static func == (lhs: State, rhs: State) -> Bool {
+        lhs.name == rhs.name
+    }
+
     /// Initial state at the time when actor is initialized but before the first connection attempt.
     case initial
 
@@ -106,7 +110,7 @@ public struct ConnectionState {
     /// This is primarily used by packet tunnel for updating constraints in tunnel provider.
     public var relayConstraints: RelayConstraints
 
-    /// Last WG key read from setings.
+    /// Last WG key read from settings.
     /// Can be `nil` if moved to `keyPolicy`.
     public var currentKey: PrivateKey?
 
@@ -188,6 +192,9 @@ public enum BlockedStateReason: String, Codable, Equatable {
     /// Tunnel adapter error.
     case tunnelAdapter
 
+    /// Invalid public key.
+    case invalidPublicKey
+
     /// Unidentified reason.
     case unknown
 }

ios/PacketTunnel/PacketTunnelProvider/AppMessageHandler.swift → ios/PacketTunnelCore/IPC/AppMessageHandler.swift

@@ -8,17 +8,16 @@
 
 import Foundation
 import MullvadLogging
-import PacketTunnelCore
 
 /**
  Actor handling packet tunnel IPC (app) messages and patching them through to the right facility.
  */
-struct AppMessageHandler {
+public struct AppMessageHandler {
     private let logger = Logger(label: "AppMessageHandler")
     private let packetTunnelActor: PacketTunnelActor
     private let urlRequestProxy: URLRequestProxy
 
-    init(packetTunnelActor: PacketTunnelActor, urlRequestProxy: URLRequestProxy) {
+    public init(packetTunnelActor: PacketTunnelActor, urlRequestProxy: URLRequestProxy) {
         self.packetTunnelActor = packetTunnelActor
         self.urlRequestProxy = urlRequestProxy
     }
@@ -34,7 +33,7 @@ struct AppMessageHandler {
      the acknowledgment from IPC before starting next operation, hence it's critical to return as soon as possible.
      (See `TunnelManager.reconnectTunnel()`, `SendTunnelProviderMessageOperation`)
      */
-    func handleAppMessage(_ messageData: Data) async -> Data? {
+    public func handleAppMessage(_ messageData: Data) async -> Data? {
         guard let message = decodeMessage(messageData) else { return nil }
 
         logger.debug("Received app message: \(message)")
@@ -51,7 +50,7 @@ struct AppMessageHandler {
             return await encodeReply(packetTunnelActor.state.packetTunnelStatus)
 
         case .privateKeyRotation:
-            packetTunnelActor.notifyKeyRotation(date: nil)
+            packetTunnelActor.notifyKeyRotation(date: Date())
             return nil
 
         case let .reconnectTunnel(selectorResult):