stellar-tui 0.1.0

A terminal user interface for exploring and executing Stellar RPC methods.
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

//! Verifies runtime tick transitions for successful, failed, and disconnected requests.

use serde_json::json;
use stellar_tui::{
    app::App,
    rpc::types::{RpcError, RpcResponse},
    settings::Settings,
};

#[test]
fn tick_handles_success_response_and_sets_completed_status() {
    let mut app = App::new(Settings::default_settings());
    let (tx, rx) = std::sync::mpsc::channel();
    app.pending_request = Some(rx);
    app.status = "Calling...".to_string();

    tx.send(Ok(RpcResponse {
        jsonrpc: "2.0".to_string(),
        id: 1,
        result: Some(json!({ "ok": true })),
        error: None,
    }))
    .expect("send should succeed");

    app.tick();

    assert!(app.pending_request.is_none());
    assert_eq!(app.status, "Ready");
    assert_eq!(
        app.timed_status
            .as_ref()
            .expect("timed status should be set")
            .message,
        "Completed"
    );
    assert!(app.last_response.contains("\"ok\": true"));
    assert!(app.paginated_response.is_some());
}

#[test]
fn tick_handles_rpc_error_payload() {
    let mut app = App::new(Settings::default_settings());
    let (tx, rx) = std::sync::mpsc::channel();
    app.pending_request = Some(rx);

    tx.send(Ok(RpcResponse {
        jsonrpc: "2.0".to_string(),
        id: 1,
        result: None,
        error: Some(RpcError {
            code: -32602,
            message: "Invalid params".to_string(),
        }),
    }))
    .expect("send should succeed");

    app.tick();

    assert_eq!(app.status, "Ready");
    assert!(app
        .timed_status
        .as_ref()
        .expect("timed status should be set")
        .message
        .contains("Error -32602: Invalid params"));
    assert!(app.last_response.contains("Invalid params"));
}

#[test]
fn tick_handles_request_transport_error_and_clears_response_state() {
    let mut app = App::new(Settings::default_settings());
    let (tx, rx) = std::sync::mpsc::channel();
    app.pending_request = Some(rx);
    app.last_response = "previous response".to_string();
    app.response_search_query = "prev".to_string();
    app.response_search_matches = vec![0];
    app.response_page = 2;
    app.response_scroll = 5;

    tx.send(Err("network down".to_string()))
        .expect("send should succeed");

    app.tick();

    assert!(app.pending_request.is_none());
    assert_eq!(app.status, "Ready");
    assert!(app.last_response.is_empty());
    assert!(app.response_search_query.is_empty());
    assert!(app.response_search_matches.is_empty());
    assert_eq!(app.response_page, 0);
    assert_eq!(app.response_scroll, 0);
    assert!(app
        .timed_status
        .as_ref()
        .expect("timed status should be set")
        .message
        .contains("Request failed: network down"));
}

#[test]
fn tick_handles_disconnected_channel() {
    let mut app = App::new(Settings::default_settings());
    let (tx, rx) = std::sync::mpsc::channel::<Result<RpcResponse<serde_json::Value>, String>>();
    app.pending_request = Some(rx);
    drop(tx);

    app.tick();

    assert!(app.pending_request.is_none());
    assert_eq!(app.status, "Ready");
    assert_eq!(
        app.timed_status
            .as_ref()
            .expect("timed status should be set")
            .message,
        "Request failed: channel closed"
    );
}