// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//! Mock HttpsClient for use in testing.
//!
//! Usage:
//! ```
//! let mut https_client = HttpsClient::mock();
//! // Set up expected requests and responses (as many as needed, in the order
//! // they should happen).
//! https_client.expect(req, res);
//! // Use the https_client in-place of the normal https_client. As matching
//! // requests come in, the premade responses will be returned.
//! ```

use {
    hyper::{Body, Request},
    std::{collections::VecDeque, sync::Mutex},
};

#[derive(Debug)]
struct HttpsClientEvent {
    req: Request<Body>,
    res: http::Result<http::Response<Body>>,
}

#[derive(Debug)]
pub struct HttpsClient {
    expected: Mutex<VecDeque<HttpsClientEvent>>,
}

impl HttpsClient {
    /// Create a new mock https client.
    ///
    /// Consider adding expected events with `.expect(req, res)`.
    pub fn mock() -> Self {
        Self { expected: Mutex::new(VecDeque::new()) }
    }

    /// Append an expected request and response.
    ///
    /// Note that `res` is actually a Result<> type.
    pub fn expect(&mut self, req: Request<Body>, res: http::Result<http::Response<Body>>) {
        self.expected.lock().expect("locking").push_back(HttpsClientEvent { req, res });
    }

    pub async fn request(&self, req: Request<Body>) -> http::Result<http::Response<Body>> {
        let expected = self.expected.lock().expect("locking").pop_front().unwrap_or_else(|| {
            panic!(
                "Error: received more https requests than expected. \
            No response available for req: {:?}",
                req
            )
        });

        assert_eq!(
            expected.req.uri(),
            req.uri(),
            "mock_https_client actual {:?}, expected {:?}, related response {:?}",
            req,
            expected.req,
            expected.res
        );
        assert_eq!(expected.req.method(), req.method());
        let expected_bytes =
            hyper::body::to_bytes(expected.req.into_body()).await.expect("expected.req.into_body");
        let req_bytes = hyper::body::to_bytes(req.into_body()).await.expect("req.into_body");
        assert_eq!(expected_bytes, req_bytes);

        expected.res
    }
}

pub fn new_https_client() -> HttpsClient {
    HttpsClient::mock()
}

#[cfg(test)]
mod tests {
    use {super::*, hyper::Method};

    #[fuchsia_async::run_singlethreaded(test)]
    async fn test_mock() {
        let mut https_client = HttpsClient::mock();

        let req = Request::builder()
            .method(Method::POST)
            .uri("https://example.com")
            .body(Body::from("alpha"))
            .expect("Request::builder");
        let builder = http::Response::builder().status(http::StatusCode::OK);
        let res = builder.body(Body::from("beta"));
        https_client.expect(req, res);

        let req = Request::builder()
            .method(Method::POST)
            .uri("https://example.com")
            .body(Body::from("alpha"))
            .expect("Request::builder");
        let res = https_client.request(req).await.expect("https_client.request");
        assert_eq!(res.status(), http::StatusCode::OK);
        let bytes = hyper::body::to_bytes(res.into_body()).await.expect("body::to_bytes");
        assert_eq!(b"beta", &bytes[..]);
    }

    #[should_panic(expected = "actual Request")]
    #[fuchsia_async::run_singlethreaded(test)]
    async fn test_mock_fail() {
        let mut https_client = HttpsClient::mock();

        let req = Request::builder()
            .method(Method::POST)
            .uri("https://example.com")
            .body(Body::from("alpha"))
            .expect("Request::builder");
        let builder = http::Response::builder().status(http::StatusCode::OK);
        let res = builder.body(Body::from("beta"));
        https_client.expect(req, res);

        let req = Request::builder()
            .method(Method::POST)
            .uri("https://not-same.com")
            .body(Body::from("alpha"))
            .expect("Request::builder");
        let res = https_client.request(req).await.expect("https_client.request");
        assert_eq!(res.status(), http::StatusCode::OK);
    }

    #[test]
    fn test_new_https_client() {
        let https_client = new_https_client();
        assert!(https_client.expected.lock().expect("locking").is_empty());
    }
}