tmdb_api/movie/
keywords.rs

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