kemitix/kxio
1
0
Fork 0
Code Issues 2 Pull requests Releases 13 Activity Actions

feat(net)!: new api: .on().respond().{status,header{s},body}(_)?, replacing respond(response)
All checks were successful
Rust / build (map[name:nightly]) (push) Successful in 4m3s
Details
Rust / build (map[name:stable]) (push) Successful in 5m41s
Details
Release Please / Release-plz (push) Successful in 2m38s
Details

Browse source
This commit is contained in:
Paul Campbell 2024-11-17 11:24:28 +00:00
parent 7da221bfde
commit d58ec0eba2
6 changed files with 188 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cargo.toml
View file

@ -14,6 +14,7 @@ unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
bytes = "1.8"
derive_more = { version = "1.0", features = [
"constructor",
"display",

9
examples/get.rs
View file

@ -102,6 +102,8 @@ fn delete_file(file_path: &Path, fs: &kxio::fs::FileSystem) -> kxio::Result<()>
#[cfg(test)]
mod tests {
use http::StatusCode;
use super::*;
// This test demonstrates how to use the `kxio` to test your program.
@ -116,8 +118,11 @@ mod tests {
let url = "http://localhost:8080";
// declare what response should be made for a given request
let response = mock_net.response().body("contents").expect("response body");
mock_net.on().get(url).respond(response);
mock_net
.on()
.get(url)
.respond(StatusCode::OK)
.body("contents");
// Create a temporary directory that will be deleted with `fs` goes out of scope
let fs = kxio::fs::temp().expect("temp fs");

12
src/net/mod.rs
View file

@ -79,15 +79,14 @@
//!
//! ```rust
//! use kxio::net;
//! use kxio::net::StatusCode;
//! # #[tokio::main]
//! # async fn main() -> net::Result<()> {
//! # let mock_net = net::mock();
//! mock_net.on()
//! .get("https://example.com")
//! .respond(mock_net.response().status(200).body("")?);
//! mock_net.on()
//! .get("https://example.com/foo")
//! .respond(mock_net.response().status(500).body("Mocked response")?);
//! mock_net.on().get("https://example.com")
//! .respond(StatusCode::OK).body("");
//! mock_net.on().get("https://example.com/foo")
//! .respond(StatusCode::INTERNAL_SERVER_ERROR).body("Mocked response");
//! # mock_net.reset();
//! # Ok(())
//! # }
@ -151,6 +150,7 @@ pub use system::{MockNet, Net};
pub use http::HeaderMap;
pub use http::Method;
pub use http::StatusCode;
pub use reqwest::Client;
pub use reqwest::Request;
pub use reqwest::RequestBuilder;

6
src/net/result.rs
View file

@ -3,6 +3,8 @@ use derive_more::derive::From;
use crate::net::Request;
use super::system::MockError;
/// The Errors that may occur within [kxio::net][crate::net].
#[derive(Debug, From, derive_more::Display)]
pub enum Error {
@ -32,6 +34,10 @@ pub enum Error {
/// Attempted to extract a [MockNet][super::MockNet] from a [Net][super::Net] that does not contain one.
NetIsNotAMock,
InvalidMock(MockError),
MockResponseHasNoBody,
}
impl std::error::Error for Error {}
impl Clone for Error {

163
src/net/system.rs
View file

@ -1,10 +1,12 @@
//
use std::{cell::RefCell, ops::Deref, rc::Rc, sync::Arc};
use std::{
cell::RefCell, collections::HashMap, marker::PhantomData, ops::Deref, rc::Rc, sync::Arc,
};
use derive_more::derive::{Display, From};
use http::Method;
use reqwest::{Body, Client};
use http::{Method, StatusCode};
use reqwest::Client;
use tokio::sync::Mutex;
use url::Url;
@ -21,7 +23,7 @@ type Plans = Vec<Plan>;
#[derive(Debug)]
struct Plan {
match_request: Vec<MatchRequest>,
response: Response,
response: reqwest::Response,
}
impl Plan {
fn matches(&self, request: &Request) -> bool {
@ -40,7 +42,7 @@ impl Plan {
})
}
MatchRequest::Body(body) => {
request.body().and_then(Body::as_bytes) == Some(body.as_bytes())
request.body().and_then(reqwest::Body::as_bytes) == Some(body)
}
})
}
@ -133,14 +135,14 @@ impl MockNet {
///
/// ```rust
/// # use kxio::net::Result;
/// use kxio::net::StatusCode;
/// # #[tokio::main]
/// # async fn run() -> Result<()> {
/// let mock_net = kxio::net::mock();
/// let client = mock_net.client();
/// // define an expected requet, and the response that should be returned
/// mock_net.on()
/// .get("https://hyper.rs")
/// .respond(mock_net.response().status(200).body("Ok")?);
/// mock_net.on().get("https://hyper.rs")
/// .respond(StatusCode::OK).body("Ok");
/// let net: kxio::net::Net = mock_net.into();
/// // use 'net' in your program, by passing it as a reference
///
@ -174,17 +176,18 @@ impl MockNet {
/// # Example
///
/// ```rust
/// use kxio::net::StatusCode;
/// # use kxio::net::Result;
/// # fn run() -> Result<()> {
/// let mock_net = kxio::net::mock();
/// let client = mock_net.client();
/// mock_net.on()
/// .get("https://hyper.rs")
/// .respond(mock_net.response().status(200).body("Ok")?);
/// mock_net.on().get("https://hyper.rs")
/// .respond(StatusCode::OK).body("Ok");
/// # Ok(())
/// # }
/// ```
pub fn on(&self) -> WhenRequest {
#[must_use]
pub fn on(&self) -> WhenRequest<WhenBuildRequest> {
WhenRequest::new(self)
}
@ -192,11 +195,6 @@ impl MockNet {
self.plans.borrow_mut().push(plan);
}
/// Creates a [http::response::Builder] to be extended and returned by a mocked network request.
pub fn response(&self) -> http::response::Builder {
Default::default()
}
/// Clears all the expected requests and responses from the [MockNet].
///
/// When the [MockNet] goes out of scope it will assert that all expected requests and
@ -247,38 +245,80 @@ pub enum MatchRequest {
Method(Method),
Url(Url),
Header { name: String, value: String },
Body(String),
Body(bytes::Bytes),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RespondWith {
Status(StatusCode),
Header { name: String, value: String },
Body(bytes::Bytes),
}
#[derive(Clone, Debug, Display, From)]
enum MockError {
pub enum MockError {
#[display("url parse: {}", 0)]
UrlParse(#[from] url::ParseError),
}
impl std::error::Error for MockError {}
pub trait WhenState {}
pub struct WhenBuildRequest;
impl WhenState for WhenBuildRequest {}
pub struct WhenBuildResponse;
impl WhenState for WhenBuildResponse {}
#[derive(Debug, Clone)]
pub struct WhenRequest<'net> {
pub struct WhenRequest<'net, State>
where
State: WhenState,
{
_state: PhantomData<State>,
net: &'net MockNet,
match_on: Vec<MatchRequest>,
errors: Vec<MockError>,
respond_with: Vec<RespondWith>,
error: Option<MockError>,
}
impl<'net> WhenRequest<'net> {
impl<'net> WhenRequest<'net, WhenBuildRequest> {
fn new(net: &'net MockNet) -> Self {
Self {
_state: PhantomData,
net,
match_on: vec![],
respond_with: vec![],
error: None,
}
}
#[must_use]
pub fn get(self, url: impl Into<String>) -> Self {
self._url(Method::GET, url)
}
#[must_use]
pub fn post(self, url: impl Into<String>) -> Self {
self._url(Method::POST, url)
}
#[must_use]
pub fn put(self, url: impl Into<String>) -> Self {
self._url(Method::PUT, url)
}
#[must_use]
pub fn delete(self, url: impl Into<String>) -> Self {
self._url(Method::DELETE, url)
}
#[must_use]
pub fn head(self, url: impl Into<String>) -> Self {
self._url(Method::HEAD, url)
}
#[must_use]
pub fn patch(self, url: impl Into<String>) -> Self {
self._url(Method::PATCH, url)
}
@ -289,10 +329,14 @@ impl<'net> WhenRequest<'net> {
Ok(url) => {
self.match_on.push(MatchRequest::Url(url));
}
Err(err) => self.errors.push(err.into()),
Err(err) => {
self.error.replace(err.into());
}
}
self
}
#[must_use]
pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
self.match_on.push(MatchRequest::Header {
name: name.into(),
@ -300,26 +344,73 @@ impl<'net> WhenRequest<'net> {
});
self
}
pub fn body(mut self, body: impl Into<String>) -> Self {
#[must_use]
pub fn body(mut self, body: impl Into<bytes::Bytes>) -> Self {
self.match_on.push(MatchRequest::Body(body.into()));
self
}
pub fn respond<T>(self, response: http::Response<T>)
where
T: Into<reqwest::Body>,
{
#[must_use]
pub fn respond(self, status: StatusCode) -> WhenRequest<'net, WhenBuildResponse> {
WhenRequest::<WhenBuildResponse> {
_state: PhantomData,
net: self.net,
match_on: self.match_on,
respond_with: vec![RespondWith::Status(status)],
error: self.error,
}
}
}
impl<'net> WhenRequest<'net, WhenBuildResponse> {
#[must_use]
pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
let name = name.into();
let value = value.into();
self.respond_with.push(RespondWith::Header { name, value });
self
}
#[must_use]
pub fn headers(mut self, headers: impl Into<HashMap<String, String>>) -> Self {
let h: HashMap<String, String> = headers.into();
for (name, value) in h.into_iter() {
self.respond_with.push(RespondWith::Header { name, value });
}
self
}
pub fn body(mut self, body: impl Into<bytes::Bytes>) {
self.respond_with.push(RespondWith::Body(body.into()));
self.mock().expect("valid mock");
}
pub fn mock(self) -> Result<()> {
if let Some(error) = self.error {
return Err(crate::net::Error::InvalidMock(error));
}
let mut builder = http::response::Builder::default();
let mut response_body = None;
for part in self.respond_with {
builder = match part {
RespondWith::Status(status) => builder.status(status),
RespondWith::Header { name, value } => builder.header(name, value),
RespondWith::Body(body) => {
response_body.replace(body);
builder
}
}
}
let Some(body) = response_body else {
return Err(crate::net::Error::MockResponseHasNoBody);
};
let response = builder.body(body)?;
self.net._when(Plan {
match_request: self.match_on,
response: response.into(),
});
}
fn new(net: &'net MockNet) -> Self {
Self {
net,
match_on: vec![],
errors: vec![],
}
Ok(())
}
}

106
tests/net.rs
View file

@ -1,3 +1,6 @@
use std::collections::HashMap;
use http::StatusCode;
//
use kxio::net::{Error, MockNet, Net};
@ -10,16 +13,14 @@ async fn test_get_url() {
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()
.get("https://www.example.com")
.respond(my_response);
.respond(StatusCode::OK)
.header("foo", "bar")
.headers(HashMap::new())
.body("Get OK");
//when
let response = Net::from(mock_net)
@ -40,9 +41,7 @@ async fn test_post_url() {
let url = "https://www.example.com";
net.on()
.post(url)
.respond(net.response().status(200).body("post OK").expect("body"));
net.on().post(url).respond(StatusCode::OK).body("post OK");
//when
let response = Net::from(net)
@ -63,9 +62,7 @@ async fn test_put_url() {
let url = "https://www.example.com";
net.on()
.put(url)
.respond(net.response().status(200).body("put OK").expect("body"));
net.on().put(url).respond(StatusCode::OK).body("put OK");
//when
let response = Net::from(net).send(client.put(url)).await.expect("reponse");
@ -85,7 +82,8 @@ async fn test_delete_url() {
net.on()
.delete(url)
.respond(net.response().status(200).body("delete OK").expect("body"));
.respond(StatusCode::OK)
.body("delete OK");
//when
let response = Net::from(net)
@ -106,9 +104,7 @@ async fn test_head_url() {
let url = "https://www.example.com";
net.on()
.head(url)
.respond(net.response().status(200).body("head OK").expect("body"));
net.on().head(url).respond(StatusCode::OK).body("head OK");
//when
let response = Net::from(net)
@ -129,9 +125,7 @@ async fn test_patch_url() {
let url = "https://www.example.com";
net.on()
.patch(url)
.respond(net.response().status(200).body("patch OK").expect("body"));
net.on().patch(url).respond(StatusCode::OK).body("patch OK");
//when
let response = Net::from(net)
@ -147,19 +141,14 @@ async fn test_patch_url() {
#[tokio::test]
async fn test_get_wrong_url() {
//given
let mock_net = kxio::net::mock();
let client = mock_net.client();
let net = kxio::net::mock();
let client = net.client();
let url = "https://www.example.com";
let my_response = mock_net
.response()
.status(200)
.body("Get OK")
.expect("body");
mock_net.on().get(url).respond(my_response);
net.on().get(url).respond(StatusCode::OK).body("Get OK");
let net = Net::from(mock_net);
let net = Net::from(net);
//when
let_assert!(
@ -181,11 +170,8 @@ async fn test_post_by_method() {
let net = kxio::net::mock();
let client = net.client();
let my_response = net.response().status(200).body("").expect("response body");
net.on()
// NOTE: No URL specified - so should match any URL
.respond(my_response);
net.on().respond(StatusCode::OK).body("");
//when
let response = Net::from(net)
@ -204,16 +190,11 @@ async fn test_post_by_body() {
let net = kxio::net::mock();
let client = net.client();
let my_response = net
.response()
.status(200)
.body("response body")
.expect("body");
net.on()
// No URL - so any POST with a matching body
net.on()
.body("match on body")
.respond(my_response);
.respond(StatusCode::OK)
.body("response body");
//when
let response = Net::from(net)
@ -235,13 +216,10 @@ async fn test_post_by_header() {
let net = kxio::net::mock();
let client = net.client();
let my_response = net
.response()
.status(200)
.body("response body")
.expect("body");
net.on().header("test", "match").respond(my_response);
net.on()
.header("test", "match")
.respond(StatusCode::OK)
.body("response body");
//when
let response = Net::from(net)
@ -268,13 +246,11 @@ async fn test_post_by_header_wrong_value() {
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().header("test", "match").respond(my_response);
mock_net
.on()
.header("test", "match")
.respond(StatusCode::OK)
.body("response body");
let net = Net::from(mock_net);
//when
@ -300,13 +276,12 @@ async fn test_unused_post_as_net() {
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().post(url).respond(my_response);
mock_net
.on()
.post(url)
.respond(StatusCode::OK)
.body("Post OK");
let _net = Net::from(mock_net);
@ -325,13 +300,12 @@ async fn test_unused_post_as_mocknet() {
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().post(url).respond(my_response);
mock_net
.on()
.post(url)
.respond(StatusCode::OK)
.body("Post OK");
//when
// don't send the planned request