tmdb_api/movie/
keywords.rs

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