| //! Tests for workspace feature unification. |
| |
| use crate::prelude::*; |
| use crate::utils::cargo_process; |
| use cargo_test_support::{ |
| basic_manifest, |
| compare::assert_e2e, |
| project, |
| registry::{Dependency, Package}, |
| str, |
| }; |
| |
| #[cargo_test] |
| fn workspace_feature_unification() { |
| let p = project() |
| .file( |
| ".cargo/config.toml", |
| r#" |
| [resolver] |
| feature-unification = "workspace" |
| "#, |
| ) |
| .file( |
| "Cargo.toml", |
| r#" |
| [workspace] |
| resolver = "2" |
| members = ["common", "a", "b"] |
| "#, |
| ) |
| .file( |
| "common/Cargo.toml", |
| r#" |
| [package] |
| name = "common" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [features] |
| a = [] |
| b = [] |
| "#, |
| ) |
| .file( |
| "common/src/lib.rs", |
| r#" |
| #[cfg(not(all(feature = "a", feature = "b")))] |
| compile_error!("features were not unified"); |
| "#, |
| ) |
| .file( |
| "a/Cargo.toml", |
| r#" |
| [package] |
| name = "a" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", features = ["a"] } |
| "#, |
| ) |
| .file("a/src/lib.rs", "") |
| .file( |
| "b/Cargo.toml", |
| r#" |
| [package] |
| name = "b" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", features = ["b"] } |
| "#, |
| ) |
| .file("b/src/lib.rs", "") |
| .build(); |
| |
| p.cargo("check -p common") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [CHECKING] common v0.1.0 ([ROOT]/foo/common) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| p.cargo("check -p a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [CHECKING] a v0.1.0 ([ROOT]/foo/a) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| p.cargo("check -p b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [CHECKING] b v0.1.0 ([ROOT]/foo/b) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| p.cargo("check") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| } |
| |
| #[cargo_test] |
| fn package_feature_unification() { |
| Package::new("outside", "0.1.0") |
| .feature("a", &[]) |
| .feature("b", &[]) |
| .file( |
| "src/lib.rs", |
| r#" |
| #[cfg(all(feature = "a", feature = "b"))] |
| compile_error!("features were unified"); |
| #[cfg(feature = "a")] |
| pub fn a() {} |
| #[cfg(feature = "b")] |
| pub fn b() {} |
| "#, |
| ) |
| .publish(); |
| |
| let p = project() |
| .file( |
| ".cargo/config.toml", |
| r#" |
| [resolver] |
| feature-unification = "package" |
| "#, |
| ) |
| .file( |
| "Cargo.toml", |
| r#" |
| [workspace] |
| resolver = "2" |
| members = ["common", "a", "b"] |
| "#, |
| ) |
| .file( |
| "common/Cargo.toml", |
| r#" |
| [package] |
| name = "common" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [features] |
| a = [] |
| b = [] |
| "#, |
| ) |
| .file( |
| "common/src/lib.rs", |
| r#" |
| #[cfg(all(feature = "a", feature = "b"))] |
| compile_error!("features were unified"); |
| #[cfg(feature = "a")] |
| pub fn a() {} |
| #[cfg(feature = "b")] |
| pub fn b() {} |
| "#, |
| ) |
| .file( |
| "a/Cargo.toml", |
| r#" |
| [package] |
| name = "a" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", features = ["a"] } |
| outside = { version = "0.1.0", features = ["a"] } |
| "#, |
| ) |
| .file("a/src/lib.rs", "pub use common::a;") |
| .file( |
| "b/Cargo.toml", |
| r#" |
| [package] |
| name = "b" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", features = ["b"] } |
| outside = { version = "0.1.0", features = ["b"] } |
| "#, |
| ) |
| .file("b/src/lib.rs", "pub use common::b;") |
| .build(); |
| |
| p.cargo("check -p common") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [UPDATING] `dummy-registry` index |
| [LOCKING] 1 package to latest compatible version |
| [CHECKING] common v0.1.0 ([ROOT]/foo/common) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| p.cargo("check -p a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data( |
| str![[r#" |
| [DOWNLOADING] crates ... |
| [DOWNLOADED] outside v0.1.0 (registry `dummy-registry`) |
| [CHECKING] outside v0.1.0 |
| [CHECKING] common v0.1.0 ([ROOT]/foo/common) |
| [CHECKING] a v0.1.0 ([ROOT]/foo/a) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]] |
| .unordered(), |
| ) |
| .run(); |
| p.cargo("check -p b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data( |
| str![[r#" |
| [CHECKING] outside v0.1.0 |
| [CHECKING] common v0.1.0 ([ROOT]/foo/common) |
| [CHECKING] b v0.1.0 ([ROOT]/foo/b) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]] |
| .unordered(), |
| ) |
| .run(); |
| p.cargo("check -p a -p b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data( |
| str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]] |
| .unordered(), |
| ) |
| .run(); |
| p.cargo("check") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| // Sanity check that compilation without package feature unification does not work |
| p.cargo("check -p a -p b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "selected") |
| .with_status(101) |
| .with_stderr_contains("[ERROR] features were unified") |
| .run(); |
| } |
| |
| #[cargo_test] |
| fn package_feature_unification_default_features() { |
| let p = project() |
| .file( |
| ".cargo/config.toml", |
| r#" |
| [resolver] |
| feature-unification = "package" |
| "#, |
| ) |
| .file( |
| "Cargo.toml", |
| r#" |
| [workspace] |
| resolver = "2" |
| members = ["common", "a", "b"] |
| "#, |
| ) |
| .file( |
| "common/Cargo.toml", |
| r#" |
| [package] |
| name = "common" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [features] |
| default = ["a"] |
| a = [] |
| b = [] |
| "#, |
| ) |
| .file( |
| "common/src/lib.rs", |
| r#" |
| #[cfg(all(feature = "a", feature = "b"))] |
| compile_error!("features were unified"); |
| #[cfg(feature = "a")] |
| pub fn a() {} |
| #[cfg(feature = "b")] |
| pub fn b() {} |
| "#, |
| ) |
| .file( |
| "a/Cargo.toml", |
| r#" |
| [package] |
| name = "a" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common" } |
| "#, |
| ) |
| .file("a/src/lib.rs", "pub use common::a;") |
| .file( |
| "b/Cargo.toml", |
| r#" |
| [package] |
| name = "b" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", features = ["b"], default-features = false } |
| "#, |
| ) |
| .file("b/src/lib.rs", "pub use common::b;") |
| .build(); |
| |
| p.cargo("check -p common") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [CHECKING] common v0.1.0 ([ROOT]/foo/common) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| p.cargo("check -p a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [CHECKING] a v0.1.0 ([ROOT]/foo/a) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| p.cargo("check -p b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [CHECKING] common v0.1.0 ([ROOT]/foo/common) |
| [CHECKING] b v0.1.0 ([ROOT]/foo/b) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| p.cargo("check") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data( |
| str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]] |
| .unordered(), |
| ) |
| .run(); |
| } |
| |
| #[cargo_test] |
| fn package_feature_unification_cli_features() { |
| Package::new("outside", "0.1.0") |
| .feature("a", &[]) |
| .feature("b", &[]) |
| .file( |
| "src/lib.rs", |
| r#" |
| #[cfg(all(feature = "a", feature = "b"))] |
| compile_error!("features were unified"); |
| #[cfg(feature = "a")] |
| pub fn a() {} |
| #[cfg(feature = "b")] |
| pub fn b() {} |
| "#, |
| ) |
| .publish(); |
| |
| let p = project() |
| .file( |
| ".cargo/config.toml", |
| r#" |
| [resolver] |
| feature-unification = "package" |
| "#, |
| ) |
| .file( |
| "Cargo.toml", |
| r#" |
| [workspace] |
| resolver = "2" |
| members = ["common", "a", "b"] |
| "#, |
| ) |
| .file( |
| "common/Cargo.toml", |
| r#" |
| [package] |
| name = "common" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [features] |
| a = [] |
| b = [] |
| "#, |
| ) |
| .file( |
| "common/src/lib.rs", |
| r#" |
| #[cfg(all(feature = "a", feature = "b"))] |
| compile_error!("features were unified"); |
| #[cfg(feature = "a")] |
| pub fn a() {} |
| #[cfg(feature = "b")] |
| pub fn b() {} |
| "#, |
| ) |
| .file( |
| "a/Cargo.toml", |
| r#" |
| [package] |
| name = "a" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common" } |
| outside = "0.1.0" |
| |
| [features] |
| a = ["common/a", "outside/a"] |
| "#, |
| ) |
| .file("a/src/lib.rs", "pub use common::a;") |
| .file( |
| "b/Cargo.toml", |
| r#" |
| [package] |
| name = "b" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", features = ["b"] } |
| outside = "0.1.0" |
| |
| [features] |
| b = ["common/b", "outside/b"] |
| "#, |
| ) |
| .file("b/src/lib.rs", "pub use common::b;") |
| .build(); |
| |
| p.cargo("check -p a -p b -F a,b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data( |
| str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| [CHECKING] common v0.1.0 ([ROOT]/foo/common) |
| [UPDATING] `dummy-registry` index |
| [LOCKING] 1 package to latest compatible version |
| [DOWNLOADING] crates ... |
| [DOWNLOADED] outside v0.1.0 (registry `dummy-registry`) |
| [CHECKING] outside v0.1.0 |
| [CHECKING] b v0.1.0 ([ROOT]/foo/b) |
| [CHECKING] a v0.1.0 ([ROOT]/foo/a) |
| |
| "#]] |
| .unordered(), |
| ) |
| .run(); |
| p.cargo("check --workspace --exclude common -F a,b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data( |
| str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]] |
| .unordered(), |
| ) |
| .run(); |
| |
| p.cargo("check -p a -p b -F a/a,b/b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data( |
| str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]] |
| .unordered(), |
| ) |
| .run(); |
| p.cargo("check -p a -p b -F a,b,c") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_status(101) |
| .with_stderr_data(str![[r#" |
| [ERROR] none of the selected packages contains this feature: c |
| selected packages: a, b |
| |
| "#]]) |
| .run(); |
| p.cargo("check -p a -F b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_status(101) |
| .with_stderr_data(str![[r#" |
| [ERROR] the package 'a' does not contain this feature: b |
| [HELP] packages with the missing feature: common, b |
| |
| "#]]) |
| .run(); |
| p.cargo("check -p a -F a/a,common/b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_status(101) |
| .with_stderr_contains("[ERROR] features were unified") |
| .run(); |
| |
| p.cargo("check -p a -F a/a,outside/b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_status(101) |
| .with_stderr_contains("[ERROR] features were unified") |
| .run(); |
| |
| // Sanity check that compilation without package feature unification does not work |
| p.cargo("check -p a -p b -F a,b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "selected") |
| .with_status(101) |
| .with_stderr_contains("[ERROR] features were unified") |
| .run(); |
| } |
| |
| #[cargo_test] |
| fn package_feature_unification_weak_dependencies() { |
| let p = project() |
| .file( |
| ".cargo/config.toml", |
| r#" |
| [resolver] |
| feature-unification = "package" |
| "#, |
| ) |
| .file( |
| "Cargo.toml", |
| r#" |
| [workspace] |
| resolver = "2" |
| members = ["common", "a", "b"] |
| "#, |
| ) |
| .file( |
| "common/Cargo.toml", |
| r#" |
| [package] |
| name = "common" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [features] |
| a = [] |
| b = [] |
| "#, |
| ) |
| .file( |
| "common/src/lib.rs", |
| r#" |
| #[cfg(all(feature = "a", feature = "b"))] |
| compile_error!("features were unified"); |
| #[cfg(feature = "a")] |
| pub fn a() {} |
| #[cfg(feature = "b")] |
| pub fn b() {} |
| "#, |
| ) |
| .file( |
| "a/Cargo.toml", |
| r#" |
| [package] |
| name = "a" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", optional = true } |
| |
| [features] |
| default = ["dep:common", "common?/a"] |
| "#, |
| ) |
| .file("a/src/lib.rs", "pub use common::a;") |
| .file( |
| "b/Cargo.toml", |
| r#" |
| [package] |
| name = "b" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", optional = true } |
| |
| [features] |
| default = ["dep:common", "common?/b"] |
| "#, |
| ) |
| .file("b/src/lib.rs", "pub use common::b;") |
| .build(); |
| |
| p.cargo("check -p a -p b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data( |
| str![[r#" |
| [CHECKING] common v0.1.0 ([ROOT]/foo/common) |
| [CHECKING] a v0.1.0 ([ROOT]/foo/a) |
| [CHECKING] b v0.1.0 ([ROOT]/foo/b) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]] |
| .unordered(), |
| ) |
| .run(); |
| p.cargo("check") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [CHECKING] common v0.1.0 ([ROOT]/foo/common) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| // Sanity check that compilation without package feature unification does not work |
| p.cargo("check -p a -p b") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "selected") |
| .with_status(101) |
| .with_stderr_contains("[ERROR] features were unified") |
| .run(); |
| } |
| |
| #[cargo_test] |
| fn feature_unification_cargo_tree() { |
| Package::new("outside", "0.1.0") |
| .feature("a", &[]) |
| .feature("b", &[]) |
| .file( |
| "src/lib.rs", |
| r#" |
| #[cfg(all(feature = "a", feature = "b"))] |
| compile_error!("features were unified"); |
| #[cfg(feature = "a")] |
| pub fn a() {} |
| #[cfg(feature = "b")] |
| pub fn b() {} |
| "#, |
| ) |
| .publish(); |
| |
| let p = project() |
| .file( |
| "Cargo.toml", |
| r#" |
| [workspace] |
| resolver = "2" |
| members = ["common", "a", "b"] |
| "#, |
| ) |
| .file( |
| "common/Cargo.toml", |
| r#" |
| [package] |
| name = "common" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [features] |
| a = [] |
| b = [] |
| "#, |
| ) |
| .file( |
| "common/src/lib.rs", |
| r#" |
| #[cfg(all(feature = "a", feature = "b"))] |
| compile_error!("features were unified"); |
| #[cfg(feature = "a")] |
| pub fn a() {} |
| #[cfg(feature = "b")] |
| pub fn b() {} |
| "#, |
| ) |
| .file( |
| "a/Cargo.toml", |
| r#" |
| [package] |
| name = "a" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", features = ["a"] } |
| outside = { version = "0.1.0", features = ["a"] } |
| "#, |
| ) |
| .file("a/src/lib.rs", "pub use common::a;") |
| .file( |
| "b/Cargo.toml", |
| r#" |
| [package] |
| name = "b" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", features = ["b"] } |
| outside = { version = "0.1.0", features = ["b"] } |
| "#, |
| ) |
| .file("b/src/lib.rs", "pub use common::b;") |
| .build(); |
| |
| p.cargo("tree -e features") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "selected") |
| .with_stdout_data(str![[r#" |
| a v0.1.0 ([ROOT]/foo/a) |
| ├── common feature "a" |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── common feature "default" (command-line) |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── outside feature "a" |
| │ └── outside v0.1.0 |
| └── outside feature "default" |
| └── outside v0.1.0 |
| |
| b v0.1.0 ([ROOT]/foo/b) |
| ├── common feature "b" |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── common feature "default" (command-line) (*) |
| ├── outside feature "b" |
| │ └── outside v0.1.0 |
| └── outside feature "default" (*) |
| |
| common v0.1.0 ([ROOT]/foo/common) |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("tree -e features") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "workspace") |
| .with_stdout_data(str![[r#" |
| a v0.1.0 ([ROOT]/foo/a) |
| ├── common feature "a" |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── common feature "default" (command-line) |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── outside feature "a" |
| │ └── outside v0.1.0 |
| └── outside feature "default" |
| └── outside v0.1.0 |
| |
| b v0.1.0 ([ROOT]/foo/b) |
| ├── common feature "b" |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── common feature "default" (command-line) (*) |
| ├── outside feature "b" |
| │ └── outside v0.1.0 |
| └── outside feature "default" (*) |
| |
| common v0.1.0 ([ROOT]/foo/common) |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("tree -e features") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "package") |
| .with_stdout_data(str![[r#" |
| common v0.1.0 ([ROOT]/foo/common) |
| a v0.1.0 ([ROOT]/foo/a) |
| ├── common feature "a" |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── common feature "default" |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── outside feature "a" |
| │ └── outside v0.1.0 |
| └── outside feature "default" |
| └── outside v0.1.0 |
| b v0.1.0 ([ROOT]/foo/b) |
| ├── common feature "b" |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── common feature "default" |
| │ └── common v0.1.0 ([ROOT]/foo/common) |
| ├── outside feature "b" |
| │ └── outside v0.1.0 |
| └── outside feature "default" |
| └── outside v0.1.0 |
| |
| "#]]) |
| .run(); |
| } |
| |
| #[cargo_test] |
| fn cargo_install_ignores_config() { |
| let p = project() |
| .file( |
| "Cargo.toml", |
| r#" |
| [package] |
| name = "a" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "common", features = ["a"] } |
| |
| [workspace] |
| members = ["common", "b"] |
| "#, |
| ) |
| .file("src/main.rs", "fn main() {}") |
| .file( |
| "common/Cargo.toml", |
| r#" |
| [package] |
| name = "common" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [features] |
| a = [] |
| b = [] |
| "#, |
| ) |
| .file( |
| "common/src/lib.rs", |
| r#" |
| #[cfg(all(feature = "a", feature = "b"))] |
| compile_error!("features should not be unified"); |
| "#, |
| ) |
| .file( |
| "b/Cargo.toml", |
| r#" |
| [package] |
| name = "b" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| common = { path = "../common", features = ["b"] } |
| "#, |
| ) |
| .file("b/src/lib.rs", "") |
| .build(); |
| |
| cargo_process("install --path") |
| .arg(p.root()) |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "workspace") |
| .with_stderr_data(str![[r#" |
| [INSTALLING] a v0.1.0 ([ROOT]/foo) |
| [COMPILING] common v0.1.0 ([ROOT]/foo/common) |
| [COMPILING] a v0.1.0 ([ROOT]/foo) |
| [FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s |
| [INSTALLING] [ROOT]/home/.cargo/bin/a[EXE] |
| [INSTALLED] package `a v0.1.0 ([ROOT]/foo)` (executable `a[EXE]`) |
| [WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries |
| |
| "#]]) |
| .run(); |
| cargo_process("install --path") |
| .arg(p.root()) |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "package") |
| .with_stderr_data(str![[r#" |
| [INSTALLING] a v0.1.0 ([ROOT]/foo) |
| [FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s |
| [REPLACING] [ROOT]/home/.cargo/bin/a[EXE] |
| [REPLACED] package `a v0.1.0 ([ROOT]/foo)` with `a v0.1.0 ([ROOT]/foo)` (executable `a[EXE]`) |
| [WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries |
| |
| "#]]) |
| .run(); |
| } |
| |
| #[cargo_test] |
| fn unstable_config_on_stable() { |
| let p = project() |
| .file( |
| "Cargo.toml", |
| r#" |
| [workspace] |
| resolver = "2" |
| members = ["bar"] |
| "#, |
| ) |
| .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0")) |
| .file("bar/src/lib.rs", "") |
| .build(); |
| |
| p.cargo("check") |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "workspace") |
| .with_stderr_data(str![[r#" |
| [WARNING] ignoring `resolver.feature-unification` without `-Zfeature-unification` |
| [CHECKING] bar v0.1.0 ([ROOT]/foo/bar) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| } |
| |
| #[cargo_test] |
| fn cargo_fix_works() { |
| let p = project() |
| .file( |
| "Cargo.toml", |
| r#" |
| # Before project |
| [ project ] # After project header |
| # After project header line |
| name = "foo" |
| edition = "2021" |
| # After project table |
| "#, |
| ) |
| .file("src/lib.rs", "") |
| .build(); |
| |
| p.cargo("fix --edition --allow-no-vcs") |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "package") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_stderr_data(str![[r#" |
| [MIGRATING] Cargo.toml from 2021 edition to 2024 |
| [FIXED] Cargo.toml (1 fix) |
| [CHECKING] foo v0.0.0 ([ROOT]/foo) |
| [MIGRATING] src/lib.rs from 2021 edition to 2024 |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| assert_e2e().eq( |
| p.read_file("Cargo.toml"), |
| str![[r#" |
| |
| # Before project |
| [ package ] # After project header |
| # After project header line |
| name = "foo" |
| edition = "2021" |
| # After project table |
| |
| "#]], |
| ); |
| } |
| |
| #[cargo_test] |
| fn edition_v2_resolver_report() { |
| // Show a report if the V2 resolver shows differences. |
| Package::new("common", "1.0.0") |
| .feature("f1", &[]) |
| .feature("dev-feat", &[]) |
| .add_dep(Dependency::new("opt_dep", "1.0").optional(true)) |
| .publish(); |
| Package::new("opt_dep", "1.0.0").publish(); |
| |
| Package::new("bar", "1.0.0") |
| .add_dep( |
| Dependency::new("common", "1.0") |
| .target("cfg(whatever)") |
| .enable_features(&["f1"]), |
| ) |
| .publish(); |
| |
| let p = project() |
| .file( |
| "Cargo.toml", |
| r#" |
| [workspace] |
| members = ["bar"] |
| |
| [package] |
| name = "foo" |
| version = "0.1.0" |
| edition = "2018" |
| |
| [dependencies] |
| common = "1.0" |
| bar = "1.0" |
| |
| [build-dependencies] |
| common = { version = "1.0", features = ["opt_dep"] } |
| |
| [dev-dependencies] |
| common = { version="1.0", features=["dev-feat"] } |
| "#, |
| ) |
| .file("src/lib.rs", "") |
| .file( |
| "bar/Cargo.toml", |
| r#" |
| [package] |
| name = "bar" |
| version = "0.1.0" |
| edition = "2018" |
| "#, |
| ) |
| .file("bar/src/lib.rs", "") |
| .build(); |
| |
| p.cargo("fix --edition --allow-no-vcs --workspace") |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "package") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .with_status(101) |
| .with_stderr_data( |
| str![[r#" |
| [MIGRATING] Cargo.toml from 2018 edition to 2021 |
| [UPDATING] `dummy-registry` index |
| [LOCKING] 3 packages to latest compatible versions |
| [DOWNLOADING] crates ... |
| [DOWNLOADED] common v1.0.0 (registry `dummy-registry`) |
| [DOWNLOADED] bar v1.0.0 (registry `dummy-registry`) |
| [DOWNLOADED] opt_dep v1.0.0 (registry `dummy-registry`) |
| [MIGRATING] bar/Cargo.toml from 2018 edition to 2021 |
| [ERROR] cannot fix edition when using `feature-unification = "package"`. |
| |
| "#]] |
| .unordered(), |
| ) |
| .run(); |
| } |
| |
| #[cargo_test] |
| fn feature_unification_of_cli_features_within_workspace() { |
| let p = project() |
| .file( |
| "Cargo.toml", |
| r#" |
| [workspace] |
| resolver = "2" |
| members = ["parent", "child", "grandchild"] |
| "#, |
| ) |
| .file( |
| "grandchild/Cargo.toml", |
| r#" |
| [package] |
| name = "grandchild" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [features] |
| a = [] |
| "#, |
| ) |
| .file( |
| "grandchild/src/lib.rs", |
| r#" |
| #[cfg(feature = "a")] |
| pub fn a() {} |
| "#, |
| ) |
| .file( |
| "child/Cargo.toml", |
| r#" |
| [package] |
| name = "child" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| grandchild = { path = "../grandchild" } |
| "#, |
| ) |
| .file("child/src/lib.rs", "pub use grandchild::*;") |
| .file( |
| "parent/Cargo.toml", |
| r#" |
| [package] |
| name = "parent" |
| version = "0.1.0" |
| edition = "2021" |
| |
| [dependencies] |
| child = { path = "../child" } |
| "#, |
| ) |
| .file("parent/src/lib.rs", "pub use child::a;") |
| .build(); |
| |
| p.cargo("check -p parent -F grandchild/a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "package") |
| .with_status(101) |
| .with_stderr_data(str![[r#" |
| [ERROR] the package 'parent' does not contain this feature: grandchild/a |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -p parent -F grandchild/a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "workspace") |
| .with_status(101) |
| .with_stderr_data(str![[r#" |
| [ERROR] the package 'parent' does not contain this feature: grandchild/a |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -p parent -F grandchild/a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "selected") |
| .with_status(101) |
| .with_stderr_data(str![[r#" |
| [ERROR] the package 'parent' does not contain this feature: grandchild/a |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -p child -F grandchild/a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "package") |
| .with_stderr_data(str![[r#" |
| [CHECKING] grandchild v0.1.0 ([ROOT]/foo/grandchild) |
| [CHECKING] child v0.1.0 ([ROOT]/foo/child) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -p child -F grandchild/a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "workspace") |
| .with_stderr_data(str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -p child -F grandchild/a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "selected") |
| .with_stderr_data(str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -F grandchild/a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "package") |
| .with_stderr_data(str![[r#" |
| [CHECKING] parent v0.1.0 ([ROOT]/foo/parent) |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -F grandchild/a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "workspace") |
| .with_stderr_data(str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -F grandchild/a") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "selected") |
| .with_stderr_data(str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -F grandchild/a --workspace --exclude grandchild") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "package") |
| .with_stderr_data(str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -F grandchild/a --workspace --exclude grandchild") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "workspace") |
| .with_stderr_data(str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -F grandchild/a --workspace --exclude grandchild") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "selected") |
| .with_stderr_data(str![[r#" |
| [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -F grandchild/a --workspace --exclude grandchild --exclude child") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "package") |
| .with_status(101) |
| .with_stderr_data(str![[r#" |
| [ERROR] the package 'parent' does not contain this feature: grandchild/a |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -F grandchild/a --workspace --exclude grandchild --exclude child") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "workspace") |
| .with_status(101) |
| .with_stderr_data(str![[r#" |
| [ERROR] the package 'parent' does not contain this feature: grandchild/a |
| |
| "#]]) |
| .run(); |
| |
| p.cargo("check -F grandchild/a --workspace --exclude grandchild --exclude child") |
| .arg("-Zfeature-unification") |
| .masquerade_as_nightly_cargo(&["feature-unification"]) |
| .env("CARGO_RESOLVER_FEATURE_UNIFICATION", "selected") |
| .with_status(101) |
| .with_stderr_data(str![[r#" |
| [ERROR] the package 'parent' does not contain this feature: grandchild/a |
| |
| "#]]) |
| .run(); |
| } |
