check: add tests

Author: NotAShelf

src/check.rs

@@ -1,4 +1,6 @@
 use std::cmp::Ordering;
+use std::env;
+use std::sync::Mutex;
 
 use color_eyre::{eyre, Result};
 use semver::Version;
@@ -14,9 +16,29 @@ pub fn check_nix_version() -> Result<()> {
     let version = util::get_nix_version()?;
     let is_lix_binary = util::is_lix()?;
 
+    // XXX: Both Nix and Lix follow semantic versioning (semver). Update the
+    // versions below once latest stable for either of those packages change.
+    // TODO: Set up a CI to automatically update those in the future.
+    const MIN_LIX_VERSION: &str = "2.91.1";
+    const MIN_NIX_VERSION: &str = "2.24.14";
+
     // Minimum supported versions. Those should generally correspond to
-    // latest package versions in the stable branch
-    let min_version = if is_lix_binary { "2.91.1" } else { "2.26.1" };
+    // latest package versions in the stable branch.
+    //
+    // Q: Why are you doing this?
+    // A: First of all to make sure we do not make baseless assumptions
+    // about the user's system; we should only work around APIs that we
+    // are fully aware of, and not try to work around every edge case.
+    // Also, nh should be responsible for nudging the user to use the
+    // relevant versions of the software it wraps, so that we do not have
+    // to try and support too many versions. NixOS stable and unstable
+    // will ALWAYS be supported, but outdated versions will not. If your
+    // Nix fork uses a different versioning scheme, please open an issue.
+    let min_version = if is_lix_binary {
+        MIN_LIX_VERSION
+    } else {
+        MIN_NIX_VERSION
+    };
 
     let current = Version::parse(&version)?;
     let required = Version::parse(min_version)?;
@@ -85,7 +107,9 @@ pub fn setup_environment() -> Result<bool> {
     Ok(do_warn)
 }
 
-/// Runs all necessary checks for Nix functionality
+/// Consolidate all necessary checks for Nix functionality into a single function. This
+/// will be executed in the main function, but can be executed before critical commands
+/// to double-check if necessary.
 ///
 /// # Returns
 ///
@@ -95,3 +119,160 @@ pub fn verify_nix_environment() -> Result<()> {
     check_nix_features()?;
     Ok(())
 }
+
+// Environment variables are global state, so tests need to be run sequentially.
+// Using a mutex to ensure that env var manipulation in one test doesn't affect others.
+// Alternatively, run tests with `cargo test -- --test-threads=1`
+#[allow(dead_code)] // suppress 'false' positives
+static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+// Clean up environment variables set during tests
+#[allow(dead_code)]
+fn cleanup_env_vars() {
+    env::remove_var("FLAKE");
+    env::remove_var("NH_FLAKE");
+    env::remove_var("NH_OS_FLAKE");
+    env::remove_var("NH_HOME_FLAKE");
+    env::remove_var("NH_DARWIN_FLAKE");
+}
+
+#[test]
+fn test_setup_environment_no_flake_set() -> Result<()> {
+    let _lock = ENV_LOCK.lock().unwrap();
+    cleanup_env_vars();
+
+    let should_warn = setup_environment()?;
+    assert!(!should_warn, "Should not warn when FLAKE is not set");
+    assert!(env::var("NH_FLAKE").is_err(), "NH_FLAKE should not be set");
+
+    cleanup_env_vars();
+    Ok(())
+}
+
+#[test]
+fn test_setup_environment_flake_set_no_nh_flake_no_specifics() -> Result<()> {
+    let _lock = ENV_LOCK.lock().unwrap();
+    cleanup_env_vars();
+
+    env::set_var("FLAKE", "test_flake_path");
+    let should_warn = setup_environment()?;
+
+    assert!(
+        should_warn,
+        "Should warn when FLAKE is set, NH_FLAKE is not, and no specific NH_*_FLAKE vars are set"
+    );
+    assert_eq!(
+        env::var("NH_FLAKE").unwrap(),
+        "test_flake_path",
+        "NH_FLAKE should be set from FLAKE"
+    );
+
+    cleanup_env_vars();
+    Ok(())
+}
+
+#[test]
+fn test_setup_environment_flake_set_nh_flake_already_set() -> Result<()> {
+    let _lock = ENV_LOCK.lock().unwrap();
+    cleanup_env_vars();
+
+    env::set_var("FLAKE", "test_flake_path");
+    env::set_var("NH_FLAKE", "existing_nh_flake_path");
+    let should_warn = setup_environment()?;
+
+    assert!(!should_warn, "Should not warn when NH_FLAKE is already set");
+    assert_eq!(
+        env::var("NH_FLAKE").unwrap(),
+        "existing_nh_flake_path",
+        "NH_FLAKE should retain its original value"
+    );
+
+    cleanup_env_vars();
+    Ok(())
+}
+
+#[test]
+fn test_setup_environment_flake_set_no_nh_flake_nh_os_flake_set() -> Result<()> {
+    let _lock = ENV_LOCK.lock().unwrap();
+    cleanup_env_vars();
+
+    env::set_var("FLAKE", "test_flake_path");
+    env::set_var("NH_OS_FLAKE", "os_specific_flake");
+    let should_warn = setup_environment()?;
+
+    assert!(
+        !should_warn,
+        "Should not warn when FLAKE is set, NH_FLAKE is not, but NH_OS_FLAKE is set"
+    );
+    assert_eq!(
+        env::var("NH_FLAKE").unwrap(),
+        "test_flake_path",
+        "NH_FLAKE should be set from FLAKE"
+    );
+    assert_eq!(
+        env::var("NH_OS_FLAKE").unwrap(),
+        "os_specific_flake",
+        "NH_OS_FLAKE should remain set"
+    );
+
+    cleanup_env_vars();
+    Ok(())
+}
+
+#[test]
+fn test_setup_environment_flake_set_no_nh_flake_nh_home_flake_set() -> Result<()> {
+    let _lock = ENV_LOCK.lock().unwrap();
+    cleanup_env_vars();
+
+    env::set_var("FLAKE", "test_flake_path");
+    env::set_var("NH_HOME_FLAKE", "home_specific_flake");
+    let should_warn = setup_environment()?;
+
+    assert!(
+        !should_warn,
+        "Should not warn when FLAKE is set, NH_FLAKE is not, but NH_HOME_FLAKE is set"
+    );
+    assert_eq!(
+        env::var("NH_FLAKE").unwrap(),
+        "test_flake_path",
+        "NH_FLAKE should be set from FLAKE"
+    );
+    assert_eq!(
+        env::var("NH_HOME_FLAKE").unwrap(),
+        "home_specific_flake",
+        "NH_HOME_FLAKE should remain set"
+    );
+
+    cleanup_env_vars();
+    Ok(())
+}
+
+#[test]
+// Greatest function name ever.
+// testSetupEnvironmentFlakeSetNoNhFlakeNhDarwinFlakeSetAbstractFactoryBuilder
+fn test_setup_environment_flake_set_no_nh_flake_nh_darwin_flake_set() -> Result<()> {
+    let _lock = ENV_LOCK.lock().unwrap();
+    cleanup_env_vars();
+
+    env::set_var("FLAKE", "test_flake_path");
+    env::set_var("NH_DARWIN_FLAKE", "darwin_specific_flake");
+    let should_warn = setup_environment()?;
+
+    assert!(
+        !should_warn,
+        "Should not warn when FLAKE is set, NH_FLAKE is not, but NH_DARWIN_FLAKE is set"
+    );
+    assert_eq!(
+        env::var("NH_FLAKE").unwrap(),
+        "test_flake_path",
+        "NH_FLAKE should be set from FLAKE"
+    );
+    assert_eq!(
+        env::var("NH_DARWIN_FLAKE").unwrap(),
+        "darwin_specific_flake",
+        "NH_DARWIN_FLAKE should remain set"
+    );
+
+    cleanup_env_vars(); // Clean up after test
+    Ok(())
+}