From aad2531c9f6e8c57e950268d243b278171d45226 Mon Sep 17 00:00:00 2001 From: Paul Campbell Date: Thu, 7 Nov 2024 09:49:38 +0000 Subject: [PATCH] tests(net): add more tests --- src/net/system.rs | 18 +++-- tests/net.rs | 163 +++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 167 insertions(+), 14 deletions(-) diff --git a/src/net/system.rs b/src/net/system.rs index 9cd4872..6c465b1 100644 --- a/src/net/system.rs +++ b/src/net/system.rs @@ -46,7 +46,7 @@ impl Net { impl Net { pub fn client(&self) -> reqwest::Client { - reqwest::Client::new() + Default::default() } } impl Net { @@ -75,7 +75,7 @@ impl Net { && (if plan.match_on.contains(&MatchOn::Body) { match (plan.request.body(), request.body()) { (None, None) => true, - (Some(plan), Some(request)) => plan.as_bytes() == request.as_bytes(), + (Some(plan), Some(req)) => plan.as_bytes().eq(&req.as_bytes()), _ => false, } } else { @@ -93,8 +93,10 @@ impl Net { None => Err(Error::UnexpectedMockRequest(request)), } } + + /// Creates a [ResponseBuilder] to be extended and returned by a mocked network request. pub fn response(&self) -> http::response::Builder { - http::Response::builder() + Default::default() } pub fn on(&mut self, request: reqwest::Request) -> OnRequest { @@ -117,6 +119,10 @@ impl Net { match_on, }) } + + pub fn reset(&mut self) { + self.plans = vec![]; + } } impl Drop for Net { fn drop(&mut self) { @@ -131,7 +137,11 @@ pub struct OnRequest<'net> { } impl<'net> OnRequest<'net> { pub fn match_on(self, match_on: Vec) -> Self { - Self{net:self.net, request:self.request, match_on} + Self { + net: self.net, + request: self.request, + match_on, + } } pub fn respond(self, response: reqwest::Response) { self.net._on(self.request, response, self.match_on) diff --git a/tests/net.rs b/tests/net.rs index 21d67f9..993929b 100644 --- a/tests/net.rs +++ b/tests/net.rs @@ -1,10 +1,9 @@ +use assert2::let_assert; // use kxio::net::{Error, MatchOn}; -type TestResult = Result<(), Error>; - #[tokio::test] -async fn test_get() -> TestResult { +async fn test_get_url() { //given let mut net = kxio::net::mock(); let client = net.client(); @@ -20,17 +19,41 @@ async fn test_get() -> TestResult { net.on(request).respond(my_response.into()); //when - let response = net.send(client.get(url)).await?; + let response = 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"); - - Ok(()) } #[tokio::test] -async fn test_post() { +async fn test_get_wrong_url() { + //given + let mut net = kxio::net::mock(); + let client = net.client(); + + let url = "https://www.example.com"; + let request = client.get(url).build().expect("build request"); + let my_response = net + .response() + .status(200) + .body("Get OK") + .expect("request body"); + + net.on(request).respond(my_response.into()); + + //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 + net.reset(); +} + +#[tokio::test] +async fn test_post_url() { //given let mut net = kxio::net::mock(); let client = net.client(); @@ -53,6 +76,39 @@ async fn test_post() { assert_eq!(response.bytes().await.expect("response body"), "Post OK"); } +#[tokio::test] +async fn test_post_by_method() { + //given + let mut net = kxio::net::mock(); + let client = net.client(); + + let url = "https://www.example.com"; + let request = client.post(url).build().expect("build request"); + let my_response = net + .response() + .status(200) + .body("Post OK") + .expect("request body"); + + net.on(request) + .match_on(vec![ + MatchOn::Method, + // MatchOn::Url + ]) + .respond(my_response.into()); + + //when + // This request is a different url - but should still match + let response = 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"), "Post OK"); +} + #[tokio::test] async fn test_post_by_url() { //given @@ -69,8 +125,8 @@ async fn test_post_by_url() { net.on(request) .match_on(vec![ - // MatchOn::Method, - MatchOn::Url + // MatchOn::Method, + MatchOn::Url, ]) .respond(my_response.into()); @@ -83,6 +139,94 @@ async fn test_post_by_url() { assert_eq!(response.bytes().await.expect("response body"), "Post OK"); } +#[tokio::test] +async fn test_post_by_body() { + //given + let mut net = kxio::net::mock(); + let client = net.client(); + + let url = "https://www.example.com"; + let request = client + .post(url) + .body("match on body") + .build() + .expect("build request"); + let my_response = net + .response() + .status(200) + .body("response body") + .expect("request body"); + + net.on(request) + .match_on(vec![ + // MatchOn::Method, + // MatchOn::Url + MatchOn::Body, + ]) + .respond(my_response.into()); + + //when + // This request is a GET, not POST - but should still match + let response = net + .send(client.get("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_headers() { + //given + let mut net = kxio::net::mock(); + let client = net.client(); + + let url = "https://www.example.com"; + let request = client + .post(url) + .body("foo") + .header("test", "match") + .build() + .expect("build request"); + let my_response = net + .response() + .status(200) + .body("response body") + .expect("request body"); + + net.on(request) + .match_on(vec![ + // MatchOn::Method, + // MatchOn::Url + MatchOn::Headers, + ]) + .respond(my_response.into()); + + //when + // This request is a GET, not POST - but should still match + let response = net + .send( + client + .get("https://some.other.url") + .body("match on 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] #[should_panic] async fn test_unused_post() { @@ -104,7 +248,6 @@ async fn test_unused_post() { // don't send the planned request // let _response = net.send(client.post(url)).await.expect("send"); - //then // Drop implementation for net should panic }