tmdb_api/movie/
release_dates.rs

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