rhood-cli 0.2.0

Terminal CLI for the Robinhood trading API
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

use crate::common::{POPULAR_TAG, STOCK_SYMBOL, STOCK_SYMBOLS_MULTI, cli, parse_json};

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_quote_echoes_requested_symbol() {
    let output = cli()
        .args(["stock", "quote", STOCK_SYMBOL])
        .assert()
        .success();
    let body = parse_json(&output);
    let quote = &body[0];
    assert_eq!(
        quote["symbol"], STOCK_SYMBOL,
        "expected {STOCK_SYMBOL} echoed in response"
    );
    assert!(quote["bid_price"].is_string() || quote["bid_price"].is_null());
    assert!(quote["ask_price"].is_string() || quote["ask_price"].is_null());
}

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_quote_multi_symbol_preserves_order() {
    let mut args = vec!["stock", "quote"];
    args.extend(STOCK_SYMBOLS_MULTI);
    let output = cli().args(&args).assert().success();
    let body = parse_json(&output);
    let array = body.as_array().expect("expected JSON array");
    assert_eq!(array.len(), STOCK_SYMBOLS_MULTI.len());
    for (index, expected_symbol) in STOCK_SYMBOLS_MULTI.iter().enumerate() {
        assert_eq!(array[index]["symbol"], *expected_symbol);
    }
}

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_history_returns_candles_for_symbol() {
    let output = cli()
        .args([
            "stock",
            "history",
            STOCK_SYMBOL,
            "--span",
            "week",
            "--interval",
            "day",
        ])
        .assert()
        .success();
    let body = parse_json(&output);
    let candles = body.as_array().expect("expected JSON array of candles");
    assert!(
        !candles.is_empty(),
        "expected at least one candle for a week-long query"
    );
    for candle in candles {
        assert!(candle["open_price"].is_string() || candle["open_price"].is_null());
        assert!(candle["close_price"].is_string() || candle["close_price"].is_null());
    }
}

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_fundamentals_echoes_symbol_via_enrichment() {
    // The CLI calls rhood-core directly (not the MCP enrichment), so the
    // response may or may not carry a `symbol` field depending on upstream.
    // We just assert the call succeeds and returns a non-empty payload.
    let output = cli()
        .args(["stock", "fundamentals", STOCK_SYMBOL])
        .assert()
        .success();
    let body = parse_json(&output);
    assert!(
        body.is_array() || body.is_object(),
        "fundamentals should be array or object"
    );
}

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_latest_prices_returns_price_per_symbol() {
    let mut args = vec!["stock", "latest-prices"];
    args.extend(STOCK_SYMBOLS_MULTI);
    let output = cli().args(&args).assert().success();
    let body = parse_json(&output);
    let prices = body.as_array().expect("expected JSON array");
    assert_eq!(prices.len(), STOCK_SYMBOLS_MULTI.len());
}

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_earnings_returns_array_for_symbol() {
    let output = cli()
        .args(["stock", "earnings", STOCK_SYMBOL])
        .assert()
        .success();
    let body = parse_json(&output);
    assert!(body.is_array(), "earnings should be a JSON array");
}

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_ratings_returns_summary_object() {
    let output = cli()
        .args(["stock", "ratings", STOCK_SYMBOL])
        .assert()
        .success();
    let body = parse_json(&output);
    assert!(body.is_object(), "ratings should be a JSON object");
}

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_news_returns_array_of_articles() {
    let output = cli()
        .args(["stock", "news", STOCK_SYMBOL])
        .assert()
        .success();
    let body = parse_json(&output);
    assert!(
        body.is_array() || body.is_null(),
        "news should be a JSON array (may be empty/null for symbols with no coverage)"
    );
}

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_splits_returns_array() {
    let output = cli()
        .args(["stock", "splits", STOCK_SYMBOL])
        .assert()
        .success();
    let body = parse_json(&output);
    assert!(body.is_array(), "splits should be a JSON array");
}

#[test]
#[ignore = "requires live Robinhood credentials"]
fn stock_tags_returns_instrument_list() {
    let output = cli()
        .args(["stock", "tags", POPULAR_TAG])
        .assert()
        .success();
    let body = parse_json(&output);
    assert!(
        body.is_array() || body.is_object(),
        "tags should be array or object"
    );
}