From 17a0b7e43c2df144ac8c0d49608d4e2f022cac64 Mon Sep 17 00:00:00 2001 From: Weihang Lo Date: Wed, 7 Aug 2024 12:02:49 -0400 Subject: [PATCH 1/7] test: disable build-std test to unblock beta-1.81 backport --- tests/build-std/main.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/build-std/main.rs b/tests/build-std/main.rs index 1075643219c..33df92459de 100644 --- a/tests/build-std/main.rs +++ b/tests/build-std/main.rs @@ -62,6 +62,8 @@ impl BuildStd for Execs { } } +#[allow(unused_attributes)] +#[ignore = "to unblock beta-1.81 backport"] #[cargo_test(build_std_real)] fn basic() { let p = project() From a15ec6a7c1e95abc288a3e5d7edacb815e47b3df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Thu, 1 Aug 2024 18:10:56 +0000 Subject: [PATCH 2/7] Change tests to support `rustc` wording changes Between rust-lang/rust#126810 and rust-lang/rust#126810 the output of rustc for resolution errors is going to change in such a way that some existing cargo tests will fail. Change them to support both the current and future output, so that those PRs can land in `rustc`. --- tests/testsuite/check.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/testsuite/check.rs b/tests/testsuite/check.rs index b3377b1f88f..a3c832f851e 100644 --- a/tests/testsuite/check.rs +++ b/tests/testsuite/check.rs @@ -820,7 +820,7 @@ fn short_message_format() { .with_status(101) .with_stderr_data(str![[r#" [CHECKING] foo v0.0.1 ([ROOT]/foo) -src/lib.rs:1:27: error[E0308]: mismatched types +src/lib.rs:1:27: error[E0308]: mismatched types[..] [ERROR] could not compile `foo` (lib) due to 1 previous error "#]]) From 505f1b911dfe1e0e54c442c6b5d360b22e178e37 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Wed, 7 Aug 2024 11:48:47 -0500 Subject: [PATCH 3/7] test(vendor): Clarify what vendor config is used --- tests/testsuite/vendor.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/testsuite/vendor.rs b/tests/testsuite/vendor.rs index c103955dfe7..e6f63440fa8 100644 --- a/tests/testsuite/vendor.rs +++ b/tests/testsuite/vendor.rs @@ -36,7 +36,7 @@ fn vendor_simple() { let lock = p.read_file("vendor/log/Cargo.toml"); assert!(lock.contains("version = \"0.3.5\"")); - add_vendor_config(&p); + add_crates_io_vendor_config(&p); p.cargo("check").run(); } @@ -151,7 +151,7 @@ directory = "deps/.vendor" assert!(lock.contains("version = \"0.3.5\"")); } -fn add_vendor_config(p: &Project) { +fn add_crates_io_vendor_config(p: &Project) { p.change_file( ".cargo/config.toml", r#" @@ -248,7 +248,7 @@ fn two_versions() { let lock = p.read_file("vendor/bitflags-0.7.0/Cargo.toml"); assert!(lock.contains("version = \"0.7.0\"")); - add_vendor_config(&p); + add_crates_io_vendor_config(&p); p.cargo("check").run(); } @@ -293,7 +293,7 @@ fn two_explicit_versions() { let lock = p.read_file("vendor/bitflags-0.7.0/Cargo.toml"); assert!(lock.contains("version = \"0.7.0\"")); - add_vendor_config(&p); + add_crates_io_vendor_config(&p); p.cargo("check").run(); } @@ -386,7 +386,7 @@ fn two_lockfiles() { let lock = p.read_file("vendor/bitflags-0.7.0/Cargo.toml"); assert!(lock.contains("version = \"0.7.0\"")); - add_vendor_config(&p); + add_crates_io_vendor_config(&p); p.cargo("check").cwd("foo").run(); p.cargo("check").cwd("bar").run(); } @@ -645,7 +645,7 @@ fn vendoring_git_crates() { p.cargo("vendor --respect-source-config").run(); p.read_file("vendor/serde_derive/src/wut.rs"); - add_vendor_config(&p); + add_crates_io_vendor_config(&p); p.cargo("check").run(); } From ccb4ac68c783871963091eb93eada058fca3248a Mon Sep 17 00:00:00 2001 From: Ed Page Date: Wed, 7 Aug 2024 11:25:14 -0500 Subject: [PATCH 4/7] test(vendor): Fork the package tests --- tests/testsuite/vendor.rs | 1053 ++++++++++++++++++++++++++++++++++++- 1 file changed, 1052 insertions(+), 1 deletion(-) diff --git a/tests/testsuite/vendor.rs b/tests/testsuite/vendor.rs index e6f63440fa8..45ef98d4ca1 100644 --- a/tests/testsuite/vendor.rs +++ b/tests/testsuite/vendor.rs @@ -4,11 +4,12 @@ //! "fake" crates.io is used. Otherwise `vendor` would download the crates.io //! index from the network. -use std::fs; +use std::fs::{self, File}; use cargo_test_support::compare::assert_e2e; use cargo_test_support::git; use cargo_test_support::prelude::*; +use cargo_test_support::publish::validate_crate_contents; use cargo_test_support::registry::{self, Package, RegistryBuilder}; use cargo_test_support::str; use cargo_test_support::{basic_lib_manifest, basic_manifest, paths, project, Project}; @@ -208,6 +209,1056 @@ fn package_exclude() { assert!(!csum.contains(".dotdir/include")); } +#[cargo_test] +fn discovery_inferred_build_rs_included() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/lib.rs", "build.rs"] + "#, + ) + .file("src/lib.rs", "") + .file("build.rs", "fn main() {}") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &["Cargo.toml", "Cargo.toml.orig", "src/lib.rs", "build.rs"], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = "build.rs" +include = [ + "src/lib.rs", + "build.rs", +] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_inferred_build_rs_excluded() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/lib.rs"] + "#, + ) + .file("src/lib.rs", "") + .file("build.rs", "fn main() {}") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[WARNING] ignoring `package.build` as `build.rs` is not included in the published package +[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &["Cargo.toml", "Cargo.toml.orig", "src/lib.rs"], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = ["src/lib.rs"] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_explicit_build_rs_included() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/lib.rs", "build.rs"] + build = "build.rs" + "#, + ) + .file("src/lib.rs", "") + .file("build.rs", "fn main() {}") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &["Cargo.toml", "Cargo.toml.orig", "src/lib.rs", "build.rs"], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = "build.rs" +include = [ + "src/lib.rs", + "build.rs", +] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_explicit_build_rs_excluded() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/lib.rs"] + build = "build.rs" + "#, + ) + .file("src/lib.rs", "") + .file("build.rs", "fn main() {}") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[WARNING] ignoring `package.build` as `build.rs` is not included in the published package +[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &["Cargo.toml", "Cargo.toml.orig", "src/lib.rs"], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = ["src/lib.rs"] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_inferred_lib_included() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/main.rs", "src/lib.rs"] + "#, + ) + .file("src/main.rs", "fn main() {}") + .file("src/lib.rs", "") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &[ + "Cargo.lock", + "Cargo.toml", + "Cargo.toml.orig", + "src/main.rs", + "src/lib.rs", + ], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = [ + "src/main.rs", + "src/lib.rs", +] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" + +[[bin]] +name = "foo" +path = "src/main.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_inferred_lib_excluded() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/main.rs"] + "#, + ) + .file("src/main.rs", "fn main() {}") + .file("src/lib.rs", "") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[WARNING] ignoring library `foo` as `src/lib.rs` is not included in the published package +[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = ["src/main.rs"] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[[bin]] +name = "foo" +path = "src/main.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_explicit_lib_included() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/main.rs", "src/lib.rs"] + + [lib] + path = "src/lib.rs" + "#, + ) + .file("src/main.rs", "fn main() {}") + .file("src/lib.rs", "") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &[ + "Cargo.lock", + "Cargo.toml", + "Cargo.toml.orig", + "src/main.rs", + "src/lib.rs", + ], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = [ + "src/main.rs", + "src/lib.rs", +] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" + +[[bin]] +name = "foo" +path = "src/main.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_explicit_lib_excluded() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/main.rs"] + + [lib] + path = "src/lib.rs" + "#, + ) + .file("src/main.rs", "fn main() {}") + .file("src/lib.rs", "") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[WARNING] ignoring library `foo` as `src/lib.rs` is not included in the published package +[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = ["src/main.rs"] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[[bin]] +name = "foo" +path = "src/main.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_inferred_other_included() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/lib.rs", "src/bin/foo/main.rs", "examples/example_foo.rs", "tests/test_foo.rs", "benches/bench_foo.rs"] + "#, + ) + .file("src/lib.rs", "") + .file("src/bin/foo/main.rs", "fn main() {}") + .file("examples/example_foo.rs", "fn main() {}") + .file("tests/test_foo.rs", "fn main() {}") + .file("benches/bench_foo.rs", "fn main() {}") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[PACKAGED] 8 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &[ + "Cargo.lock", + "Cargo.toml", + "Cargo.toml.orig", + "src/lib.rs", + "src/bin/foo/main.rs", + "examples/example_foo.rs", + "tests/test_foo.rs", + "benches/bench_foo.rs", + ], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = [ + "src/lib.rs", + "src/bin/foo/main.rs", + "examples/example_foo.rs", + "tests/test_foo.rs", + "benches/bench_foo.rs", +] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" + +[[bin]] +name = "foo" +path = "src/bin/foo/main.rs" + +[[example]] +name = "example_foo" +path = "examples/example_foo.rs" + +[[test]] +name = "test_foo" +path = "tests/test_foo.rs" + +[[bench]] +name = "bench_foo" +path = "benches/bench_foo.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_inferred_other_excluded() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/lib.rs"] + "#, + ) + .file("src/lib.rs", "") + .file("src/bin/foo/main.rs", "fn main() {}") + .file("examples/example_foo.rs", "fn main() {}") + .file("tests/test_foo.rs", "fn main() {}") + .file("benches/bench_foo.rs", "fn main() {}") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[WARNING] ignoring binary `foo` as `src/bin/foo/main.rs` is not included in the published package +[WARNING] ignoring example `example_foo` as `examples/example_foo.rs` is not included in the published package +[WARNING] ignoring test `test_foo` as `tests/test_foo.rs` is not included in the published package +[WARNING] ignoring benchmark `bench_foo` as `benches/bench_foo.rs` is not included in the published package +[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/lib.rs"], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = ["src/lib.rs"] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_explicit_other_included() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/lib.rs", "src/bin/foo/main.rs", "examples/example_foo.rs", "tests/test_foo.rs", "benches/bench_foo.rs"] + + [[bin]] + name = "foo" + + [[example]] + name = "example_foo" + + [[test]] + name = "test_foo" + + [[bench]] + name = "bench_foo" + "#, + ) + .file("src/lib.rs", "") + .file("src/bin/foo/main.rs", "fn main() {}") + .file("examples/example_foo.rs", "fn main() {}") + .file("tests/test_foo.rs", "fn main() {}") + .file("benches/bench_foo.rs", "fn main() {}") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[PACKAGED] 8 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &[ + "Cargo.lock", + "Cargo.toml", + "Cargo.toml.orig", + "src/lib.rs", + "src/bin/foo/main.rs", + "examples/example_foo.rs", + "tests/test_foo.rs", + "benches/bench_foo.rs", + ], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = [ + "src/lib.rs", + "src/bin/foo/main.rs", + "examples/example_foo.rs", + "tests/test_foo.rs", + "benches/bench_foo.rs", +] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" + +[[bin]] +name = "foo" +path = "src/bin/foo/main.rs" + +[[example]] +name = "example_foo" +path = "examples/example_foo.rs" + +[[test]] +name = "test_foo" +path = "tests/test_foo.rs" + +[[bench]] +name = "bench_foo" +path = "benches/bench_foo.rs" +"#, + )], + ); +} + +#[cargo_test] +fn discovery_explicit_other_excluded() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + edition = "2015" + license = "MIT" + description = "foo" + documentation = "docs.rs/foo" + authors = [] + include = ["src/lib.rs"] + + [[main]] + name = "foo" + + [[example]] + name = "example_foo" + + [[test]] + name = "test_foo" + + [[bench]] + name = "bench_foo" + "#, + ) + .file("src/lib.rs", "") + .file("src/bin/foo/main.rs", "fn main() {}") + .file("examples/example_foo.rs", "fn main() {}") + .file("tests/test_foo.rs", "fn main() {}") + .file("benches/bench_foo.rs", "fn main() {}") + .build(); + + p.cargo("package") + .with_stdout_data("") + .with_stderr_data(str![[r#" +[PACKAGING] foo v0.0.1 ([ROOT]/foo) +[WARNING] ignoring binary `foo` as `src/bin/foo/main.rs` is not included in the published package +[WARNING] ignoring example `example_foo` as `examples/example_foo.rs` is not included in the published package +[WARNING] ignoring test `test_foo` as `tests/test_foo.rs` is not included in the published package +[WARNING] ignoring benchmark `bench_foo` as `benches/bench_foo.rs` is not included in the published package +[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) +[VERIFYING] foo v0.0.1 ([ROOT]/foo) +[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) +[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + +"#]]) + .run(); + + let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); + validate_crate_contents( + f, + "foo-0.0.1.crate", + &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/lib.rs"], + &[( + "Cargo.toml", + r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2015" +name = "foo" +version = "0.0.1" +authors = [] +build = false +include = ["src/lib.rs"] +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "foo" +documentation = "docs.rs/foo" +readme = false +license = "MIT" + +[lib] +name = "foo" +path = "src/lib.rs" +"#, + )], + ); +} + #[cargo_test] fn two_versions() { let p = project() From b7223bab51cfe786190fa53c4f28086c66217664 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Wed, 7 Aug 2024 11:36:23 -0500 Subject: [PATCH 5/7] test(vendor): Drop explicitlu specified build-target cases Since we already cover this for `cargo package` and we turn all implicit targets into explicit targets (making implicit tests cover explicit cases), this becomes redundant. --- tests/testsuite/vendor.rs | 545 +------------------------------------- 1 file changed, 2 insertions(+), 543 deletions(-) diff --git a/tests/testsuite/vendor.rs b/tests/testsuite/vendor.rs index 45ef98d4ca1..c238d816613 100644 --- a/tests/testsuite/vendor.rs +++ b/tests/testsuite/vendor.rs @@ -364,327 +364,7 @@ path = "src/lib.rs" } #[cargo_test] -fn discovery_explicit_build_rs_included() { - let p = project() - .file( - "Cargo.toml", - r#" - [package] - name = "foo" - version = "0.0.1" - edition = "2015" - license = "MIT" - description = "foo" - documentation = "docs.rs/foo" - authors = [] - include = ["src/lib.rs", "build.rs"] - build = "build.rs" - "#, - ) - .file("src/lib.rs", "") - .file("build.rs", "fn main() {}") - .build(); - - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); - - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &["Cargo.toml", "Cargo.toml.orig", "src/lib.rs", "build.rs"], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2015" -name = "foo" -version = "0.0.1" -authors = [] -build = "build.rs" -include = [ - "src/lib.rs", - "build.rs", -] -autobins = false -autoexamples = false -autotests = false -autobenches = false -description = "foo" -documentation = "docs.rs/foo" -readme = false -license = "MIT" - -[lib] -name = "foo" -path = "src/lib.rs" -"#, - )], - ); -} - -#[cargo_test] -fn discovery_explicit_build_rs_excluded() { - let p = project() - .file( - "Cargo.toml", - r#" - [package] - name = "foo" - version = "0.0.1" - edition = "2015" - license = "MIT" - description = "foo" - documentation = "docs.rs/foo" - authors = [] - include = ["src/lib.rs"] - build = "build.rs" - "#, - ) - .file("src/lib.rs", "") - .file("build.rs", "fn main() {}") - .build(); - - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[WARNING] ignoring `package.build` as `build.rs` is not included in the published package -[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); - - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &["Cargo.toml", "Cargo.toml.orig", "src/lib.rs"], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2015" -name = "foo" -version = "0.0.1" -authors = [] -build = false -include = ["src/lib.rs"] -autobins = false -autoexamples = false -autotests = false -autobenches = false -description = "foo" -documentation = "docs.rs/foo" -readme = false -license = "MIT" - -[lib] -name = "foo" -path = "src/lib.rs" -"#, - )], - ); -} - -#[cargo_test] -fn discovery_inferred_lib_included() { - let p = project() - .file( - "Cargo.toml", - r#" - [package] - name = "foo" - version = "0.0.1" - edition = "2015" - license = "MIT" - description = "foo" - documentation = "docs.rs/foo" - authors = [] - include = ["src/main.rs", "src/lib.rs"] - "#, - ) - .file("src/main.rs", "fn main() {}") - .file("src/lib.rs", "") - .build(); - - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); - - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &[ - "Cargo.lock", - "Cargo.toml", - "Cargo.toml.orig", - "src/main.rs", - "src/lib.rs", - ], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2015" -name = "foo" -version = "0.0.1" -authors = [] -build = false -include = [ - "src/main.rs", - "src/lib.rs", -] -autobins = false -autoexamples = false -autotests = false -autobenches = false -description = "foo" -documentation = "docs.rs/foo" -readme = false -license = "MIT" - -[lib] -name = "foo" -path = "src/lib.rs" - -[[bin]] -name = "foo" -path = "src/main.rs" -"#, - )], - ); -} - -#[cargo_test] -fn discovery_inferred_lib_excluded() { - let p = project() - .file( - "Cargo.toml", - r#" - [package] - name = "foo" - version = "0.0.1" - edition = "2015" - license = "MIT" - description = "foo" - documentation = "docs.rs/foo" - authors = [] - include = ["src/main.rs"] - "#, - ) - .file("src/main.rs", "fn main() {}") - .file("src/lib.rs", "") - .build(); - - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[WARNING] ignoring library `foo` as `src/lib.rs` is not included in the published package -[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); - - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2015" -name = "foo" -version = "0.0.1" -authors = [] -build = false -include = ["src/main.rs"] -autobins = false -autoexamples = false -autotests = false -autobenches = false -description = "foo" -documentation = "docs.rs/foo" -readme = false -license = "MIT" - -[[bin]] -name = "foo" -path = "src/main.rs" -"#, - )], - ); -} - -#[cargo_test] -fn discovery_explicit_lib_included() { +fn discovery_inferred_lib_included() { let p = project() .file( "Cargo.toml", @@ -698,9 +378,6 @@ fn discovery_explicit_lib_included() { documentation = "docs.rs/foo" authors = [] include = ["src/main.rs", "src/lib.rs"] - - [lib] - path = "src/lib.rs" "#, ) .file("src/main.rs", "fn main() {}") @@ -775,7 +452,7 @@ path = "src/main.rs" } #[cargo_test] -fn discovery_explicit_lib_excluded() { +fn discovery_inferred_lib_excluded() { let p = project() .file( "Cargo.toml", @@ -789,9 +466,6 @@ fn discovery_explicit_lib_excluded() { documentation = "docs.rs/foo" authors = [] include = ["src/main.rs"] - - [lib] - path = "src/lib.rs" "#, ) .file("src/main.rs", "fn main() {}") @@ -1044,221 +718,6 @@ path = "src/lib.rs" ); } -#[cargo_test] -fn discovery_explicit_other_included() { - let p = project() - .file( - "Cargo.toml", - r#" - [package] - name = "foo" - version = "0.0.1" - edition = "2015" - license = "MIT" - description = "foo" - documentation = "docs.rs/foo" - authors = [] - include = ["src/lib.rs", "src/bin/foo/main.rs", "examples/example_foo.rs", "tests/test_foo.rs", "benches/bench_foo.rs"] - - [[bin]] - name = "foo" - - [[example]] - name = "example_foo" - - [[test]] - name = "test_foo" - - [[bench]] - name = "bench_foo" - "#, - ) - .file("src/lib.rs", "") - .file("src/bin/foo/main.rs", "fn main() {}") - .file("examples/example_foo.rs", "fn main() {}") - .file("tests/test_foo.rs", "fn main() {}") - .file("benches/bench_foo.rs", "fn main() {}") - .build(); - - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[PACKAGED] 8 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); - - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &[ - "Cargo.lock", - "Cargo.toml", - "Cargo.toml.orig", - "src/lib.rs", - "src/bin/foo/main.rs", - "examples/example_foo.rs", - "tests/test_foo.rs", - "benches/bench_foo.rs", - ], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2015" -name = "foo" -version = "0.0.1" -authors = [] -build = false -include = [ - "src/lib.rs", - "src/bin/foo/main.rs", - "examples/example_foo.rs", - "tests/test_foo.rs", - "benches/bench_foo.rs", -] -autobins = false -autoexamples = false -autotests = false -autobenches = false -description = "foo" -documentation = "docs.rs/foo" -readme = false -license = "MIT" - -[lib] -name = "foo" -path = "src/lib.rs" - -[[bin]] -name = "foo" -path = "src/bin/foo/main.rs" - -[[example]] -name = "example_foo" -path = "examples/example_foo.rs" - -[[test]] -name = "test_foo" -path = "tests/test_foo.rs" - -[[bench]] -name = "bench_foo" -path = "benches/bench_foo.rs" -"#, - )], - ); -} - -#[cargo_test] -fn discovery_explicit_other_excluded() { - let p = project() - .file( - "Cargo.toml", - r#" - [package] - name = "foo" - version = "0.0.1" - edition = "2015" - license = "MIT" - description = "foo" - documentation = "docs.rs/foo" - authors = [] - include = ["src/lib.rs"] - - [[main]] - name = "foo" - - [[example]] - name = "example_foo" - - [[test]] - name = "test_foo" - - [[bench]] - name = "bench_foo" - "#, - ) - .file("src/lib.rs", "") - .file("src/bin/foo/main.rs", "fn main() {}") - .file("examples/example_foo.rs", "fn main() {}") - .file("tests/test_foo.rs", "fn main() {}") - .file("benches/bench_foo.rs", "fn main() {}") - .build(); - - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[WARNING] ignoring binary `foo` as `src/bin/foo/main.rs` is not included in the published package -[WARNING] ignoring example `example_foo` as `examples/example_foo.rs` is not included in the published package -[WARNING] ignoring test `test_foo` as `tests/test_foo.rs` is not included in the published package -[WARNING] ignoring benchmark `bench_foo` as `benches/bench_foo.rs` is not included in the published package -[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); - - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/lib.rs"], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2015" -name = "foo" -version = "0.0.1" -authors = [] -build = false -include = ["src/lib.rs"] -autobins = false -autoexamples = false -autotests = false -autobenches = false -description = "foo" -documentation = "docs.rs/foo" -readme = false -license = "MIT" - -[lib] -name = "foo" -path = "src/lib.rs" -"#, - )], - ); -} - #[cargo_test] fn two_versions() { let p = project() From 567f66d567dc6997d56f8e52415b418c151ac162 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Wed, 7 Aug 2024 11:47:40 -0500 Subject: [PATCH 6/7] test(vendor): Port 'package' tests to 'vendor' --- tests/testsuite/vendor.rs | 513 +++++++++++++++++++++++--------------- 1 file changed, 312 insertions(+), 201 deletions(-) diff --git a/tests/testsuite/vendor.rs b/tests/testsuite/vendor.rs index c238d816613..1a2b783fe8f 100644 --- a/tests/testsuite/vendor.rs +++ b/tests/testsuite/vendor.rs @@ -4,12 +4,11 @@ //! "fake" crates.io is used. Otherwise `vendor` would download the crates.io //! index from the network. -use std::fs::{self, File}; +use std::fs; use cargo_test_support::compare::assert_e2e; use cargo_test_support::git; use cargo_test_support::prelude::*; -use cargo_test_support::publish::validate_crate_contents; use cargo_test_support::registry::{self, Package, RegistryBuilder}; use cargo_test_support::str; use cargo_test_support::{basic_lib_manifest, basic_manifest, paths, project, Project}; @@ -165,6 +164,23 @@ fn add_crates_io_vendor_config(p: &Project) { ); } +fn add_git_vendor_config(p: &Project, git_project: &Project) { + p.change_file( + ".cargo/config.toml", + &format!( + r#" + [source."git+{url}"] + git = "{url}" + replace-with = 'vendor' + + [source.vendor] + directory = 'vendor' + "#, + url = git_project.url() + ), + ); +} + #[cargo_test] fn package_exclude() { let p = project() @@ -211,12 +227,13 @@ fn package_exclude() { #[cargo_test] fn discovery_inferred_build_rs_included() { - let p = project() - .file( - "Cargo.toml", - r#" + let git_project = git::new("dep", |project| { + project + .file( + "Cargo.toml", + r#" [package] - name = "foo" + name = "dep" version = "0.0.1" edition = "2015" license = "MIT" @@ -225,31 +242,38 @@ fn discovery_inferred_build_rs_included() { authors = [] include = ["src/lib.rs", "build.rs"] "#, + ) + .file("src/lib.rs", "") + .file("build.rs", "fn main() {}") + }); + + let p = project() + .file( + "Cargo.toml", + &format!( + r#" + [package] + name = "foo" + version = "0.5.0" + edition = "2015" + + [dependencies.dep] + git = '{}' + "#, + git_project.url() + ), ) - .file("src/lib.rs", "") - .file("build.rs", "fn main() {}") + .file("src/main.rs", "fn main() {}") .build(); - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); + p.cargo("vendor --respect-source-config").run(); + add_git_vendor_config(&p, &git_project); - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &["Cargo.toml", "Cargo.toml.orig", "src/lib.rs", "build.rs"], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO + let lock = p.read_file("vendor/dep/Cargo.toml"); + assert_e2e().eq( + lock, + str![[r##" +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility @@ -260,9 +284,14 @@ fn discovery_inferred_build_rs_included() { # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. +bin = [] +example = [] +test = [] +bench = [] + [package] edition = "2015" -name = "foo" +name = "dep" version = "0.0.1" authors = [] build = "build.rs" @@ -280,21 +309,24 @@ readme = false license = "MIT" [lib] -name = "foo" +name = "dep" path = "src/lib.rs" -"#, - )], + +"##]], ); + + p.cargo("check").run(); } #[cargo_test] fn discovery_inferred_build_rs_excluded() { - let p = project() - .file( - "Cargo.toml", - r#" + let git_project = git::new("dep", |project| { + project + .file( + "Cargo.toml", + r#" [package] - name = "foo" + name = "dep" version = "0.0.1" edition = "2015" license = "MIT" @@ -303,32 +335,38 @@ fn discovery_inferred_build_rs_excluded() { authors = [] include = ["src/lib.rs"] "#, + ) + .file("src/lib.rs", "") + .file("build.rs", "fn main() {}") + }); + + let p = project() + .file( + "Cargo.toml", + &format!( + r#" + [package] + name = "foo" + version = "0.5.0" + edition = "2015" + + [dependencies.dep] + git = '{}' + "#, + git_project.url() + ), ) - .file("src/lib.rs", "") - .file("build.rs", "fn main() {}") + .file("src/main.rs", "fn main() {}") .build(); - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[WARNING] ignoring `package.build` as `build.rs` is not included in the published package -[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); + p.cargo("vendor --respect-source-config").run(); + add_git_vendor_config(&p, &git_project); - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &["Cargo.toml", "Cargo.toml.orig", "src/lib.rs"], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO + let lock = p.read_file("vendor/dep/Cargo.toml"); + assert_e2e().eq( + lock, + str![[r##" +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility @@ -339,12 +377,17 @@ fn discovery_inferred_build_rs_excluded() { # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. +bin = [] +example = [] +test = [] +bench = [] + [package] edition = "2015" -name = "foo" +name = "dep" version = "0.0.1" authors = [] -build = false +build = "build.rs" include = ["src/lib.rs"] autobins = false autoexamples = false @@ -356,21 +399,33 @@ readme = false license = "MIT" [lib] -name = "foo" +name = "dep" path = "src/lib.rs" -"#, - )], + +"##]], ); + + p.cargo("check") + .with_status(101) + .with_stderr_data(str![[r#" +[COMPILING] dep v0.0.1 ([ROOTURL]/dep#[..]) +[ERROR] couldn't read [ROOT]/foo/vendor/dep/build.rs: [NOT_FOUND] + +[ERROR] could not compile `dep` (build script) due to 1 previous error + +"#]]) + .run(); } #[cargo_test] fn discovery_inferred_lib_included() { - let p = project() - .file( - "Cargo.toml", - r#" + let git_project = git::new("dep", |project| { + project + .file( + "Cargo.toml", + r#" [package] - name = "foo" + name = "dep" version = "0.0.1" edition = "2015" license = "MIT" @@ -379,37 +434,38 @@ fn discovery_inferred_lib_included() { authors = [] include = ["src/main.rs", "src/lib.rs"] "#, + ) + .file("src/main.rs", "fn main() {}") + .file("src/lib.rs", "") + }); + + let p = project() + .file( + "Cargo.toml", + &format!( + r#" + [package] + name = "foo" + version = "0.5.0" + edition = "2015" + + [dependencies.dep] + git = '{}' + "#, + git_project.url() + ), ) .file("src/main.rs", "fn main() {}") - .file("src/lib.rs", "") .build(); - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[PACKAGED] 5 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); + p.cargo("vendor --respect-source-config").run(); + add_git_vendor_config(&p, &git_project); - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &[ - "Cargo.lock", - "Cargo.toml", - "Cargo.toml.orig", - "src/main.rs", - "src/lib.rs", - ], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO + let lock = p.read_file("vendor/dep/Cargo.toml"); + assert_e2e().eq( + lock, + str![[r##" +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility @@ -420,9 +476,13 @@ fn discovery_inferred_lib_included() { # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. +example = [] +test = [] +bench = [] + [package] edition = "2015" -name = "foo" +name = "dep" version = "0.0.1" authors = [] build = false @@ -440,25 +500,28 @@ readme = false license = "MIT" [lib] -name = "foo" +name = "dep" path = "src/lib.rs" [[bin]] -name = "foo" +name = "dep" path = "src/main.rs" -"#, - )], + +"##]], ); + + p.cargo("check").run(); } #[cargo_test] fn discovery_inferred_lib_excluded() { - let p = project() - .file( - "Cargo.toml", - r#" + let git_project = git::new("dep", |project| { + project + .file( + "Cargo.toml", + r#" [package] - name = "foo" + name = "dep" version = "0.0.1" edition = "2015" license = "MIT" @@ -467,32 +530,38 @@ fn discovery_inferred_lib_excluded() { authors = [] include = ["src/main.rs"] "#, + ) + .file("src/main.rs", "fn main() {}") + .file("src/lib.rs", "") + }); + + let p = project() + .file( + "Cargo.toml", + &format!( + r#" + [package] + name = "foo" + version = "0.5.0" + edition = "2015" + + [dependencies.dep] + git = '{}' + "#, + git_project.url() + ), ) .file("src/main.rs", "fn main() {}") - .file("src/lib.rs", "") .build(); - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[WARNING] ignoring library `foo` as `src/lib.rs` is not included in the published package -[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); + p.cargo("vendor --respect-source-config").run(); + add_git_vendor_config(&p, &git_project); - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO + let lock = p.read_file("vendor/dep/Cargo.toml"); + assert_e2e().eq( + lock, + str![[r##" +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility @@ -503,9 +572,13 @@ fn discovery_inferred_lib_excluded() { # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. +example = [] +test = [] +bench = [] + [package] edition = "2015" -name = "foo" +name = "dep" version = "0.0.1" authors = [] build = false @@ -519,22 +592,38 @@ documentation = "docs.rs/foo" readme = false license = "MIT" +[lib] +name = "dep" +path = "src/lib.rs" + [[bin]] -name = "foo" +name = "dep" path = "src/main.rs" -"#, - )], + +"##]], ); + + p.cargo("check") + .with_status(101) + .with_stderr_data(str![[r#" +[CHECKING] dep v0.0.1 ([ROOTURL]/dep#[..]) +[ERROR] couldn't read [ROOT]/foo/vendor/dep/src/lib.rs: [NOT_FOUND] + +[ERROR] could not compile `dep` (lib) due to 1 previous error + +"#]]) + .run(); } #[cargo_test] fn discovery_inferred_other_included() { - let p = project() + let git_project = git::new("dep", |project| { + project .file( "Cargo.toml", r#" [package] - name = "foo" + name = "dep" version = "0.0.1" edition = "2015" license = "MIT" @@ -549,37 +638,35 @@ fn discovery_inferred_other_included() { .file("examples/example_foo.rs", "fn main() {}") .file("tests/test_foo.rs", "fn main() {}") .file("benches/bench_foo.rs", "fn main() {}") - .build(); + }); - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[PACKAGED] 8 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s + let p = project() + .file( + "Cargo.toml", + &format!( + r#" + [package] + name = "foo" + version = "0.5.0" + edition = "2015" -"#]]) - .run(); + [dependencies.dep] + git = '{}' + "#, + git_project.url() + ), + ) + .file("src/main.rs", "fn main() {}") + .build(); - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &[ - "Cargo.lock", - "Cargo.toml", - "Cargo.toml.orig", - "src/lib.rs", - "src/bin/foo/main.rs", - "examples/example_foo.rs", - "tests/test_foo.rs", - "benches/bench_foo.rs", - ], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO + p.cargo("vendor --respect-source-config").run(); + add_git_vendor_config(&p, &git_project); + + let lock = p.read_file("vendor/dep/Cargo.toml"); + assert_e2e().eq( + lock, + str![[r##" +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility @@ -592,7 +679,7 @@ fn discovery_inferred_other_included() { [package] edition = "2015" -name = "foo" +name = "dep" version = "0.0.1" authors = [] build = false @@ -613,7 +700,7 @@ readme = false license = "MIT" [lib] -name = "foo" +name = "dep" path = "src/lib.rs" [[bin]] @@ -631,19 +718,22 @@ path = "tests/test_foo.rs" [[bench]] name = "bench_foo" path = "benches/bench_foo.rs" -"#, - )], + +"##]], ); + + p.cargo("check").run(); } #[cargo_test] fn discovery_inferred_other_excluded() { - let p = project() - .file( - "Cargo.toml", - r#" + let git_project = git::new("dep", |project| { + project + .file( + "Cargo.toml", + r#" [package] - name = "foo" + name = "dep" version = "0.0.1" edition = "2015" license = "MIT" @@ -652,38 +742,41 @@ fn discovery_inferred_other_excluded() { authors = [] include = ["src/lib.rs"] "#, + ) + .file("src/lib.rs", "") + .file("src/bin/foo/main.rs", "fn main() {}") + .file("examples/example_foo.rs", "fn main() {}") + .file("tests/test_foo.rs", "fn main() {}") + .file("benches/bench_foo.rs", "fn main() {}") + }); + + let p = project() + .file( + "Cargo.toml", + &format!( + r#" + [package] + name = "foo" + version = "0.5.0" + edition = "2015" + + [dependencies.dep] + git = '{}' + "#, + git_project.url() + ), ) - .file("src/lib.rs", "") - .file("src/bin/foo/main.rs", "fn main() {}") - .file("examples/example_foo.rs", "fn main() {}") - .file("tests/test_foo.rs", "fn main() {}") - .file("benches/bench_foo.rs", "fn main() {}") + .file("src/main.rs", "fn main() {}") .build(); - p.cargo("package") - .with_stdout_data("") - .with_stderr_data(str![[r#" -[PACKAGING] foo v0.0.1 ([ROOT]/foo) -[WARNING] ignoring binary `foo` as `src/bin/foo/main.rs` is not included in the published package -[WARNING] ignoring example `example_foo` as `examples/example_foo.rs` is not included in the published package -[WARNING] ignoring test `test_foo` as `tests/test_foo.rs` is not included in the published package -[WARNING] ignoring benchmark `bench_foo` as `benches/bench_foo.rs` is not included in the published package -[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed) -[VERIFYING] foo v0.0.1 ([ROOT]/foo) -[COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1) -[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s - -"#]]) - .run(); + p.cargo("vendor --respect-source-config").run(); + add_git_vendor_config(&p, &git_project); - let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap(); - validate_crate_contents( - f, - "foo-0.0.1.crate", - &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/lib.rs"], - &[( - "Cargo.toml", - r#"# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO + let lock = p.read_file("vendor/dep/Cargo.toml"); + assert_e2e().eq( + lock, + str![[r##" +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility @@ -696,7 +789,7 @@ fn discovery_inferred_other_excluded() { [package] edition = "2015" -name = "foo" +name = "dep" version = "0.0.1" authors = [] build = false @@ -711,11 +804,29 @@ readme = false license = "MIT" [lib] -name = "foo" +name = "dep" path = "src/lib.rs" -"#, - )], + +[[bin]] +name = "foo" +path = "src/bin/foo/main.rs" + +[[example]] +name = "example_foo" +path = "examples/example_foo.rs" + +[[test]] +name = "test_foo" +path = "tests/test_foo.rs" + +[[bench]] +name = "bench_foo" +path = "benches/bench_foo.rs" + +"##]], ); + + p.cargo("check").run(); } #[cargo_test] From 78651cd33fa8326127ccfc0f3dfea1086d9457e3 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Wed, 7 Aug 2024 12:27:37 -0500 Subject: [PATCH 7/7] fix(vendor): Strip excluded build targets This is a **very** hacky solution, duplicating the minimum of what `prepare_for_publish` does to fix this one issue and in the least intrusive way to the vendor code. The intention is to keep this low risk for backporting to beta and stable. We need to revisit this, refactoring the `cargo package` code so that we can call into that for each vendored dependency. Fixes #14348 --- src/cargo/ops/vendor.rs | 120 ++++++++++++++++++++++++++++++++++++- src/cargo/util/toml/mod.rs | 8 +-- tests/testsuite/vendor.rs | 68 ++------------------- 3 files changed, 126 insertions(+), 70 deletions(-) diff --git a/src/cargo/ops/vendor.rs b/src/cargo/ops/vendor.rs index f319dedce38..bdec76a4efa 100644 --- a/src/cargo/ops/vendor.rs +++ b/src/cargo/ops/vendor.rs @@ -221,7 +221,7 @@ fn sync( let pathsource = PathSource::new(src, id.source_id(), gctx); let paths = pathsource.list_files(pkg)?; let mut map = BTreeMap::new(); - cp_sources(pkg, src, &paths, &dst, &mut map, &mut tmp_buf) + cp_sources(pkg, src, &paths, &dst, &mut map, &mut tmp_buf, gctx) .with_context(|| format!("failed to copy over vendored sources for: {}", id))?; // Finally, emit the metadata about this package @@ -317,6 +317,7 @@ fn cp_sources( dst: &Path, cksums: &mut BTreeMap, tmp_buf: &mut [u8], + gctx: &GlobalContext, ) -> CargoResult<()> { for p in paths { let relative = p.strip_prefix(&src).unwrap(); @@ -360,7 +361,12 @@ fn cp_sources( let cksum = if dst.file_name() == Some(OsStr::new("Cargo.toml")) && pkg.package_id().source_id().is_git() { - let contents = pkg.manifest().to_resolved_contents()?; + let packaged_files = paths + .iter() + .map(|p| p.strip_prefix(src).unwrap().to_owned()) + .collect::>(); + let vendored_pkg = prepare_for_vendor(pkg, &packaged_files, gctx)?; + let contents = vendored_pkg.manifest().to_resolved_contents()?; copy_and_checksum( &dst, &mut dst_opts, @@ -392,6 +398,116 @@ fn cp_sources( Ok(()) } +/// HACK: Perform the bare minimum of `prepare_for_publish` needed for #14348. +/// +/// There are parts of `prepare_for_publish` that could be directly useful (e.g. stripping +/// `[workspace]`) while other parts that require other filesystem operations (moving the README +/// file) and ideally we'd reuse `cargo package` code to take care of all of this for us. +fn prepare_for_vendor( + me: &Package, + packaged_files: &[PathBuf], + gctx: &GlobalContext, +) -> CargoResult { + let contents = me.manifest().contents(); + let document = me.manifest().document(); + let original_toml = + prepare_toml_for_vendor(me.manifest().resolved_toml().clone(), packaged_files, gctx)?; + let normalized_toml = original_toml.clone(); + let features = me.manifest().unstable_features().clone(); + let workspace_config = me.manifest().workspace_config().clone(); + let source_id = me.package_id().source_id(); + let mut warnings = Default::default(); + let mut errors = Default::default(); + let manifest = crate::util::toml::to_real_manifest( + contents.to_owned(), + document.clone(), + original_toml, + normalized_toml, + features, + workspace_config, + source_id, + me.manifest_path(), + gctx, + &mut warnings, + &mut errors, + )?; + let new_pkg = Package::new(manifest, me.manifest_path()); + Ok(new_pkg) +} + +fn prepare_toml_for_vendor( + mut me: cargo_util_schemas::manifest::TomlManifest, + packaged_files: &[PathBuf], + gctx: &GlobalContext, +) -> CargoResult { + let package = me + .package + .as_mut() + .expect("venedored manifests must have packages"); + if let Some(cargo_util_schemas::manifest::StringOrBool::String(path)) = &package.build { + let path = paths::normalize_path(Path::new(path)); + let included = packaged_files.contains(&path); + let build = if included { + let path = path + .into_os_string() + .into_string() + .map_err(|_err| anyhow::format_err!("non-UTF8 `package.build`"))?; + let path = crate::util::toml::normalize_path_string_sep(path); + cargo_util_schemas::manifest::StringOrBool::String(path) + } else { + gctx.shell().warn(format!( + "ignoring `package.build` as `{}` is not included in the published package", + path.display() + ))?; + cargo_util_schemas::manifest::StringOrBool::Bool(false) + }; + package.build = Some(build); + } + + let lib = if let Some(target) = &me.lib { + crate::util::toml::prepare_target_for_publish( + target, + Some(packaged_files), + "library", + gctx, + )? + } else { + None + }; + let bin = crate::util::toml::prepare_targets_for_publish( + me.bin.as_ref(), + Some(packaged_files), + "binary", + gctx, + )?; + let example = crate::util::toml::prepare_targets_for_publish( + me.example.as_ref(), + Some(packaged_files), + "example", + gctx, + )?; + let test = crate::util::toml::prepare_targets_for_publish( + me.test.as_ref(), + Some(packaged_files), + "test", + gctx, + )?; + let bench = crate::util::toml::prepare_targets_for_publish( + me.bench.as_ref(), + Some(packaged_files), + "benchmark", + gctx, + )?; + + me.lib = lib; + me.bin = bin; + me.example = example; + me.test = test; + me.bench = bench; + + Ok(me) +} + fn copy_and_checksum( dst_path: &Path, dst_opts: &mut OpenOptions, diff --git a/src/cargo/util/toml/mod.rs b/src/cargo/util/toml/mod.rs index ef66abf24d5..834f49f3fc7 100644 --- a/src/cargo/util/toml/mod.rs +++ b/src/cargo/util/toml/mod.rs @@ -1107,7 +1107,7 @@ fn deprecated_ws_default_features( } #[tracing::instrument(skip_all)] -fn to_real_manifest( +pub fn to_real_manifest( contents: String, document: toml_edit::ImDocument, original_toml: manifest::TomlManifest, @@ -2897,7 +2897,7 @@ fn prepare_toml_for_publish( } } -fn prepare_targets_for_publish( +pub fn prepare_targets_for_publish( targets: Option<&Vec>, included: Option<&[PathBuf]>, context: &str, @@ -2922,7 +2922,7 @@ fn prepare_targets_for_publish( } } -fn prepare_target_for_publish( +pub fn prepare_target_for_publish( target: &manifest::TomlTarget, included: Option<&[PathBuf]>, context: &str, @@ -2957,7 +2957,7 @@ fn normalize_path_sep(path: PathBuf, context: &str) -> CargoResult { Ok(path.into()) } -fn normalize_path_string_sep(path: String) -> String { +pub fn normalize_path_string_sep(path: String) -> String { if std::path::MAIN_SEPARATOR != '/' { path.replace(std::path::MAIN_SEPARATOR, "/") } else { diff --git a/tests/testsuite/vendor.rs b/tests/testsuite/vendor.rs index 1a2b783fe8f..0f3a7f7b4ef 100644 --- a/tests/testsuite/vendor.rs +++ b/tests/testsuite/vendor.rs @@ -284,11 +284,6 @@ fn discovery_inferred_build_rs_included() { # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. -bin = [] -example = [] -test = [] -bench = [] - [package] edition = "2015" name = "dep" @@ -377,17 +372,12 @@ fn discovery_inferred_build_rs_excluded() { # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. -bin = [] -example = [] -test = [] -bench = [] - [package] edition = "2015" name = "dep" version = "0.0.1" authors = [] -build = "build.rs" +build = false include = ["src/lib.rs"] autobins = false autoexamples = false @@ -405,16 +395,7 @@ path = "src/lib.rs" "##]], ); - p.cargo("check") - .with_status(101) - .with_stderr_data(str![[r#" -[COMPILING] dep v0.0.1 ([ROOTURL]/dep#[..]) -[ERROR] couldn't read [ROOT]/foo/vendor/dep/build.rs: [NOT_FOUND] - -[ERROR] could not compile `dep` (build script) due to 1 previous error - -"#]]) - .run(); + p.cargo("check").run(); } #[cargo_test] @@ -476,10 +457,6 @@ fn discovery_inferred_lib_included() { # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. -example = [] -test = [] -bench = [] - [package] edition = "2015" name = "dep" @@ -572,10 +549,6 @@ fn discovery_inferred_lib_excluded() { # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. -example = [] -test = [] -bench = [] - [package] edition = "2015" name = "dep" @@ -592,10 +565,6 @@ documentation = "docs.rs/foo" readme = false license = "MIT" -[lib] -name = "dep" -path = "src/lib.rs" - [[bin]] name = "dep" path = "src/main.rs" @@ -603,16 +572,7 @@ path = "src/main.rs" "##]], ); - p.cargo("check") - .with_status(101) - .with_stderr_data(str![[r#" -[CHECKING] dep v0.0.1 ([ROOTURL]/dep#[..]) -[ERROR] couldn't read [ROOT]/foo/vendor/dep/src/lib.rs: [NOT_FOUND] - -[ERROR] could not compile `dep` (lib) due to 1 previous error - -"#]]) - .run(); + p.cargo("check").run(); } #[cargo_test] @@ -807,22 +767,6 @@ license = "MIT" name = "dep" path = "src/lib.rs" -[[bin]] -name = "foo" -path = "src/bin/foo/main.rs" - -[[example]] -name = "example_foo" -path = "examples/example_foo.rs" - -[[test]] -name = "test_foo" -path = "tests/test_foo.rs" - -[[bench]] -name = "bench_foo" -path = "benches/bench_foo.rs" - "##]], ); @@ -1577,10 +1521,6 @@ fn git_deterministic() { # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. -bin = [] -test = [] -bench = [] - [package] edition = "2021" name = "git_dep" @@ -1598,7 +1538,7 @@ license = "MIT" [lib] name = "git_dep" -path = [..] +path = "src/lib.rs" [[example]] name = "a"