src/tools/cargo/tests/testsuite/rustdoc.rs

   1 //! Tests for the `cargo rustdoc` command.
   2
   3 use cargo_test_support::{basic_manifest, cross_compile, project};
   4
   5 #[cargo_test]
   6 fn rustdoc_simple() {
   7     let p = project().file("src/lib.rs", "").build();
   8
   9     p.cargo("rustdoc -v")
  10         .with_stderr(
  11             "\
  12 [DOCUMENTING] foo v0.0.1 ([CWD])
  13 [RUNNING] `rustdoc [..]--crate-name foo src/lib.rs [..]\
  14         -o [CWD]/target/doc \
  15         [..] \
  16         -L dependency=[CWD]/target/debug/deps [..]`
  17 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
  18 ",
  19         )
  20         .run();
  21 }
  22
  23 #[cargo_test]
  24 fn rustdoc_args() {
  25     let p = project().file("src/lib.rs", "").build();
  26
  27     p.cargo("rustdoc -v -- --cfg=foo")
  28         .with_stderr(
  29             "\
  30 [DOCUMENTING] foo v0.0.1 ([CWD])
  31 [RUNNING] `rustdoc [..]--crate-name foo src/lib.rs [..]\
  32         -o [CWD]/target/doc \
  33         [..] \
  34         --cfg=foo \
  35         -C metadata=[..] \
  36         -L dependency=[CWD]/target/debug/deps [..]`
  37 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
  38 ",
  39         )
  40         .run();
  41 }
  42
  43 #[cargo_test]
  44 fn rustdoc_binary_args_passed() {
  45     let p = project().file("src/main.rs", "").build();
  46
  47     p.cargo("rustdoc -v")
  48         .arg("--")
  49         .arg("--markdown-no-toc")
  50         .with_stderr_contains("[RUNNING] `rustdoc [..] --markdown-no-toc[..]`")
  51         .run();
  52 }
  53
  54 #[cargo_test]
  55 fn rustdoc_foo_with_bar_dependency() {
  56     let foo = project()
  57         .file(
  58             "Cargo.toml",
  59             r#"
  60                 [package]
  61                 name = "foo"
  62                 version = "0.0.1"
  63                 authors = []
  64
  65                 [dependencies.bar]
  66                 path = "../bar"
  67             "#,
  68         )
  69         .file("src/lib.rs", "extern crate bar; pub fn foo() {}")
  70         .build();
  71     let _bar = project()
  72         .at("bar")
  73         .file("Cargo.toml", &basic_manifest("bar", "0.0.1"))
  74         .file("src/lib.rs", "pub fn baz() {}")
  75         .build();
  76
  77     foo.cargo("rustdoc -v -- --cfg=foo")
  78         .with_stderr(
  79             "\
  80 [CHECKING] bar v0.0.1 ([..])
  81 [RUNNING] `rustc [..]bar/src/lib.rs [..]`
  82 [DOCUMENTING] foo v0.0.1 ([CWD])
  83 [RUNNING] `rustdoc [..]--crate-name foo src/lib.rs [..]\
  84         -o [CWD]/target/doc \
  85         [..] \
  86         --cfg=foo \
  87         -C metadata=[..] \
  88         -L dependency=[CWD]/target/debug/deps \
  89         --extern [..]`
  90 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
  91 ",
  92         )
  93         .run();
  94 }
  95
  96 #[cargo_test]
  97 fn rustdoc_only_bar_dependency() {
  98     let foo = project()
  99         .file(
 100             "Cargo.toml",
 101             r#"
 102                 [package]
 103                 name = "foo"
 104                 version = "0.0.1"
 105                 authors = []
 106
 107                 [dependencies.bar]
 108                 path = "../bar"
 109             "#,
 110         )
 111         .file("src/main.rs", "extern crate bar; fn main() { bar::baz() }")
 112         .build();
 113     let _bar = project()
 114         .at("bar")
 115         .file("Cargo.toml", &basic_manifest("bar", "0.0.1"))
 116         .file("src/lib.rs", "pub fn baz() {}")
 117         .build();
 118
 119     foo.cargo("rustdoc -v -p bar -- --cfg=foo")
 120         .with_stderr(
 121             "\
 122 [DOCUMENTING] bar v0.0.1 ([..])
 123 [RUNNING] `rustdoc [..]--crate-name bar [..]bar/src/lib.rs [..]\
 124         -o [CWD]/target/doc \
 125         [..] \
 126         --cfg=foo \
 127         -C metadata=[..] \
 128         -L dependency=[CWD]/target/debug/deps [..]`
 129 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
 130 ",
 131         )
 132         .run();
 133 }
 134
 135 #[cargo_test]
 136 fn rustdoc_same_name_documents_lib() {
 137     let p = project()
 138         .file("src/main.rs", "fn main() {}")
 139         .file("src/lib.rs", r#" "#)
 140         .build();
 141
 142     p.cargo("rustdoc -v -- --cfg=foo")
 143         .with_stderr(
 144             "\
 145 [DOCUMENTING] foo v0.0.1 ([..])
 146 [RUNNING] `rustdoc [..]--crate-name foo src/lib.rs [..]\
 147         -o [CWD]/target/doc \
 148         [..] \
 149         --cfg=foo \
 150         -C metadata=[..] \
 151         -L dependency=[CWD]/target/debug/deps [..]`
 152 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
 153 ",
 154         )
 155         .run();
 156 }
 157
 158 #[cargo_test]
 159 fn features() {
 160     let p = project()
 161         .file(
 162             "Cargo.toml",
 163             r#"
 164                 [package]
 165                 name = "foo"
 166                 version = "0.0.1"
 167                 authors = []
 168
 169                 [features]
 170                 quux = []
 171             "#,
 172         )
 173         .file("src/lib.rs", "")
 174         .build();
 175
 176     p.cargo("rustdoc --verbose --features quux")
 177         .with_stderr_contains("[..]feature=[..]quux[..]")
 178         .run();
 179 }
 180
 181 #[cargo_test]
 182 fn proc_macro_crate_type() {
 183     let p = project()
 184         .file(
 185             "Cargo.toml",
 186             r#"
 187                 [package]
 188                 name = "foo"
 189                 version = "0.0.1"
 190                 authors = []
 191
 192                 [lib]
 193                 proc-macro = true
 194
 195             "#,
 196         )
 197         .file("src/lib.rs", "")
 198         .build();
 199
 200     p.cargo("rustdoc --verbose")
 201         .with_stderr_contains(
 202             "\
 203 [RUNNING] `rustdoc --crate-type proc-macro [..]`
 204 ",
 205         )
 206         .run();
 207 }
 208
 209 #[cargo_test]
 210 fn rustdoc_target() {
 211     if cross_compile::disabled() {
 212         return;
 213     }
 214
 215     let p = project().file("src/lib.rs", "").build();
 216
 217     p.cargo("rustdoc --verbose --target")
 218         .arg(cross_compile::alternate())
 219         .with_stderr(format!(
 220             "\
 221 [DOCUMENTING] foo v0.0.1 ([..])
 222 [RUNNING] `rustdoc [..]--crate-name foo src/lib.rs [..]\
 223     --target {target} \
 224     -o [CWD]/target/{target}/doc \
 225     [..] \
 226     -L dependency=[CWD]/target/{target}/debug/deps \
 227     -L dependency=[CWD]/target/debug/deps[..]`
 228 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]",
 229             target = cross_compile::alternate()
 230         ))
 231         .run();
 232 }
 233
 234 #[cargo_test]
 235 fn fail_with_glob() {
 236     let p = project()
 237         .file(
 238             "Cargo.toml",
 239             r#"
 240                 [workspace]
 241                 members = ["bar"]
 242             "#,
 243         )
 244         .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
 245         .file("bar/src/lib.rs", "pub fn bar() {  break_the_build(); }")
 246         .build();
 247
 248     p.cargo("rustdoc -p '*z'")
 249         .with_status(101)
 250         .with_stderr("[ERROR] Glob patterns on package selection are not supported.")
 251         .run();
 252 }