Refactor

mullvad-daemon/src/version_check.rs

@@ -8,6 +8,7 @@ use mullvad_api::{availability::ApiAvailability, rest::MullvadRestHandle, AppVer
 use mullvad_types::version::AppVersionInfo;
 use mullvad_version::Version;
 use serde::{Deserialize, Serialize};
+use std::cmp::Ordering;
 use std::{
     future::Future,
     io,
@@ -554,7 +555,7 @@ fn suggested_upgrade(
         (Some(_), None) => stable_version,
         (None, Some(_)) => beta_version,
         (Some(stable), Some(beta)) => {
-            if beta.is_later_version_than(stable) {
+            if beta.version_ordering(stable) == Ordering::Greater {
                 beta_version
             } else {
                 stable_version
@@ -563,7 +564,7 @@ fn suggested_upgrade(
         (None, None) => None,
     }?;
 
-    if latest_version.is_later_version_than(current_version) {
+    if latest_version.version_ordering(current_version) == Ordering::Greater {
         Some(latest_version.to_string())
     } else {
         None

mullvad-setup/src/main.rs

@@ -1,9 +1,9 @@
 use clap::Parser;
-use std::{path::PathBuf, process, str::FromStr, sync::LazyLock, time::Duration};
-
 use mullvad_api::{proxy::ApiConnectionMode, ApiEndpoint, DEVICE_NOT_FOUND};
 use mullvad_management_interface::MullvadProxyClient;
 use mullvad_version::Version;
+use std::cmp::Ordering;
+use std::{path::PathBuf, process, str::FromStr, sync::LazyLock, time::Duration};
 use talpid_core::firewall::{self, Firewall};
 use talpid_future::retry::{retry_future, ConstantInterval};
 use talpid_types::ErrorExt;
@@ -116,11 +116,13 @@ fn is_older_version(old_version: &str) -> Result<ExitStatus, Error> {
     let parsed_version =
         Version::from_str(old_version).map_err(|_| Error::ParseVersionStringError)?;
 
-    Ok(if APP_VERSION.is_later_version_than(&parsed_version) {
-        ExitStatus::Ok
-    } else {
-        ExitStatus::VersionNotOlder
-    })
+    Ok(
+        if APP_VERSION.version_ordering(&parsed_version) == Ordering::Greater {
+            ExitStatus::Ok
+        } else {
+            ExitStatus::VersionNotOlder
+        },
+    )
 }
 
 async fn prepare_restart() -> Result<(), Error> {

mullvad-version/src/lib.rs

@@ -55,13 +55,17 @@ impl Version {
         }
     }
 
-    /// Returns true if self is a later version than `other`.
+    /// Returns the ordering between two versions. The reason the Ord trait isn't implemented
+    /// is that dev versions are not ordered, so for example 2025.1-dev-fd42ad is equal to
+    /// 2025.1-dev-af23b4 when it comes to the version ordering, but they are not equal when it
+    /// comes to the derived Eq and PartialEq implementations.
+    ///
     /// The following order is used: stable > beta > alpha
     /// If two versions are identical except for one being a dev version
-    /// (ending with the suffix -dev-[SHA]), he dev version is considered greater than
+    /// (ending with the suffix -dev-[SHA]), the dev version is considered greater than
     /// the non-dev version, but if both are dev versions they are considered equal
     /// since the dev version SHA is not ordered.
-    pub fn is_later_version_than(&self, other: &Self) -> bool {
+    pub fn version_ordering(&self, other: &Self) -> Ordering {
         let type_ordering = if self.is_stable() || other.is_stable() {
             match (self.is_stable(), other.is_stable()) {
                 (true, false) => Ordering::Greater,
@@ -89,7 +93,6 @@ impl Version {
             .then(self.incremental.cmp(&other.incremental))
             .then(type_ordering)
             .then(dev_ordering)
-            == Ordering::Greater
     }
 }
 
@@ -180,47 +183,111 @@ mod tests {
     #[test]
     fn test_version_ordering() {
         // Test year comparison
-        assert!(parse("2022.1").is_later_version_than(&parse("2021.1")));
+        assert_eq!(
+            parse("2022.1").version_ordering(&parse("2021.1")),
+            Ordering::Greater
+        );
 
         // Test incremental comparison
-        assert!(parse("2021.2").is_later_version_than(&parse("2021.1")));
+        assert_eq!(
+            parse("2021.2").version_ordering(&parse("2021.1")),
+            Ordering::Greater
+        );
 
         // Test stable vs pre-release
-        assert!(parse("2021.1").is_later_version_than(&parse("2021.1-beta1")));
-        assert!(parse("2021.1").is_later_version_than(&parse("2021.1-alpha1")));
+        assert_eq!(
+            parse("2021.1").version_ordering(&parse("2021.1-beta1")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2021.1").version_ordering(&parse("2021.1-alpha1")),
+            Ordering::Greater
+        );
 
         // Test beta vs alpha
-        assert!(parse("2021.1-beta1").is_later_version_than(&parse("2021.1-alpha1")));
-        assert!(parse("2021.1-beta1").is_later_version_than(&parse("2021.1-alpha2")));
-        assert!(parse("2021.2-alpha1").is_later_version_than(&parse("2021.1-beta2")));
+        assert_eq!(
+            parse("2021.1-beta1").version_ordering(&parse("2021.1-alpha1")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2021.1-beta1").version_ordering(&parse("2021.1-alpha2")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2021.2-alpha1").version_ordering(&parse("2021.1-beta2")),
+            Ordering::Greater
+        );
 
         // Test version numbers within same type
-        assert!(parse("2021.1-beta2").is_later_version_than(&parse("2021.1-beta1")));
-        assert!(parse("2021.1-alpha2").is_later_version_than(&parse("2021.1-alpha1")));
+        assert_eq!(
+            parse("2021.1-beta2").version_ordering(&parse("2021.1-beta1")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2021.1-alpha2").version_ordering(&parse("2021.1-alpha1")),
+            Ordering::Greater
+        );
 
         // Test dev versions
-        assert!(parse("2021.1-dev-abc").is_later_version_than(&parse("2021.1")));
-        assert!(parse("2021.2").is_later_version_than(&parse("2021.1-dev-abc")));
-        assert!(parse("2021.1-dev-abc").is_later_version_than(&parse("2021.1-beta1")));
-        assert!(parse("2021.1-dev-abc").is_later_version_than(&parse("2021.1-alpha1")));
-        assert!(parse("2025.1-dev-abc").is_later_version_than(&parse("2025.1-beta1-dev-abc")));
-        assert!(parse("2025.1-dev-abc").is_later_version_than(&parse("2025.1-beta2-dev-abc")));
-        assert!(parse("2025.1-dev-abc").is_later_version_than(&parse("2025.1-alpha2-dev-abc")));
-        assert!(
-            parse("2025.1-beta1-dev-abc").is_later_version_than(&parse("2025.1-alpha7-dev-abc"))
+        assert_eq!(
+            parse("2021.1-dev-abc").version_ordering(&parse("2021.1")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2021.2").version_ordering(&parse("2021.1-dev-abc")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2021.1-dev-abc").version_ordering(&parse("2021.1-beta1")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2021.1-dev-abc").version_ordering(&parse("2021.1-alpha1")),
+            Ordering::Greater
         );
-        assert!(
-            parse("2025.2-alpha1-dev-abc").is_later_version_than(&parse("2025.1-beta7-dev-abc"))
+        assert_eq!(
+            parse("2025.1-dev-abc").version_ordering(&parse("2025.1-beta1-dev-abc")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2025.1-dev-abc").version_ordering(&parse("2025.1-beta2-dev-abc")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2025.1-dev-abc").version_ordering(&parse("2025.1-alpha2-dev-abc")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2025.1-beta1-dev-abc").version_ordering(&parse("2025.1-alpha7-dev-abc")),
+            Ordering::Greater
+        );
+        assert_eq!(
+            parse("2025.2-alpha1-dev-abc").version_ordering(&parse("2025.1-beta7-dev-abc")),
+            Ordering::Greater
         );
 
         // Test equal versions
         assert_eq!(parse("2021.1"), parse("2021.1"));
         assert_eq!(parse("2021.1-beta1"), parse("2021.1-beta1"));
         assert_eq!(parse("2021.1-dev-abc123"), parse("2021.1-dev-abc123"));
+        assert_ne!(parse("2021.1-dev-abc123"), parse("2021.1-dev-def123"));
 
-        assert!(!parse("2021.1").is_later_version_than(&parse("2021.1")));
-        assert!(!parse("2021.1-beta1").is_later_version_than(&parse("2021.1-beta1")));
-        assert!(!parse("2021.1-dev-abc123").is_later_version_than(&parse("2021.1-dev-abc123")));
+        assert_eq!(
+            parse("2021.1").version_ordering(&parse("2021.1")),
+            Ordering::Equal
+        );
+        assert_eq!(
+            parse("2021.1-beta1").version_ordering(&parse("2021.1-beta1")),
+            Ordering::Equal
+        );
+        assert_eq!(
+            parse("2021.1-dev-abc123").version_ordering(&parse("2021.1-dev-abc123")),
+            Ordering::Equal
+        );
+        assert_eq!(
+            parse("2021.1-dev-abc123").version_ordering(&parse("2021.1-dev-abc123")),
+            Ordering::Equal
+        );
     }
 
     #[test]

mullvad-version/src/main.rs

@@ -75,11 +75,11 @@ fn to_android_version_code(version: &str) -> String {
         }
     };
 
-    let decade_and_year = version.year % 100;
+    let year_last_two_digits = version.year % 100;
 
     format!(
         "{}{:0>2}{}{:0>3}",
-        decade_and_year, version.incremental, build_type, build_number,
+        year_last_two_digits, version.incremental, build_type, build_number,
     )
 }