use std::fs::{self, File};
use std::io::{Read, Write};

use toml;
use cargotest::support::git;
use cargotest::support::paths;
use cargotest::support::registry::Package;
use cargotest::support::{execs, project};
use hamcrest::assert_that;

#[test]
fn replace() {
    Package::new("foo", "0.1.0").publish();
    Package::new("deep-foo", "0.1.0")
        .file(
            "src/lib.rs",
            r#"
            extern crate foo;
            pub fn deep() {
                foo::foo();
            }
        "#,
        )
        .dep("foo", "0.1.0")
        .publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1.0"
            deep-foo = "0.1.0"

            [patch.crates-io]
            foo = { path = "foo" }
        "#,
        )
        .file(
            "src/lib.rs",
            "
            extern crate foo;
            extern crate deep_foo;
            pub fn bar() {
                foo::foo();
                deep_foo::deep();
            }
        ",
        )
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file(
            "foo/src/lib.rs",
            r#"
            pub fn foo() {}
        "#,
        )
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[DOWNLOADING] deep-foo v0.1.0 ([..])
[COMPILING] foo v0.1.0 (file://[..])
[COMPILING] deep-foo v0.1.0
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );

    assert_that(
        p.cargo("build"), //.env("RUST_LOG", "trace"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );
}

#[test]
fn nonexistent() {
    Package::new("baz", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1.0"

            [patch.crates-io]
            foo = { path = "foo" }
        "#,
        )
        .file(
            "src/lib.rs",
            "
            extern crate foo;
            pub fn bar() {
                foo::foo();
            }
        ",
        )
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file(
            "foo/src/lib.rs",
            r#"
            pub fn foo() {}
        "#,
        )
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[COMPILING] foo v0.1.0 (file://[..])
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );
}

#[test]
fn patch_git() {
    let foo = git::repo(&paths::root().join("override"))
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file("src/lib.rs", "")
        .build();

    let p = project("bar")
        .file(
            "Cargo.toml",
            &format!(
                r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = {{ git = '{}' }}

            [patch.'{0}']
            foo = {{ path = "foo" }}
        "#,
                foo.url()
            ),
        )
        .file(
            "src/lib.rs",
            "
            extern crate foo;
            pub fn bar() {
                foo::foo();
            }
        ",
        )
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file(
            "foo/src/lib.rs",
            r#"
            pub fn foo() {}
        "#,
        )
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] git repository `file://[..]`
[COMPILING] foo v0.1.0 (file://[..])
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );
}

#[test]
fn patch_to_git() {
    let foo = git::repo(&paths::root().join("override"))
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file("src/lib.rs", "pub fn foo() {}")
        .build();

    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            &format!(
                r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1"

            [patch.crates-io]
            foo = {{ git = '{}' }}
        "#,
                foo.url()
            ),
        )
        .file(
            "src/lib.rs",
            "
            extern crate foo;
            pub fn bar() {
                foo::foo();
            }
        ",
        )
        .build();

    assert_that(
        p.cargo("build"), //.env("RUST_LOG", "cargo=trace"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] git repository `file://[..]`
[UPDATING] registry `file://[..]`
[COMPILING] foo v0.1.0 (file://[..])
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );
}

#[test]
fn unused() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1.0"

            [patch.crates-io]
            foo = { path = "foo" }
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.2.0"
            authors = []
        "#,
        )
        .file(
            "foo/src/lib.rs",
            r#"
            not rust code
        "#,
        )
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[DOWNLOADING] foo v0.1.0 [..]
[COMPILING] foo v0.1.0
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );

    // unused patch should be in the lock file
    let mut lock = String::new();
    File::open(p.root().join("Cargo.lock"))
        .unwrap()
        .read_to_string(&mut lock)
        .unwrap();
    let toml: toml::Value = toml::from_str(&lock).unwrap();
    assert_eq!(toml["patch"]["unused"].as_array().unwrap().len(), 1);
    assert_eq!(toml["patch"]["unused"][0]["name"].as_str(), Some("foo"));
    assert_eq!(
        toml["patch"]["unused"][0]["version"].as_str(),
        Some("0.2.0")
    );
}

