embers-cli 0.1.0

Interactive terminal UI and automation CLI for the Embers terminal multiplexer.
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use std::fs;
use std::path::Path;
use std::time::Duration;

use embers_test_support::cargo_bin;
use predicates::prelude::*;

use embers_test_support::TestServer;
use tempfile::tempdir;

use crate::support::{cli_command, run_cli, stdout};

async fn shutdown_spawned_server(socket_path: &Path) {
    let pid_path = socket_path.with_extension("pid");
    let pid = wait_for_pid(&pid_path)
        .await
        .trim()
        .parse::<i32>()
        .expect("pid parses");
    assert!(pid > 0, "invalid pid: {pid}");

    // SAFETY: pid comes from our own pid file and SIGTERM targets that specific process.
    let result = unsafe { libc::kill(pid, libc::SIGTERM) };
    assert_eq!(result, 0, "failed to signal spawned server");

    for _ in 0..50 {
        if !socket_path.exists() && !pid_path.exists() {
            return;
        }
        tokio::time::sleep(Duration::from_millis(50)).await;
    }

    panic!(
        "timed out waiting for spawned server shutdown (socket: {}, pid file: {})",
        socket_path.display(),
        pid_path.display()
    );
}

async fn wait_for_socket(socket_path: &Path) {
    for _ in 0..50 {
        if socket_path.exists() {
            return;
        }
        tokio::time::sleep(Duration::from_millis(50)).await;
    }

    panic!("timed out waiting for socket {}", socket_path.display());
}

async fn wait_for_pid(pid_path: &Path) -> String {
    for _ in 0..50 {
        if let Ok(pid) = fs::read_to_string(pid_path) {
            return pid;
        }
        tokio::time::sleep(Duration::from_millis(50)).await;
    }

    panic!("timed out waiting for pid file {}", pid_path.display());
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn session_commands_round_trip_through_cli() {
    let server = TestServer::start().await.expect("start server");

    let created = run_cli(&server, ["new-session", "alpha"]);
    assert_eq!(stdout(&created).trim(), "1\talpha");

    let listed = run_cli(&server, ["list-sessions"]);
    assert_eq!(stdout(&listed).trim(), "1\talpha");

    cli_command(&server)
        .arg("rename-session")
        .arg("-t")
        .arg("alpha")
        .arg("ops")
        .assert()
        .success()
        .stdout(predicate::str::is_empty());

    let listed = run_cli(&server, ["list-sessions"]);
    assert_eq!(stdout(&listed).trim(), "1\tops");

    cli_command(&server)
        .arg("has-session")
        .arg("-t")
        .arg("ops")
        .assert()
        .success()
        .stdout(predicate::str::is_empty());

    cli_command(&server)
        .arg("has-session")
        .arg("-t")
        .arg("alpha")
        .assert()
        .failure()
        .stderr(predicate::str::contains("session 'alpha' was not found"));

    cli_command(&server)
        .arg("kill-session")
        .arg("-t")
        .arg("ops")
        .assert()
        .success()
        .stdout(predicate::str::is_empty());

    let listed = run_cli(&server, ["list-sessions"]);
    assert!(stdout(&listed).trim().is_empty());

    server.shutdown().await.expect("shutdown server");
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn has_session_reports_missing_names_precisely() {
    let server = TestServer::start().await.expect("start server");

    cli_command(&server)
        .arg("has-session")
        .arg("-t")
        .arg("missing")
        .assert()
        .failure()
        .stderr(predicate::str::contains("session 'missing' was not found"));

    server.shutdown().await.expect("shutdown server");
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn list_sessions_bootstraps_server_on_first_run() {
    let tempdir = tempdir().expect("tempdir");
    let socket_path = tempdir.path().join("embers.sock");

    let output = cargo_bin("embers")
        .arg("--socket")
        .arg(&socket_path)
        .arg("list-sessions")
        .output()
        .expect("cli command runs");
    assert!(
        output.status.success(),
        "list-sessions failed without a pre-existing server:\nstdout:\n{}\nstderr:\n{}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    assert!(String::from_utf8_lossy(&output.stdout).trim().is_empty());

    wait_for_socket(&socket_path).await;
    shutdown_spawned_server(&socket_path).await;
}