Remove "Any" tunnel protocol from query builder

Author: Serock3

mullvad-relay-selector/src/relay_selector/mod.rs

@@ -62,21 +62,19 @@ pub static WIREGUARD_RETRY_ORDER: LazyLock<Vec<RelayQuery>> = LazyLock::new(|| {
     use query::builder::{IpVersion, RelayQueryBuilder};
     vec![
         // 1 This works with any wireguard relay
-        RelayQueryBuilder::new().wireguard().build(),
+        RelayQueryBuilder::wireguard().build(),
         // 2
-        RelayQueryBuilder::new().wireguard().port(443).build(),
+        RelayQueryBuilder::wireguard().port(443).build(),
         // 3
-        RelayQueryBuilder::new()
-            .wireguard()
+        RelayQueryBuilder::wireguard()
             .ip_version(IpVersion::V6)
             .build(),
         // 4
-        RelayQueryBuilder::new().wireguard().shadowsocks().build(),
+        RelayQueryBuilder::wireguard().shadowsocks().build(),
         // 5
-        RelayQueryBuilder::new().wireguard().udp2tcp().build(),
+        RelayQueryBuilder::wireguard().udp2tcp().build(),
         // 6
-        RelayQueryBuilder::new()
-            .wireguard()
+        RelayQueryBuilder::wireguard()
             .udp2tcp()
             .ip_version(IpVersion::V6)
             .build(),
@@ -92,16 +90,14 @@ pub static OPENVPN_RETRY_ORDER: LazyLock<Vec<RelayQuery>> = LazyLock::new(|| {
     use query::builder::RelayQueryBuilder;
     vec![
         // 1 (openvpn) This works with any openvpn relay
-        RelayQueryBuilder::new().openvpn().build(),
+        RelayQueryBuilder::openvpn().build(),
         // 2
-        RelayQueryBuilder::new()
-            .openvpn()
+        RelayQueryBuilder::openvpn()
             .transport_protocol(TransportProtocol::Tcp)
             .port(443)
             .build(),
         // 3
-        RelayQueryBuilder::new()
-            .openvpn()
+        RelayQueryBuilder::openvpn()
             .transport_protocol(TransportProtocol::Tcp)
             .bridge()
             .build(),

mullvad-relay-selector/src/relay_selector/query.rs

@@ -63,8 +63,7 @@ use talpid_types::net::{proxy::CustomProxy, IpVersion, TunnelType};
 /// use mullvad_relay_selector::query::builder::RelayQueryBuilder;
 /// use mullvad_relay_selector::query::builder::{Ownership, GeographicLocationConstraint};
 ///
-/// let query: RelayQuery = RelayQueryBuilder::new()
-///     .wireguard()                                            // Specify the tunnel protocol
+/// let query: RelayQuery = RelayQueryBuilder::wireguard()      // Specify the tunnel protocol
 ///     .location(GeographicLocationConstraint::country("no"))  // Specify the country as Norway
 ///     .ownership(Ownership::MullvadOwned)                     // Specify that the relay must be owned by Mullvad
 ///     .port(443)                                              // Specify the port to use when connecting to the relay
@@ -570,52 +569,44 @@ pub mod builder {
     }
 
     impl RelayQueryBuilder<Any> {
-        /// Create a new [`RelayQueryBuilder`] with unopinionated defaults.
+        /// Create a new [`RelayQueryBuilder`] for Wireguard.
         ///
         /// Call [`Self::build`] to convert the builder into a [`RelayQuery`],
         /// which is used to guide the [`RelaySelector`]
         ///
         /// [`RelaySelector`]: crate::RelaySelector
-        pub fn new() -> RelayQueryBuilder<Any> {
-            RelayQueryBuilder {
-                query: RelayQuery::default(),
-                protocol: Any,
-            }
-        }
-        /// Set the VPN protocol for this [`RelayQueryBuilder`] to Wireguard.
-        pub fn wireguard(mut self) -> RelayQueryBuilder<Wireguard<Any, Any, Any, Any>> {
+        pub fn wireguard() -> RelayQueryBuilder<Wireguard<Any, Any, Any, Any>> {
             let protocol = Wireguard {
                 multihop: Any,
                 obfuscation: Any,
                 daita: Any,
                 quantum_resistant: Any,
             };
-            self.query.tunnel_protocol = TunnelType::Wireguard;
+            let query = RelayQuery {
+                tunnel_protocol: TunnelType::Wireguard,
+                ..Default::default()
+            };
             // Update the type state
-            RelayQueryBuilder {
-                query: self.query,
-                protocol,
-            }
+            RelayQueryBuilder { query, protocol }
         }
 
-        /// Set the VPN protocol for this [`RelayQueryBuilder`] to OpenVPN.
-        pub fn openvpn(mut self) -> RelayQueryBuilder<OpenVPN<Any, Any>> {
+        /// Create a new [`RelayQueryBuilder`] for OpenVPN.
+        ///
+        /// Call [`Self::build`] to convert the builder into a [`RelayQuery`],
+        /// which is used to guide the [`RelaySelector`]
+        ///
+        /// [`RelaySelector`]: crate::RelaySelector
+        pub fn openvpn() -> RelayQueryBuilder<OpenVPN<Any, Any>> {
             let protocol = OpenVPN {
                 transport_port: Any,
                 bridge_settings: Any,
             };
-            self.query.tunnel_protocol = TunnelType::OpenVpn;
+            let query = RelayQuery {
+                tunnel_protocol: TunnelType::OpenVpn,
+                ..Default::default()
+            };
             // Update the type state
-            RelayQueryBuilder {
-                query: self.query,
-                protocol,
-            }
-        }
-    }
-
-    impl Default for RelayQueryBuilder<Any> {
-        fn default() -> Self {
-            Self::new()
+            RelayQueryBuilder { query, protocol }
         }
     }
 
@@ -1061,7 +1052,7 @@ mod test {
     /// DAITA is a core privacy feature.
     #[test]
     fn test_relay_query_daita_openvpn() {
-        let mut query = RelayQueryBuilder::new().wireguard().daita().build();
+        let mut query = RelayQueryBuilder::wireguard().daita().build();
         query
             .set_tunnel_protocol(TunnelType::OpenVpn)
             .expect_err("expected query to be invalid for OpenVPN");
@@ -1071,7 +1062,7 @@ mod test {
     /// Multihop is a core privacy feature.
     #[test]
     fn test_relay_query_multihop_openvpn() {
-        let mut query = RelayQueryBuilder::new().wireguard().multihop().build();
+        let mut query = RelayQueryBuilder::wireguard().multihop().build();
         query
             .set_tunnel_protocol(TunnelType::OpenVpn)
             .expect_err("expected query to be invalid for OpenVPN");
@@ -1081,10 +1072,7 @@ mod test {
     /// PQ is a core privacy feature.
     #[test]
     fn test_relay_query_quantum_resistant_openvpn() {
-        let mut query = RelayQueryBuilder::new()
-            .wireguard()
-            .quantum_resistant()
-            .build();
+        let mut query = RelayQueryBuilder::wireguard().quantum_resistant().build();
         query
             .set_tunnel_protocol(TunnelType::OpenVpn)
             .expect_err("expected query to be invalid for OpenVPN");