bijux-cli 0.3.4

Command-line runtime for automation, plugin-driven tools, and interactive workflows with structured output.
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

#![forbid(unsafe_code)]
//! Parity-style coverage for commands that were previously Python-only.

use std::env;
use std::fs;
use std::path::PathBuf;
use std::process::Command;

use bijux_cli as _;
use libc as _;
use serde_json as _;
use shlex as _;
use thiserror as _;

fn temp_home(label: &str) -> PathBuf {
    let path = env::temp_dir().join(format!("bijux-parity-{label}-{}", std::process::id()));
    let _ = fs::remove_dir_all(&path);
    fs::create_dir_all(&path).expect("create temp home");
    path
}

fn run_with_home(args: &[&str], home: &PathBuf) -> std::process::Output {
    Command::new(env!("CARGO_BIN_EXE_bijux"))
        .args(args)
        .env("HOME", home)
        .output()
        .expect("binary should execute")
}

#[test]
fn plugins_root_and_info_are_routed_and_return_success() {
    let home = temp_home("plugins-root");

    let root = run_with_home(&["plugins"], &home);
    assert_eq!(root.status.code(), Some(0));
    let root_stdout = String::from_utf8(root.stdout).expect("utf8 stdout");
    let root_json: serde_json::Value = serde_json::from_str(&root_stdout).expect("json payload");
    assert!(root_json.get("plugins").is_some());

    let info = run_with_home(&["plugins", "info"], &home);
    assert_eq!(info.status.code(), Some(0));
    let info_stdout = String::from_utf8(info.stdout).expect("utf8 stdout");
    let info_json: serde_json::Value = serde_json::from_str(&info_stdout).expect("json payload");
    assert!(info_json.get("compatibility_warnings").is_some());

    let _ = fs::remove_dir_all(home);
}

#[test]
fn history_clear_has_help_and_success_exit_code() {
    let help = Command::new(env!("CARGO_BIN_EXE_bijux"))
        .args(["history", "clear", "--help"])
        .output()
        .expect("binary should execute");
    assert_eq!(help.status.code(), Some(0));
    let help_stdout = String::from_utf8(help.stdout).expect("utf8 stdout");
    assert!(help_stdout.contains("history"));
    assert!(help_stdout.contains("clear"));

    let home = temp_home("history-clear");
    let output = run_with_home(&["history", "clear"], &home);
    assert_eq!(output.status.code(), Some(0));
    let stdout = String::from_utf8(output.stdout).expect("utf8 stdout");
    let payload: serde_json::Value = serde_json::from_str(&stdout).expect("json payload");
    assert_eq!(payload["status"], "cleared");

    let _ = fs::remove_dir_all(home);
}

#[test]
fn memory_set_get_delete_clear_have_expected_exit_and_streams() {
    let home = temp_home("memory-crud");

    let set = run_with_home(&["memory", "set", "alpha=1"], &home);
    assert_eq!(set.status.code(), Some(0));
    assert!(set.stderr.is_empty());

    let get = run_with_home(&["memory", "get", "alpha"], &home);
    assert_eq!(get.status.code(), Some(0));
    let get_stdout = String::from_utf8(get.stdout).expect("utf8 stdout");
    let get_payload: serde_json::Value = serde_json::from_str(&get_stdout).expect("json payload");
    assert_eq!(get_payload["key"], "alpha");

    let delete = run_with_home(&["memory", "delete", "alpha"], &home);
    assert_eq!(delete.status.code(), Some(0));

    let clear = run_with_home(&["memory", "clear"], &home);
    assert_eq!(clear.status.code(), Some(0));
    let clear_stdout = String::from_utf8(clear.stdout).expect("utf8 stdout");
    let clear_payload: serde_json::Value =
        serde_json::from_str(&clear_stdout).expect("json payload");
    assert_eq!(clear_payload["status"], "cleared");

    let _ = fs::remove_dir_all(home);
}

#[test]
fn config_list_alias_path_returns_object_payload() {
    let home = temp_home("config-list");
    let set = run_with_home(&["cli", "config", "set", "alpha=1"], &home);
    assert_eq!(set.status.code(), Some(0));

    let output = run_with_home(&["config", "list"], &home);
    assert_eq!(output.status.code(), Some(0));
    let stdout = String::from_utf8(output.stdout).expect("utf8 stdout");
    let payload: serde_json::Value = serde_json::from_str(&stdout).expect("json payload");
    assert!(payload.is_object());

    let _ = fs::remove_dir_all(home);
}