2019-11-25 02:42:45 +00:00
|
|
|
//! Tests for the `cargo package` command.
|
|
|
|
|
2019-09-12 17:14:29 +00:00
|
|
|
use cargo_test_support::paths::CargoPathExt;
|
|
|
|
use cargo_test_support::registry::Package;
|
|
|
|
use cargo_test_support::{
|
2019-07-29 06:36:13 +00:00
|
|
|
basic_manifest, cargo_process, git, path2url, paths, project, publish::validate_crate_contents,
|
2019-09-12 17:14:29 +00:00
|
|
|
registry, symlink_supported, t,
|
2018-12-30 04:46:15 +00:00
|
|
|
};
|
2020-04-11 17:38:21 +00:00
|
|
|
use std::fs::{self, read_to_string, File};
|
2020-04-17 04:10:11 +00:00
|
|
|
use std::path::Path;
|
2014-07-18 15:40:45 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn simple() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-12-08 11:19:47 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2014-07-18 15:40:45 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
2014-09-09 02:38:16 +00:00
|
|
|
exclude = ["*.txt"]
|
2014-11-18 12:23:53 +00:00
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
2018-12-08 11:19:47 +00:00
|
|
|
"#,
|
|
|
|
)
|
2018-07-25 00:30:32 +00:00
|
|
|
.file("src/main.rs", r#"fn main() { println!("hello"); }"#)
|
2017-07-22 03:12:21 +00:00
|
|
|
.file("src/bar.txt", "") // should be ignored when packaging
|
|
|
|
.build();
|
2014-07-18 15:40:45 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package")
|
2018-09-03 09:38:29 +00:00
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-05-20 00:52:13 +00:00
|
|
|
[WARNING] manifest has no documentation[..]
|
2016-09-01 00:04:29 +00:00
|
|
|
See [..]
|
2018-09-08 02:42:26 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([CWD])
|
|
|
|
[VERIFYING] foo v0.0.1 ([CWD])
|
|
|
|
[COMPILING] foo v0.0.1 ([CWD][..])
|
2017-01-12 01:03:36 +00:00
|
|
|
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
|
2014-07-18 15:40:45 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2018-08-29 06:11:10 +00:00
|
|
|
assert!(p.root().join("target/package/foo-0.0.1.crate").is_file());
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package -l")
|
|
|
|
.with_stdout(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2019-06-10 19:38:51 +00:00
|
|
|
Cargo.lock
|
2014-11-13 06:28:30 +00:00
|
|
|
Cargo.toml
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig
|
2018-08-02 09:18:48 +00:00
|
|
|
src/main.rs
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package").with_stdout("").run();
|
2014-09-09 02:38:16 +00:00
|
|
|
|
2014-12-21 23:19:44 +00:00
|
|
|
let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap();
|
2018-12-30 04:46:15 +00:00
|
|
|
validate_crate_contents(
|
|
|
|
f,
|
|
|
|
"foo-0.0.1.crate",
|
2019-06-10 19:38:51 +00:00
|
|
|
&["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"],
|
2018-12-30 04:46:15 +00:00
|
|
|
&[],
|
|
|
|
);
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2014-11-18 12:23:53 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn metadata_warning() {
|
2018-08-28 09:20:03 +00:00
|
|
|
let p = project().file("src/main.rs", "fn main() {}").build();
|
|
|
|
p.cargo("package")
|
2018-09-03 09:38:29 +00:00
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-05-20 00:52:13 +00:00
|
|
|
warning: manifest has no description, license, license-file, documentation, \
|
2016-09-01 00:04:29 +00:00
|
|
|
homepage or repository.
|
2019-01-30 20:34:37 +00:00
|
|
|
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
|
2018-09-08 02:42:26 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([CWD])
|
|
|
|
[VERIFYING] foo v0.0.1 ([CWD])
|
|
|
|
[COMPILING] foo v0.0.1 ([CWD][..])
|
2017-01-12 01:03:36 +00:00
|
|
|
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
|
2014-11-18 12:23:53 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2014-11-18 12:23:53 +00:00
|
|
|
|
2018-07-20 17:41:44 +00:00
|
|
|
let p = project()
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2014-11-18 12:23:53 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/main.rs", "fn main() {}")
|
2017-07-22 03:12:21 +00:00
|
|
|
.build();
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package")
|
2018-09-03 09:38:29 +00:00
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-09-01 00:04:29 +00:00
|
|
|
warning: manifest has no description, documentation, homepage or repository.
|
2019-01-30 20:34:37 +00:00
|
|
|
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
|
2018-09-08 02:42:26 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([CWD])
|
|
|
|
[VERIFYING] foo v0.0.1 ([CWD])
|
|
|
|
[COMPILING] foo v0.0.1 ([CWD][..])
|
2017-01-12 01:03:36 +00:00
|
|
|
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
|
2014-11-18 12:23:53 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2014-11-18 12:23:53 +00:00
|
|
|
|
2018-07-20 17:41:44 +00:00
|
|
|
let p = project()
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2014-11-18 12:23:53 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
2014-12-15 04:43:38 +00:00
|
|
|
repository = "bar"
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/main.rs", "fn main() {}")
|
2017-07-22 03:12:21 +00:00
|
|
|
.build();
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package")
|
2018-09-03 09:38:29 +00:00
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2018-09-08 02:42:26 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([CWD])
|
|
|
|
[VERIFYING] foo v0.0.1 ([CWD])
|
|
|
|
[COMPILING] foo v0.0.1 ([CWD][..])
|
2017-01-12 01:03:36 +00:00
|
|
|
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
|
2014-11-18 12:23:53 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2014-11-18 12:23:53 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn package_verbose() {
|
2014-11-21 20:31:00 +00:00
|
|
|
let root = paths::root().join("all");
|
2018-07-23 23:55:06 +00:00
|
|
|
let repo = git::repo(&root)
|
2018-07-24 22:35:01 +00:00
|
|
|
.file("Cargo.toml", &basic_manifest("foo", "0.0.1"))
|
2018-07-25 00:30:32 +00:00
|
|
|
.file("src/main.rs", "fn main() {}")
|
2018-07-24 22:35:01 +00:00
|
|
|
.file("a/Cargo.toml", &basic_manifest("a", "0.0.1"))
|
2017-07-22 03:12:21 +00:00
|
|
|
.file("a/src/lib.rs", "")
|
|
|
|
.build();
|
2018-08-28 09:20:03 +00:00
|
|
|
cargo_process("build").cwd(repo.root()).run();
|
2016-03-01 16:24:43 +00:00
|
|
|
|
|
|
|
println!("package main repo");
|
2018-08-28 09:20:03 +00:00
|
|
|
cargo_process("package -v --no-verify")
|
|
|
|
.cwd(repo.root())
|
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-05-20 00:52:13 +00:00
|
|
|
[WARNING] manifest has no description[..]
|
2019-01-30 20:34:37 +00:00
|
|
|
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
|
2016-05-12 15:23:53 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([..])
|
2018-07-23 23:55:06 +00:00
|
|
|
[ARCHIVING] .cargo_vcs_info.json
|
2019-06-10 19:38:51 +00:00
|
|
|
[ARCHIVING] Cargo.lock
|
2020-02-19 18:46:54 +00:00
|
|
|
[ARCHIVING] Cargo.toml
|
|
|
|
[ARCHIVING] Cargo.toml.orig
|
|
|
|
[ARCHIVING] src/main.rs
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-03-01 16:24:43 +00:00
|
|
|
|
2018-07-23 23:55:06 +00:00
|
|
|
let f = File::open(&repo.root().join("target/package/foo-0.0.1.crate")).unwrap();
|
2018-12-30 04:46:15 +00:00
|
|
|
let vcs_contents = format!(
|
|
|
|
r#"{{
|
2018-07-23 23:55:06 +00:00
|
|
|
"git": {{
|
|
|
|
"sha1": "{}"
|
|
|
|
}}
|
|
|
|
}}
|
|
|
|
"#,
|
2018-12-30 04:46:15 +00:00
|
|
|
repo.revparse_head()
|
|
|
|
);
|
|
|
|
validate_crate_contents(
|
|
|
|
f,
|
|
|
|
"foo-0.0.1.crate",
|
|
|
|
&[
|
2019-06-10 19:38:51 +00:00
|
|
|
"Cargo.lock",
|
2018-12-30 04:46:15 +00:00
|
|
|
"Cargo.toml",
|
|
|
|
"Cargo.toml.orig",
|
|
|
|
"src/main.rs",
|
|
|
|
".cargo_vcs_info.json",
|
|
|
|
],
|
|
|
|
&[(".cargo_vcs_info.json", &vcs_contents)],
|
2018-07-23 23:55:06 +00:00
|
|
|
);
|
|
|
|
|
2016-03-01 16:24:43 +00:00
|
|
|
println!("package sub-repo");
|
2018-08-28 09:20:03 +00:00
|
|
|
cargo_process("package -v --no-verify")
|
|
|
|
.cwd(repo.root().join("a"))
|
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-05-20 00:52:13 +00:00
|
|
|
[WARNING] manifest has no description[..]
|
2019-01-30 20:34:37 +00:00
|
|
|
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
|
2016-05-12 15:23:53 +00:00
|
|
|
[PACKAGING] a v0.0.1 ([..])
|
2020-02-19 18:46:54 +00:00
|
|
|
[ARCHIVING] .cargo_vcs_info.json
|
2018-07-23 23:55:06 +00:00
|
|
|
[ARCHIVING] Cargo.toml
|
2020-02-19 18:46:54 +00:00
|
|
|
[ARCHIVING] Cargo.toml.orig
|
2018-07-23 23:55:06 +00:00
|
|
|
[ARCHIVING] src/lib.rs
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2014-11-21 06:48:18 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn package_verification() {
|
2018-08-28 09:20:03 +00:00
|
|
|
let p = project().file("src/main.rs", "fn main() {}").build();
|
|
|
|
p.cargo("build").run();
|
|
|
|
p.cargo("package")
|
2018-09-03 09:38:29 +00:00
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-05-20 00:52:13 +00:00
|
|
|
[WARNING] manifest has no description[..]
|
2019-01-30 20:34:37 +00:00
|
|
|
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
|
2018-09-08 02:42:26 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([CWD])
|
|
|
|
[VERIFYING] foo v0.0.1 ([CWD])
|
|
|
|
[COMPILING] foo v0.0.1 ([CWD][..])
|
2017-01-12 01:03:36 +00:00
|
|
|
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
|
2014-11-21 06:48:18 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2015-01-06 07:54:16 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2018-07-24 21:53:30 +00:00
|
|
|
fn vcs_file_collision() {
|
|
|
|
let p = project().build();
|
|
|
|
let _ = git::repo(&paths::root().join("foo"))
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
description = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
|
|
|
documentation = "foo"
|
|
|
|
homepage = "foo"
|
|
|
|
repository = "foo"
|
|
|
|
exclude = ["*.no-existe"]
|
2018-08-28 09:20:03 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file(
|
2018-07-24 21:53:30 +00:00
|
|
|
"src/main.rs",
|
|
|
|
r#"
|
|
|
|
fn main() {}
|
2018-08-28 09:20:03 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file(".cargo_vcs_info.json", "foo")
|
2018-07-24 21:53:30 +00:00
|
|
|
.build();
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package")
|
|
|
|
.arg("--no-verify")
|
|
|
|
.with_status(101)
|
2018-09-03 09:38:29 +00:00
|
|
|
.with_stderr(
|
2018-07-24 21:53:30 +00:00
|
|
|
"\
|
2020-02-19 18:46:54 +00:00
|
|
|
[ERROR] invalid inclusion of reserved file name .cargo_vcs_info.json \
|
2018-07-24 21:53:30 +00:00
|
|
|
in package source
|
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2018-07-24 21:53:30 +00:00
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-08-31 23:13:26 +00:00
|
|
|
fn path_dependency_no_version() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2016-08-31 23:13:26 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
|
|
|
|
[dependencies.bar]
|
|
|
|
path = "bar"
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/main.rs", "fn main() {}")
|
2018-07-24 22:35:01 +00:00
|
|
|
.file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
|
2017-07-22 03:12:21 +00:00
|
|
|
.file("bar/src/lib.rs", "")
|
|
|
|
.build();
|
2016-08-31 23:13:26 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package")
|
|
|
|
.with_status(101)
|
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-09-01 00:04:29 +00:00
|
|
|
[WARNING] manifest has no documentation, homepage or repository.
|
2019-01-30 20:34:37 +00:00
|
|
|
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
|
2016-08-31 23:13:26 +00:00
|
|
|
[ERROR] all path dependencies must have a version specified when packaging.
|
|
|
|
dependency `bar` does not specify a version.
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-08-31 23:13:26 +00:00
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn exclude() {
|
2018-11-04 16:59:20 +00:00
|
|
|
let root = paths::root().join("exclude");
|
|
|
|
let repo = git::repo(&root)
|
2018-12-08 11:19:47 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2015-01-06 07:54:16 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
2017-07-07 18:52:03 +00:00
|
|
|
exclude = [
|
|
|
|
"*.txt",
|
|
|
|
# file in root
|
|
|
|
"file_root_1", # NO_CHANGE (ignored)
|
|
|
|
"/file_root_2", # CHANGING (packaged -> ignored)
|
|
|
|
"file_root_3/", # NO_CHANGE (packaged)
|
|
|
|
"file_root_4/*", # NO_CHANGE (packaged)
|
|
|
|
"file_root_5/**", # NO_CHANGE (packaged)
|
|
|
|
# file in sub-dir
|
|
|
|
"file_deep_1", # CHANGING (packaged -> ignored)
|
|
|
|
"/file_deep_2", # NO_CHANGE (packaged)
|
|
|
|
"file_deep_3/", # NO_CHANGE (packaged)
|
|
|
|
"file_deep_4/*", # NO_CHANGE (packaged)
|
|
|
|
"file_deep_5/**", # NO_CHANGE (packaged)
|
|
|
|
# dir in root
|
|
|
|
"dir_root_1", # CHANGING (packaged -> ignored)
|
|
|
|
"/dir_root_2", # CHANGING (packaged -> ignored)
|
|
|
|
"dir_root_3/", # CHANGING (packaged -> ignored)
|
|
|
|
"dir_root_4/*", # NO_CHANGE (ignored)
|
|
|
|
"dir_root_5/**", # NO_CHANGE (ignored)
|
|
|
|
# dir in sub-dir
|
|
|
|
"dir_deep_1", # CHANGING (packaged -> ignored)
|
|
|
|
"/dir_deep_2", # NO_CHANGE
|
|
|
|
"dir_deep_3/", # CHANGING (packaged -> ignored)
|
|
|
|
"dir_deep_4/*", # CHANGING (packaged -> ignored)
|
|
|
|
"dir_deep_5/**", # CHANGING (packaged -> ignored)
|
|
|
|
]
|
2018-12-08 11:19:47 +00:00
|
|
|
"#,
|
|
|
|
)
|
2018-07-25 00:30:32 +00:00
|
|
|
.file("src/main.rs", r#"fn main() { println!("hello"); }"#)
|
2015-01-06 07:54:16 +00:00
|
|
|
.file("bar.txt", "")
|
2017-07-07 18:52:03 +00:00
|
|
|
.file("src/bar.txt", "")
|
2019-02-03 04:01:23 +00:00
|
|
|
// File in root.
|
2017-07-07 18:52:03 +00:00
|
|
|
.file("file_root_1", "")
|
|
|
|
.file("file_root_2", "")
|
|
|
|
.file("file_root_3", "")
|
|
|
|
.file("file_root_4", "")
|
|
|
|
.file("file_root_5", "")
|
2019-02-03 04:01:23 +00:00
|
|
|
// File in sub-dir.
|
2017-07-07 18:52:03 +00:00
|
|
|
.file("some_dir/file_deep_1", "")
|
|
|
|
.file("some_dir/file_deep_2", "")
|
|
|
|
.file("some_dir/file_deep_3", "")
|
|
|
|
.file("some_dir/file_deep_4", "")
|
|
|
|
.file("some_dir/file_deep_5", "")
|
2019-02-03 04:01:23 +00:00
|
|
|
// Dir in root.
|
2017-07-07 18:52:03 +00:00
|
|
|
.file("dir_root_1/some_dir/file", "")
|
|
|
|
.file("dir_root_2/some_dir/file", "")
|
|
|
|
.file("dir_root_3/some_dir/file", "")
|
|
|
|
.file("dir_root_4/some_dir/file", "")
|
|
|
|
.file("dir_root_5/some_dir/file", "")
|
2019-02-03 04:01:23 +00:00
|
|
|
// Dir in sub-dir.
|
2017-07-07 18:52:03 +00:00
|
|
|
.file("some_dir/dir_deep_1/some_dir/file", "")
|
|
|
|
.file("some_dir/dir_deep_2/some_dir/file", "")
|
|
|
|
.file("some_dir/dir_deep_3/some_dir/file", "")
|
|
|
|
.file("some_dir/dir_deep_4/some_dir/file", "")
|
|
|
|
.file("some_dir/dir_deep_5/some_dir/file", "")
|
2017-07-22 03:12:21 +00:00
|
|
|
.build();
|
2015-01-06 07:54:16 +00:00
|
|
|
|
2018-11-04 16:59:20 +00:00
|
|
|
cargo_process("package --no-verify -v")
|
|
|
|
.cwd(repo.root())
|
2018-08-28 09:20:03 +00:00
|
|
|
.with_stdout("")
|
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-05-20 00:52:13 +00:00
|
|
|
[WARNING] manifest has no description[..]
|
2019-01-30 20:34:37 +00:00
|
|
|
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
|
2018-07-23 23:55:06 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([..])
|
2020-02-19 18:46:54 +00:00
|
|
|
[ARCHIVING] .cargo_vcs_info.json
|
|
|
|
[ARCHIVING] Cargo.lock
|
2019-06-10 19:38:51 +00:00
|
|
|
[ARCHIVING] Cargo.toml
|
2020-02-19 18:46:54 +00:00
|
|
|
[ARCHIVING] Cargo.toml.orig
|
2019-06-10 19:38:51 +00:00
|
|
|
[ARCHIVING] file_root_3
|
|
|
|
[ARCHIVING] file_root_4
|
|
|
|
[ARCHIVING] file_root_5
|
|
|
|
[ARCHIVING] some_dir/dir_deep_2/some_dir/file
|
|
|
|
[ARCHIVING] some_dir/dir_deep_4/some_dir/file
|
|
|
|
[ARCHIVING] some_dir/dir_deep_5/some_dir/file
|
|
|
|
[ARCHIVING] some_dir/file_deep_2
|
|
|
|
[ARCHIVING] some_dir/file_deep_3
|
|
|
|
[ARCHIVING] some_dir/file_deep_4
|
|
|
|
[ARCHIVING] some_dir/file_deep_5
|
|
|
|
[ARCHIVING] src/main.rs
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2017-07-07 18:52:03 +00:00
|
|
|
|
2018-11-04 16:59:20 +00:00
|
|
|
assert!(repo.root().join("target/package/foo-0.0.1.crate").is_file());
|
2017-07-07 18:52:03 +00:00
|
|
|
|
2018-11-04 16:59:20 +00:00
|
|
|
cargo_process("package -l")
|
|
|
|
.cwd(repo.root())
|
2018-08-28 09:20:03 +00:00
|
|
|
.with_stdout(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2018-11-04 16:59:20 +00:00
|
|
|
.cargo_vcs_info.json
|
2019-06-10 19:38:51 +00:00
|
|
|
Cargo.lock
|
2017-07-07 18:52:03 +00:00
|
|
|
Cargo.toml
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig
|
2017-07-07 18:52:03 +00:00
|
|
|
file_root_3
|
|
|
|
file_root_4
|
|
|
|
file_root_5
|
2018-08-02 09:18:48 +00:00
|
|
|
some_dir/dir_deep_2/some_dir/file
|
|
|
|
some_dir/dir_deep_4/some_dir/file
|
|
|
|
some_dir/dir_deep_5/some_dir/file
|
|
|
|
some_dir/file_deep_2
|
|
|
|
some_dir/file_deep_3
|
|
|
|
some_dir/file_deep_4
|
|
|
|
some_dir/file_deep_5
|
|
|
|
src/main.rs
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2015-01-06 07:54:16 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn include() {
|
2018-11-04 16:59:20 +00:00
|
|
|
let root = paths::root().join("include");
|
|
|
|
let repo = git::repo(&root)
|
2018-12-08 11:19:47 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2015-01-06 07:54:16 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
exclude = ["*.txt"]
|
2019-12-08 11:10:13 +00:00
|
|
|
include = ["foo.txt", "**/*.rs", "Cargo.toml", ".dotfile"]
|
2018-12-08 11:19:47 +00:00
|
|
|
"#,
|
|
|
|
)
|
2015-01-06 07:54:16 +00:00
|
|
|
.file("foo.txt", "")
|
2018-07-25 00:30:32 +00:00
|
|
|
.file("src/main.rs", r#"fn main() { println!("hello"); }"#)
|
2019-12-08 11:10:13 +00:00
|
|
|
.file(".dotfile", "")
|
2019-02-03 04:01:23 +00:00
|
|
|
// Should be ignored when packaging.
|
|
|
|
.file("src/bar.txt", "")
|
2017-07-22 03:12:21 +00:00
|
|
|
.build();
|
2015-01-06 07:54:16 +00:00
|
|
|
|
2018-11-04 16:59:20 +00:00
|
|
|
cargo_process("package --no-verify -v")
|
|
|
|
.cwd(repo.root())
|
2018-08-28 09:20:03 +00:00
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-05-20 00:52:13 +00:00
|
|
|
[WARNING] manifest has no description[..]
|
2019-01-30 20:34:37 +00:00
|
|
|
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
|
2019-05-10 02:05:31 +00:00
|
|
|
[WARNING] both package.include and package.exclude are specified; the exclude list will be ignored
|
2016-05-12 15:23:53 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([..])
|
2020-02-19 18:46:54 +00:00
|
|
|
[ARCHIVING] .cargo_vcs_info.json
|
2019-12-08 11:10:13 +00:00
|
|
|
[ARCHIVING] .dotfile
|
2020-02-19 18:46:54 +00:00
|
|
|
[ARCHIVING] Cargo.lock
|
2019-06-10 19:38:51 +00:00
|
|
|
[ARCHIVING] Cargo.toml
|
2020-02-19 18:46:54 +00:00
|
|
|
[ARCHIVING] Cargo.toml.orig
|
2019-06-10 19:38:51 +00:00
|
|
|
[ARCHIVING] foo.txt
|
|
|
|
[ARCHIVING] src/main.rs
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2015-03-11 20:32:59 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn package_lib_with_bin() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-07-25 00:30:32 +00:00
|
|
|
.file("src/main.rs", "extern crate foo; fn main() {}")
|
2017-07-22 03:12:21 +00:00
|
|
|
.file("src/lib.rs", "")
|
|
|
|
.build();
|
2015-03-11 20:32:59 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package -v").run();
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2015-01-14 05:40:22 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn package_git_submodule() {
|
2015-06-02 13:56:44 +00:00
|
|
|
let project = git::new("foo", |project| {
|
2018-03-14 15:17:44 +00:00
|
|
|
project
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2015-06-02 13:56:44 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = ["foo@example.com"]
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
repository = "foo"
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/lib.rs", "pub fn foo() {}")
|
2019-08-13 05:25:36 +00:00
|
|
|
});
|
2018-08-28 09:20:03 +00:00
|
|
|
let library = git::new("bar", |library| {
|
|
|
|
library.no_manifest().file("Makefile", "all:")
|
2019-08-13 05:25:36 +00:00
|
|
|
});
|
2015-06-02 13:56:44 +00:00
|
|
|
|
|
|
|
let repository = git2::Repository::open(&project.root()).unwrap();
|
|
|
|
let url = path2url(library.root()).to_string();
|
|
|
|
git::add_submodule(&repository, &url, Path::new("bar"));
|
|
|
|
git::commit(&repository);
|
|
|
|
|
|
|
|
let repository = git2::Repository::open(&project.root().join("bar")).unwrap();
|
2018-03-14 15:17:44 +00:00
|
|
|
repository
|
|
|
|
.reset(
|
|
|
|
&repository.revparse_single("HEAD").unwrap(),
|
|
|
|
git2::ResetType::Hard,
|
|
|
|
None,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.unwrap();
|
2018-03-14 15:17:44 +00:00
|
|
|
|
2018-12-08 11:19:47 +00:00
|
|
|
project
|
|
|
|
.cargo("package --no-verify -v")
|
2018-08-28 09:20:03 +00:00
|
|
|
.with_stderr_contains("[ARCHIVING] bar/Makefile")
|
|
|
|
.run();
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2015-07-05 18:34:43 +00:00
|
|
|
|
2019-04-08 05:53:00 +00:00
|
|
|
#[cargo_test]
|
2019-07-04 11:21:50 +00:00
|
|
|
/// Tests if a symlink to a git submodule is properly handled.
|
|
|
|
///
|
2019-07-29 06:36:13 +00:00
|
|
|
/// This test requires you to be able to make symlinks.
|
|
|
|
/// For windows, this may require you to enable developer mode.
|
2019-04-08 05:53:00 +00:00
|
|
|
fn package_symlink_to_submodule() {
|
2019-04-03 13:07:04 +00:00
|
|
|
#[cfg(unix)]
|
2019-07-04 11:21:50 +00:00
|
|
|
use std::os::unix::fs::symlink;
|
2019-04-03 13:07:04 +00:00
|
|
|
#[cfg(windows)]
|
2019-04-11 11:28:45 +00:00
|
|
|
use std::os::windows::fs::symlink_dir as symlink;
|
2019-04-03 13:07:04 +00:00
|
|
|
|
2019-07-29 06:36:13 +00:00
|
|
|
if !symlink_supported() {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-04-08 05:53:00 +00:00
|
|
|
let project = git::new("foo", |project| {
|
2019-07-04 11:21:50 +00:00
|
|
|
project.file("src/lib.rs", "pub fn foo() {}")
|
2019-08-13 05:25:36 +00:00
|
|
|
});
|
2019-04-08 05:53:00 +00:00
|
|
|
|
|
|
|
let library = git::new("submodule", |library| {
|
|
|
|
library.no_manifest().file("Makefile", "all:")
|
2019-08-13 05:25:36 +00:00
|
|
|
});
|
2019-04-08 05:53:00 +00:00
|
|
|
|
|
|
|
let repository = git2::Repository::open(&project.root()).unwrap();
|
|
|
|
let url = path2url(library.root()).to_string();
|
|
|
|
git::add_submodule(&repository, &url, Path::new("submodule"));
|
2019-07-04 11:21:50 +00:00
|
|
|
t!(symlink(
|
|
|
|
&project.root().join("submodule"),
|
|
|
|
&project.root().join("submodule-link")
|
|
|
|
));
|
2019-04-03 13:07:04 +00:00
|
|
|
git::add(&repository);
|
2019-04-08 05:53:00 +00:00
|
|
|
git::commit(&repository);
|
|
|
|
|
|
|
|
let repository = git2::Repository::open(&project.root().join("submodule")).unwrap();
|
|
|
|
repository
|
|
|
|
.reset(
|
|
|
|
&repository.revparse_single("HEAD").unwrap(),
|
|
|
|
git2::ResetType::Hard,
|
2019-07-04 11:21:50 +00:00
|
|
|
None,
|
|
|
|
)
|
|
|
|
.unwrap();
|
2019-04-08 05:53:00 +00:00
|
|
|
|
|
|
|
project
|
|
|
|
.cargo("package --no-verify -v")
|
|
|
|
.with_stderr_contains("[ARCHIVING] submodule/Makefile")
|
|
|
|
.run();
|
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn no_duplicates_from_modified_tracked_files() {
|
2020-04-17 04:10:11 +00:00
|
|
|
let p = git::new("all", |p| p.file("src/main.rs", "fn main() {}"));
|
|
|
|
p.change_file("src/main.rs", r#"fn main() { println!("A change!"); }"#);
|
|
|
|
p.cargo("build").run();
|
|
|
|
p.cargo("package --list --allow-dirty")
|
2018-08-28 09:20:03 +00:00
|
|
|
.with_stdout(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2019-06-10 19:38:51 +00:00
|
|
|
Cargo.lock
|
2016-01-10 19:47:02 +00:00
|
|
|
Cargo.toml
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig
|
2016-01-10 19:47:02 +00:00
|
|
|
src/main.rs
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2016-01-10 19:47:02 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn ignore_nested() {
|
2015-07-05 18:34:43 +00:00
|
|
|
let cargo_toml = r#"
|
|
|
|
[project]
|
2018-07-20 17:41:44 +00:00
|
|
|
name = "foo"
|
2015-07-05 18:34:43 +00:00
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
2018-07-20 17:41:44 +00:00
|
|
|
description = "foo"
|
2015-07-05 18:34:43 +00:00
|
|
|
"#;
|
|
|
|
let main_rs = r#"
|
|
|
|
fn main() { println!("hello"); }
|
|
|
|
"#;
|
2018-07-20 17:41:44 +00:00
|
|
|
let p = project()
|
2015-07-05 18:34:43 +00:00
|
|
|
.file("Cargo.toml", cargo_toml)
|
|
|
|
.file("src/main.rs", main_rs)
|
|
|
|
// If a project happens to contain a copy of itself, we should
|
|
|
|
// ignore it.
|
2018-07-20 17:41:44 +00:00
|
|
|
.file("a_dir/foo/Cargo.toml", cargo_toml)
|
|
|
|
.file("a_dir/foo/src/main.rs", main_rs)
|
2017-07-22 03:12:21 +00:00
|
|
|
.build();
|
2015-07-05 18:34:43 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package")
|
2018-09-03 09:38:29 +00:00
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-05-20 00:52:13 +00:00
|
|
|
[WARNING] manifest has no documentation[..]
|
2019-01-30 20:34:37 +00:00
|
|
|
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
|
2018-09-08 02:42:26 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([CWD])
|
|
|
|
[VERIFYING] foo v0.0.1 ([CWD])
|
|
|
|
[COMPILING] foo v0.0.1 ([CWD][..])
|
2017-01-12 01:03:36 +00:00
|
|
|
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
|
2015-07-05 18:34:43 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2018-08-29 06:11:10 +00:00
|
|
|
assert!(p.root().join("target/package/foo-0.0.1.crate").is_file());
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package -l")
|
|
|
|
.with_stdout(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2019-06-10 19:38:51 +00:00
|
|
|
Cargo.lock
|
2015-07-05 18:34:43 +00:00
|
|
|
Cargo.toml
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig
|
|
|
|
src/main.rs
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package").with_stdout("").run();
|
2015-07-05 18:34:43 +00:00
|
|
|
|
2018-07-20 17:41:44 +00:00
|
|
|
let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap();
|
2018-12-30 04:46:15 +00:00
|
|
|
validate_crate_contents(
|
|
|
|
f,
|
|
|
|
"foo-0.0.1.crate",
|
2019-06-10 19:38:51 +00:00
|
|
|
&["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"],
|
2018-12-30 04:46:15 +00:00
|
|
|
&[],
|
|
|
|
);
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2015-11-04 21:11:19 +00:00
|
|
|
|
2019-02-03 04:01:23 +00:00
|
|
|
// Windows doesn't allow these characters in filenames.
|
|
|
|
#[cfg(unix)]
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-05-25 20:55:42 +00:00
|
|
|
fn package_weird_characters() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-07-25 00:30:32 +00:00
|
|
|
.file("src/main.rs", r#"fn main() { println!("hello"); }"#)
|
2017-07-22 03:12:21 +00:00
|
|
|
.file("src/:foo", "")
|
|
|
|
.build();
|
2015-11-04 21:11:19 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package")
|
|
|
|
.with_status(101)
|
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2015-11-04 21:11:19 +00:00
|
|
|
warning: [..]
|
2016-09-01 00:04:29 +00:00
|
|
|
See [..]
|
2020-02-19 18:46:54 +00:00
|
|
|
[ERROR] cannot package a filename with a special character `:`: src/:foo
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-05-25 20:55:42 +00:00
|
|
|
}
|
2016-07-05 19:32:04 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-07-05 19:32:04 +00:00
|
|
|
fn repackage_on_source_change() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-07-25 00:30:32 +00:00
|
|
|
.file("src/main.rs", r#"fn main() { println!("hello"); }"#)
|
2017-07-22 03:12:21 +00:00
|
|
|
.build();
|
2016-07-05 19:32:04 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package").run();
|
2016-07-05 19:32:04 +00:00
|
|
|
|
|
|
|
// Add another source file
|
2020-04-17 04:10:11 +00:00
|
|
|
p.change_file("src/foo.rs", r#"fn main() { println!("foo"); }"#);
|
2016-07-05 19:32:04 +00:00
|
|
|
|
|
|
|
// Check that cargo rebuilds the tarball
|
2018-09-06 00:12:53 +00:00
|
|
|
p.cargo("package")
|
2018-09-03 09:38:29 +00:00
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-07-05 19:32:04 +00:00
|
|
|
[WARNING] [..]
|
2016-09-01 00:04:29 +00:00
|
|
|
See [..]
|
2018-09-08 02:42:26 +00:00
|
|
|
[PACKAGING] foo v0.0.1 ([CWD])
|
|
|
|
[VERIFYING] foo v0.0.1 ([CWD])
|
|
|
|
[COMPILING] foo v0.0.1 ([CWD][..])
|
2017-01-12 01:03:36 +00:00
|
|
|
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
|
2016-07-05 19:32:04 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-07-05 19:32:04 +00:00
|
|
|
|
|
|
|
// Check that the tarball contains the added file
|
|
|
|
let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap();
|
2018-12-30 04:46:15 +00:00
|
|
|
validate_crate_contents(
|
|
|
|
f,
|
|
|
|
"foo-0.0.1.crate",
|
2019-06-10 19:38:51 +00:00
|
|
|
&[
|
|
|
|
"Cargo.lock",
|
|
|
|
"Cargo.toml",
|
|
|
|
"Cargo.toml.orig",
|
|
|
|
"src/main.rs",
|
|
|
|
"src/foo.rs",
|
|
|
|
],
|
2018-12-30 04:46:15 +00:00
|
|
|
&[],
|
|
|
|
);
|
2016-07-05 19:32:04 +00:00
|
|
|
}
|
2016-07-26 19:55:10 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2019-07-04 11:21:50 +00:00
|
|
|
/// Tests if a broken symlink is properly handled when packaging.
|
|
|
|
///
|
2019-07-29 06:36:13 +00:00
|
|
|
/// This test requires you to be able to make symlinks.
|
|
|
|
/// For windows, this may require you to enable developer mode.
|
2016-07-26 19:55:10 +00:00
|
|
|
fn broken_symlink() {
|
2019-04-11 11:28:45 +00:00
|
|
|
#[cfg(unix)]
|
2019-07-04 11:21:50 +00:00
|
|
|
use std::os::unix::fs::symlink;
|
2019-04-11 11:28:45 +00:00
|
|
|
#[cfg(windows)]
|
|
|
|
use std::os::windows::fs::symlink_dir as symlink;
|
2016-07-26 19:55:10 +00:00
|
|
|
|
2019-07-29 06:36:13 +00:00
|
|
|
if !symlink_supported() {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2016-07-26 19:55:10 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
|
|
|
description = 'foo'
|
|
|
|
documentation = 'foo'
|
|
|
|
homepage = 'foo'
|
|
|
|
repository = 'foo'
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/main.rs", r#"fn main() { println!("hello"); }"#)
|
2017-07-22 03:12:21 +00:00
|
|
|
.build();
|
2019-04-11 11:28:45 +00:00
|
|
|
t!(symlink("nowhere", &p.root().join("src/foo.rs")));
|
2016-07-26 19:55:10 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package -v")
|
|
|
|
.with_status(101)
|
|
|
|
.with_stderr_contains(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2016-07-26 19:55:10 +00:00
|
|
|
error: failed to prepare local package for uploading
|
|
|
|
|
|
|
|
Caused by:
|
|
|
|
failed to open for archiving: `[..]foo.rs`
|
|
|
|
|
|
|
|
Caused by:
|
|
|
|
[..]
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-07-26 19:55:10 +00:00
|
|
|
}
|
2016-09-03 01:05:26 +00:00
|
|
|
|
2019-04-08 05:53:00 +00:00
|
|
|
#[cargo_test]
|
2019-12-11 14:31:26 +00:00
|
|
|
/// Tests if a symlink to a directory is properly included.
|
2019-07-04 11:21:50 +00:00
|
|
|
///
|
2019-07-29 06:36:13 +00:00
|
|
|
/// This test requires you to be able to make symlinks.
|
|
|
|
/// For windows, this may require you to enable developer mode.
|
2019-04-08 05:53:00 +00:00
|
|
|
fn package_symlink_to_dir() {
|
2019-07-29 06:36:13 +00:00
|
|
|
if !symlink_supported() {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-04-08 05:53:00 +00:00
|
|
|
project()
|
|
|
|
.file("src/main.rs", r#"fn main() { println!("hello"); }"#)
|
|
|
|
.file("bla/Makefile", "all:")
|
|
|
|
.symlink_dir("bla", "foo")
|
|
|
|
.build()
|
|
|
|
.cargo("package -v")
|
|
|
|
.with_stderr_contains("[ARCHIVING] foo/Makefile")
|
|
|
|
.run();
|
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2016-09-03 01:05:26 +00:00
|
|
|
fn do_not_package_if_repository_is_dirty() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project().build();
|
2017-02-15 14:16:41 +00:00
|
|
|
|
2016-09-03 01:05:26 +00:00
|
|
|
// Create a Git repository containing a minimal Rust project.
|
2017-07-22 03:12:21 +00:00
|
|
|
let _ = git::repo(&paths::root().join("foo"))
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2016-09-03 01:05:26 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
documentation = "foo"
|
|
|
|
homepage = "foo"
|
|
|
|
repository = "foo"
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/main.rs", "fn main() {}")
|
2016-09-03 01:05:26 +00:00
|
|
|
.build();
|
|
|
|
|
|
|
|
// Modify Cargo.toml without committing the change.
|
2018-03-14 15:17:44 +00:00
|
|
|
p.change_file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2017-02-15 14:16:41 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
documentation = "foo"
|
|
|
|
homepage = "foo"
|
|
|
|
repository = "foo"
|
|
|
|
# change
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
|
|
|
);
|
2016-09-03 01:05:26 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package")
|
|
|
|
.with_status(101)
|
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2017-04-09 02:20:41 +00:00
|
|
|
error: 1 files in the working directory contain changes that were not yet \
|
|
|
|
committed into git:
|
2016-09-03 01:05:26 +00:00
|
|
|
|
|
|
|
Cargo.toml
|
|
|
|
|
2019-12-11 14:31:26 +00:00
|
|
|
to proceed despite this and include the uncommitted changes, pass the `--allow-dirty` flag
|
2018-03-14 15:17:44 +00:00
|
|
|
",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2016-09-03 01:05:26 +00:00
|
|
|
}
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
fn generated_manifest() {
|
2017-10-02 10:04:02 +00:00
|
|
|
Package::new("abc", "1.0.0").publish();
|
2018-02-27 15:56:04 +00:00
|
|
|
Package::new("def", "1.0.0").alternative(true).publish();
|
2017-10-02 10:04:02 +00:00
|
|
|
Package::new("ghi", "1.0.0").publish();
|
2019-06-10 19:38:51 +00:00
|
|
|
Package::new("bar", "0.1.0").publish();
|
2018-02-27 15:56:04 +00:00
|
|
|
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
exclude = ["*.txt"]
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
|
2017-06-14 14:56:40 +00:00
|
|
|
[project.metadata]
|
|
|
|
foo = 'bar'
|
|
|
|
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
[workspace]
|
|
|
|
|
|
|
|
[dependencies]
|
|
|
|
bar = { path = "bar", version = "0.1" }
|
2018-01-18 19:33:26 +00:00
|
|
|
def = { version = "1.0", registry = "alternative" }
|
2017-10-02 10:04:02 +00:00
|
|
|
ghi = "1.0"
|
|
|
|
abc = "1.0"
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/main.rs", "")
|
2018-07-24 22:35:01 +00:00
|
|
|
.file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
|
2017-07-22 03:12:21 +00:00
|
|
|
.file("bar/src/lib.rs", "")
|
|
|
|
.build();
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
|
2019-05-09 17:58:18 +00:00
|
|
|
p.cargo("package --no-verify").run();
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
|
|
|
|
let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap();
|
2018-12-30 04:46:15 +00:00
|
|
|
let rewritten_toml = format!(
|
2020-04-17 18:20:38 +00:00
|
|
|
r#"{}
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
exclude = ["*.txt"]
|
|
|
|
description = "foo"
|
|
|
|
license = "MIT"
|
2017-06-14 14:56:40 +00:00
|
|
|
|
|
|
|
[package.metadata]
|
|
|
|
foo = "bar"
|
2017-10-02 10:04:02 +00:00
|
|
|
[dependencies.abc]
|
|
|
|
version = "1.0"
|
|
|
|
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
[dependencies.bar]
|
|
|
|
version = "0.1"
|
2017-10-02 10:04:02 +00:00
|
|
|
|
|
|
|
[dependencies.def]
|
|
|
|
version = "1.0"
|
2018-01-18 19:53:12 +00:00
|
|
|
registry-index = "{}"
|
2017-10-02 10:04:02 +00:00
|
|
|
|
|
|
|
[dependencies.ghi]
|
|
|
|
version = "1.0"
|
2018-01-18 19:33:26 +00:00
|
|
|
"#,
|
2020-04-17 18:20:38 +00:00
|
|
|
cargo::core::package::MANIFEST_PREAMBLE,
|
2019-01-11 23:56:46 +00:00
|
|
|
registry::alt_registry_url()
|
2018-12-30 04:46:15 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
validate_crate_contents(
|
|
|
|
f,
|
|
|
|
"foo-0.0.1.crate",
|
2019-06-10 19:38:51 +00:00
|
|
|
&["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"],
|
2018-12-30 04:46:15 +00:00
|
|
|
&[("Cargo.toml", &rewritten_toml)],
|
2018-03-14 15:17:44 +00:00
|
|
|
);
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
fn ignore_workspace_specifier() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
2017-05-22 15:56:27 +00:00
|
|
|
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
authors = []
|
|
|
|
|
|
|
|
[workspace]
|
|
|
|
|
|
|
|
[dependencies]
|
|
|
|
bar = { path = "bar", version = "0.1" }
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/main.rs", "")
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"bar/Cargo.toml",
|
|
|
|
r#"
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
[package]
|
|
|
|
name = "bar"
|
|
|
|
version = "0.1.0"
|
|
|
|
authors = []
|
|
|
|
workspace = ".."
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("bar/src/lib.rs", "")
|
2017-07-22 03:12:21 +00:00
|
|
|
.build();
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
|
2019-04-05 19:55:01 +00:00
|
|
|
p.cargo("package --no-verify").cwd("bar").run();
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
|
|
|
|
let f = File::open(&p.root().join("target/package/bar-0.1.0.crate")).unwrap();
|
2020-04-17 18:20:38 +00:00
|
|
|
let rewritten_toml = format!(
|
|
|
|
r#"{}
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
[package]
|
|
|
|
name = "bar"
|
|
|
|
version = "0.1.0"
|
|
|
|
authors = []
|
2020-04-17 18:20:38 +00:00
|
|
|
"#,
|
|
|
|
cargo::core::package::MANIFEST_PREAMBLE
|
|
|
|
);
|
2018-12-30 04:46:15 +00:00
|
|
|
validate_crate_contents(
|
|
|
|
f,
|
|
|
|
"bar-0.1.0.crate",
|
|
|
|
&["Cargo.toml", "Cargo.toml.orig", "src/lib.rs"],
|
2020-04-17 18:20:38 +00:00
|
|
|
&[("Cargo.toml", &rewritten_toml)],
|
2018-03-14 15:17:44 +00:00
|
|
|
);
|
Rewrite Cargo.toml when packaging crates
This commit is an implementation of rewriting TOML manifests when we publish
them to the registry. The rationale for doing this is to provide a guarantee
that downloaded tarballs from crates.io can be built with `cargo build`
(literally). This in turn eases a number of other possible consumers of crates
from crates.io
* Vendored sources can now be more easily modified/checked as cargo build should
work and they're standalone crates that suffice for `path` dependencies
* Tools like cargobomb/crater no longer need to edit the manifest and can
instead perform regression testing on the literal tarballs they download
* Other systems such as packaging Rust code may be able to take advantage of
this, but this is a less clear benefit.
Overall I'm hesitatnt about this, unfortunately. This is a silent translation
happening on *publish*, a rare operation, that's difficult to inspect before it
flies up to crates.io. I wrote a script to run this transformation over all
crates.io crates and found a surprisingly large number of discrepancies. The
transformation basically just downloaded all crates at all versions,
regenerated the manifest, and then tested if the two manifests were (in memory)
the same.
Unfortunately historical Cargo had a critical bug which I think made this
exercise not too useful. Cargo used to *not* recreate tarballs if one already
existed, which I believe led to situations such as:
1. `cargo publish`
2. Cargo generates an error about a dependency. This could be that there's a
`version` not present in a `path` dependency, there could be a `git`
dependency, etc.
3. Errors are fixed.
4. `cargo publish`
5. Publish is successful
In step 4 above historical Cargo *would not recreate the tarball*. This means
that the contents of the index (what was published) aren't guaranteed to match
with the tarball's `Cargo.toml`. When building from crates.io this is ok as the
index is the source of truth for dependency information, but it means that *any*
transformation to rewrite Cargo.toml is impossible to verify against all crates
on crates.io (due to historical bugs like these).
I strove to read as many errors as possible regardless, attempting to suss out
bugs in the implementation here. To further guard against surprises I've updated
the verification step of packaging to work "normally" in these sense that it's
not rewriting dependencies itself or changing summaries. I'm hoping that this
serves as a good last-ditch effort that what we're about to publish will indeed
build as expected when uploaded to crates.io
Overall I'm probably 70% confident in this change. I think it's necessary to
make progress, but I think there are going to be very painful bugs that arise
from this feature. I'm open to ideas to help weed out these bugs ahead of time!
I've done what I can but I fear it may not be entirely enough.
Closes #4027
2017-05-11 05:09:44 +00:00
|
|
|
}
|
2017-05-22 15:56:27 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2017-05-22 15:56:27 +00:00
|
|
|
fn package_two_kinds_of_deps() {
|
|
|
|
Package::new("other", "1.0.0").publish();
|
|
|
|
Package::new("other1", "1.0.0").publish();
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2017-05-22 15:56:27 +00:00
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
|
|
|
|
[dependencies]
|
|
|
|
other = "1.0"
|
|
|
|
other1 = { version = "1.0" }
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/main.rs", "")
|
2017-07-22 03:12:21 +00:00
|
|
|
.build();
|
2017-05-22 15:56:27 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package --no-verify").run();
|
2017-05-22 15:56:27 +00:00
|
|
|
}
|
2018-02-05 21:42:42 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2018-03-21 16:41:22 +00:00
|
|
|
fn test_edition() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2018-03-21 16:41:22 +00:00
|
|
|
cargo-features = ["edition"]
|
2018-02-05 21:42:42 +00:00
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
2018-05-03 16:14:25 +00:00
|
|
|
edition = "2018"
|
2018-03-14 15:17:44 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/lib.rs", r#" "#)
|
2018-02-05 21:42:42 +00:00
|
|
|
.build();
|
|
|
|
|
2018-12-08 11:19:47 +00:00
|
|
|
p.cargo("build -v")
|
|
|
|
.with_stderr_contains(
|
|
|
|
"\
|
2018-05-15 16:29:34 +00:00
|
|
|
[COMPILING] foo v0.0.1 ([..])
|
|
|
|
[RUNNING] `rustc [..]--edition=2018 [..]
|
2018-12-08 11:19:47 +00:00
|
|
|
",
|
|
|
|
)
|
|
|
|
.run();
|
2018-02-05 21:42:42 +00:00
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2018-08-18 22:21:01 +00:00
|
|
|
fn edition_with_metadata() {
|
|
|
|
let p = project()
|
2018-08-28 09:20:03 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2018-09-05 22:29:22 +00:00
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
edition = "2018"
|
|
|
|
|
|
|
|
[package.metadata.docs.rs]
|
|
|
|
features = ["foobar"]
|
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/lib.rs", "")
|
2018-08-18 22:21:01 +00:00
|
|
|
.build();
|
|
|
|
|
2018-09-05 22:29:22 +00:00
|
|
|
p.cargo("package").run();
|
2018-02-05 21:42:42 +00:00
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2018-03-21 16:41:22 +00:00
|
|
|
fn test_edition_malformed() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-03-14 15:17:44 +00:00
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
2018-09-05 22:29:22 +00:00
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
edition = "chicken"
|
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.file("src/lib.rs", r#" "#)
|
2018-02-05 21:42:42 +00:00
|
|
|
.build();
|
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("build -v")
|
|
|
|
.with_status(101)
|
|
|
|
.with_stderr(
|
2018-03-14 15:17:44 +00:00
|
|
|
"\
|
2018-02-05 21:42:42 +00:00
|
|
|
error: failed to parse manifest at `[..]`
|
|
|
|
|
|
|
|
Caused by:
|
2018-05-03 16:14:25 +00:00
|
|
|
failed to parse the `edition` key
|
|
|
|
|
|
|
|
Caused by:
|
|
|
|
supported edition values are `2015` or `2018`, but `chicken` is unknown
|
2018-12-08 11:19:47 +00:00
|
|
|
"
|
|
|
|
.to_string(),
|
|
|
|
)
|
|
|
|
.run();
|
2018-02-05 21:42:42 +00:00
|
|
|
}
|
|
|
|
|
2020-04-15 14:03:09 +00:00
|
|
|
#[cargo_test]
|
|
|
|
fn test_edition_from_the_future() {
|
|
|
|
let p = project()
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"[package]
|
|
|
|
edition = "2038"
|
|
|
|
name = "foo"
|
|
|
|
version = "99.99.99"
|
|
|
|
authors = []
|
|
|
|
"#,
|
|
|
|
)
|
|
|
|
.file("src/main.rs", r#""#)
|
|
|
|
.build();
|
|
|
|
|
|
|
|
p.cargo("build")
|
|
|
|
.with_status(101)
|
|
|
|
.with_stderr(
|
|
|
|
"\
|
|
|
|
error: failed to parse manifest at `[..]`
|
|
|
|
|
|
|
|
Caused by:
|
|
|
|
failed to parse the `edition` key
|
|
|
|
|
|
|
|
Caused by:
|
|
|
|
this version of Cargo is older than the `2038` edition, and only supports `2015` and `2018` editions.
|
|
|
|
"
|
|
|
|
.to_string(),
|
|
|
|
)
|
|
|
|
.run();
|
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2018-05-28 11:59:35 +00:00
|
|
|
fn do_not_package_if_src_was_modified() {
|
2018-07-20 11:47:47 +00:00
|
|
|
let p = project()
|
2018-07-25 00:30:32 +00:00
|
|
|
.file("src/main.rs", r#"fn main() { println!("hello"); }"#)
|
2019-05-21 01:11:34 +00:00
|
|
|
.file("dir/foo.txt", "")
|
2019-03-13 03:33:45 +00:00
|
|
|
.file("bar.txt", "")
|
2018-08-28 09:20:03 +00:00
|
|
|
.file(
|
|
|
|
"build.rs",
|
|
|
|
r#"
|
2019-03-13 03:33:45 +00:00
|
|
|
use std::fs;
|
2018-05-28 11:59:35 +00:00
|
|
|
|
|
|
|
fn main() {
|
2019-03-13 03:33:45 +00:00
|
|
|
fs::write("src/generated.txt",
|
|
|
|
"Hello, world of generated files."
|
|
|
|
).expect("failed to create file");
|
2019-05-21 01:11:34 +00:00
|
|
|
fs::remove_file("dir/foo.txt").expect("failed to remove file");
|
|
|
|
fs::remove_dir("dir").expect("failed to remove dir");
|
2019-03-13 03:33:45 +00:00
|
|
|
fs::write("bar.txt", "updated content").expect("failed to update");
|
2019-05-21 01:11:34 +00:00
|
|
|
fs::create_dir("new-dir").expect("failed to create dir");
|
2018-05-28 11:59:35 +00:00
|
|
|
}
|
2018-08-28 09:20:03 +00:00
|
|
|
"#,
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.build();
|
2018-05-28 11:59:35 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package")
|
|
|
|
.with_status(101)
|
|
|
|
.with_stderr_contains(
|
|
|
|
"\
|
2018-05-29 09:05:34 +00:00
|
|
|
error: failed to verify package tarball
|
|
|
|
|
|
|
|
Caused by:
|
|
|
|
Source directory was modified by build.rs during cargo publish. \
|
2019-03-13 03:33:45 +00:00
|
|
|
Build scripts should not modify anything outside of OUT_DIR.
|
|
|
|
Changed: [CWD]/target/package/foo-0.0.1/bar.txt
|
2019-05-21 01:11:34 +00:00
|
|
|
Added: [CWD]/target/package/foo-0.0.1/new-dir
|
|
|
|
<tab>[CWD]/target/package/foo-0.0.1/src/generated.txt
|
|
|
|
Removed: [CWD]/target/package/foo-0.0.1/dir
|
|
|
|
<tab>[CWD]/target/package/foo-0.0.1/dir/foo.txt
|
2018-05-29 09:05:34 +00:00
|
|
|
|
|
|
|
To proceed despite this, pass the `--no-verify` flag.",
|
2018-12-08 11:19:47 +00:00
|
|
|
)
|
|
|
|
.run();
|
2018-05-28 11:59:35 +00:00
|
|
|
|
2018-08-28 09:20:03 +00:00
|
|
|
p.cargo("package --no-verify").run();
|
2018-05-28 11:59:35 +00:00
|
|
|
}
|
2018-12-26 13:48:25 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2018-12-26 13:48:25 +00:00
|
|
|
fn package_with_select_features() {
|
|
|
|
let p = project()
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
|
|
|
|
[features]
|
|
|
|
required = []
|
|
|
|
optional = []
|
|
|
|
"#,
|
2019-01-27 13:39:49 +00:00
|
|
|
)
|
|
|
|
.file(
|
2018-12-26 13:48:25 +00:00
|
|
|
"src/main.rs",
|
|
|
|
"#[cfg(not(feature = \"required\"))]
|
|
|
|
compile_error!(\"This crate requires `required` feature!\");
|
|
|
|
fn main() {}",
|
2019-01-27 13:39:49 +00:00
|
|
|
)
|
|
|
|
.build();
|
2018-12-26 13:48:25 +00:00
|
|
|
|
2019-05-09 17:58:18 +00:00
|
|
|
p.cargo("package --features required").run();
|
2018-12-26 13:48:25 +00:00
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2018-12-26 13:48:25 +00:00
|
|
|
fn package_with_all_features() {
|
|
|
|
let p = project()
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
|
|
|
|
[features]
|
|
|
|
required = []
|
|
|
|
optional = []
|
|
|
|
"#,
|
2019-01-27 13:39:49 +00:00
|
|
|
)
|
|
|
|
.file(
|
2018-12-26 13:48:25 +00:00
|
|
|
"src/main.rs",
|
|
|
|
"#[cfg(not(feature = \"required\"))]
|
|
|
|
compile_error!(\"This crate requires `required` feature!\");
|
|
|
|
fn main() {}",
|
2019-01-27 13:39:49 +00:00
|
|
|
)
|
|
|
|
.build();
|
2018-12-26 13:48:25 +00:00
|
|
|
|
2019-05-09 17:58:18 +00:00
|
|
|
p.cargo("package --all-features").run();
|
2018-12-26 13:48:25 +00:00
|
|
|
}
|
2019-01-09 17:25:36 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2019-01-09 17:25:36 +00:00
|
|
|
fn package_no_default_features() {
|
|
|
|
let p = project()
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[project]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.0.1"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
|
|
|
|
[features]
|
|
|
|
default = ["required"]
|
|
|
|
required = []
|
|
|
|
"#,
|
2019-01-27 13:39:49 +00:00
|
|
|
)
|
|
|
|
.file(
|
2019-01-09 17:25:36 +00:00
|
|
|
"src/main.rs",
|
|
|
|
"#[cfg(not(feature = \"required\"))]
|
|
|
|
compile_error!(\"This crate requires `required` feature!\");
|
|
|
|
fn main() {}",
|
2019-01-27 13:39:49 +00:00
|
|
|
)
|
|
|
|
.build();
|
2019-01-09 17:25:36 +00:00
|
|
|
|
|
|
|
p.cargo("package --no-default-features")
|
|
|
|
.with_stderr_contains("error: This crate requires `required` feature!")
|
|
|
|
.with_status(101)
|
|
|
|
.run();
|
|
|
|
}
|
2019-05-09 16:09:42 +00:00
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2019-05-09 16:09:42 +00:00
|
|
|
fn include_cargo_toml_implicit() {
|
|
|
|
let p = project()
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.1.0"
|
|
|
|
include = ["src/lib.rs"]
|
|
|
|
"#,
|
|
|
|
)
|
|
|
|
.file("src/lib.rs", "")
|
|
|
|
.build();
|
|
|
|
|
|
|
|
p.cargo("package --list")
|
2020-02-19 18:46:54 +00:00
|
|
|
.with_stdout("Cargo.toml\nCargo.toml.orig\nsrc/lib.rs\n")
|
2019-05-09 16:09:42 +00:00
|
|
|
.run();
|
|
|
|
}
|
2019-05-09 23:18:14 +00:00
|
|
|
|
2019-07-23 20:49:17 +00:00
|
|
|
fn include_exclude_test(include: &str, exclude: &str, files: &[&str], expected: &str) {
|
2019-05-09 23:18:14 +00:00
|
|
|
let mut pb = project().file(
|
|
|
|
"Cargo.toml",
|
|
|
|
&format!(
|
|
|
|
r#"
|
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.1.0"
|
|
|
|
authors = []
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
documentation = "foo"
|
|
|
|
homepage = "foo"
|
|
|
|
repository = "foo"
|
|
|
|
include = {}
|
|
|
|
exclude = {}
|
|
|
|
"#,
|
|
|
|
include, exclude
|
|
|
|
),
|
|
|
|
);
|
|
|
|
for file in files {
|
|
|
|
pb = pb.file(file, "");
|
|
|
|
}
|
|
|
|
let p = pb.build();
|
|
|
|
|
2019-07-23 20:49:17 +00:00
|
|
|
p.cargo("package --list")
|
|
|
|
.with_stderr("")
|
|
|
|
.with_stdout(expected)
|
|
|
|
.run();
|
2019-05-09 23:18:14 +00:00
|
|
|
p.root().rm_rf();
|
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2019-05-09 23:18:14 +00:00
|
|
|
fn package_include_ignore_only() {
|
|
|
|
// Test with a gitignore pattern that fails to parse with glob.
|
|
|
|
// This is a somewhat nonsense pattern, but is an example of something git
|
|
|
|
// allows and glob does not.
|
|
|
|
assert!(glob::Pattern::new("src/abc**").is_err());
|
|
|
|
|
|
|
|
include_exclude_test(
|
|
|
|
r#"["Cargo.toml", "src/abc**", "src/lib.rs"]"#,
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", "src/abc1.rs", "src/abc2.rs", "src/abc/mod.rs"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-09 23:18:14 +00:00
|
|
|
src/abc/mod.rs\n\
|
|
|
|
src/abc1.rs\n\
|
|
|
|
src/abc2.rs\n\
|
|
|
|
src/lib.rs\n\
|
|
|
|
",
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2019-05-09 23:18:14 +00:00
|
|
|
fn gitignore_patterns() {
|
|
|
|
include_exclude_test(
|
|
|
|
r#"["Cargo.toml", "foo"]"#, // include
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", "foo", "a/foo", "a/b/foo", "x/foo/y", "bar"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-09 23:18:14 +00:00
|
|
|
a/b/foo\n\
|
|
|
|
a/foo\n\
|
|
|
|
foo\n\
|
|
|
|
x/foo/y\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
include_exclude_test(
|
|
|
|
r#"["Cargo.toml", "/foo"]"#, // include
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", "foo", "a/foo", "a/b/foo", "x/foo/y", "bar"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-09 23:18:14 +00:00
|
|
|
foo\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
include_exclude_test(
|
|
|
|
"[]",
|
|
|
|
r#"["foo/"]"#, // exclude
|
|
|
|
&["src/lib.rs", "foo", "a/foo", "x/foo/y", "bar"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-09 23:18:14 +00:00
|
|
|
a/foo\n\
|
|
|
|
bar\n\
|
|
|
|
foo\n\
|
|
|
|
src/lib.rs\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
include_exclude_test(
|
|
|
|
"[]",
|
|
|
|
r#"["*.txt", "[ab]", "[x-z]"]"#, // exclude
|
|
|
|
&[
|
|
|
|
"src/lib.rs",
|
|
|
|
"foo.txt",
|
|
|
|
"bar/foo.txt",
|
|
|
|
"other",
|
|
|
|
"a",
|
|
|
|
"b",
|
|
|
|
"c",
|
|
|
|
"x",
|
|
|
|
"y",
|
|
|
|
"z",
|
|
|
|
],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-09 23:18:14 +00:00
|
|
|
c\n\
|
|
|
|
other\n\
|
|
|
|
src/lib.rs\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
include_exclude_test(
|
|
|
|
r#"["Cargo.toml", "**/foo/bar"]"#, // include
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", "a/foo/bar", "foo", "bar"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-09 23:18:14 +00:00
|
|
|
a/foo/bar\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
include_exclude_test(
|
|
|
|
r#"["Cargo.toml", "foo/**"]"#, // include
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", "a/foo/bar", "foo/x/y/z"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-09 23:18:14 +00:00
|
|
|
foo/x/y/z\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
include_exclude_test(
|
|
|
|
r#"["Cargo.toml", "a/**/b"]"#, // include
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", "a/b", "a/x/b", "a/x/y/b"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-09 23:18:14 +00:00
|
|
|
a/b\n\
|
|
|
|
a/x/b\n\
|
|
|
|
a/x/y/b\n\
|
|
|
|
",
|
2019-05-10 00:55:25 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-06-05 18:52:53 +00:00
|
|
|
#[cargo_test]
|
2019-05-10 00:55:25 +00:00
|
|
|
fn gitignore_negate() {
|
|
|
|
include_exclude_test(
|
|
|
|
r#"["Cargo.toml", "*.rs", "!foo.rs", "\\!important"]"#, // include
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", "foo.rs", "!important"],
|
|
|
|
"!important\n\
|
|
|
|
Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-10 00:55:25 +00:00
|
|
|
src/lib.rs\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
// NOTE: This is unusual compared to git. Git treats `src/` as a
|
|
|
|
// short-circuit which means rules like `!src/foo.rs` would never run.
|
|
|
|
// However, because Cargo only works by iterating over *files*, it doesn't
|
|
|
|
// short-circuit.
|
|
|
|
include_exclude_test(
|
|
|
|
r#"["Cargo.toml", "src/", "!src/foo.rs"]"#, // include
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", "src/foo.rs"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-10 00:55:25 +00:00
|
|
|
src/lib.rs\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
include_exclude_test(
|
2019-05-14 01:05:10 +00:00
|
|
|
r#"["Cargo.toml", "src/*.rs", "!foo.rs"]"#, // include
|
2019-05-10 00:55:25 +00:00
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", "foo.rs", "src/foo.rs", "src/bar/foo.rs"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-10 00:55:25 +00:00
|
|
|
src/lib.rs\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
include_exclude_test(
|
|
|
|
"[]",
|
|
|
|
r#"["*.rs", "!foo.rs", "\\!important"]"#, // exclude
|
|
|
|
&["src/lib.rs", "foo.rs", "!important"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-05-10 00:55:25 +00:00
|
|
|
foo.rs\n\
|
|
|
|
",
|
2019-05-09 23:18:14 +00:00
|
|
|
);
|
|
|
|
}
|
2019-12-08 11:43:39 +00:00
|
|
|
|
|
|
|
#[cargo_test]
|
|
|
|
fn exclude_dot_files_and_directories_by_default() {
|
|
|
|
include_exclude_test(
|
|
|
|
"[]",
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", ".dotfile", ".dotdir/file"],
|
|
|
|
"Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-12-08 11:43:39 +00:00
|
|
|
src/lib.rs\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
include_exclude_test(
|
|
|
|
r#"["Cargo.toml", "src/lib.rs", ".dotfile", ".dotdir/file"]"#,
|
|
|
|
"[]",
|
|
|
|
&["src/lib.rs", ".dotfile", ".dotdir/file"],
|
|
|
|
".dotdir/file\n\
|
|
|
|
.dotfile\n\
|
|
|
|
Cargo.toml\n\
|
2020-02-19 18:46:54 +00:00
|
|
|
Cargo.toml.orig\n\
|
2019-12-08 11:43:39 +00:00
|
|
|
src/lib.rs\n\
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
2020-02-18 19:40:04 +00:00
|
|
|
|
|
|
|
#[cargo_test]
|
|
|
|
fn invalid_license_file_path() {
|
|
|
|
// Test warning when license-file points to a non-existent file.
|
|
|
|
let p = project()
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "1.0.0"
|
|
|
|
license-file = "does-not-exist"
|
|
|
|
description = "foo"
|
|
|
|
homepage = "foo"
|
|
|
|
"#,
|
|
|
|
)
|
|
|
|
.file("src/lib.rs", "")
|
|
|
|
.build();
|
|
|
|
|
|
|
|
p.cargo("package --no-verify")
|
|
|
|
.with_stderr(
|
|
|
|
"\
|
|
|
|
[WARNING] license-file `does-not-exist` does not appear to exist (relative to `[..]/foo`).
|
|
|
|
Please update the license-file setting in the manifest at `[..]/foo/Cargo.toml`
|
|
|
|
This may become a hard error in the future.
|
|
|
|
[PACKAGING] foo v1.0.0 ([..]/foo)
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.run();
|
|
|
|
}
|
2020-02-19 18:46:54 +00:00
|
|
|
|
|
|
|
#[cargo_test]
|
|
|
|
fn license_file_implicit_include() {
|
|
|
|
// license-file should be automatically included even if not listed.
|
|
|
|
let p = git::new("foo", |p| {
|
|
|
|
p.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "1.0.0"
|
|
|
|
license-file = "subdir/LICENSE"
|
|
|
|
description = "foo"
|
|
|
|
homepage = "foo"
|
|
|
|
include = ["src"]
|
|
|
|
"#,
|
|
|
|
)
|
|
|
|
.file("src/lib.rs", "")
|
|
|
|
.file("subdir/LICENSE", "license text")
|
|
|
|
});
|
|
|
|
|
|
|
|
p.cargo("package --list")
|
|
|
|
.with_stdout(
|
|
|
|
"\
|
|
|
|
.cargo_vcs_info.json
|
|
|
|
Cargo.toml
|
|
|
|
Cargo.toml.orig
|
|
|
|
src/lib.rs
|
|
|
|
subdir/LICENSE
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.with_stderr("")
|
|
|
|
.run();
|
|
|
|
|
|
|
|
p.cargo("package --no-verify -v")
|
|
|
|
.with_stderr(
|
|
|
|
"\
|
|
|
|
[PACKAGING] foo v1.0.0 [..]
|
|
|
|
[ARCHIVING] .cargo_vcs_info.json
|
|
|
|
[ARCHIVING] Cargo.toml
|
|
|
|
[ARCHIVING] Cargo.toml.orig
|
|
|
|
[ARCHIVING] src/lib.rs
|
|
|
|
[ARCHIVING] subdir/LICENSE
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.run();
|
|
|
|
let f = File::open(&p.root().join("target/package/foo-1.0.0.crate")).unwrap();
|
|
|
|
validate_crate_contents(
|
|
|
|
f,
|
|
|
|
"foo-1.0.0.crate",
|
|
|
|
&[
|
|
|
|
".cargo_vcs_info.json",
|
|
|
|
"Cargo.toml",
|
|
|
|
"Cargo.toml.orig",
|
|
|
|
"subdir/LICENSE",
|
|
|
|
"src/lib.rs",
|
|
|
|
],
|
|
|
|
&[("subdir/LICENSE", "license text")],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cargo_test]
|
|
|
|
fn relative_license_included() {
|
|
|
|
// license-file path outside of package will copy into root.
|
|
|
|
let p = project()
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "1.0.0"
|
|
|
|
license-file = "../LICENSE"
|
|
|
|
description = "foo"
|
|
|
|
homepage = "foo"
|
|
|
|
"#,
|
|
|
|
)
|
|
|
|
.file("src/lib.rs", "")
|
|
|
|
.file("../LICENSE", "license text")
|
|
|
|
.build();
|
|
|
|
|
|
|
|
p.cargo("package --list")
|
|
|
|
.with_stdout(
|
|
|
|
"\
|
|
|
|
Cargo.toml
|
|
|
|
Cargo.toml.orig
|
|
|
|
LICENSE
|
|
|
|
src/lib.rs
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.with_stderr("")
|
|
|
|
.run();
|
|
|
|
|
|
|
|
p.cargo("package")
|
|
|
|
.with_stderr(
|
|
|
|
"\
|
|
|
|
[PACKAGING] foo v1.0.0 [..]
|
|
|
|
[VERIFYING] foo v1.0.0 [..]
|
|
|
|
[COMPILING] foo v1.0.0 [..]
|
|
|
|
[FINISHED] [..]
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.run();
|
|
|
|
let f = File::open(&p.root().join("target/package/foo-1.0.0.crate")).unwrap();
|
|
|
|
validate_crate_contents(
|
|
|
|
f,
|
|
|
|
"foo-1.0.0.crate",
|
|
|
|
&["Cargo.toml", "Cargo.toml.orig", "LICENSE", "src/lib.rs"],
|
|
|
|
&[("LICENSE", "license text")],
|
|
|
|
);
|
|
|
|
let manifest =
|
|
|
|
std::fs::read_to_string(p.root().join("target/package/foo-1.0.0/Cargo.toml")).unwrap();
|
|
|
|
assert!(manifest.contains("license-file = \"LICENSE\""));
|
|
|
|
let orig =
|
|
|
|
std::fs::read_to_string(p.root().join("target/package/foo-1.0.0/Cargo.toml.orig")).unwrap();
|
|
|
|
assert!(orig.contains("license-file = \"../LICENSE\""));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cargo_test]
|
|
|
|
fn relative_license_include_collision() {
|
|
|
|
// Can't copy a relative license-file if there is a file with that name already.
|
|
|
|
let p = project()
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "1.0.0"
|
|
|
|
license-file = "../LICENSE"
|
|
|
|
description = "foo"
|
|
|
|
homepage = "foo"
|
|
|
|
"#,
|
|
|
|
)
|
|
|
|
.file("src/lib.rs", "")
|
|
|
|
.file("../LICENSE", "outer license")
|
|
|
|
.file("LICENSE", "inner license")
|
|
|
|
.build();
|
|
|
|
|
|
|
|
p.cargo("package --list")
|
|
|
|
.with_stdout(
|
|
|
|
"\
|
|
|
|
Cargo.toml
|
|
|
|
Cargo.toml.orig
|
|
|
|
LICENSE
|
|
|
|
src/lib.rs
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.with_stderr("[WARNING] license-file `../LICENSE` appears to be [..]")
|
|
|
|
.run();
|
|
|
|
|
|
|
|
p.cargo("package")
|
|
|
|
.with_stderr(
|
|
|
|
"\
|
|
|
|
[WARNING] license-file `../LICENSE` appears to be [..]
|
|
|
|
[PACKAGING] foo v1.0.0 [..]
|
|
|
|
[VERIFYING] foo v1.0.0 [..]
|
|
|
|
[COMPILING] foo v1.0.0 [..]
|
|
|
|
[FINISHED] [..]
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.run();
|
|
|
|
let f = File::open(&p.root().join("target/package/foo-1.0.0.crate")).unwrap();
|
|
|
|
validate_crate_contents(
|
|
|
|
f,
|
|
|
|
"foo-1.0.0.crate",
|
|
|
|
&["Cargo.toml", "Cargo.toml.orig", "LICENSE", "src/lib.rs"],
|
|
|
|
&[("LICENSE", "inner license")],
|
|
|
|
);
|
|
|
|
let manifest = read_to_string(p.root().join("target/package/foo-1.0.0/Cargo.toml")).unwrap();
|
|
|
|
assert!(manifest.contains("license-file = \"LICENSE\""));
|
|
|
|
let orig = read_to_string(p.root().join("target/package/foo-1.0.0/Cargo.toml.orig")).unwrap();
|
|
|
|
assert!(orig.contains("license-file = \"../LICENSE\""));
|
|
|
|
}
|
2020-03-03 00:14:36 +00:00
|
|
|
|
|
|
|
#[cargo_test]
|
|
|
|
#[cfg(not(windows))] // Don't want to create invalid files on Windows.
|
|
|
|
fn package_restricted_windows() {
|
|
|
|
let p = project()
|
|
|
|
.file(
|
|
|
|
"Cargo.toml",
|
|
|
|
r#"
|
|
|
|
[package]
|
|
|
|
name = "foo"
|
|
|
|
version = "0.1.0"
|
|
|
|
license = "MIT"
|
|
|
|
description = "foo"
|
|
|
|
homepage = "foo"
|
|
|
|
"#,
|
|
|
|
)
|
|
|
|
.file("src/lib.rs", "pub mod con;\npub mod aux;")
|
|
|
|
.file("src/con.rs", "pub fn f() {}")
|
|
|
|
.file("src/aux/mod.rs", "pub fn f() {}")
|
|
|
|
.build();
|
|
|
|
|
|
|
|
p.cargo("package")
|
|
|
|
.with_stderr(
|
|
|
|
"\
|
|
|
|
[WARNING] file src/aux/mod.rs is a reserved Windows filename, it will not work on Windows platforms
|
|
|
|
[WARNING] file src/con.rs is a reserved Windows filename, it will not work on Windows platforms
|
|
|
|
[PACKAGING] foo [..]
|
|
|
|
[VERIFYING] foo [..]
|
|
|
|
[COMPILING] foo [..]
|
|
|
|
[FINISHED] [..]
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.run();
|
|
|
|
}
|
2020-04-11 17:38:21 +00:00
|
|
|
|
|
|
|
#[cargo_test]
|
|
|
|
fn finds_git_in_parent() {
|
|
|
|
// Test where `Cargo.toml` is not in the root of the git repo.
|
|
|
|
let repo_path = paths::root().join("repo");
|
|
|
|
fs::create_dir(&repo_path).unwrap();
|
|
|
|
let p = project()
|
|
|
|
.at("repo/foo")
|
|
|
|
.file("Cargo.toml", &basic_manifest("foo", "0.1.0"))
|
|
|
|
.file("src/lib.rs", "")
|
|
|
|
.build();
|
|
|
|
let repo = git::init(&repo_path);
|
|
|
|
git::add(&repo);
|
|
|
|
git::commit(&repo);
|
|
|
|
p.change_file("ignoreme", "");
|
|
|
|
p.change_file("ignoreme2", "");
|
|
|
|
p.cargo("package --list --allow-dirty")
|
|
|
|
.with_stdout(
|
|
|
|
"\
|
|
|
|
Cargo.toml
|
|
|
|
Cargo.toml.orig
|
|
|
|
ignoreme
|
|
|
|
ignoreme2
|
|
|
|
src/lib.rs
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.run();
|
|
|
|
|
|
|
|
p.change_file(".gitignore", "ignoreme");
|
|
|
|
p.cargo("package --list --allow-dirty")
|
|
|
|
.with_stdout(
|
|
|
|
"\
|
|
|
|
.gitignore
|
|
|
|
Cargo.toml
|
|
|
|
Cargo.toml.orig
|
|
|
|
ignoreme2
|
|
|
|
src/lib.rs
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.run();
|
|
|
|
|
|
|
|
fs::write(repo_path.join(".gitignore"), "ignoreme2").unwrap();
|
|
|
|
p.cargo("package --list --allow-dirty")
|
|
|
|
.with_stdout(
|
|
|
|
"\
|
|
|
|
.gitignore
|
|
|
|
Cargo.toml
|
|
|
|
Cargo.toml.orig
|
|
|
|
src/lib.rs
|
|
|
|
",
|
|
|
|
)
|
|
|
|
.run();
|
|
|
|
}
|