cargo-rahti 0.0.18

Create and maintain Rahti projects: cargo rahti new, cargo rahti upgrade.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! Delegation to the optional packaging tool.

use super::*;

#[test]
fn the_missing_message_names_the_command_that_fixes_it() {
    let message = missing();
    assert!(
        message.contains("cargo install cargo-rahti-native"),
        "{message}"
    );
    // And says why it is not already there, so "optional" is a fact rather
    // than an apology.
    assert!(message.contains("optional"), "{message}");
}

#[test]
fn the_missing_message_offers_no_way_to_install_it_for_you() {
    // A tool that reacted to a missing dependency by fetching and running one
    // is a tool that decides what runs on somebody's machine.
    let message = missing().to_ascii_lowercase();
    for forbidden in ["installing", "downloading", "shall i", "would you like"] {
        assert!(!message.contains(forbidden), "{forbidden}");
    }
}

#[test]
fn the_helper_is_looked_for_beside_this_executable_first() {
    // `cargo install` puts both binaries in one directory, and a workspace
    // checkout puts both in one `target/debug` — so a local build of one
    // should reach the local build of the other rather than an installed
    // version.
    let path = locate();
    let name = path
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or_default();
    assert_eq!(name, format!("{HELPER}{}", std::env::consts::EXE_SUFFIX));

    // In this workspace the sibling exists whenever it has been built, and
    // then the path is absolute rather than a bare name for `PATH` to resolve.
    let sibling = std::env::current_exe()
        .unwrap()
        .parent()
        .unwrap()
        .join(format!("{HELPER}{}", std::env::consts::EXE_SUFFIX));
    if sibling.is_file() {
        assert_eq!(path, sibling);
    }
}

/// The real thing, end to end, when the helper has been built.
///
/// Both are workspace members, so a `cargo test --workspace` run has the
/// binary — but `cargo test -p cargo-rahti` alone may not, and a test that
/// failed because of what else had been built would be a bad test. So it
/// checks and says which it did.
#[test]
fn a_forwarded_command_reaches_the_helper() {
    let helper = std::env::current_exe()
        .unwrap()
        .parent()
        .unwrap()
        .join(format!("{HELPER}{}", std::env::consts::EXE_SUFFIX));

    if !helper.is_file() {
        eprintln!(
            "skipped: {} has not been built — run `cargo build --workspace` first",
            helper.display()
        );
        return;
    }

    // What `cargo rahti native --help` forwards.
    let output = std::process::Command::new(&helper)
        .args(["native", "--help"])
        .output()
        .expect("the helper runs");

    assert!(output.status.success());
    let text = String::from_utf8_lossy(&output.stdout);
    assert!(text.contains("cargo rahti native init"), "{text}");
    assert!(text.contains("--target"), "{text}");
}

#[test]
fn a_forwarded_failure_is_forwarded_as_a_failure() {
    let helper = std::env::current_exe()
        .unwrap()
        .parent()
        .unwrap()
        .join(format!("{HELPER}{}", std::env::consts::EXE_SUFFIX));

    if !helper.is_file() {
        eprintln!("skipped: the helper has not been built");
        return;
    }

    let output = std::process::Command::new(&helper)
        .args(["native", "build", "--target", "ios"])
        .output()
        .expect("the helper runs");

    assert!(!output.status.success(), "an unsupported target succeeded");
    let text = String::from_utf8_lossy(&output.stderr);
    assert!(text.contains("ios"), "{text}");
}