twitch_highway 0.2.1

Twitch API
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

pub mod request;
pub mod response;
pub mod types;

use request::{CreateStreamMarkerRequest, GetStreamsRequest, StreamMarkerSelector};
use response::{
    CreateStreamMarkerResponse, GetStreamMarkersResponse, StreamKeyResponse, StreamsResponse,
};

use crate::types::{
    constants::{BROADCASTER_ID, USER_ID},
    BroadcasterId, PaginationQuery, UserId,
};

const STREAMS: &str = "streams";

endpoints! {
    StreamsAPI {
        /// <https://dev.twitch.tv/docs/api/reference/#get-stream-key>
        fn get_stream_key(
            &self,
            broadcaster_id: &BroadcasterId,
        ) -> StreamKeyResponse {
            endpoint_type: GetStreamKey,
            method: GET,
            path: [STREAMS, "key"],
            query_params: {
                query(BROADCASTER_ID, broadcaster_id)
            }
        }

        /// <https://dev.twitch.tv/docs/api/reference/#get-streams>
        fn get_streams(
            &self,
            opts: Option<GetStreamsRequest>,
            pagination: Option<PaginationQuery>,
        ) -> StreamsResponse {
            endpoint_type: GetStreams,
            method: GET,
            path: [STREAMS],
            query_params: {
                opt_into_query(opts),
                pagination(pagination)
            }
        }

        /// <https://dev.twitch.tv/docs/api/reference/#get-followed-streams>
        fn get_followed_streams(
            &self,
            user_id: &UserId,
            pagination: Option<PaginationQuery>,
        ) -> StreamsResponse {
            endpoint_type: GetFollowedStreams,
            method: GET,
            path: [STREAMS, "followed"],
            query_params: {
                query(USER_ID, user_id),
                pagination(pagination)
            }
        }

        /// <https://dev.twitch.tv/docs/api/reference/#create-stream-marker>
        fn create_stream_marker(
            &self,
            user_id: &UserId,
            description: Option<&str>,
        ) -> CreateStreamMarkerResponse {
            endpoint_type: CreateStreamMarker,
            method: POST,
            path: [STREAMS, "markers"],
            headers: [json],
            body: CreateStreamMarkerRequest::new(user_id, description).into_json()
        }

        /// <https://dev.twitch.tv/docs/api/reference/#get-stream-markers>
        fn get_stream_markers(
            &self,
            selector: StreamMarkerSelector,
            pagination: Option<PaginationQuery>,
        ) -> GetStreamMarkersResponse {
            endpoint_type: GetStreamMarkers,
            method: GET,
            path: [STREAMS, "markers"],
            query_params: {
                into_query(selector),
                pagination(pagination)
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        streams::{
            request::{GetStreamsRequest, StreamMarkerSelector},
            StreamsAPI,
        },
        test_utils::TwitchApiTest,
        types::{BroadcasterId, PaginationQuery, UserId},
    };

    api_test!(get_stream_key, [&BroadcasterId::from("141981764")]);
    api_test!(get_streams, [None, None]);
    api_test!(get_followed_streams, [&UserId::from("141981764"), None]);
    api_test!(
        create_stream_marker,
        [&UserId::from("123"), Some("hello, this is a marker!")]
    );
    api_test!(
        get_stream_markers,
        [
            StreamMarkerSelector::by_user_id(&UserId::from("123")),
            Some(PaginationQuery::new().first(5))
        ]
    );

    #[tokio::test]
    pub(crate) async fn get_streams_2() {
        let suite = TwitchApiTest::new().await;

        suite.get_streams_2().await;

        let _ = suite
            .execute(|api| {
                api.get_streams(
                    Some(GetStreamsRequest::new().user_login(&["cohhcarnage", "lana_lux"])),
                    None,
                )
            })
            .json()
            .await
            .unwrap();
    }
}