#[test]
fn unused_git() {
    Package::new("foo", "0.1.0").publish();

    let foo = git::repo(&paths::root().join("override"))
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.2.0"
            authors = []
        "#,
        )
        .file("src/lib.rs", "")
        .build();

    let p = project("bar")
        .file(
            "Cargo.toml",
            &format!(
                r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1"

            [patch.crates-io]
            foo = {{ git = '{}' }}
        "#,
                foo.url()
            ),
        )
        .file("src/lib.rs", "")
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] git repository `file://[..]`
[UPDATING] registry `file://[..]`
[DOWNLOADING] foo v0.1.0 [..]
[COMPILING] foo v0.1.0
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );
}

#[test]
fn add_patch() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1.0"
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[DOWNLOADING] foo v0.1.0 [..]
[COMPILING] foo v0.1.0
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );

    t!(t!(File::create(p.root().join("Cargo.toml"))).write_all(
        br#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1.0"

            [patch.crates-io]
            foo = { path = 'foo' }
    "#
    ));

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[COMPILING] foo v0.1.0 (file://[..])
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );
}

#[test]
fn add_ignored_patch() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1.0"
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.1"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[DOWNLOADING] foo v0.1.0 [..]
[COMPILING] foo v0.1.0
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );

    t!(t!(File::create(p.root().join("Cargo.toml"))).write_all(
        br#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1.0"

            [patch.crates-io]
            foo = { path = 'foo' }
    "#
    ));

    assert_that(
        p.cargo("build"),
        execs()
            .with_status(0)
            .with_stderr("[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]"),
    );
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );
}

#[test]
fn new_minor() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1.0"

            [patch.crates-io]
            foo = { path = 'foo' }
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.1"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[COMPILING] foo v0.1.1 [..]
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
}

#[test]
fn transitive_new_minor() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            subdir = { path = 'subdir' }

            [patch.crates-io]
            foo = { path = 'foo' }
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "subdir/Cargo.toml",
            r#"
            [package]
            name = "subdir"
            version = "0.1.0"
            authors = []

            [dependencies]
            foo = '0.1.0'
        "#,
        )
        .file("subdir/src/lib.rs", r#""#)
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.1"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[COMPILING] foo v0.1.1 [..]
[COMPILING] subdir v0.1.0 [..]
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
}

#[test]
fn new_major() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.2.0"

            [patch.crates-io]
            foo = { path = 'foo' }
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.2.0"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[COMPILING] foo v0.2.0 [..]
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );

    Package::new("foo", "0.2.0").publish();
    assert_that(p.cargo("update"), execs().with_status(0));
    assert_that(
        p.cargo("build"),
        execs()
            .with_status(0)
            .with_stderr("[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]"),
    );

    t!(t!(File::create(p.root().join("Cargo.toml"))).write_all(
        br#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.2.0"
    "#
    ));
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[DOWNLOADING] foo v0.2.0 [..]
[COMPILING] foo v0.2.0
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
}

#[test]
fn transitive_new_major() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            subdir = { path = 'subdir' }

            [patch.crates-io]
            foo = { path = 'foo' }
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "subdir/Cargo.toml",
            r#"
            [package]
            name = "subdir"
            version = "0.1.0"
            authors = []

            [dependencies]
            foo = '0.2.0'
        "#,
        )
        .file("subdir/src/lib.rs", r#""#)
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.2.0"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr(
            "\
[UPDATING] registry `file://[..]`
[COMPILING] foo v0.2.0 [..]
[COMPILING] subdir v0.1.0 [..]
[COMPILING] bar v0.0.1 (file://[..])
[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
",
        ),
    );
}

