Add tests.

crates/core/Cargo.toml

@@ -34,3 +34,4 @@ url = "2.4.1"
 
 [dev-dependencies]
 starbase_sandbox = { workspace = true }
+tokio = { workspace = true }

crates/core/src/version_detector.rs

@@ -6,7 +6,7 @@ use std::{env, path::Path};
 use tracing::{debug, trace};
 use version_spec::*;
 
-async fn detect_version_first_available(
+pub async fn detect_version_first_available(
     tool: &Tool,
     start_dir: &Path,
     end_dir: &Path,
@@ -53,7 +53,7 @@ async fn detect_version_first_available(
     Ok(None)
 }
 
-async fn detect_version_prefer_prototools(
+pub async fn detect_version_prefer_prototools(
     tool: &Tool,
     start_dir: &Path,
     end_dir: &Path,

crates/core/tests/user_config_test.rs

@@ -1,4 +1,4 @@
-use proto_core::{PinType, UserConfig, USER_CONFIG_NAME};
+use proto_core::{DetectStrategy, PinType, UserConfig, USER_CONFIG_NAME};
 use starbase_sandbox::create_empty_sandbox;
 use std::collections::BTreeMap;
 use std::env;
@@ -17,6 +17,7 @@ mod user_config {
             UserConfig {
                 auto_clean: false,
                 auto_install: false,
+                detect_strategy: DetectStrategy::default(),
                 node_intercept_globals: true,
                 http: HttpOptions::default(),
                 pin_latest: None,
@@ -46,6 +47,7 @@ pin-latest = "global"
             UserConfig {
                 auto_clean: true,
                 auto_install: true,
+                detect_strategy: DetectStrategy::default(),
                 node_intercept_globals: false,
                 http: HttpOptions::default(),
                 pin_latest: Some(PinType::Global),
@@ -71,6 +73,7 @@ pin-latest = "global"
             UserConfig {
                 auto_clean: true,
                 auto_install: true,
+                detect_strategy: DetectStrategy::default(),
                 node_intercept_globals: false,
                 http: HttpOptions::default(),
                 pin_latest: None,

crates/core/tests/version_detector_test.rs

@@ -0,0 +1,103 @@
+use proto_core::{
+    detect_version_first_available, detect_version_prefer_prototools, load_tool_from_locator,
+    ProtoEnvironment, Tool, ToolsConfig, UnresolvedVersionSpec, UserConfig,
+};
+use starbase_sandbox::create_empty_sandbox;
+use std::path::Path;
+use warpgate::Id;
+
+mod version_detector {
+    use super::*;
+
+    async fn create_node(_root: &Path) -> Tool {
+        load_tool_from_locator(
+            Id::raw("node"),
+            ProtoEnvironment::new().unwrap(),
+            ToolsConfig::builtin_plugins().get("node").unwrap(),
+            &UserConfig::default(),
+        )
+        .await
+        .unwrap()
+    }
+
+    #[tokio::test]
+    async fn uses_deepest_prototools() {
+        let sandbox = create_empty_sandbox();
+        sandbox.create_file("a/.prototools", "node = \"20\"");
+        sandbox.create_file("a/b/.prototools", "node = \"18\"");
+        sandbox.create_file("a/b/c/.prototools", "node = \"16\"");
+
+        let tool = create_node(sandbox.path()).await;
+
+        assert_eq!(
+            detect_version_first_available(&tool, &sandbox.path().join("a/b/c"), sandbox.path())
+                .await
+                .unwrap(),
+            Some(UnresolvedVersionSpec::parse("~16").unwrap())
+        );
+
+        assert_eq!(
+            detect_version_first_available(&tool, &sandbox.path().join("a/b"), sandbox.path())
+                .await
+                .unwrap(),
+            Some(UnresolvedVersionSpec::parse("~18").unwrap())
+        );
+
+        assert_eq!(
+            detect_version_first_available(&tool, &sandbox.path().join("a"), sandbox.path())
+                .await
+                .unwrap(),
+            Some(UnresolvedVersionSpec::parse("~20").unwrap())
+        );
+    }
+
+    #[tokio::test]
+    async fn finds_first_available_prototools() {
+        let sandbox = create_empty_sandbox();
+        sandbox.create_file("a/.prototools", "node = \"20\"");
+        sandbox.create_file("package.json", r#"{ "engines": { "node": "18" } }"#);
+
+        let tool = create_node(sandbox.path()).await;
+
+        assert_eq!(
+            detect_version_first_available(&tool, &sandbox.path().join("a/b"), sandbox.path())
+                .await
+                .unwrap(),
+            Some(UnresolvedVersionSpec::parse("~20").unwrap())
+        );
+    }
+
+    #[tokio::test]
+    async fn finds_first_available_ecosystem() {
+        let sandbox = create_empty_sandbox();
+        sandbox.create_file(".prototools", "node = \"20\"");
+        sandbox.create_file("a/package.json", r#"{ "engines": { "node": "18" } }"#);
+
+        let tool = create_node(sandbox.path()).await;
+
+        assert_eq!(
+            detect_version_first_available(&tool, &sandbox.path().join("a/b"), sandbox.path())
+                .await
+                .unwrap(),
+            Some(UnresolvedVersionSpec::parse("~18").unwrap())
+        );
+    }
+
+    #[tokio::test]
+    async fn prefers_prototools() {
+        let sandbox = create_empty_sandbox();
+        sandbox.create_file("a/.prototools", "node = \"20\"");
+        sandbox.create_file("a/b/.prototools", "node = \"18\"");
+        sandbox.create_file("a/b/package.json", r#"{ "engines": { "node": "17" } }"#);
+        sandbox.create_file("a/b/c/package.json", r#"{ "engines": { "node": "19" } }"#);
+
+        let tool = create_node(sandbox.path()).await;
+
+        assert_eq!(
+            detect_version_prefer_prototools(&tool, &sandbox.path().join("a/b/c"), sandbox.path())
+                .await
+                .unwrap(),
+            Some(UnresolvedVersionSpec::parse("~18").unwrap())
+        );
+    }
+}