extern crate cargo;

#[macro_use]

extern crate cargotest;

extern crate hamcrest;

use std::fs::{self, File};

use std::io::prelude::*;

use cargo::util::process;

use cargotest::sleep_ms;

use cargotest::support::paths::{self, CargoPathExt};

use cargotest::support::{project, execs, main_file};

use cargotest::support::registry::Package;

use hamcrest::{assert_that, existing_file};

#[test]

#[cfg(not(windows))] // I have no idea why this is failing spuriously on

// Windows, for more info see #3466.

fn cargo_compile_with_nested_deps_shorthand() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

version = "0.5.0"

path = "bar"

"#)

.file("src/main.rs",

&main_file(r#""{}", bar::gimme()"#, &["bar"]))

.file("bar/Cargo.toml", r#"

[project]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.baz]

version = "0.5.0"

path = "baz"

[lib]

name = "bar"

"#)

.file("bar/src/bar.rs", r#"

extern crate baz;

pub fn gimme() -> String {

baz::gimme()

}

"#)

.file("bar/baz/Cargo.toml", r#"

[project]

name = "baz"

version = "0.5.0"

authors = ["wycats@example.com"]

[lib]

name = "baz"

"#)

.file("bar/baz/src/baz.rs", r#"

pub fn gimme() -> String {

"test passed".to_string()

}

"#)

.build();

assert_that(p.cargo("build"),

execs().with_status(0)

.with_stderr(&format!("[COMPILING] baz v0.5.0 ({}/bar/baz)\n\

[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url(),

p.url(),

p.url())));

assert_that(&p.bin("foo"), existing_file());

assert_that(process(&p.bin("foo")),

execs().with_stdout("test passed\n").with_status(0));

println!("cleaning");

assert_that(p.cargo("clean").arg("-v"),

execs().with_stdout("").with_status(0));

println!("building baz");

assert_that(p.cargo("build").arg("-p").arg("baz"),

execs().with_status(0)

.with_stderr(&format!("[COMPILING] baz v0.5.0 ({}/bar/baz)\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url())));

println!("building foo");

assert_that(p.cargo("build")

.arg("-p").arg("foo"),

execs().with_status(0)

.with_stderr(&format!("[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url(),

p.url())));

}

#[test]

fn cargo_compile_with_root_dev_deps() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dev-dependencies.bar]

version = "0.5.0"

path = "../bar"

[[bin]]

name = "foo"

"#)

.file("src/main.rs",

&main_file(r#""{}", bar::gimme()"#, &["bar"]))

.build();

let _p2 = project("bar")

.file("Cargo.toml", r#"

[package]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

"#)

.file("src/lib.rs", r#"

pub fn gimme() -> &'static str {

"zoidberg"

}

"#)

.build();

assert_that(p.cargo("build"),

execs().with_status(101))

}

#[test]

fn cargo_compile_with_root_dev_deps_with_testing() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dev-dependencies.bar]

version = "0.5.0"

path = "../bar"

[[bin]]

name = "foo"

"#)

.file("src/main.rs",

&main_file(r#""{}", bar::gimme()"#, &["bar"]))

.build();

let _p2 = project("bar")

.file("Cargo.toml", r#"

[package]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

"#)

.file("src/lib.rs", r#"

pub fn gimme() -> &'static str {

"zoidberg"

}

"#)

.build();

assert_that(p.cargo("test"),

execs().with_stderr("\

[COMPILING] [..] v0.5.0 ([..])

[COMPILING] [..] v0.5.0 ([..])

[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]

[RUNNING] target[/]debug[/]deps[/]foo-[..][EXE]")

.with_stdout_contains("running 0 tests"));

}

#[test]

fn cargo_compile_with_transitive_dev_deps() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

version = "0.5.0"

path = "bar"

"#)

.file("src/main.rs",

&main_file(r#""{}", bar::gimme()"#, &["bar"]))

.file("bar/Cargo.toml", r#"

[project]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

[dev-dependencies.baz]

git = "git://example.com/path/to/nowhere"

[lib]

name = "bar"

"#)

.file("bar/src/bar.rs", r#"

pub fn gimme() -> &'static str {

"zoidberg"

}

"#)

.build();

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) in \

[..]\n",

p.url(),

p.url())));

assert_that(&p.bin("foo"), existing_file());

assert_that(process(&p.bin("foo")),

execs().with_stdout("zoidberg\n"));

}

#[test]

fn no_rebuild_dependency() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

path = "bar"

"#)

.file("src/main.rs", r#"

extern crate bar;

fn main() { bar::bar() }

"#)

.file("bar/Cargo.toml", r#"

[project]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

[lib]

name = "bar"

"#)

.file("bar/src/bar.rs", r#"

pub fn bar() {}

"#)

.build();

// First time around we should compile both foo and bar

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url(),

p.url())));

sleep_ms(1000);

p.change_file("src/main.rs", r#"

extern crate bar;

fn main() { bar::bar(); }

"#);

// Don't compile bar, but do recompile foo.

assert_that(p.cargo("build"),

execs().with_stderr("\

[COMPILING] foo v0.5.0 ([..])\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n"));

}

#[test]

fn deep_dependencies_trigger_rebuild() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

path = "bar"

"#)

.file("src/main.rs", r#"

extern crate bar;

fn main() { bar::bar() }

"#)

.file("bar/Cargo.toml", r#"

[project]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

[lib]

name = "bar"

[dependencies.baz]

path = "../baz"

"#)

.file("bar/src/bar.rs", r#"

extern crate baz;

pub fn bar() { baz::baz() }

"#)

.file("baz/Cargo.toml", r#"

[project]

name = "baz"

version = "0.5.0"

authors = ["wycats@example.com"]

[lib]

name = "baz"

"#)

.file("baz/src/baz.rs", r#"

pub fn baz() {}

"#)

.build();

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] baz v0.5.0 ({}/baz)\n\

[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url(),

p.url(),

p.url())));

assert_that(p.cargo("build"),

execs().with_stdout(""));

// Make sure an update to baz triggers a rebuild of bar

//

// We base recompilation off mtime, so sleep for at least a second to ensure

// that this write will change the mtime.

sleep_ms(1000);

File::create(&p.root().join("baz/src/baz.rs")).unwrap().write_all(br#"

pub fn baz() { println!("hello!"); }

"#).unwrap();

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] baz v0.5.0 ({}/baz)\n\

[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url(),

p.url(),

p.url())));

// Make sure an update to bar doesn't trigger baz

sleep_ms(1000);

File::create(&p.root().join("bar/src/bar.rs")).unwrap().write_all(br#"

extern crate baz;

pub fn bar() { println!("hello!"); baz::baz(); }

"#).unwrap();

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url(),

p.url())));

}

#[test]

fn no_rebuild_two_deps() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

path = "bar"

[dependencies.baz]

path = "baz"

"#)

.file("src/main.rs", r#"

extern crate bar;

fn main() { bar::bar() }

"#)

.file("bar/Cargo.toml", r#"

[project]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

[lib]

name = "bar"

[dependencies.baz]

path = "../baz"

"#)

.file("bar/src/bar.rs", r#"

pub fn bar() {}

"#)

.file("baz/Cargo.toml", r#"

[project]

name = "baz"

version = "0.5.0"

authors = ["wycats@example.com"]

[lib]

name = "baz"

"#)

.file("baz/src/baz.rs", r#"

pub fn baz() {}

"#)

.build();

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] baz v0.5.0 ({}/baz)\n\

[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url(),

p.url(),

p.url())));

assert_that(&p.bin("foo"), existing_file());

assert_that(p.cargo("build"),

execs().with_stdout(""));

assert_that(&p.bin("foo"), existing_file());

}

#[test]

fn nested_deps_recompile() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

version = "0.5.0"

path = "src/bar"

"#)

.file("src/main.rs",

&main_file(r#""{}", bar::gimme()"#, &["bar"]))

.file("src/bar/Cargo.toml", r#"

[project]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

[lib]

name = "bar"

"#)

.file("src/bar/src/bar.rs", "pub fn gimme() -> i32 { 92 }")

.build();

let bar = p.url();

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] bar v0.5.0 ({}/src/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

bar,

p.url())));

sleep_ms(1000);

File::create(&p.root().join("src/main.rs")).unwrap().write_all(br#"

fn main() {}

"#).unwrap();

// This shouldn't recompile `bar`

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url())));

}

#[test]

fn error_message_for_missing_manifest() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

path = "src/bar"

"#)

.file("src/lib.rs", "")

.file("src/bar/not-a-manifest", "")

.build();

assert_that(p.cargo("build"),

execs().with_status(101)

.with_stderr("\

[ERROR] failed to load source for a dependency on `bar`

Caused by:

Unable to update file://[..]

Caused by:

failed to read `[..]bar[/]Cargo.toml`

Caused by:

[..] (os error [..])

"));

}

#[test]

fn override_relative() {

let bar = project("bar")

.file("Cargo.toml", r#"

[package]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

"#)

.file("src/lib.rs", "")

.build();

fs::create_dir(&paths::root().join(".cargo")).unwrap();

File::create(&paths::root().join(".cargo/config")).unwrap()

.write_all(br#"paths = ["bar"]"#).unwrap();

let p = project("foo")

.file("Cargo.toml", &format!(r#"

[package]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

path = '{}'

"#, bar.root().display()))

.file("src/lib.rs", "")

.build();

assert_that(p.cargo("build").arg("-v"), execs().with_status(0));

}

#[test]

fn override_self() {

let bar = project("bar")

.file("Cargo.toml", r#"

[package]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

"#)

.file("src/lib.rs", "")

.build();

let p = project("foo");

let root = p.root().clone();

let p = p

.file(".cargo/config", &format!(r#"

paths = ['{}']

"#, root.display()))

.file("Cargo.toml", &format!(r#"

[package]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

path = '{}'

"#, bar.root().display()))

.file("src/lib.rs", "")

.file("src/main.rs", "fn main() {}")

.build();

assert_that(p.cargo("build"), execs().with_status(0));

}

#[test]

fn override_path_dep() {

let bar = project("bar")

.file("p1/Cargo.toml", r#"

[package]

name = "p1"

version = "0.5.0"

authors = []

[dependencies.p2]

path = "../p2"

"#)

.file("p1/src/lib.rs", "")

.file("p2/Cargo.toml", r#"

[package]

name = "p2"

version = "0.5.0"

authors = []

"#)

.file("p2/src/lib.rs", "")

.build();

let p = project("foo")

.file(".cargo/config", &format!(r#"

paths = ['{}', '{}']

"#, bar.root().join("p1").display(),

bar.root().join("p2").display()))

.file("Cargo.toml", &format!(r#"

[package]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.p2]

path = '{}'

"#, bar.root().join("p2").display()))

.file("src/lib.rs", "")

.build();

assert_that(p.cargo("build").arg("-v"),

execs().with_status(0));

}

#[test]

fn path_dep_build_cmd() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = ["wycats@example.com"]

[dependencies.bar]

version = "0.5.0"

path = "bar"

"#)

.file("src/main.rs",

&main_file(r#""{}", bar::gimme()"#, &["bar"]))

.file("bar/Cargo.toml", r#"

[project]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

build = "build.rs"

[lib]

name = "bar"

path = "src/bar.rs"

"#)

.file("bar/build.rs", r#"

use std::fs;

fn main() {

fs::copy("src/bar.rs.in", "src/bar.rs").unwrap();

}

"#)

.file("bar/src/bar.rs.in", r#"

pub fn gimme() -> i32 { 0 }

"#).build();

p.root().join("bar").move_into_the_past();

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) in \

[..]\n",

p.url(),

p.url())));

assert_that(&p.bin("foo"), existing_file());

assert_that(process(&p.bin("foo")),

execs().with_stdout("0\n"));

// Touching bar.rs.in should cause the `build` command to run again.

{

let file = fs::File::create(&p.root().join("bar/src/bar.rs.in"));

file.unwrap().write_all(br#"pub fn gimme() -> i32 { 1 }"#).unwrap();

}

assert_that(p.cargo("build"),

execs().with_stderr(&format!("[COMPILING] bar v0.5.0 ({}/bar)\n\

[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) in \

[..]\n",

p.url(),

p.url())));

assert_that(process(&p.bin("foo")),

execs().with_stdout("1\n"));

}

#[test]

fn dev_deps_no_rebuild_lib() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = []

[dev-dependencies.bar]

path = "bar"

[lib]

name = "foo"

doctest = false

"#)

.file("src/lib.rs", r#"

#[cfg(test)] #[allow(unused_extern_crates)] extern crate bar;

#[cfg(not(test))] pub fn foo() { env!("FOO"); }

"#)

.file("bar/Cargo.toml", r#"

[package]

name = "bar"

version = "0.5.0"

authors = ["wycats@example.com"]

"#)

.file("bar/src/lib.rs", "pub fn bar() {}")

.build();

assert_that(p.cargo("build")

.env("FOO", "bar"),

execs().with_status(0)

.with_stderr(&format!("[COMPILING] foo v0.5.0 ({})\n\

[FINISHED] dev [unoptimized + debuginfo] target(s) \

in [..]\n",

p.url())));

assert_that(p.cargo("test"),

execs().with_status(0)

.with_stderr(&format!("\

[COMPILING] [..] v0.5.0 ({url}[..])

[COMPILING] [..] v0.5.0 ({url}[..])

[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]

[RUNNING] target[/]debug[/]deps[/]foo-[..][EXE]", url = p.url()))

.with_stdout_contains("running 0 tests"));

}

#[test]

fn custom_target_no_rebuild() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = []

[dependencies]

a = { path = "a" }

[workspace]

members = ["a", "b"]

"#)

.file("src/lib.rs", "")

.file("a/Cargo.toml", r#"

[project]

name = "a"

version = "0.5.0"

authors = []

"#)

.file("a/src/lib.rs", "")

.file("b/Cargo.toml", r#"

[project]

name = "b"

version = "0.5.0"

authors = []

[dependencies]

a = { path = "../a" }

"#)

.file("b/src/lib.rs", "")

.build();

assert_that(p.cargo("build"),

execs().with_status(0)

.with_stderr("\

[COMPILING] a v0.5.0 ([..])

[COMPILING] foo v0.5.0 ([..])

[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]

"));

t!(fs::rename(p.root().join("target"), p.root().join("target_moved")));

assert_that(p.cargo("build")

.arg("--manifest-path=b/Cargo.toml")

.env("CARGO_TARGET_DIR", "target_moved"),

execs().with_status(0)

.with_stderr("\

[COMPILING] b v0.5.0 ([..])

[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]

"));

}

#[test]

fn override_and_depend() {

let p = project("foo")

.file("a/a1/Cargo.toml", r#"

[project]

name = "a1"

version = "0.5.0"

authors = []

[dependencies]

a2 = { path = "../a2" }

"#)

.file("a/a1/src/lib.rs", "")

.file("a/a2/Cargo.toml", r#"

[project]

name = "a2"

version = "0.5.0"

authors = []

"#)

.file("a/a2/src/lib.rs", "")

.file("b/Cargo.toml", r#"

[project]

name = "b"

version = "0.5.0"

authors = []

[dependencies]

a1 = { path = "../a/a1" }

a2 = { path = "../a/a2" }

"#)

.file("b/src/lib.rs", "")

.file("b/.cargo/config", r#"

paths = ["../a"]

"#)

.build();

assert_that(p.cargo("build").cwd(p.root().join("b")),

execs().with_status(0)

.with_stderr("\

[COMPILING] a2 v0.5.0 ([..])

[COMPILING] a1 v0.5.0 ([..])

[COMPILING] b v0.5.0 ([..])

[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]

"));

}

#[test]

fn missing_path_dependency() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "a"

version = "0.5.0"

authors = []

"#)

.file("src/lib.rs", "")

.file(".cargo/config", r#"

paths = ["../whoa-this-does-not-exist"]

"#)

.build();

assert_that(p.cargo("build"),

execs().with_status(101)

.with_stderr("\

[ERROR] failed to update path override `[..]../whoa-this-does-not-exist` \

(defined in `[..]`)

Caused by:

failed to read directory `[..]`

Caused by:

[..] (os error [..])

"));

}

#[test]

fn invalid_path_dep_in_workspace_with_lockfile() {

Package::new("bar", "1.0.0").publish();

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "top"

version = "0.5.0"

authors = []

[workspace]

[dependencies]

foo = { path = "foo" }

"#)

.file("src/lib.rs", "")

.file("foo/Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = []

[dependencies]

bar = "*"

"#)

.file("foo/src/lib.rs", "")

.build();

// Generate a lock file

assert_that(p.cargo("build"), execs().with_status(0));

// Change the dependency on `bar` to an invalid path

File::create(&p.root().join("foo/Cargo.toml")).unwrap().write_all(br#"

[project]

name = "foo"

version = "0.5.0"

authors = []

[dependencies]

bar = { path = "" }

"#).unwrap();

// Make sure we get a nice error. In the past this actually stack

// overflowed!

assert_that(p.cargo("build"),

execs().with_status(101)

.with_stderr("\

error: no matching package named `bar` found (required by `foo`)

location searched: [..]

version required: *

"));

}

#[test]

fn workspace_produces_rlib() {

let p = project("foo")

.file("Cargo.toml", r#"

[project]

name = "top"

version = "0.5.0"

authors = []

[workspace]

[dependencies]

foo = { path = "foo" }

"#)

.file("src/lib.rs", "")

.file("foo/Cargo.toml", r#"

[project]

name = "foo"

version = "0.5.0"

authors = []

"#)

.file("foo/src/lib.rs", "")

.build();

assert_that(p.cargo("build"), execs().with_status(0));

assert_that(&p.root().join("target/debug/libtop.rlib"), existing_file());

assert_that(&p.root().join("target/debug/libfoo.rlib"), existing_file());

}