tmp

Author: ethowitz

Cargo.lock

@@ -19,6 +19,11 @@ tracing = "0.1.41"
 tracing-appender = "0.2.3"
 tracing-subscriber = { version = "0.3.20", features = ["json"] }
 
+[dev-dependencies]
+cargo-test-macro = "0.4.5"
+cargo-test-support = "=0.8.0" # Pinned to avoid pulling in breaking changes
+snapbox = "0.6.21"
+
 [target.'cfg(not(target_os = "windows"))'.dependencies]
 pprof = { version = "0.15.0", features = ["flamegraph"] }
 

Cargo.toml

@@ -8,6 +8,7 @@ use crate::{
     util::{FilePath, FilePathBuf},
 };
 
+#[derive(Debug)]
 pub struct CrateGraph {
     pub inner: HashMap<PackageId, PackageNode>,
 }
@@ -227,7 +228,7 @@ impl CrateGraph {
 }
 
 /// Represents one target of a single package
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct PackageNode {
     pub name: String,
     pub targets: Vec<Target>,
@@ -241,13 +242,13 @@ pub struct PackageNode {
     pub proc_macro_dylib: Option<FilePathBuf>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Dependency {
     pub id: PackageId,
     pub name: String,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Target {
     pub name: String,
     pub edition: Edition,

src/graph.rs

@@ -1,7 +1,7 @@
 pub mod cli;
-mod discover;
-mod graph;
-mod rust_project;
+pub mod discover;
+pub mod graph;
+pub mod rust_project;
 pub mod util;
 
 use std::path::PathBuf;

src/lib.rs

@@ -0,0 +1,307 @@
+mod utils;
+
+use cargo_subspace::graph::Dependency;
+use utils::prelude::*;
+
+use crate::utils::{DiscoverRunnerExt, bin, discover, discover_path_builder, lib, workspace};
+
+// TEST STRATEGY
+// - Snapshot testing (output doesn't change and is in expected format)
+// - want to be able to inspect crate graph
+//
+// need to test
+// - output format is expected (snapshot testing)
+// - inspect crate graph for specific inputs
+// - (stretch) RA returns correct diagnostics for specific inputs
+//
+// TODOS
+// - make CARGO_HOME dynamic based on home (or something)
+// - move move functionality into lib crate with public functions for discover_path,
+// discover_buildfile that return pruned DepGraph
+
+#[cargo_test]
+fn standalone_crate() {
+    let p = bin("foo")
+        .file(
+            "src/main.rs",
+            stringify! {
+                fn main() {
+                    println!("hi!");
+                }
+            },
+        )
+        .build();
+
+    let crate_graph = discover(p.file("Cargo.toml"));
+
+    assert_eq!(crate_graph.len(), 1);
+
+    crate_graph.get(&p);
+}
+
+#[cargo_test]
+fn test_workspace_with_independent_members() {
+    let bar = lib("bar");
+    let foo = lib("foo");
+    let w = workspace().member(foo).member(bar).build();
+
+    let crate_graph = discover(w.file("bar/Cargo.toml"));
+
+    // We only ran discover on bar, so foo should not be in the graph
+    assert_eq!(crate_graph.len(), 1);
+
+    let bar = w.member("bar");
+    let pkg = crate_graph.get(bar);
+    assert!(pkg.dependencies.is_empty());
+
+    let crate_graph = discover(w.file("foo/Cargo.toml"));
+
+    // We only ran discover on foo, so bar should not be in the graph
+    assert_eq!(crate_graph.graph.inner.len(), 1);
+
+    let foo = w.member("foo");
+    let pkg = crate_graph.get(foo);
+    assert!(pkg.dependencies.is_empty());
+}
+
+#[cargo_test]
+fn test_workspace_with_dependent_members() {
+    // foo --> bar
+    let bar = lib("bar");
+    let foo = lib("foo").path_dependency(&bar);
+    let w = workspace().member(foo).member(bar).build();
+
+    let crate_graph = discover(w.file("bar/Cargo.toml"));
+
+    // We only ran discover on bar, so foo should not be in the graph
+    assert_eq!(crate_graph.len(), 1);
+
+    let bar = w.member("bar");
+    let pkg = crate_graph.get(bar);
+    assert!(pkg.dependencies.is_empty());
+
+    let crate_graph = discover(w.file("foo/Cargo.toml"));
+
+    // We ran discover on foo, so both foo AND bar should be in the graph
+    assert_eq!(crate_graph.graph.inner.len(), 2);
+
+    let bar = w.member("bar");
+    let pkg = crate_graph.get(bar);
+    assert!(pkg.dependencies.is_empty());
+
+    let foo = w.member("foo");
+    let pkg = crate_graph.get(foo);
+    assert_eq!(pkg.dependencies, vec![bar.as_dependency()]);
+}
+
+#[cargo_test]
+fn test_workspace_with_shared_dependencies() {
+    // c1 --> c3
+    // c2 --> c3
+    let c3 = lib("c3");
+    let c2 = lib("c2").path_dependency(&c3);
+    let c1 = lib("c1").path_dependency(&c3);
+    let w = workspace().member(c1).member(c2).member(c3).build();
+
+    let crate_graph = discover(w.file("c3/Cargo.toml"));
+
+    // We only ran discover on c3, so c1 and c2 should not be in the graph
+    assert_eq!(crate_graph.len(), 1);
+
+    let c3 = w.member("c3");
+    let pkg = crate_graph.get(c3);
+    assert!(pkg.dependencies.is_empty());
+
+    let crate_graph = discover(w.file("c1/Cargo.toml"));
+
+    // We ran discover on c1, so both c1 AND c3 should be in the graph
+    assert_eq!(crate_graph.graph.inner.len(), 2);
+
+    let c3 = w.member("c3");
+    let pkg = crate_graph.get(c3);
+    assert!(pkg.dependencies.is_empty());
+
+    let c1 = w.member("c1");
+    let pkg = crate_graph.get(c1);
+    assert_eq!(pkg.dependencies, vec![c3.as_dependency()]);
+
+    let crate_graph = discover(w.file("c2/Cargo.toml"));
+
+    // We ran discover on c2, so both c2 AND c3 should be in the graph
+    assert_eq!(crate_graph.graph.inner.len(), 2);
+
+    let c3 = w.member("c3");
+    let pkg = crate_graph.get(c3);
+    assert!(pkg.dependencies.is_empty());
+
+    let c2 = w.member("c2");
+    let pkg = crate_graph.get(c2);
+    assert_eq!(pkg.dependencies, vec![c3.as_dependency()]);
+}
+
+#[cargo_test]
+fn standalone_crate_with_external_dependency() {
+    let mut builder = bin("foo");
+    let hashbrown_id = builder.dependency("hashbrown", "0.16.0", true);
+    let foo = builder.build();
+
+    let crate_graph = discover_path_builder(foo.file("Cargo.toml"))
+        .with_no_default_features()
+        .build();
+
+    assert_eq!(crate_graph.len(), 2);
+
+    let hashbrown = crate_graph.get_pkg(&hashbrown_id);
+    assert_eq!(hashbrown.name, "hashbrown");
+    assert_eq!(hashbrown.version.to_string(), "0.16.0");
+    assert!(hashbrown.dependencies.is_empty());
+
+    let foo = crate_graph.get(&foo);
+    assert_eq!(
+        foo.dependencies,
+        vec![Dependency {
+            id: hashbrown_id,
+            name: "hashbrown".into(),
+        }]
+    )
+}
+
+#[cargo_test]
+fn workspace_with_external_dependency() {
+    // foo --> hashbrown
+    // bar
+    let mut foo = lib("foo");
+    let hashbrown_id = foo.dependency("hashbrown", "0.16.0", true);
+    let bar = lib("bar");
+    let w = workspace().member(foo).member(bar).build();
+
+    let crate_graph = discover_path_builder(w.file("foo/Cargo.toml"))
+        .with_no_default_features()
+        .build();
+
+    assert_eq!(crate_graph.len(), 2);
+
+    let hashbrown = crate_graph.get_pkg(&hashbrown_id);
+    assert_eq!(hashbrown.name, "hashbrown");
+    assert_eq!(hashbrown.version.to_string(), "0.16.0");
+    assert!(hashbrown.dependencies.is_empty());
+
+    let foo = crate_graph.get(w.member("foo"));
+    assert_eq!(
+        foo.dependencies,
+        vec![Dependency {
+            id: hashbrown_id,
+            name: "hashbrown".into(),
+        }]
+    );
+
+    let crate_graph = discover_path_builder(w.file("bar/Cargo.toml"))
+        .with_no_default_features()
+        .build();
+
+    assert_eq!(crate_graph.len(), 1);
+
+    let foo = crate_graph.get(w.member("bar"));
+    assert!(foo.dependencies.is_empty());
+}
+
+#[cargo_test]
+fn workspace_with_path_and_external_dependency() {
+    // foo --> hashbrown, bar
+    // bar
+    let bar = lib("bar");
+    let mut foo = lib("foo").path_dependency(&bar);
+    let hashbrown_id = foo.dependency("hashbrown", "0.16.0", true);
+    let w = workspace().member(foo).member(bar).build();
+
+    let crate_graph = discover_path_builder(w.file("bar/Cargo.toml"))
+        .with_no_default_features()
+        .build();
+
+    assert_eq!(crate_graph.len(), 1);
+
+    let foo = crate_graph.get(w.member("bar"));
+    assert!(foo.dependencies.is_empty());
+
+    let crate_graph = discover_path_builder(w.file("foo/Cargo.toml"))
+        .with_no_default_features()
+        .build();
+
+    assert_eq!(crate_graph.len(), 3);
+
+    let hashbrown = crate_graph.get_pkg(&hashbrown_id);
+    assert_eq!(hashbrown.name, "hashbrown");
+    assert_eq!(hashbrown.version.to_string(), "0.16.0");
+    assert!(hashbrown.dependencies.is_empty());
+
+    let foo = crate_graph.get(w.member("foo"));
+
+    assert_eq!(foo.dependencies.len(), 2);
+    assert!(foo.dependencies.contains(&Dependency {
+        id: hashbrown_id,
+        name: "hashbrown".into(),
+    }));
+    assert!(foo.dependencies.contains(&w.member("bar").as_dependency()));
+}
+
+#[cargo_test]
+fn external_dependency_proc_macro_dylib() {
+    let mut builder = bin("foo");
+    let serde_derive_id = builder.dependency("serde_derive", "1.0.228", true);
+    let foo = builder.build();
+
+    let crate_graph = discover_path_builder(foo.file("Cargo.toml"))
+        .with_no_default_features()
+        .build();
+
+    let serde_derive = crate_graph.get_pkg(&serde_derive_id);
+
+    #[cfg(target_os = "macos")]
+    assert_eq!(
+        serde_derive.proc_macro_dylib.as_ref().unwrap().as_str(),
+        foo.root
+            .join("target/debug/deps/libserde_derive-1793a7b2113a3756.dylib")
+            .display()
+            .to_string()
+    );
+
+    #[cfg(target_os = "windows")]
+    assert_eq!(
+        serde_derive.proc_macro_dylib.as_ref().unwrap().as_str(),
+        foo.root
+            .join("target/debug/deps/libserde_derive-1793a7b2113a3756.dll")
+            .display()
+            .to_string()
+    );
+
+    #[cfg(target_os = "linux")]
+    assert_eq!(
+        serde_derive.proc_macro_dylib.as_ref().unwrap().as_str(),
+        foo.root
+            .join("target/debug/deps/libserde_derive-1793a7b2113a3756.so")
+            .display()
+            .to_string()
+    );
+}
+
+#[cargo_test]
+fn internal_dependency_proc_macro_dylib() {
+    todo!()
+}
+
+// standalone crate, workspace, external dep for proc macros and build scripts
+#[cargo_test]
+fn external_dependency_build_script() {
+    todo!()
+}
+
+#[cargo_test]
+fn internal_dependency_build_script() {
+    todo!()
+}
+
+// All the existing tests but with external dependencies
+// A standalone crate nested under the root of a workspace from which it's excluded
+// Multiple build targets in a single crate
+// Intra-crate target dependencies
+// Feature flags (both ws + external deps)