Merge branch 'refactor-relay-settings-update' into main

6 files changed, 78 insertions, 109 deletions

diff --git a/test/Cargo.lock b/test/Cargo.lock
index b23c26adee..b2fc6bcb73 100644
--- a/test/Cargo.lock
+++ b/test/Cargo.lock
@@ -1442,9 +1442,9 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
 
 [[package]]
 name = "jnix"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aecfa741840d59de75e6e9e2985ee44b6794cbc0b2074899089be6bf7ffa0afc"
+checksum = "5fd797d41e48568eb956ded20d7e5e3f2df1c02980d9e5b9aab9b47bd3a9f599"
 dependencies = [
  "jni",
  "jnix-macros",
diff --git a/test/test-manager/src/tests/dns.rs b/test/test-manager/src/tests/dns.rs
index 69de367b88..310d5eb0dc 100644
--- a/test/test-manager/src/tests/dns.rs
+++ b/test/test-manager/src/tests/dns.rs
@@ -6,9 +6,7 @@ use std::{
 
 use itertools::Itertools;
 use mullvad_management_interface::{types, ManagementServiceClient};
-use mullvad_types::{
-    relay_constraints::RelaySettingsUpdate, ConnectionConfig, CustomTunnelEndpoint,
-};
+use mullvad_types::{relay_constraints::RelaySettings, ConnectionConfig, CustomTunnelEndpoint};
 use talpid_types::net::wireguard;
 use test_macro::test_function;
 use test_rpc::{Interface, ServiceClient};
@@ -24,7 +22,7 @@ use crate::vm::network::{
     CUSTOM_TUN_REMOTE_TUN_ADDR, NON_TUN_GATEWAY,
 };
 
-use super::helpers::update_relay_settings;
+use super::helpers::set_relay_settings;
 
 /// How long to wait for expected "DNS queries" to appear
 const MONITOR_TIMEOUT: Duration = Duration::from_secs(5);
@@ -631,7 +629,7 @@ async fn connect_local_wg_relay(mullvad_client: &mut ManagementServiceClient) ->
         CUSTOM_TUN_REMOTE_REAL_PORT,
     );
 
-    let relay_settings = RelaySettingsUpdate::CustomTunnelEndpoint(CustomTunnelEndpoint {
+    let relay_settings = RelaySettings::CustomTunnelEndpoint(CustomTunnelEndpoint {
         host: peer_addr.ip().to_string(),
         config: ConnectionConfig::Wireguard(wireguard::ConnectionConfig {
             tunnel: wireguard::TunnelConfig {
@@ -652,7 +650,7 @@ async fn connect_local_wg_relay(mullvad_client: &mut ManagementServiceClient) ->
         }),
     });
 
-    update_relay_settings(mullvad_client, relay_settings)
+    set_relay_settings(mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");
 
diff --git a/test/test-manager/src/tests/helpers.rs b/test/test-manager/src/tests/helpers.rs
index c51f6875da..e7c2e12d0f 100644
--- a/test/test-manager/src/tests/helpers.rs
+++ b/test/test-manager/src/tests/helpers.rs
@@ -5,7 +5,7 @@ use mullvad_management_interface::{types, ManagementServiceClient};
 use mullvad_types::{
     relay_constraints::{
         BridgeState, Constraint, GeographicLocationConstraint, LocationConstraint,
-        ObfuscationSettings, OpenVpnConstraints, RelayConstraintsUpdate, RelaySettingsUpdate,
+        ObfuscationSettings, OpenVpnConstraints, RelayConstraints, RelaySettings,
         WireguardConstraints,
     },
     states::TunnelState,
@@ -321,7 +321,7 @@ impl<T> Drop for AbortOnDrop<T> {
 
 /// Disconnect and reset all relay, bridge, and obfuscation settings.
 ///
-/// See [`mullvad_types::relay_constraints::RelayConstraintsUpdate`] for details, but in short:
+/// See [`mullvad_types::relay_constraints::RelayConstraints`] for details, but in short:
 /// * Location constraint is [`Constraint::Any`]
 /// * Provider constraint is [`Constraint::Any`]
 /// * Ownership constraint is [`Constraint::Any`]
@@ -335,18 +335,18 @@ pub async fn reset_relay_settings(
 ) -> Result<(), Error> {
     disconnect_and_wait(mullvad_client).await?;
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-        location: Some(Constraint::Any),
-        tunnel_protocol: Some(Constraint::Any),
-        openvpn_constraints: Some(OpenVpnConstraints::default()),
-        wireguard_constraints: Some(WireguardConstraints::default()),
-        providers: Some(Constraint::Any),
-        ownership: Some(Constraint::Any),
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
+        location: Constraint::Any,
+        tunnel_protocol: Constraint::Any,
+        openvpn_constraints: OpenVpnConstraints::default(),
+        wireguard_constraints: WireguardConstraints::default(),
+        providers: Constraint::Any,
+        ownership: Constraint::Any,
     });
     let bridge_state = BridgeState::Auto;
     let obfuscation_settings = ObfuscationSettings::default();
 
-    update_relay_settings(mullvad_client, relay_settings)
+    set_relay_settings(mullvad_client, relay_settings)
         .await
         .map_err(|error| {
             Error::DaemonError(format!("Failed to reset relay settings: {}", error))
@@ -365,14 +365,14 @@ pub async fn reset_relay_settings(
     Ok(())
 }
 
-pub async fn update_relay_settings(
+pub async fn set_relay_settings(
     mullvad_client: &mut ManagementServiceClient,
-    relay_settings_update: RelaySettingsUpdate,
+    relay_settings: RelaySettings,
 ) -> Result<(), Error> {
-    let update = types::RelaySettingsUpdate::from(relay_settings_update);
+    let new_settings = types::RelaySettings::from(relay_settings);
 
     mullvad_client
-        .update_relay_settings(update)
+        .set_relay_settings(new_settings)
         .await
         .map_err(|error| Error::DaemonError(format!("Failed to set relay settings: {}", error)))?;
     Ok(())
@@ -493,17 +493,10 @@ pub fn flatten_relaylist(relays: types::RelayList) -> Vec<types::Relay> {
 
 /// Convenience function for constructing a constraint from a given [`Relay`].
 ///
-/// Returns an [`Option`] because a [`Relay`] is not guaranteed to be poplutaed with a location
-/// vaule.
-pub fn into_constraint(relay: &types::Relay) -> Option<Constraint<LocationConstraint>> {
-    into_locationconstraint(relay).map(Constraint::Only)
-}
-
-/// Convenience function for constructing a location constraint from a given [`Relay`].
+/// # Panics
 ///
-/// Returns an [`Option`] because a [`Relay`] is not guaranteed to be poplutaed with a location
-/// vaule.
-pub fn into_locationconstraint(relay: &types::Relay) -> Option<LocationConstraint> {
+/// The relay must have a location set.
+pub fn into_constraint(relay: &types::Relay) -> Constraint<LocationConstraint> {
     relay
         .location
         .as_ref()
@@ -521,4 +514,6 @@ pub fn into_locationconstraint(relay: &types::Relay) -> Option<LocationConstrain
             },
         )
         .map(LocationConstraint::Location)
+        .map(Constraint::Only)
+        .expect("relay is missing location")
 }
diff --git a/test/test-manager/src/tests/tunnel.rs b/test/test-manager/src/tests/tunnel.rs
index 99e30b087c..1592f7c2a3 100644
--- a/test/test-manager/src/tests/tunnel.rs
+++ b/test/test-manager/src/tests/tunnel.rs
@@ -1,4 +1,4 @@
-use super::helpers::{self, connect_and_wait, disconnect_and_wait, update_relay_settings};
+use super::helpers::{self, connect_and_wait, disconnect_and_wait, set_relay_settings};
 use super::{Error, TestContext};
 use std::net::IpAddr;
 
@@ -6,8 +6,8 @@ use crate::network_monitor::{start_packet_monitor, MonitorOptions};
 use mullvad_management_interface::{types, ManagementServiceClient};
 use mullvad_types::relay_constraints::{
     BridgeConstraints, BridgeSettings, BridgeState, Constraint, ObfuscationSettings,
-    OpenVpnConstraints, RelayConstraintsUpdate, RelaySettingsUpdate, SelectedObfuscation,
-    TransportPort, Udp2TcpObfuscationSettings, WireguardConstraints,
+    OpenVpnConstraints, RelayConstraints, RelaySettings, SelectedObfuscation, TransportPort,
+    Udp2TcpObfuscationSettings, WireguardConstraints,
 };
 use mullvad_types::wireguard;
 use pnet_packet::ip::IpNextHeaderProtocols;
@@ -48,13 +48,13 @@ pub async fn test_openvpn_tunnel(
     for (protocol, constraint) in CONSTRAINTS {
         log::info!("Connect to {protocol} OpenVPN endpoint");
 
-        let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-            tunnel_protocol: Some(Constraint::Only(TunnelType::OpenVpn)),
-            openvpn_constraints: Some(OpenVpnConstraints { port: constraint }),
+        let relay_settings = RelaySettings::Normal(RelayConstraints {
+            tunnel_protocol: Constraint::Only(TunnelType::OpenVpn),
+            openvpn_constraints: OpenVpnConstraints { port: constraint },
             ..Default::default()
         });
 
-        update_relay_settings(&mut mullvad_client, relay_settings)
+        set_relay_settings(&mut mullvad_client, relay_settings)
             .await
             .expect("failed to update relay settings");
 
@@ -88,16 +88,16 @@ pub async fn test_wireguard_tunnel(
     for (port, should_succeed) in PORTS {
         log::info!("Connect to WireGuard endpoint on port {port}");
 
-        let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-            tunnel_protocol: Some(Constraint::Only(TunnelType::Wireguard)),
-            wireguard_constraints: Some(WireguardConstraints {
+        let relay_settings = RelaySettings::Normal(RelayConstraints {
+            tunnel_protocol: Constraint::Only(TunnelType::Wireguard),
+            wireguard_constraints: WireguardConstraints {
                 port: Constraint::Only(port),
                 ..Default::default()
-            }),
+            },
             ..Default::default()
         });
 
-        update_relay_settings(&mut mullvad_client, relay_settings)
+        set_relay_settings(&mut mullvad_client, relay_settings)
             .await
             .expect("failed to update relay settings");
 
@@ -143,12 +143,12 @@ pub async fn test_udp2tcp_tunnel(
         .await
         .expect("failed to enable udp2tcp");
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-        tunnel_protocol: Some(Constraint::Only(TunnelType::Wireguard)),
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
+        tunnel_protocol: Constraint::Only(TunnelType::Wireguard),
         ..Default::default()
     });
 
-    update_relay_settings(&mut mullvad_client, relay_settings)
+    set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");
 
@@ -230,23 +230,20 @@ pub async fn test_bridge(
     mullvad_client
         .set_bridge_settings(types::BridgeSettings::from(BridgeSettings::Normal(
             BridgeConstraints {
-                location: helpers::into_constraint(&entry).expect(&format!(
-                    "Could not resolve location constraint: {:?}",
-                    entry
-                )),
+                location: helpers::into_constraint(&entry),
                 ..Default::default()
             },
         )))
         .await
         .expect("failed to update bridge settings");
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
         location: helpers::into_constraint(&exit),
-        tunnel_protocol: Some(Constraint::Only(TunnelType::OpenVpn)),
+        tunnel_protocol: Constraint::Only(TunnelType::OpenVpn),
         ..Default::default()
     });
 
-    update_relay_settings(&mut mullvad_client, relay_settings)
+    set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");
 
@@ -312,20 +309,19 @@ pub async fn test_multihop(
     };
     let (entry, exit) = helpers::random_entry_and_exit(&mut mullvad_client, relay_filter).await?;
     let exit_constraint = helpers::into_constraint(&exit);
-    let entry_constraint =
-        helpers::into_constraint(&entry).map(|entry_location| WireguardConstraints {
-            use_multihop: true,
-            entry_location,
-            ..Default::default()
-        });
+    let wireguard_constraints = WireguardConstraints {
+        use_multihop: true,
+        entry_location: helpers::into_constraint(&entry),
+        ..Default::default()
+    };
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
         location: exit_constraint,
-        wireguard_constraints: entry_constraint,
+        wireguard_constraints,
         ..Default::default()
     });
 
-    update_relay_settings(&mut mullvad_client, relay_settings)
+    set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");
 
@@ -381,12 +377,12 @@ pub async fn test_wireguard_autoconnect(
 ) -> Result<(), Error> {
     log::info!("Setting tunnel protocol to WireGuard");
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-        tunnel_protocol: Some(Constraint::Only(TunnelType::Wireguard)),
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
+        tunnel_protocol: Constraint::Only(TunnelType::Wireguard),
         ..Default::default()
     });
 
-    update_relay_settings(&mut mullvad_client, relay_settings)
+    set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");
 
@@ -423,12 +419,12 @@ pub async fn test_openvpn_autoconnect(
 ) -> Result<(), Error> {
     log::info!("Setting tunnel protocol to OpenVPN");
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-        tunnel_protocol: Some(Constraint::Only(TunnelType::OpenVpn)),
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
+        tunnel_protocol: Constraint::Only(TunnelType::OpenVpn),
         ..Default::default()
     });
 
-    update_relay_settings(&mut mullvad_client, relay_settings)
+    set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");
 
@@ -481,11 +477,11 @@ pub async fn test_quantum_resistant_tunnel(
 
     log::info!("Setting tunnel protocol to WireGuard");
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-        tunnel_protocol: Some(Constraint::Only(TunnelType::Wireguard)),
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
+        tunnel_protocol: Constraint::Only(TunnelType::Wireguard),
         ..Default::default()
     });
-    update_relay_settings(&mut mullvad_client, relay_settings)
+    set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("Failed to update relay settings");
 
@@ -564,8 +560,8 @@ pub async fn test_quantum_resistant_multihop_udp2tcp_tunnel(
         .expect("Failed to enable obfuscation");
 
     mullvad_client
-        .update_relay_settings(types::RelaySettingsUpdate::from(
-            RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
+        .set_relay_settings(types::RelaySettings::from(RelaySettings::Normal(
+            RelayConstraints {
                 wireguard_constraints: WireguardConstraints {
                     use_multihop: true,
                     ..Default::default()
@@ -573,8 +569,8 @@ pub async fn test_quantum_resistant_multihop_udp2tcp_tunnel(
                 .into(),
                 tunnel_protocol: Constraint::Only(TunnelType::Wireguard).into(),
                 ..Default::default()
-            }),
-        ))
+            },
+        )))
         .await
         .expect("Failed to update relay settings");
 
diff --git a/test/test-manager/src/tests/tunnel_state.rs b/test/test-manager/src/tests/tunnel_state.rs
index 55b1d2074e..cf0b7f4efe 100644
--- a/test/test-manager/src/tests/tunnel_state.rs
+++ b/test/test-manager/src/tests/tunnel_state.rs
@@ -1,6 +1,6 @@
 use super::helpers::{
     self, connect_and_wait, disconnect_and_wait, get_tunnel_state, send_guest_probes,
-    unreachable_wireguard_tunnel, update_relay_settings, wait_for_tunnel_state,
+    set_relay_settings, unreachable_wireguard_tunnel, wait_for_tunnel_state,
 };
 use super::{ui, Error, TestContext};
 use crate::assert_tunnel_state;
@@ -10,9 +10,7 @@ use mullvad_management_interface::{types, ManagementServiceClient};
 use mullvad_types::relay_constraints::GeographicLocationConstraint;
 use mullvad_types::CustomTunnelEndpoint;
 use mullvad_types::{
-    relay_constraints::{
-        Constraint, LocationConstraint, RelayConstraintsUpdate, RelaySettingsUpdate,
-    },
+    relay_constraints::{Constraint, LocationConstraint, RelayConstraints, RelaySettings},
     states::TunnelState,
 };
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
@@ -88,12 +86,12 @@ pub async fn test_connecting_state(
     log::info!("Verify tunnel state: disconnected");
     assert_tunnel_state!(&mut mullvad_client, TunnelState::Disconnected);
 
-    let relay_settings = RelaySettingsUpdate::CustomTunnelEndpoint(CustomTunnelEndpoint {
+    let relay_settings = RelaySettings::CustomTunnelEndpoint(CustomTunnelEndpoint {
         host: "1.3.3.7".to_owned(),
         config: mullvad_types::ConnectionConfig::Wireguard(unreachable_wireguard_tunnel()),
     });
 
-    update_relay_settings(&mut mullvad_client, relay_settings)
+    set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");
 
@@ -154,15 +152,6 @@ pub async fn test_connecting_state(
 
     disconnect_and_wait(&mut mullvad_client).await?;
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-        location: Some(Constraint::Any),
-        ..Default::default()
-    });
-
-    update_relay_settings(&mut mullvad_client, relay_settings)
-        .await
-        .expect("failed to update relay settings");
-
     Ok(())
 }
 
@@ -188,10 +177,10 @@ pub async fn test_error_state(
 
     log::info!("Enter error state");
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-        location: Some(Constraint::Only(LocationConstraint::Location(
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
+        location: Constraint::Only(LocationConstraint::Location(
             GeographicLocationConstraint::Country("xx".to_string()),
-        ))),
+        )),
         ..Default::default()
     });
 
@@ -200,7 +189,7 @@ pub async fn test_error_state(
         .await
         .expect("failed to disable LAN sharing");
 
-    update_relay_settings(&mut mullvad_client, relay_settings)
+    set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");
 
@@ -244,15 +233,6 @@ pub async fn test_error_state(
 
     disconnect_and_wait(&mut mullvad_client).await?;
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
-        location: Some(Constraint::Any),
-        ..Default::default()
-    });
-
-    update_relay_settings(&mut mullvad_client, relay_settings)
-        .await
-        .expect("failed to update relay settings");
-
     Ok(())
 }
 
@@ -286,12 +266,12 @@ pub async fn test_connected_state(
         .pop()
         .unwrap();
 
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
         location: helpers::into_constraint(&relay),
         ..Default::default()
     });
 
-    update_relay_settings(&mut mullvad_client, relay_settings)
+    set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");
 
diff --git a/test/test-manager/src/tests/ui.rs b/test/test-manager/src/tests/ui.rs
index 1e97430061..91f124338f 100644
--- a/test/test-manager/src/tests/ui.rs
+++ b/test/test-manager/src/tests/ui.rs
@@ -2,7 +2,7 @@ use super::config::TEST_CONFIG;
 use super::helpers;
 use super::{Error, TestContext};
 use mullvad_management_interface::{types, ManagementServiceClient};
-use mullvad_types::relay_constraints::{RelayConstraintsUpdate, RelaySettingsUpdate};
+use mullvad_types::relay_constraints::{RelayConstraints, RelaySettings};
 use std::{
     collections::BTreeMap,
     fmt::Debug,
@@ -95,12 +95,12 @@ pub async fn test_ui_tunnel_settings(
     .unwrap();
 
     // The test expects us to be disconnected and logged in but to have a specific relay selected
-    let relay_settings = RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
+    let relay_settings = RelaySettings::Normal(RelayConstraints {
         location: helpers::into_constraint(&entry),
         ..Default::default()
     });
 
-    helpers::update_relay_settings(&mut mullvad_client, relay_settings)
+    helpers::set_relay_settings(&mut mullvad_client, relay_settings)
         .await
         .expect("failed to update relay settings");