kxio/tests/net.rs

use assert2::let_assert;
use http::Method;
//
use kxio::net::{Error, MockNet, Net};
use reqwest::Url;

#[tokio::test]
async fn test_get_url() {
    //given
    let mock_net = kxio::net::mock();
    let client = mock_net.client();

    let url = "https://www.example.com";
    let my_response = mock_net
        .response()
        .status(200)
        .body("Get OK")
        .expect("body");

    mock_net
        .on(Method::GET)
        .url(Url::parse(url).expect("parse url"))
        .respond(my_response);

    //when
    let response = Net::from(mock_net)
        .send(client.get(url))
        .await
        .expect("response");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(response.bytes().await.expect("response body"), "Get OK");
}

#[tokio::test]
async fn test_get_wrong_url() {
    //given
    let mock_net = kxio::net::mock();
    let client = mock_net.client();

    let url = "https://www.example.com";
    let my_response = mock_net
        .response()
        .status(200)
        .body("Get OK")
        .expect("body");

    mock_net
        .on(Method::GET)
        .url(Url::parse(url).expect("parse url"))
        .respond(my_response);

    let net = Net::from(mock_net);

    //when
    let_assert!(
        Err(Error::UnexpectedMockRequest(invalid_request)) =
            net.send(client.get("https://some.other.url/")).await
    );

    //then
    assert_eq!(invalid_request.url().to_string(), "https://some.other.url/");

    // remove pending unmatched request - we never meant to match against it
    let mock_net = MockNet::try_from(net).expect("recover net");
    mock_net.reset();
}

#[tokio::test]
async fn test_post_url() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let url = "https://www.example.com";
    let my_response = net.response().status(200).body("Post OK").expect("body");

    net.on(Method::POST)
        .url(Url::parse(url).expect("parse url"))
        .respond(my_response);

    //when
    let response = Net::from(net)
        .send(client.post(url))
        .await
        .expect("reponse");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(response.bytes().await.expect("response body"), "Post OK");
}

#[tokio::test]
async fn test_post_by_method() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let my_response = net.response().status(200).body("").expect("response body");

    net.on(Method::POST)
        // NOTE: No URL specified - so shou∂ match any URL
        .respond(my_response);

    //when
    let response = Net::from(net)
        .send(client.post("https://some.other.url"))
        .await
        .expect("response");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(response.bytes().await.expect("response body"), "");
}

#[tokio::test]
async fn test_post_by_body() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let my_response = net
        .response()
        .status(200)
        .body("response body")
        .expect("body");

    net.on(Method::POST)
        // No URL - so any POST with a matching body
        .body("match on body")
        .respond(my_response);

    //when
    let response = Net::from(net)
        .send(client.post("https://some.other.url").body("match on body"))
        .await
        .expect("response");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(
        response.bytes().await.expect("response body"),
        "response body"
    );
}

#[tokio::test]
async fn test_post_by_header() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let my_response = net
        .response()
        .status(200)
        .body("response body")
        .expect("body");

    net.on(Method::POST)
        .header("test", "match")
        .respond(my_response);

    //when
    let response = Net::from(net)
        .send(
            client
                .post("https://some.other.url")
                .body("nay body")
                .header("test", "match"),
        )
        .await
        .expect("response");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(
        response.bytes().await.expect("response body"),
        "response body"
    );
}

#[tokio::test]
async fn test_post_by_header_wrong_value() {
    //given
    let mock_net = kxio::net::mock();
    let client = mock_net.client();

    let my_response = mock_net
        .response()
        .status(200)
        .body("response body")
        .expect("body");

    mock_net
        .on(Method::POST)
        .header("test", "match")
        .respond(my_response);
    let net = Net::from(mock_net);

    //when
    let response = net
        .send(
            client
                .post("https://some.other.url")
                .body("nay body")
                .header("test", "no match"),
        )
        .await;

    //then
    let_assert!(Err(kxio::net::Error::UnexpectedMockRequest(_)) = response);

    MockNet::try_from(net).expect("recover mock").reset();
}

#[tokio::test]
#[should_panic]
async fn test_unused_post_as_net() {
    //given
    let mock_net = kxio::net::mock();

    let url = "https://www.example.com";
    let my_response = mock_net
        .response()
        .status(200)
        .body("Post OK")
        .expect("body");

    mock_net
        .on(Method::POST)
        .url(Url::parse(url).expect("prase url"))
        .respond(my_response);

    let _net = Net::from(mock_net);

    //when
    // don't send the planned request
    // let _response = Net::from(net).send(client.post(url)).await.expect("send");

    //then
    // Drop implementation for net should panic
}

#[tokio::test]
#[should_panic]
async fn test_unused_post_as_mocknet() {
    //given
    let mock_net = kxio::net::mock();

    let url = "https://www.example.com";
    let my_response = mock_net
        .response()
        .status(200)
        .body("Post OK")
        .expect("body");

    mock_net
        .on(Method::POST)
        .url(Url::parse(url).expect("parse url"))
        .respond(my_response);

    //when
    // don't send the planned request
    // let _response = Net::from(net).send(client.post(url)).await.expect("send");

    //then
    // Drop implementation for mock_net should panic
}