tmdb_api/movie/

now_playing.rs

use chrono::NaiveDate;
use std::borrow::Cow;

use crate::common::PaginatedResult;

#[derive(Clone, Debug, Default, serde::Serialize)]
pub struct Params<'a> {
    /// ISO 639-1 value to display translated data for the fields that support it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<Cow<'a, str>>,
    /// Specify which page to query.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page: Option<u32>,
    /// Specify a ISO 3166-1 code to filter release dates. Must be uppercase.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub region: Option<Cow<'a, str>>,
}

impl<'a> Params<'a> {
    pub fn set_page(&mut self, value: u32) {
        self.page = Some(value);
    }

    pub fn with_page(mut self, value: u32) -> Self {
        self.set_page(value);
        self
    }

    pub fn set_language(&mut self, value: impl Into<Cow<'a, str>>) {
        self.language = Some(value.into());
    }

    pub fn with_language(mut self, value: impl Into<Cow<'a, str>>) -> Self {
        self.set_language(value);
        self
    }

    pub fn set_region(&mut self, value: impl Into<Cow<'a, str>>) {
        self.region = Some(value.into());
    }

    pub fn with_region(mut self, value: impl Into<Cow<'a, str>>) -> Self {
        self.set_region(value);
        self
    }
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct DateRange {
    #[serde(deserialize_with = "crate::util::empty_string::deserialize")]
    pub maximum: Option<NaiveDate>,
    #[serde(deserialize_with = "crate::util::empty_string::deserialize")]
    pub minimum: Option<NaiveDate>,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct ListMoviesNowPlayingResponse {
    #[serde(flatten)]
    pub inner: PaginatedResult<super::MovieShort>,
    pub dates: DateRange,
}

impl<E: crate::client::Executor> crate::Client<E> {
    /// Get a list of movies in theatres. This is a release type query that looks for
    /// all movies that have a release type of 2 or 3 within the specified date range.
    ///
    /// You can optionally specify a region parameter which will narrow the search
    /// to only look for theatrical release dates within the specified country.
    ///
    /// ```rust
    /// use tmdb_api::client::Client;
    /// use tmdb_api::client::reqwest::Client as ReqwestClient;
    ///
    /// #[tokio::main]
    /// async fn main() {
    ///     let client = Client::<ReqwestClient>::new("this-is-my-secret-token".into());
    ///     match client.list_movies_now_playing(&Default::default()).await {
    ///         Ok(res) => println!("found: {:#?}", res),
    ///         Err(err) => eprintln!("error: {:?}", err),
    ///     };
    /// }
    /// ```
    pub async fn list_movies_now_playing(
        &self,
        params: &Params<'_>,
    ) -> crate::Result<ListMoviesNowPlayingResponse> {
        self.execute("/movie/now_playing", params).await
    }
}

#[cfg(test)]
mod tests {
    use crate::client::Client;
    use crate::client::reqwest::Client as ReqwestClient;
    use mockito::Matcher;

    #[tokio::test]
    async fn it_works() {
        let mut server = mockito::Server::new_async().await;
        let client = Client::<ReqwestClient>::builder()
            .with_api_key("secret".into())
            .with_base_url(server.url())
            .build()
            .unwrap();

        let _m = server
            .mock("GET", "/movie/now_playing")
            .match_query(Matcher::UrlEncoded("api_key".into(), "secret".into()))
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(include_str!("../../assets/movie-now-playing.json"))
            .create_async()
            .await;

        let result = client
            .list_movies_now_playing(&Default::default())
            .await
            .unwrap();
        assert_eq!(result.inner.page, 1);
    }

    #[tokio::test]
    async fn invalid_api_key() {
        let mut server = mockito::Server::new_async().await;
        let client = Client::<ReqwestClient>::builder()
            .with_api_key("secret".into())
            .with_base_url(server.url())
            .build()
            .unwrap();

        let _m = server
            .mock("GET", "/movie/now_playing")
            .match_query(Matcher::UrlEncoded("api_key".into(), "secret".into()))
            .with_status(401)
            .with_header("content-type", "application/json")
            .with_body(include_str!("../../assets/invalid-api-key.json"))
            .create_async()
            .await;

        let err = client
            .list_movies_now_playing(&Default::default())
            .await
            .unwrap_err();
        let server_err = err.as_server_error().unwrap();
        assert_eq!(server_err.status_code, 7);
    }

    #[tokio::test]
    async fn resource_not_found() {
        let mut server = mockito::Server::new_async().await;
        let client = Client::<ReqwestClient>::builder()
            .with_api_key("secret".into())
            .with_base_url(server.url())
            .build()
            .unwrap();

        let _m = server
            .mock("GET", "/movie/now_playing")
            .match_query(Matcher::UrlEncoded("api_key".into(), "secret".into()))
            .with_status(404)
            .with_header("content-type", "application/json")
            .with_body(include_str!("../../assets/resource-not-found.json"))
            .create_async()
            .await;

        let err = client
            .list_movies_now_playing(&Default::default())
            .await
            .unwrap_err();
        let server_err = err.as_server_error().unwrap();
        assert_eq!(server_err.status_code, 34);
    }
}

#[cfg(all(test, feature = "integration"))]
mod integration_tests {
    use crate::client::Client;
    use crate::client::reqwest::Client as ReqwestClient;

    #[tokio::test]
    async fn execute() {
        let secret = std::env::var("TMDB_TOKEN_V3").unwrap();
        let client = Client::<ReqwestClient>::new(secret);

        let _result = client
            .list_movies_now_playing(&Default::default())
            .await
            .unwrap();
    }
}