#[test]
fn remove_patch() {
    Package::new("foo", "0.1.0").publish();
    Package::new("bar", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [dependencies]
            foo = "0.1"

            [patch.crates-io]
            foo = { path = 'foo' }
            bar = { path = 'bar' }
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .file(
            "bar/Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file("bar/src/lib.rs", r#""#)
        .build();

    // Generate a lock file where `bar` is unused
    assert_that(p.cargo("build"), execs().with_status(0));
    let mut lock_file1 = String::new();
    File::open(p.root().join("Cargo.lock"))
        .unwrap()
        .read_to_string(&mut lock_file1)
        .unwrap();

    // Remove `bar` and generate a new lock file form the old one
    File::create(p.root().join("Cargo.toml"))
        .unwrap()
        .write_all(
            r#"
        [package]
        name = "bar"
        version = "0.0.1"
        authors = []

        [dependencies]
        foo = "0.1"

        [patch.crates-io]
        foo = { path = 'foo' }
    "#.as_bytes(),
        )
        .unwrap();
    assert_that(p.cargo("build"), execs().with_status(0));
    let mut lock_file2 = String::new();
    File::open(p.root().join("Cargo.lock"))
        .unwrap()
        .read_to_string(&mut lock_file2)
        .unwrap();

    // Remove the lock file and build from scratch
    fs::remove_file(p.root().join("Cargo.lock")).unwrap();
    assert_that(p.cargo("build"), execs().with_status(0));
    let mut lock_file3 = String::new();
    File::open(p.root().join("Cargo.lock"))
        .unwrap()
        .read_to_string(&mut lock_file3)
        .unwrap();

    assert!(lock_file1.contains("bar"));
    assert_eq!(lock_file2, lock_file3);
    assert_ne!(lock_file1, lock_file2);
}

#[test]
fn non_crates_io() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [patch.some-other-source]
            foo = { path = 'foo' }
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(101).with_stderr(
            "\
error: failed to parse manifest at `[..]`

Caused by:
  invalid url `some-other-source`: relative URL without a base
",
        ),
    );
}

#[test]
fn replace_with_crates_io() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.0.1"
            authors = []

            [patch.crates-io]
            foo = "0.1"
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .build();

    assert_that(
        p.cargo("build"),
        execs().with_status(101).with_stderr(
            "\
[UPDATING] [..]
error: failed to resolve patches for `[..]`

Caused by:
  patch for `foo` in `[..]` points to the same source, but patches must point \
  to different sources
",
        ),
    );
}

#[test]
fn patch_in_virtual() {
    Package::new("foo", "0.1.0").publish();

    let p = project("bar")
        .file(
            "Cargo.toml",
            r#"
            [workspace]
            members = ["bar"]

            [patch.crates-io]
            foo = { path = "foo" }
        "#,
        )
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.0"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .file(
            "bar/Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.1.0"
            authors = []

            [dependencies]
            foo = "0.1"
        "#,
        )
        .file("bar/src/lib.rs", r#""#)
        .build();

    assert_that(p.cargo("build"), execs().with_status(0));
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );
}

#[test]
fn patch_depends_on_another_patch() {
    Package::new("foo", "0.1.0")
        .file("src/lib.rs", "broken code")
        .publish();

    Package::new("bar", "0.1.0")
        .dep("foo", "0.1")
        .file("src/lib.rs", "broken code")
        .publish();

    let p = project("p")
        .file(
            "Cargo.toml",
            r#"
            [package]
            name = "p"
            authors = []
            version = "0.1.0"

            [dependencies]
            foo = "0.1"
            bar = "0.1"

            [patch.crates-io]
            foo = { path = "foo" }
            bar = { path = "bar" }
        "#,
        )
        .file("src/lib.rs", "")
        .file(
            "foo/Cargo.toml",
            r#"
            [package]
            name = "foo"
            version = "0.1.1"
            authors = []
        "#,
        )
        .file("foo/src/lib.rs", r#""#)
        .file(
            "bar/Cargo.toml",
            r#"
            [package]
            name = "bar"
            version = "0.1.1"
            authors = []

            [dependencies]
            foo = "0.1"
        "#,
        )
        .file("bar/src/lib.rs", r#""#)
        .build();

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

    // Nothing should be rebuilt, no registry should be updated.
    assert_that(
        p.cargo("build"),
        execs().with_status(0).with_stderr("[FINISHED] [..]"),
    );
}

#[test]
fn replace_prerelease() {
    Package::new("bar", "1.1.0-pre.1").publish();
    let p = project("foo")
        .file(
            "Cargo.toml",
            r#"
            [workspace]
            members = ["foo"]

            [patch.crates-io]
            bar = { path = "./bar" }
        "#,
        )
        .file(
            "foo/Cargo.toml",
            r#"
            [project]
            name = "foo"
            version = "0.5.0"
            authors = []

            [dependencies]
            bar = "1.1.0-pre.1"
        "#,
        )
        .file(
            "foo/src/main.rs",
            "
            extern crate bar;
            fn main() { bar::bar() }
        ",
        )
        .file(
            "bar/Cargo.toml",
            r#"
            [project]
            name = "bar"
            version = "1.1.0-pre.1"
            authors = []
            [workspace]
        "#,
        )
        .file("bar/src/lib.rs", "pub fn bar() {}")
        .build();

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