chore(shim): add config detection tests and logging

crates/turborepo-lib/fixtures/local_config/turbo.v1.json

@@ -0,0 +1,6 @@
+{
+ // some comments
+ "pipeline": {
+   "build": {"dependsOn": ["^build"]}
+ }
+}

crates/turborepo-lib/fixtures/local_config/turbo.v2.json

@@ -0,0 +1,6 @@
+{
+ // some comments
+ "tasks": {
+   "build": {"dependsOn": ["^build"]}
+ }
+}

crates/turborepo-lib/src/shim/local_turbo_config.rs

@@ -4,12 +4,14 @@ use jsonc_parser::{
     ast::{ObjectPropName, Value},
     parse_to_ast,
 };
+use tracing::debug;
 use turborepo_repository::{inference::RepoState, package_manager::PackageManager};
 
 const TURBO_DOWNLOAD_LOCAL_DISABLED: &str = "TURBO_DOWNLOAD_LOCAL_DISABLED";
 
 /// Struct containing information about the desired local turbo version
 /// according to lockfiles, package.jsons, and if all else fails turbo.json
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct LocalTurboConfig {
     turbo_version: String,
 }
@@ -20,11 +22,21 @@ impl LocalTurboConfig {
         if env::var(TURBO_DOWNLOAD_LOCAL_DISABLED)
             .map_or(false, |disable| matches!(disable.as_str(), "1" | "true"))
         {
+            debug!("downloading correct local version disabled");
             return None;
         }
         let turbo_version = Self::turbo_version_from_lockfile(repo_state)
-            .or_else(|| Self::turbo_version_from_package_json(repo_state))
-            .or_else(|| Self::turbo_version_from_turbo_json_schema(repo_state))?;
+            .or_else(|| {
+                debug!(
+                    "No turbo version found in a lockfile. Attempting to read version from root \
+                     package.json"
+                );
+                Self::turbo_version_from_package_json(repo_state)
+            })
+            .or_else(|| {
+                debug!("No turbo version found in package.json. Checking if turbo.json is for v1");
+                Self::turbo_version_from_turbo_json_schema(repo_state)
+            })?;
         Some(Self { turbo_version })
     }
 
@@ -90,3 +102,168 @@ impl LocalTurboConfig {
         None
     }
 }
