tmdb_api/movie/
external_ids.rs

1use crate::client::Executor;
2
3#[derive(Debug, Deserialize)]
4pub struct MovieExternalIds {
5    pub id: u64,
6    #[serde(deserialize_with = "crate::util::empty_string::deserialize")]
7    pub imdb_id: Option<String>,
8    #[serde(deserialize_with = "crate::util::empty_string::deserialize")]
9    pub wikidata_id: Option<String>,
10    #[serde(deserialize_with = "crate::util::empty_string::deserialize")]
11    pub facebook_id: Option<String>,
12    #[serde(deserialize_with = "crate::util::empty_string::deserialize")]
13    pub instagram_id: Option<String>,
14    #[serde(deserialize_with = "crate::util::empty_string::deserialize")]
15    pub twitter_id: Option<String>,
16}
17
18impl<E: Executor> crate::Client<E> {
19    /// Get movie external ids
20    ///
21    /// ```rust
22    /// use tmdb_api::client::Client;
23    /// use tmdb_api::client::reqwest::Client as ReqwestClient;
24    ///
25    /// #[tokio::main]
26    /// async fn main() {
27    ///     let client = Client::<ReqwestClient>::new("this-is-my-secret-token".into());
28    ///     match client.get_movie_external_ids(42).await {
29    ///         Ok(res) => println!("found: {:#?}", res),
30    ///         Err(err) => eprintln!("error: {:?}", err),
31    ///     };
32    /// }
33    /// ```
34    pub async fn get_movie_external_ids(&self, movie_id: u64) -> crate::Result<MovieExternalIds> {
35        let url = format!("/movie/{movie_id}/external_ids");
36        self.execute(&url, &()).await
37    }
38}
39
40#[cfg(test)]
41mod tests {
42    use mockito::Matcher;
43
44    use crate::client::Client;
45    use crate::client::reqwest::Client as ReqwestClient;
46
47    #[tokio::test]
48    async fn it_works() {
49        let mut server = mockito::Server::new_async().await;
50        let m = server
51            .mock("GET", "/movie/335984/external_ids")
52            .match_query(Matcher::UrlEncoded("api_key".into(), "secret".into()))
53            .with_status(200)
54            .with_header("content-type", "application/json")
55            .with_body(include_str!("../../assets/movie-external-ids.json"))
56            .create_async()
57            .await;
58
59        let client = Client::<ReqwestClient>::builder()
60            .with_api_key("secret".into())
61            .with_base_url(server.url())
62            .build()
63            .unwrap();
64        let result = client.get_movie_external_ids(335984).await.unwrap();
65        assert_eq!(result.id, 550);
66
67        m.assert_async().await;
68    }
69
70    #[tokio::test]
71    async fn invalid_api_key() {
72        let mut server = mockito::Server::new_async().await;
73        let m = server
74            .mock("GET", "/movie/42/external_ids")
75            .match_query(Matcher::UrlEncoded("api_key".into(), "secret".into()))
76            .with_status(401)
77            .with_header("content-type", "application/json")
78            .with_body(include_str!("../../assets/invalid-api-key.json"))
79            .create_async()
80            .await;
81
82        let client = Client::<ReqwestClient>::builder()
83            .with_api_key("secret".into())
84            .with_base_url(server.url())
85            .build()
86            .unwrap();
87        let err = client.get_movie_external_ids(42).await.unwrap_err();
88        let server_err = err.as_server_error().unwrap();
89        assert_eq!(server_err.status_code, 7);
90
91        m.assert_async().await;
92    }
93
94    #[tokio::test]
95    async fn resource_not_found() {
96        let mut server = mockito::Server::new_async().await;
97        let m = server
98            .mock("GET", "/movie/42/external_ids")
99            .match_query(Matcher::UrlEncoded("api_key".into(), "secret".into()))
100            .with_status(404)
101            .with_header("content-type", "application/json")
102            .with_body(include_str!("../../assets/resource-not-found.json"))
103            .create_async()
104            .await;
105
106        let client = Client::<ReqwestClient>::builder()
107            .with_api_key("secret".into())
108            .with_base_url(server.url())
109            .build()
110            .unwrap();
111        let err = client.get_movie_external_ids(42).await.unwrap_err();
112        let server_err = err.as_server_error().unwrap();
113        assert_eq!(server_err.status_code, 34);
114
115        m.assert_async().await;
116    }
117}
118
119#[cfg(all(test, feature = "integration"))]
120mod integration_tests {
121    use crate::client::Client;
122    use crate::client::reqwest::Client as ReqwestClient;
123
124    #[tokio::test]
125    async fn execute() {
126        let secret = std::env::var("TMDB_TOKEN_V3").unwrap();
127        let client = Client::<ReqwestClient>::new(secret);
128        let result = client.get_movie_external_ids(335984).await.unwrap();
129        assert_eq!(result.id, 335984);
130    }
131}