jbx 0.4.0

jbx: one-stop Java toolbox for scripts, tools, and agents
Documentation 
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::process::Command;

fn jbx_command() -> Command {
    Command::new(env!("CARGO_BIN_EXE_jbx"))
}

fn jbx_output(args: &[&str]) -> String {
    let output = jbx_command()
        .args(args)
        .output()
        .expect("failed to run jbx");
    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);
    if !output.status.success() {
        panic!(
            "jbx {} failed:\nstdout={stdout}\nstderr={stderr}",
            args.join(" ")
        );
    }
    stdout.to_string()
}

#[test]
fn jdk_list_shows_discovered_jdks() {
    // At minimum, the system JDK should be discoverable
    let output = jbx_output(&["jdk", "list"]);
    // Should contain at least one JDK with a version number
    assert!(
        output
            .lines()
            .any(|line| line.starts_with(char::is_numeric)),
        "jdk list should show at least one JDK, got: {output}"
    );
}

#[test]
fn jdk_home_returns_path_for_baseline_jdk() {
    // CI installs Java 25, and jbx's baseline/default is Java 25.
    let output = jbx_output(&["jdk", "home", "25"]);
    assert!(
        output.contains("jdks") || output.contains("jvm") || output.contains("Java"),
        "jdk home 25 should return a JDK path, got: {output}"
    );
}

#[test]
fn jdk_home_accepts_jbang_plus_version_selector() {
    let plain = jbx_output(&["jdk", "home", "25"]);
    let plus = jbx_output(&["jdk", "home", "25+"]);
    assert_eq!(
        plain.trim(),
        plus.trim(),
        "jdk home 25+ should resolve to the same path as jdk home 25"
    );
}

#[test]
fn jdk_home_fails_for_missing_version_without_auto_install() {
    // Version 999 doesn't exist; without auto-install it should fail
    let output = jbx_command()
        .args(["jdk", "home", "999"])
        .output()
        .expect("failed to run jbx");
    assert!(
        !output.status.success(),
        "jdk home 999 should fail without auto-install"
    );
}

#[test]
fn jdk_home_defaults_to_25() {
    // No version specified should default to 25
    let output = jbx_output(&["jdk", "home"]);
    // The output should contain "25" somewhere in the path
    assert!(
        output.contains("25"),
        "jdk home (default) should reference JDK 25, got: {output}"
    );
}

#[test]
fn jdk_symlink_cache_avoids_re_search() {
    // After calling jdk home, the cache should have a valid entry.
    let output = jbx_output(&["jdk", "home", "25"]);
    let _jdk_path = output.trim();

    let cache_dir = dirs::cache_dir().unwrap().join("jbx").join("jdks");
    let link = cache_dir.join("25");
    assert!(link.exists(), "JDK cache should exist for JDK 25");

    // The symlink target should match what jdk home returned
    // (either it's a symlink pointing to the right place or it IS the JDK)
    let resolved = if link.is_symlink() {
        std::fs::read_link(&link).unwrap_or_else(|_| link.clone())
    } else {
        std::fs::canonicalize(&link).unwrap_or_else(|_| link.clone())
    };
    assert!(
        resolved.join("bin").join("java").is_file(),
        "symlink target should have bin/java, got: {}",
        resolved.display()
    );
    assert!(
        resolved.join("bin").join("javac").is_file(),
        "symlink target should have bin/javac, got: {}",
        resolved.display()
    );
    assert!(
        resolved.join("release").is_file(),
        "symlink target should have a release file, got: {}",
        resolved.display()
    );
}
#[cfg(unix)]
#[test]
fn jdk_home_removes_stale_cache_entry_that_is_not_jdk_root() {
    let cache_dir = dirs::cache_dir().unwrap().join("jbx").join("jdks");
    std::fs::create_dir_all(&cache_dir).unwrap();
    let stale = cache_dir.join("999");
    let _ = std::fs::remove_file(&stale);
    std::os::unix::fs::symlink("/usr", &stale).unwrap();

    let output = jbx_command()
        .args(["jdk", "home", "999"])
        .output()
        .expect("failed to run jbx");

    assert!(
        !output.status.success(),
        "stale /usr symlink must not be accepted as a JDK"
    );
    assert!(!stale.exists(), "stale cache entry should be removed");
}