+
+#[cfg(test)]
+mod test {
+    use tempfile::TempDir;
+    use turbopath::AbsoluteSystemPath;
+    use turborepo_repository::{
+        inference::RepoMode, package_json::PackageJson, package_manager::Error,
+    };
+
+    use super::*;
+
+    #[test]
+    fn test_package_manager_and_lockfile() {
+        let tmpdir = TempDir::with_prefix("local_config").unwrap();
+        let root = AbsoluteSystemPath::from_std_path(tmpdir.path()).unwrap();
+        let repo = RepoState {
+            root: root.to_owned(),
+            mode: RepoMode::MultiPackage,
+            root_package_json: PackageJson::default(),
+            package_manager: Ok(PackageManager::Npm),
+        };
+        let lockfile = root.join_component("package-lock.json");
+        lockfile
+            .create_with_contents(include_bytes!(
+                "../../fixtures/local_config/turbov2.package-lock.json"
+            ))
+            .unwrap();
+
+        assert_eq!(
+            LocalTurboConfig::infer(&repo),
+            Some(LocalTurboConfig {
+                turbo_version: "2.0.3".into()
+            })
+        );
+    }
+
+    #[test]
+    fn test_just_lockfile() {
+        let tmpdir = TempDir::with_prefix("local_config").unwrap();
+        let root = AbsoluteSystemPath::from_std_path(tmpdir.path()).unwrap();
+        let repo = RepoState {
+            root: root.to_owned(),
+            mode: RepoMode::MultiPackage,
+            root_package_json: PackageJson::default(),
+            package_manager: Err(Error::MissingPackageManager),
+        };
+        let lockfile = root.join_component("package-lock.json");
+        lockfile
+            .create_with_contents(include_bytes!(
+                "../../fixtures/local_config/turbov2.package-lock.json"
+            ))
+            .unwrap();
+
+        assert_eq!(
+            LocalTurboConfig::infer(&repo),
+            Some(LocalTurboConfig {
+                turbo_version: "2.0.3".into()
+            })
+        );
+    }
+
+    #[test]
+    fn test_package_json_dep() {
+        let tmpdir = TempDir::with_prefix("local_config").unwrap();
+        let root = AbsoluteSystemPath::from_std_path(tmpdir.path()).unwrap();
+        let repo = RepoState {
+            root: root.to_owned(),
+            mode: RepoMode::MultiPackage,
+            root_package_json: PackageJson {
+                dependencies: Some(
+                    vec![("turbo".into(), "^2.0.0".into())]
+                        .into_iter()
+                        .collect(),
+                ),
+                ..Default::default()
+            },
+            package_manager: Err(Error::MissingPackageManager),
+        };
+
+        assert_eq!(
+            LocalTurboConfig::infer(&repo),
+            Some(LocalTurboConfig {
+                turbo_version: "^2.0.0".into()
+            })
+        );
+    }
+
+    #[test]
+    fn test_package_json_dev_dep() {
+        let tmpdir = TempDir::with_prefix("local_config").unwrap();
+        let root = AbsoluteSystemPath::from_std_path(tmpdir.path()).unwrap();
+        let repo = RepoState {
+            root: root.to_owned(),
+            mode: RepoMode::MultiPackage,
+            root_package_json: PackageJson {
+                dev_dependencies: Some(
+                    vec![("turbo".into(), "^2.0.0".into())]
+                        .into_iter()
+                        .collect(),
+                ),
+                ..Default::default()
+            },
+            package_manager: Err(Error::MissingPackageManager),
+        };
+
+        assert_eq!(
+            LocalTurboConfig::infer(&repo),
+            Some(LocalTurboConfig {
+                turbo_version: "^2.0.0".into()
+            })
+        );
+    }
+
+    #[test]
+    fn test_v1_schema() {
+        let tmpdir = TempDir::with_prefix("local_config").unwrap();
+        let root = AbsoluteSystemPath::from_std_path(tmpdir.path()).unwrap();
+        let repo = RepoState {
+            root: root.to_owned(),
+            mode: RepoMode::MultiPackage,
+            root_package_json: PackageJson::default(),
+            package_manager: Err(Error::MissingPackageManager),
+        };
+        let turbo_json = root.join_component("turbo.json");
+        turbo_json
+            .create_with_contents(include_bytes!("../../fixtures/local_config/turbo.v1.json"))
+            .unwrap();
+        assert_eq!(
+            LocalTurboConfig::infer(&repo),
+            Some(LocalTurboConfig {
+                turbo_version: "^1".into()
+            })
+        );
+    }
+
+    #[test]
+    fn test_v2_schema() {
+        let tmpdir = TempDir::with_prefix("local_config").unwrap();
+        let root = AbsoluteSystemPath::from_std_path(tmpdir.path()).unwrap();
+        let repo = RepoState {
+            root: root.to_owned(),
+            mode: RepoMode::MultiPackage,
+            root_package_json: PackageJson::default(),
+            package_manager: Err(Error::MissingPackageManager),
+        };
+        let turbo_json = root.join_component("turbo.json");
+        turbo_json
+            .create_with_contents(include_bytes!("../../fixtures/local_config/turbo.v2.json"))
+            .unwrap();
+        assert_eq!(LocalTurboConfig::infer(&repo), None,);
+    }
+
+    #[test]
+    fn nothing() {
+        let tmpdir = TempDir::with_prefix("local_config").unwrap();
+        let root = AbsoluteSystemPath::from_std_path(tmpdir.path()).unwrap();
+        let repo = RepoState {
+            root: root.to_owned(),
+            mode: RepoMode::MultiPackage,
+            root_package_json: PackageJson::default(),
+            package_manager: Err(Error::MissingPackageManager),
+        };
+        assert_eq!(LocalTurboConfig::infer(&repo), None,);
+    }
+}

crates/turborepo-lib/src/shim/mod.rs

@@ -88,6 +88,10 @@ fn run_correct_turbo(
             spawn_local_turbo(&repo_state, turbo_state, shim_args)
         }
     } else if let Some(local_config) = LocalTurboConfig::infer(&repo_state) {
+        debug!(
+            "Found configuration for turbo version {}",
+            local_config.turbo_version()
+        );
         spawn_npx_turbo(&repo_state, local_config.turbo_version(), shim_args)
     } else {
         let version = get_version();