marketsurge-client 0.2.1

Unofficial HTTP client library for the MarketSurge platform
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

//! Coach tree navigation endpoints (watchlists and screens).

use serde::{Deserialize, Serialize};

use crate::client::Client;

// ---------------------------------------------------------------------------
// GraphQL query
// ---------------------------------------------------------------------------

const QUERY_COACH_TREE: &str = include_str!("graphql/coach_tree.graphql");

// ---------------------------------------------------------------------------
// Wire variable types (serialization only)
// ---------------------------------------------------------------------------

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct CoachTreeVariables {
    site: String,
    tree_type: String,
}

// ---------------------------------------------------------------------------
// Response types
// ---------------------------------------------------------------------------

/// Top-level response from the `CoachTree` query.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CoachTreeResponse {
    /// User-scoped coach tree data.
    pub user: Option<CoachTreeUser>,
}

/// User-scoped coach tree containing watchlists and screens.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CoachTreeUser {
    /// Watchlist tree nodes.
    #[serde(default)]
    pub watchlists: Vec<CoachTreeNode>,
    /// Screen tree nodes.
    #[serde(default)]
    pub screens: Vec<CoachTreeNode>,
}

/// A node in the coach tree.
pub type CoachTreeNode = crate::types::TreeNode;

/// A child node summary within a coach tree folder.
pub type CoachTreeChildNode = crate::types::TreeChildNode;

// ---------------------------------------------------------------------------
// Client methods
// ---------------------------------------------------------------------------

impl Client {
    /// Fetches the coach tree for watchlists and screens.
    ///
    /// # Errors
    ///
    /// Returns an error if the GraphQL request fails or the response
    /// cannot be deserialized.
    pub async fn coach_tree(
        &self,
        site: &str,
        tree_type: &str,
    ) -> crate::error::Result<CoachTreeResponse> {
        let variables = CoachTreeVariables {
            site: site.to_string(),
            tree_type: tree_type.to_string(),
        };

        self.graphql_operation("CoachTree", variables, QUERY_COACH_TREE)
            .await
    }
}

#[cfg(test)]
mod tests {
    use crate::test_support::mock_test;

    #[tokio::test]
    async fn coach_tree_parses_response() {
        let (_server, client, mock) = mock_test("CoachTree").await;

        let resp = client
            .coach_tree("marketsurge", "MSR_NAV")
            .await
            .expect("coach_tree should succeed");

        let user = resp.user.as_ref().expect("user");

        // Watchlists
        assert_eq!(user.watchlists.len(), 2);
        let folder = &user.watchlists[0];
        assert_eq!(folder.id.as_deref(), Some("folder-1"));
        assert_eq!(folder.name.as_deref(), Some("My Watchlists"));
        assert_eq!(folder.node_type.as_deref(), Some("FOLDER"));
        assert_eq!(folder.content_type.as_deref(), Some("WATCHLIST"));
        assert_eq!(folder.children.len(), 1);
        assert_eq!(folder.children[0].id.as_deref(), Some("leaf-1"));
        assert_eq!(folder.children[0].name.as_deref(), Some("Growth Stocks"));

        let leaf = &user.watchlists[1];
        assert_eq!(leaf.id.as_deref(), Some("leaf-2"));
        assert_eq!(leaf.url.as_deref(), Some("/watchlist/tech-leaders"));
        assert_eq!(leaf.reference_id.as_deref(), Some("12345"));

        // Screens
        assert_eq!(user.screens.len(), 1);
        assert_eq!(user.screens[0].id.as_deref(), Some("screen-leaf-1"));
        assert_eq!(user.screens[0].name.as_deref(), Some("IBD 50"));
        assert_eq!(user.screens[0].url.as_deref(), Some("/screen/ibd50"));

        mock.assert();
    }

    #[cfg(not(coverage))]
    #[tokio::test]
    #[ignore]
    async fn integration_coach_tree() {
        let client = crate::test_support::live_client().await;
        let resp = client
            .coach_tree("marketsurge", "MSR_NAV")
            .await
            .expect("live coach_tree should succeed");

        assert!(resp.user.is_some());
    }
}