CHANGELOG.md

@@ -7,35 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [3.1.0](https://git.kemitix.net/kemitix/kxio/compare/v3.0.0...v3.1.0) - 2024-11-21
-
-### Added
-
-- *(net)* mock request builder adds .with and .with_{option,result}
-
-### Fixed
-
-- impl Display for path, file and dir
-
-### Other
-
-- *(example)* clean up get example
-
-## [3.0.0](https://git.kemitix.net/kemitix/kxio/compare/v2.1.1...v3.0.0) - 2024-11-20
-
-### Added
-
-- *(net)* [**breaking**] net api: net.{get,post,etc..}(url) alternative to net.send(request)
-- *(fs)* add TempFileSystem::as_real()
-- *(net)* [**breaking**] new api: .on().respond().{status,header{s},body}(_)?, replacing respond(response)
-- *(net)* [**breaking**] new api: .on().{get,post, etc}(url), replacing .on(method).get(url)
-- re-export http::HeaderMap
-- Add Debug, Clone, Default, PartialEq, Eq, Send, Sync to as many or our types as possible.
-
-### Fixed
-
-- *(net)* [**breaking**] Remove MatchOn
-
 ## [2.1.1](https://git.kemitix.net/kemitix/kxio/compare/v2.1.0...v2.1.1) - 2024-11-15
 
 ### Fixed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kxio"
-version = "3.1.0"
+version = "2.1.1"
 edition = "2021"
 authors = ["Paul Campbell <pcampbell@kemitix.net>"]
 description = "Provides injectable Filesystem and Network resources to make code more testable"
@@ -14,7 +14,6 @@ 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", 
@@ -25,7 +24,6 @@ path-clean = "1.0"
 reqwest = { version = "0.12", features = [ "json" ] }
 url = "2.5"
 tempfile = "3.10"
-tokio = { version = "1.41", features = [ "sync" ] }
 
 [dev-dependencies]
 assert2 = "0.3"

examples/get.rs

@@ -10,8 +10,6 @@
 /// `example-readme.md` in the current directory.
 use std::path::Path;
 
-use kxio::fs::FileHandle;
-
 #[tokio::main]
 async fn main() -> kxio::Result<()> {
     // Create a `Net` object for making real network requests.
@@ -29,7 +27,7 @@ async fn main() -> kxio::Result<()> {
     let file_path = fs.base().join("example-readme.md");
 
     // Create a generic handle for the file. This doesn't open the file, and always succeeds.
-    let path = fs.path(&file_path);
+    let path: kxio::fs::PathReal<kxio::fs::PathMarker> = fs.path(&file_path);
 
     // Other options are;
     // `fs.file(&file_path)` - for a file
@@ -37,16 +35,17 @@ async fn main() -> kxio::Result<()> {
 
     // Checks if the path exists (whether a file, directory, etc)
     if path.exists()? {
-        eprintln!("The file {path} already exists. Aborting!");
+        // extracts the path from the handle
+        let pathbuf = path.as_pathbuf();
+        eprintln!("The file {} already exists. Aborting!", pathbuf.display());
         return Ok(());
     }
 
     // Passes a reference to the `fs` and `net` objects for use by your program.
     // Your programs should not know whether they are handling a mock or the real thing.
     // Any file or network access should be made using these handlers to be properly testable.
-    let file = download_and_save_to_file(url, &file_path, &fs, &net).await?;
+    download_and_save_to_file(url, &file_path, &fs, &net).await?;
-    read_file(&file)?;
+    delete_file(&file_path, &fs)?;
-    delete_file(file)?;
 
     Ok(())
 }
@@ -55,37 +54,44 @@ async fn main() -> kxio::Result<()> {
 async fn download_and_save_to_file(
     url: &str,
     file_path: &Path,
-    // The filesystem abstraction
+    // The file system abstraction
     fs: &kxio::fs::FileSystem,
     // The network abstraction
     net: &kxio::net::Net,
-) -> kxio::Result<FileHandle> {
+) -> kxio::Result<()> {
     println!("fetching: {url}");
 
-    // Makes a GET request that can be mocked in a test
+    // Uses the network abstraction to create a perfectly normal `reqwest::ResponseBuilder`.
-    let response: reqwest::Response = net.get(url).header("key", "value").send().await?;
+    // `kxio::net::RequestBuilder` is an alias.
+    let request: kxio::net::RequestBuilder = net.client().get(url);
 
-    // As you can see, we use [reqwest] under the hood.
+    // Rather than calling `.build().send()?` on the request, pass it to the `net`
-    //
+    // This allows the `net` to either make the network request as normal, or, if we are
-    // If you need to create a more complex request than the [kxio] fluent API allows, you
+    // under test, to handle the request as the test dictates.
-    // can create a request using [reqwest] and pass it to [net.send(request)].
+    // NOTE: if the `.build().send()` is called on the `request` then that WILL result in
+    // a real network request being made, even under test conditions. Only ever use the
+    // `net.send(...)` function to keep your code testable.
+    // `kxio::net::Response` is an alias for `reqwest::Response`.
+    let response: kxio::net::Response = net.send(request).await?;
 
     let body = response.text().await?;
     println!("fetched {} bytes", body.bytes().len());
 
+    println!("writing file: {}", file_path.display());
     // Uses the file system abstraction to create a handle for a file.
     let file: kxio::fs::PathReal<kxio::fs::FileMarker> = fs.file(file_path);
-    println!("writing file: {file}");
     // Writes the body to the file.
     file.write(body)?;
 
-    Ok(file)
+    Ok(())
 }
 
-/// A function that reads the file contents
+/// An function that uses a `FileSystem` object to interact with the outside world.
-fn read_file(file: &FileHandle) -> kxio::Result<()> {
+fn delete_file(file_path: &Path, fs: &kxio::fs::FileSystem) -> kxio::Result<()> {
-    println!("reading file: {file}");
+    println!("reading file: {}", file_path.display());
 
+    // Uses the file system abstraction to create a handle for a file.
+    let file: kxio::fs::PathReal<kxio::fs::FileMarker> = fs.file(file_path);
     // Creates a `Reader` which loaded the file into memory.
     let reader: kxio::fs::Reader = file.reader()?;
     let contents: &str = reader.as_str();
@@ -94,21 +100,12 @@ fn read_file(file: &FileHandle) -> kxio::Result<()> {
     Ok(())
 }
 
-/// A function that deletes the file
-fn delete_file(file: FileHandle) -> kxio::Result<()> {
-    println!("deleting file: {file}");
-
-    file.remove()?;
-
-    Ok(())
-}
-
 #[cfg(test)]
 mod tests {
-    use http::StatusCode;
-
     use super::*;
 
+    use kxio::net::{Method, Url};
+
     // This test demonstrates how to use the `kxio` to test your program.
     #[tokio::test]
     async fn should_save_remote_body() {
@@ -121,12 +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()
+            .on(Method::GET)
-            .get(url)
+            .url(Url::parse(url).expect("parse url"))
-            .respond(StatusCode::OK)
+            .respond(response);
-            .body("contents")
-            .expect("valid mock");
 
         // Create a temporary directory that will be deleted with `fs` goes out of scope
         let fs = kxio::fs::temp().expect("temp fs");

src/fs/dir.rs

@@ -1,9 +1,7 @@
-use std::fmt::Display;
-
 //
 use crate::fs::{DirItem, DirItemIterator, Result};
 
-use super::{DirHandle, Error, PathHandle, PathMarker};
+use super::{DirHandle, Error, FileHandle, PathHandle, PathMarker};
 
 impl DirHandle {
     /// Creates a new, empty directory at the path
@@ -95,6 +93,19 @@ impl DirHandle {
         std::fs::remove_dir_all(self.as_pathbuf()).map_err(Error::Io)
     }
 }
+impl TryFrom<PathHandle<PathMarker>> for FileHandle {
+    type Error = crate::fs::Error;
+
+    fn try_from(path: PathHandle<PathMarker>) -> std::result::Result<Self, Self::Error> {
+        match path.as_file() {
+            Ok(Some(dir)) => Ok(dir.clone()),
+            Ok(None) => Err(crate::fs::Error::NotADirectory {
+                path: path.as_pathbuf(),
+            }),
+            Err(err) => Err(err),
+        }
+    }
+}
 impl TryFrom<PathHandle<PathMarker>> for DirHandle {
     type Error = crate::fs::Error;
 
@@ -108,9 +119,3 @@ impl TryFrom<PathHandle<PathMarker>> for DirHandle {
         }
     }
 }
-
-impl Display for DirHandle {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}/", self.as_pathbuf().display())
-    }
-}

src/fs/dir_item.rs

@@ -7,7 +7,7 @@ use std::{
 use super::Error;
 
 /// Represents an item in a directory
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum DirItem {
     File(PathBuf),
     Dir(PathBuf),

src/fs/file.rs

@@ -1,9 +1,7 @@
-use std::fmt::Display;
-
 //
 use crate::fs::Result;
 
-use super::{reader::Reader, Error, FileHandle, FileMarker, PathHandle, PathMarker, PathReal};
+use super::{reader::Reader, Error, FileHandle};
 
 impl FileHandle {
     /// Returns a [Reader] for the file.
@@ -101,22 +99,3 @@ impl FileHandle {
         std::fs::hard_link(self.as_pathbuf(), dest.as_pathbuf()).map_err(Error::Io)
     }
 }
-impl TryFrom<PathHandle<PathMarker>> for FileHandle {
-    type Error = crate::fs::Error;
-
-    fn try_from(path: PathHandle<PathMarker>) -> std::result::Result<Self, Self::Error> {
-        match path.as_file() {
-            Ok(Some(dir)) => Ok(dir.clone()),
-            Ok(None) => Err(crate::fs::Error::NotAFile {
-                path: path.as_pathbuf(),
-            }),
-            Err(err) => Err(err),
-        }
-    }
-}
-
-impl Display for PathReal<FileMarker> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.as_pathbuf().display())
-    }
-}

src/fs/mod.rs

@@ -98,25 +98,3 @@ pub fn new(base: impl Into<PathBuf>) -> FileSystem {
 pub fn temp() -> Result<temp::TempFileSystem> {
     temp::TempFileSystem::new()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn is_normal<T: Sized + Send + Sync + Unpin>() {}
-
-    #[test]
-    fn normal_types() {
-        is_normal::<FileSystem>();
-        is_normal::<DirItem>();
-        is_normal::<DirItemIterator>();
-        is_normal::<Reader>();
-        is_normal::<PathReal<PathMarker>>();
-        is_normal::<DirMarker>();
-        is_normal::<FileMarker>();
-        is_normal::<PathMarker>();
-        is_normal::<DirHandle>();
-        is_normal::<FileHandle>();
-        is_normal::<PathHandle<PathMarker>>();
-    }
-}

src/fs/path.rs

@@ -1,6 +1,5 @@
 //
 use std::{
-    fmt::Display,
     marker::PhantomData,
     path::{Path, PathBuf},
 };
@@ -13,24 +12,24 @@ use super::{DirHandle, FileHandle, PathHandle};
 pub trait PathType {}
 
 /// Path marker for the type of [PathReal].
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Debug)]
 pub struct PathMarker;
 impl PathType for PathMarker {}
 
 /// File marker for the type of [PathReal].
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Debug)]
 pub struct FileMarker;
 impl PathType for FileMarker {}
 
 /// Dir marker for the type of [PathReal].
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Debug)]
 pub struct DirMarker;
 impl PathType for DirMarker {}
 
 /// Represents a path in the filesystem.
 ///
 /// It can be a simple path, or it can be a file or a directory.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug)]
 pub struct PathReal<T: PathType> {
     base: PathBuf,
     path: PathBuf,
@@ -368,9 +367,3 @@ impl From<FileHandle> for PathHandle<PathMarker> {
         PathReal::new(file.base, file.path)
     }
 }
-
-impl Display for PathReal<PathMarker> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.as_pathbuf().display())
-    }
-}

src/fs/reader.rs

@@ -6,7 +6,6 @@ use crate::fs::Result;
 use super::Error;
 
 /// A reader for a file.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct Reader {
     contents: String,
 }

src/fs/system.rs

@@ -9,7 +9,7 @@ use super::{
 };
 
 /// Represents to base of a section of a file system.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Debug)]
 pub struct FileSystem {
     base: PathBuf,
 }

src/fs/temp.rs

@@ -21,11 +21,6 @@ impl TempFileSystem {
             _temp_dir: temp_dir,
         })
     }
-
-    /// Create a clone of the wrapped [FileSystem].
-    pub fn as_real(&self) -> FileSystem {
-        self.real.clone()
-    }
 }
 impl std::ops::Deref for TempFileSystem {
     type Target = FileSystem;

src/net/mod.rs

@@ -79,19 +79,28 @@
 //!
 //! ```rust
 //! use kxio::net;
-//! use kxio::net::StatusCode;
+//! use kxio::net::{Method, Url};
+//!
 //! # #[tokio::main]
 //! # async fn main() -> net::Result<()> {
 //! # let mock_net = net::mock();
-//! mock_net.on().get("https://example.com")
+//! mock_net.on(Method::GET)
-//!     .respond(StatusCode::OK).body("");
+//!     .url(Url::parse("https://example.com")?)
-//! mock_net.on().get("https://example.com/foo")
+//!     .respond(mock_net.response().status(200).body("")?);
-//!     .respond(StatusCode::INTERNAL_SERVER_ERROR).body("Mocked response");
+//! mock_net.on(Method::GET)
+//!     .url(Url::parse("https://example.com/foo")?)
+//!     .respond(mock_net.response().status(500).body("Mocked response")?);
 //! # mock_net.reset();
 //! # Ok(())
 //! # }
 //! ```
 //!
+//! All [MatchOn] options:
+//! - [MatchOn::Method] (default)
+//! - [MatchOn::Url] (default)
+//! - [MatchOn::Headers]
+//! - [MatchOn::Body].
+//!
 //! Once you have defined all your expected responses, convert the [MockNet] into a [Net].
 //!
 //! ```rust
@@ -125,14 +134,10 @@
 //!
 //! ```rust
 //! # use kxio::net;
-//! # #[tokio::main]
-//! # async fn main() -> net::Result<()> {
 //! # let mock_net = net::mock();
 //! # let net = net::Net::from(mock_net);
-//! let mock_net = kxio::net::MockNet::try_from(net).await.expect("recover mock");
+//! let mock_net = kxio::net::MockNet::try_from(net).expect("recover mock");
 //! mock_net.reset();
-//! # Ok(())
-//! # }
 //! ````
 //!
 //! ## Error Handling
@@ -146,14 +151,14 @@ mod system;
 
 pub use result::{Error, Result};
 
-pub use system::{MockNet, Net, ReqBuilder, WithOption, WithResult};
+pub use system::{MatchOn, MockNet, Net};
 
-pub use http::StatusCode;
+pub use http::Method;
 pub use reqwest::Client;
-pub use reqwest::Error as RequestError;
 pub use reqwest::Request;
 pub use reqwest::RequestBuilder;
 pub use reqwest::Response;
+pub use url::Url;
 
 /// Creates a new `Net`.
 pub const fn new() -> Net {
@@ -162,5 +167,5 @@ pub const fn new() -> Net {
 
 /// Creates a new `MockNet` for use in tests.
 pub fn mock() -> MockNet {
-    Default::default()
+    Net::mock()
 }

src/net/result.rs

@@ -3,8 +3,6 @@ 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 {
@@ -34,14 +32,6 @@ pub enum Error {
 
     /// Attempted to extract a [MockNet][super::MockNet] from a [Net][super::Net] that does not contain one.
     NetIsNotAMock,
-
-    InvalidMock(MockError),
-
-    /// The returned response is has an error status code (i.e. 4xx or 5xx)
-    #[display("response error: {}", response.status())]
-    ResponseError {
-        response: reqwest::Response,
-    },
 }
 impl std::error::Error for Error {}
 impl Clone for Error {

src/net/system.rs

@@ -1,41 +1,42 @@
 //
+use std::{cell::RefCell, rc::Rc};
 
-use std::{
+use reqwest::{Body, Client};
-    cell::RefCell,
-    collections::HashMap,
-    fmt::{Debug, Display},
-    marker::PhantomData,
-    ops::Deref,
-    rc::Rc,
-    sync::Arc,
-};
 
-use bytes::Bytes;
+use crate::net::{Method, Request, RequestBuilder, Response, Url};
-use derive_more::derive::{Display, From};
-use http::StatusCode;
-use reqwest::{Client, RequestBuilder};
-use tokio::sync::Mutex;
-use url::Url;
-
-use crate::net::{Request, Response};
 
 use super::{Error, Result};
 
 /// A list of planned requests and responses
 type Plans = Vec<Plan>;
 
+/// The different ways to match a request.
+#[derive(Debug, PartialEq, Eq)]
+pub enum MatchOn {
+    /// The request must have a specific HTTP Request Method.
+    Method,
+
+    /// The request must have a specific URL.
+    Url,
+
+    /// The request must have a specify HTTP Body.
+    Body,
+
+    /// The request must have a specific set of HTTP Headers.
+    Headers,
+}
+
 /// A planned request and the response to return
 ///
 /// Contains a list of the criteria that a request must meet before being considered a match.
-#[derive(Debug)]
 struct Plan {
     match_request: Vec<MatchRequest>,
-    response: reqwest::Response,
+    response: Response,
 }
 impl Plan {
     fn matches(&self, request: &Request) -> bool {
         self.match_request.iter().all(|criteria| match criteria {
-            MatchRequest::Method(method) => request.method() == http::Method::from(method),
+            MatchRequest::Method(method) => request.method() == method,
             MatchRequest::Url(uri) => request.url() == uri,
             MatchRequest::Header { name, value } => {
                 request
@@ -49,30 +50,29 @@ impl Plan {
                     })
             }
             MatchRequest::Body(body) => {
-                request.body().and_then(reqwest::Body::as_bytes) == Some(body)
+                request.body().and_then(Body::as_bytes) == Some(body.as_bytes())
             }
         })
     }
 }
-impl Display for Plan {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        for m in &self.match_request {
-            write!(f, "{m} ")?;
-        }
-        writeln!(f, "=> {:?}", self.response)
-    }
-}
 
 /// An abstraction for the network
-#[derive(Debug, Clone, Default)]
+#[derive(Clone)]
 pub struct Net {
-    plans: Option<Arc<Mutex<RefCell<Plans>>>>,
+    plans: Option<Rc<RefCell<Plans>>>,
 }
 impl Net {
     /// Creates a new unmocked [Net] for creating real network requests.
     pub(super) const fn new() -> Self {
         Self { plans: None }
     }
+
+    /// Creats a new [MockNet] for use in tests.
+    pub(super) const fn mock() -> MockNet {
+        MockNet {
+            plans: RefCell::new(vec![]),
+        }
+    }
 }
 impl Net {
     /// Helper to create a default [Client].
@@ -85,7 +85,6 @@ impl Net {
     /// let client = net.client();
     /// let request = client.get("https://hyper.rs");
     /// ```
-    #[must_use]
     pub fn client(&self) -> Client {
         Default::default()
     }
@@ -93,19 +92,10 @@ impl Net {
     /// Constructs the Request and sends it to the target URL, returning a
     /// future Response.
     ///
-    /// However, if this request is from a [Net] that was created from a [MockNet],
-    /// then the request will be matched and any stored response returned, or an
-    /// error if no matched request was found.
-    ///
-    /// This method provides an escape-hatch from `kxio`'s fluent API, and allows you
-    /// to create a request using [reqwest] directly.
-    ///
     /// # Errors
     ///
     /// This method fails if there was an error while sending request,
     /// redirect loop was detected or redirect limit was exhausted.
-    /// If the response has a Status Code of `4xx` or `5xx` then the
-    /// response will be returned as an [Error::ResponseError].
     ///
     /// # Example
     ///
@@ -123,291 +113,32 @@ impl Net {
             return request.into().send().await.map_err(Error::from);
         };
         let request = request.into().build()?;
-        eprintln!(
-            "? {} {} {:?}",
-            request.method(),
-            request.url(),
-            request.headers()
-        );
         let index = plans
-            .lock()
-            .await
-            .deref()
             .borrow()
             .iter()
             .position(|plan| plan.matches(&request));
         match index {
             Some(i) => {
-                let plan = plans.lock().await.borrow_mut().remove(i);
+                let response = plans.borrow_mut().remove(i).response;
-                eprintln!("- matched: {plan}");
+                Ok(response)
-                let response = plan.response;
-                if response.status().is_success() {
-                    Ok(response)
-                } else {
-                    Err(crate::net::Error::ResponseError { response })
-                }
             }
             None => Err(Error::UnexpectedMockRequest(request)),
         }
     }
-
-    /// Starts building an http DELETE request for the URL.
-    #[must_use]
-    pub fn delete(&self, url: impl Into<String>) -> ReqBuilder {
-        ReqBuilder::new(self, NetMethod::Delete, url)
-    }
-
-    /// Starts building an http GET request for the URL.
-    #[must_use]
-    pub fn get(&self, url: impl Into<String>) -> ReqBuilder {
-        ReqBuilder::new(self, NetMethod::Get, url)
-    }
-
-    /// Starts building an http HEAD request for the URL.
-    #[must_use]
-    pub fn head(&self, url: impl Into<String>) -> ReqBuilder {
-        ReqBuilder::new(self, NetMethod::Head, url)
-    }
-
-    /// Starts building an http PATCH request for the URL.
-    #[must_use]
-    pub fn patch(&self, url: impl Into<String>) -> ReqBuilder {
-        ReqBuilder::new(self, NetMethod::Patch, url)
-    }
-
-    /// Starts building an http POST request for the URL.
-    #[must_use]
-    pub fn post(&self, url: impl Into<String>) -> ReqBuilder {
-        ReqBuilder::new(self, NetMethod::Post, url)
-    }
-
-    /// Starts building an http PUT request for the URL.
-    #[must_use]
-    pub fn put(&self, url: impl Into<String>) -> ReqBuilder {
-        ReqBuilder::new(self, NetMethod::Put, url)
-    }
 }
-impl MockNet {
+impl TryFrom<Net> for MockNet {
-    pub async fn try_from(net: Net) -> std::result::Result<Self, super::Error> {
+    type Error = super::Error;
+
+    fn try_from(net: Net) -> std::result::Result<Self, Self::Error> {
         match &net.plans {
             Some(plans) => Ok(MockNet {
-                plans: Rc::new(RefCell::new(plans.lock().await.take())),
+                plans: RefCell::new(plans.take()),
             }),
-            None => Err(super::Error::NetIsNotAMock),
+            None => Err(Self::Error::NetIsNotAMock),
         }
     }
 }
 
-#[derive(Debug, Clone, Display, PartialEq, Eq)]
-pub enum NetMethod {
-    Delete,
-    Get,
-    Head,
-    Patch,
-    Post,
-    Put,
-}
-impl From<&NetMethod> for http::Method {
-    fn from(value: &NetMethod) -> Self {
-        match value {
-            NetMethod::Delete => http::Method::DELETE,
-            NetMethod::Get => http::Method::GET,
-            NetMethod::Head => http::Method::HEAD,
-            NetMethod::Patch => http::Method::PATCH,
-            NetMethod::Post => http::Method::POST,
-            NetMethod::Put => http::Method::PUT,
-        }
-    }
-}
-
-/// A builder for an http request.
-pub struct ReqBuilder<'net> {
-    net: &'net Net,
-    url: String,
-    method: NetMethod,
-    headers: Vec<(String, String)>,
-    body: Option<Bytes>,
-}
-impl<'net> ReqBuilder<'net> {
-    #[must_use]
-    fn new(net: &'net Net, method: NetMethod, url: impl Into<String>) -> Self {
-        Self {
-            net,
-            url: url.into(),
-            method,
-            headers: vec![],
-            body: None,
-        }
-    }
-
-    /// Use the function to modify the request in-line.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use kxio::net::Result;
-    /// # async fn run() -> Result<()> {
-    /// let net = kxio::net::new();
-    /// let response= net
-    ///     .get("http://localhost/")
-    ///     .with(|request| add_std_headers(request))
-    ///     .send()
-    ///     .await?;
-    /// # Ok(())
-    /// # }
-    /// fn add_std_headers(request: kxio::net::ReqBuilder) -> kxio::net::ReqBuilder {
-    ///   request
-    ///     .header("ClientVersion", "1.23.45")
-    ///     .header("Agent", "MyApp/1.1")
-    /// }
-    /// ````
-    #[must_use]
-    pub fn with(self, f: impl FnOnce(Self) -> Self) -> Self {
-        f(self)
-    }
-
-    /// Starts an Option clause for the supplied option.
-    ///
-    /// Must be followed by [WithOption::some], [WithOption::none] or [WithOption::either]
-    /// to resume the with the [ReqBuilder].
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use kxio::net::Result;
-    /// # async fn run() -> Result<()> {
-    /// let net = kxio::net::new();
-    /// let response= net
-    ///     .get("http://localhost/")
-    ///     .with_option(Some("value"))
-    ///     .some(|request, value| request.header("optional-header", value))
-    ///     .with_option(Some("value"))
-    ///     .none(|request| request.header("special-header", "not-found"))
-    ///     .with_option(Some("value"))
-    ///     .either(
-    ///     /* some */ |request, value| request.header("Setting", value),
-    ///     /* none */ |request| request.header("Setting", "missing")
-    ///     )
-    ///     .send()
-    ///     .await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[must_use]
-    pub fn with_option<T>(self, option: Option<T>) -> WithOption<'net, T> {
-        WithOption {
-            req_builder: self,
-            option,
-        }
-    }
-
-    /// Starts a Result clause for the supplied result.
-    ///
-    /// Must be followed by [WithResult::ok], [WithResult::err] or [WithResult::either]
-    /// to resume the with the [ReqBuilder].
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use kxio::net::Result;
-    /// # async fn run() -> Result<()> {
-    /// let net = kxio::net::new();
-    /// let response = net
-    ///     .get("http://localhost/")
-    ///     .with_result::<&str, ()>(Ok("value"))
-    ///     .ok(|request, value| request.header("good-header", value))
-    ///     .with_result::<(), &str>(Err("value"))
-    ///     .err(|request, err| request.header("bad-header", err))
-    ///     .with_result::<&str, &str>(Ok("value"))
-    ///     .either(
-    ///     /* ok  */ |request, ok|  request.header("Setting", ok),
-    ///     /* err */ |request, err| request.header("SettingError", err)
-    ///     )
-    ///     .send()
-    ///     .await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[must_use]
-    pub fn with_result<T, E>(self, result: std::result::Result<T, E>) -> WithResult<'net, T, E> {
-        WithResult {
-            req_builder: self,
-            result,
-        }
-    }
-
-    /// Constructs the Request and sends it to the target URL, returning a
-    /// future Response.
-    ///
-    /// However, if this request is from a [Net] that was created from a [MockNet],
-    /// then the request will be matched and any stored response returned, or an
-    /// error if no matched request was found.
-    ///
-    /// # Errors
-    ///
-    /// This method fails if there was an error while sending request,
-    /// redirect loop was detected or redirect limit was exhausted.
-    /// If the response has a Status Code of `4xx` or `5xx` then the
-    /// response will be returned as an [Error::ResponseError].
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// # use kxio::net::Result;
-    /// # async fn run() -> Result<()> {
-    /// let net = kxio::net::new();
-    /// let response = net.get("https://hyper.rs")
-    ///   .header("foo", "bar")
-    ///   .body("{}")
-    ///   .send().await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub async fn send(self) -> Result<Response> {
-        let client = self.net.client();
-        // Method
-        let mut req = match self.method {
-            NetMethod::Delete => client.delete(self.url),
-            NetMethod::Get => client.get(self.url),
-            NetMethod::Head => client.head(self.url),
-            NetMethod::Patch => client.patch(self.url),
-            NetMethod::Post => client.post(self.url),
-            NetMethod::Put => client.put(self.url),
-        };
-        // Headers
-        for (name, value) in self.headers.into_iter() {
-            req = req.header(name, value);
-        }
-        // Body
-        if let Some(bytes) = self.body {
-            req = req.body(bytes);
-        }
-
-        self.net.send(req).await
-    }
-
-    /// Adds the header and value to the request.
-    #[must_use]
-    pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
-        self.headers.push((name.into(), value.into()));
-        self
-    }
-
-    /// Adds the headers to the request.
-    #[must_use]
-    pub fn headers(mut self, headers: HashMap<String, String>) -> Self {
-        self.headers.extend(headers);
-        self
-    }
-
-    /// Sets the request body.
-    #[must_use]
-    pub fn body(mut self, bytes: impl Into<Bytes>) -> Self {
-        self.body = Some(bytes.into());
-        self
-    }
-}
-
 /// A struct for defining the expected requests and their responses that should be made
 /// during a test.
 ///
@@ -417,28 +148,27 @@ impl<'net> ReqBuilder<'net> {
 /// # Example
 ///
 /// ```rust
+/// use kxio::net::{Method, Url};
 /// # use kxio::net::Result;
-/// use kxio::net::StatusCode;
+/// # fn run() -> Result<()> {
-/// # #[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")
+/// mock_net.on(Method::GET)
-///     .respond(StatusCode::OK).body("Ok");
+///     .url(Url::parse("https://hyper.rs")?)
+///     .respond(mock_net.response().status(200).body("Ok")?);
 /// let net: kxio::net::Net = mock_net.into();
 /// // use 'net' in your program, by passing it as a reference
 ///
 /// // In some rare cases you don't want to assert that all expected requests were made.
 /// // You should recover the `MockNet` from the `Net` and `MockNet::reset` it.
-/// let mock_net = kxio::net::MockNet::try_from(net).await?;
+/// let mock_net = kxio::net::MockNet::try_from(net)?;
 /// mock_net.reset(); // only if explicitly needed
 /// # Ok(())
 /// # }
 /// ```
-#[derive(Debug, Clone, Default)]
 pub struct MockNet {
-    plans: Rc<RefCell<Plans>>,
+    plans: RefCell<Plans>,
 }
 impl MockNet {
     /// Helper to create a default [Client].
@@ -459,25 +189,30 @@ impl MockNet {
     /// # Example
     ///
     /// ```rust
-    /// use kxio::net::StatusCode;
+    /// use kxio::net::{Method, Url};
     /// # 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")
+    /// mock_net.on(Method::GET)
-    ///     .respond(StatusCode::OK).body("Ok");
+    ///     .url(Url::parse("https://hyper.rs")?)
+    ///     .respond(mock_net.response().status(200).body("Ok")?);
     /// # Ok(())
     /// # }
     /// ```
-    #[must_use]
+    pub fn on(&self, method: impl Into<Method>) -> WhenRequest {
-    pub fn on(&self) -> WhenRequest<WhenBuildRequest> {
+        WhenRequest::new(self, method)
-        WhenRequest::new(self)
     }
 
     fn _when(&self, plan: Plan) {
         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
@@ -487,11 +222,10 @@ impl MockNet {
     ///
     /// ```rust
     /// # use kxio::net::Result;
-    /// # #[tokio::main]
+    /// # fn run() -> Result<()> {
-    /// # async fn run() -> Result<()> {
     /// # let mock_net = kxio::net::mock();
     /// # let net: kxio::net::Net = mock_net.into();
-    /// let mock_net = kxio::net::MockNet::try_from(net).await?;
+    /// let mock_net = kxio::net::MockNet::try_from(net)?;
     /// mock_net.reset(); // only if explicitly needed
     /// # Ok(())
     /// # }
@@ -505,156 +239,41 @@ impl From<MockNet> for Net {
         Self {
             // keep the original `inner` around to allow it's Drop impelmentation to run when we go
             // out of scope at the end of the test
-            plans: Some(Arc::new(Mutex::new(RefCell::new(mock_net.plans.take())))),
+            plans: Some(Rc::new(RefCell::new(mock_net.plans.take()))),
         }
     }
 }
 
 impl Drop for MockNet {
     fn drop(&mut self) {
-        let unused = self.plans.take();
+        assert!(self.plans.borrow().is_empty())
-        if unused.is_empty() {
-            return; // all good
-        }
-        panic_with_unused_plans(unused);
     }
 }
 impl Drop for Net {
     fn drop(&mut self) {
         if let Some(plans) = &self.plans {
-            let unused = plans.try_lock().expect("lock plans").take();
+            assert!(plans.borrow().is_empty())
-            if unused.is_empty() {
-                return; // all good
-            }
-            panic_with_unused_plans(unused);
         }
     }
 }
 
-fn panic_with_unused_plans(unused: Vec<Plan>) {
-    eprintln!("These requests were expected, but not made:");
-    for plan in unused {
-        eprintln!("- {plan}");
-    }
-    panic!("There were expected requests that were not made.");
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum MatchRequest {
-    Method(NetMethod),
+    Method(Method),
     Url(Url),
     Header { name: String, value: String },
-    Body(bytes::Bytes),
+    Body(String),
-}
-impl Display for MatchRequest {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Method(method) => write!(f, "{method}"),
-            Self::Url(url) => write!(f, "{url}"),
-            Self::Header { name, value } => write!(f, "({name}: {value})"),
-            Self::Body(body) => write!(f, "Body: {body:?}"),
-        }
-    }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WhenRequest<'net> {
-pub enum RespondWith {
-    Status(StatusCode),
-    Header { name: String, value: String },
-    Body(bytes::Bytes),
-}
-
-#[derive(Clone, Debug, Display, From)]
-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, State>
-where
-    State: WhenState,
-{
-    _state: PhantomData<State>,
     net: &'net MockNet,
     match_on: Vec<MatchRequest>,
-    respond_with: Vec<RespondWith>,
-    error: Option<MockError>,
 }
 
-impl<'net> WhenRequest<'net, WhenBuildRequest> {
+impl<'net> WhenRequest<'net> {
-    fn new(net: &'net MockNet) -> Self {
+    pub fn url(mut self, url: impl Into<Url>) -> Self {
-        Self {
+        self.match_on.push(MatchRequest::Url(url.into()));
-            _state: PhantomData,
-            net,
-            match_on: vec![],
-            respond_with: vec![],
-            error: None,
-        }
-    }
-
-    /// Starts mocking a GET http request.
-    #[must_use]
-    pub fn get(self, url: impl Into<String>) -> Self {
-        self._url(NetMethod::Get, url)
-    }
-
-    /// Starts mocking a POST http request.
-    #[must_use]
-    pub fn post(self, url: impl Into<String>) -> Self {
-        self._url(NetMethod::Post, url)
-    }
-
-    /// Starts mocking a PUT http request.
-    #[must_use]
-    pub fn put(self, url: impl Into<String>) -> Self {
-        self._url(NetMethod::Put, url)
-    }
-
-    /// Starts mocking a DELETE http request.
-    #[must_use]
-    pub fn delete(self, url: impl Into<String>) -> Self {
-        self._url(NetMethod::Delete, url)
-    }
-
-    /// Starts mocking a HEAD http request.
-    #[must_use]
-    pub fn head(self, url: impl Into<String>) -> Self {
-        self._url(NetMethod::Head, url)
-    }
-
-    /// Starts mocking a PATCH http request.
-    #[must_use]
-    pub fn patch(self, url: impl Into<String>) -> Self {
-        self._url(NetMethod::Patch, url)
-    }
-
-    fn _url(mut self, method: NetMethod, url: impl Into<String>) -> Self {
-        self.match_on.push(MatchRequest::Method(method));
-        match Url::parse(&url.into()) {
-            Ok(url) => {
-                self.match_on.push(MatchRequest::Url(url));
-            }
-            Err(err) => {
-                self.error.replace(err.into());
-            }
-        }
         self
     }
-
-    /// Specifies a header that the mock will match against.
-    ///
-    /// Any request that does not have this header will not match the mock.
-    #[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(),
@@ -662,233 +281,24 @@ impl<'net> WhenRequest<'net, WhenBuildRequest> {
         });
         self
     }
-
+    pub fn body(mut self, body: impl Into<String>) -> Self {
-    /// Specifies headers that the mock will match against.
-    ///
-    /// Any request that does not have this header will not match the mock.
-    #[must_use]
-    pub fn headers(mut self, headers: HashMap<String, String>) -> Self {
-        for (name, value) in headers {
-            self.match_on.push(MatchRequest::Header { name, value });
-        }
-        self
-    }
-
-    /// Specifies the body that the mock will match against.
-    ///
-    /// Any request that does not have this body will not match the mock.
-    #[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>)
-    /// Specifies the http Status Code that will be returned for the matching request.
+    where
-    #[must_use]
+        T: Into<reqwest::Body>,
-    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> {
-    /// Specifies a header that will be on the response sent for the matching request.
-    #[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
-    }
-
-    /// Specifies headers that will be on the response sent for the matching request.
-    #[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
-    }
-
-    /// Specifies the body of the response sent for the matching request.
-    pub fn body(mut self, body: impl Into<bytes::Bytes>) -> Result<()> {
-        self.respond_with.push(RespondWith::Body(body.into()));
-        self.mock()
-    }
-
-    /// Marks a response that has no body as complete.
-    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 body = response_body.unwrap_or_default();
-        let response = builder.body(body)?;
         self.net._when(Plan {
             match_request: self.match_on,
             response: response.into(),
         });
-        Ok(())
-    }
-}
-
-/// Option clause for building a request with [ReqBuilder].
-///
-/// See: [ReqBuilder::with_option].
-pub struct WithOption<'net, T> {
-    req_builder: ReqBuilder<'net>,
-    option: Option<T>,
-}
-impl<'net, T> WithOption<'net, T> {
-    /// Handles when the preceeding [Option] is [Some].
-    ///
-    /// The function is passed the [ReqBuilder] and the value in the [Some].
-    ///
-    /// Returns the [ReqBuilder].
-    pub fn some(
-        self,
-        f_some: impl FnOnce(ReqBuilder<'net>, T) -> ReqBuilder<'net>,
-    ) -> ReqBuilder<'net> {
-        match self.option {
-            Some(value) => f_some(self.req_builder, value),
-            None => self.req_builder,
-        }
     }
 
-    /// Handles when the preceeding [Option] is [None].
+    fn new(net: &'net MockNet, method: impl Into<Method>) -> Self {
-    ///
+        Self {
-    /// The function is passed the [ReqBuilder].
+            net,
-    ///
+            match_on: vec![MatchRequest::Method(method.into())],
-    /// Returns the [ReqBuilder].
-    pub fn none(
-        self,
-        f_none: impl FnOnce(ReqBuilder<'net>) -> ReqBuilder<'net>,
-    ) -> ReqBuilder<'net> {
-        match self.option {
-            None => f_none(self.req_builder),
-            Some(_) => self.req_builder,
-        }
-    }
-
-    /// Handles the preceeding [Option].
-    ///
-    /// If the [Option] is [Some], then the `f_some` function is passed the [ReqBuilder] and the value in the [Some].
-    ///
-    /// If the [Option] is [None], then the `f_none` function is passed the [ReqBuilder].
-    ///
-    /// Returns the [ReqBuilder].
-    pub fn either(
-        self,
-        f_some: impl FnOnce(ReqBuilder<'net>, T) -> ReqBuilder<'net>,
-        f_none: impl FnOnce(ReqBuilder<'net>) -> ReqBuilder<'net>,
-    ) -> ReqBuilder<'net> {
-        match self.option {
-            Some(value) => f_some(self.req_builder, value),
-            None => f_none(self.req_builder),
         }
     }
 }
-
-pub struct WithResult<'net, T, E> {
-    req_builder: ReqBuilder<'net>,
-    result: std::result::Result<T, E>,
-}
-impl<'net, T, E> WithResult<'net, T, E> {
-    pub fn ok(
-        self,
-        f_ok: impl FnOnce(ReqBuilder<'net>, T) -> ReqBuilder<'net>,
-    ) -> ReqBuilder<'net> {
-        match self.result {
-            Ok(ok) => f_ok(self.req_builder, ok),
-            Err(_) => self.req_builder,
-        }
-    }
-    pub fn err(
-        self,
-        f_err: impl FnOnce(ReqBuilder<'net>, E) -> ReqBuilder<'net>,
-    ) -> ReqBuilder<'net> {
-        match self.result {
-            Err(err) => f_err(self.req_builder, err),
-            Ok(_) => self.req_builder,
-        }
-    }
-    pub fn either(
-        self,
-        f_ok: impl FnOnce(ReqBuilder<'net>, T) -> ReqBuilder<'net>,
-        f_err: impl FnOnce(ReqBuilder<'net>, E) -> ReqBuilder<'net>,
-    ) -> ReqBuilder<'net> {
-        match self.result {
-            Ok(ok) => f_ok(self.req_builder, ok),
-            Err(err) => f_err(self.req_builder, err),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn is_normal<T: Sized + Send + Sync + Unpin>() {}
-
-    #[test]
-    fn normal_types() {
-        is_normal::<Net>();
-        // is_normal::<MockNet>(); // only used in test setup - no need to be Send or Sync
-        is_normal::<MatchRequest>();
-        is_normal::<Plan>();
-        // is_normal::<WhenRequest>(); // only used in test setup - no need to be Send or Sync
-    }
-
-    #[test]
-    fn plan_display() {
-        let plan = Plan {
-            match_request: vec![
-                MatchRequest::Method(NetMethod::Put),
-                MatchRequest::Header {
-                    name: "alpha".into(),
-                    value: "1".into(),
-                },
-                MatchRequest::Body("req body".into()),
-            ],
-            response: http::response::Builder::default()
-                .status(204)
-                .header("foo", "bar")
-                .header("baz", "buck")
-                .body("contents")
-                .expect("body")
-                .into(),
-        };
-        let result = plan.to_string();
-
-        let expected = [
-            "Put",
-            "(alpha: 1)",
-            "Body: b\"req body\"",
-            "=>",
-            "Response {",
-            "url: \"http://no.url.provided.local/\",",
-            "status: 204,",
-            "headers: {\"foo\": \"bar\", \"baz\": \"buck\"}",
-            "}\n",
-        ]
-        .join(" ");
-        assert_eq!(result, expected);
-    }
-}

tests/fs.rs

@@ -5,25 +5,8 @@ use kxio::fs;
 type TestResult = Result<(), fs::Error>;
 
 mod path {
-    use fs::{PathHandle, PathMarker};
-
     use super::*;
 
-    #[test]
-    fn temp_as_real() {
-        let fs = fs::temp().expect("temp fs");
-        let read = fs.as_real();
-
-        assert_eq!(read.base(), fs.base());
-    }
-
-    #[test]
-    fn display() {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        let path_handle = fs.path(&path);
-        assert_eq!(path_handle.to_string(), format!("{}", path.display()));
-    }
     mod is_link {
         use super::*;
 
@@ -435,42 +418,25 @@ mod path {
             assert_eq!(src_pathbuf, dst_pathbuf);
         }
     }
-
-    #[test]
-    fn from_file() {
-        let fs = fs::temp().expect("temp fs");
-
-        let file_path = fs.base().join("foo");
-        let file = fs.file(&file_path);
-
-        let path: PathHandle<PathMarker> = file.into();
-
-        assert_eq!(path.as_pathbuf(), file_path);
-    }
-
-    #[test]
-    fn from_dir() {
-        let fs = fs::temp().expect("temp fs");
-
-        let dir_path = fs.base().join("foo");
-        let dir = fs.dir(&dir_path);
-
-        let path: PathHandle<PathMarker> = dir.into();
-
-        assert_eq!(path.as_pathbuf(), dir_path);
-    }
 }
 
 mod file {
     use super::*;
 
-    #[test]
+    // // test for reading the symlink metadata
-    fn display() {
+    // #[test]
-        let fs = fs::temp().expect("temp fs");
+    // fn symlink_metadata() -> TestResult {
-        let path = fs.base().join("foo");
+    //     let fs = fs::temp().expect("temp fs");
-        let file_handle = fs.file(&path);
+    //     let file_path = fs.base().join("foo");
-        assert_eq!(file_handle.to_string(), format!("{}", path.display()));
+    //     let file = fs.file(&file_path);
-    }
+    //     file.write("bar").expect("write");
+    //     let link_path = fs.base().join("bar");
+    //     let link = fs.path(&link_path);
+    //     file.soft_link(&link).expect("soft_link");
+    //     let md = link.symlink_metadata().expect("symlink metadata");
+    //     assert!(md.is_file());
+    //     Ok(())
+    // }
 
     #[test]
     fn create_hard_link() -> TestResult {
@@ -552,53 +518,6 @@ mod file {
         path.remove().expect("remove");
     }
 
-    mod from_path {
-        use fs::{Error, FileHandle};
-
-        use super::*;
-
-        #[test]
-        fn path_is_dir() {
-            let fs = fs::temp().expect("temp fs");
-            let pathbuf = fs.base().join("foo");
-            let dir = fs.dir(&pathbuf);
-            dir.create().expect("create dir");
-
-            let path = fs.path(&pathbuf);
-
-            let_assert!(Err(Error::NotAFile { path: err_path }) = FileHandle::try_from(path));
-
-            assert_eq!(err_path, pathbuf);
-        }
-
-        #[test]
-        fn path_is_file() {
-            let fs = fs::temp().expect("temp fs");
-            let pathbuf = fs.base().join("foo");
-            let file = fs.file(&pathbuf);
-            file.write("contents").expect("write file");
-
-            let path = fs.path(&pathbuf);
-
-            let_assert!(Ok(file_result) = FileHandle::try_from(path));
-
-            assert_eq!(file_result.as_pathbuf(), pathbuf);
-        }
-
-        #[test]
-        fn path_is_error() {
-            let fs = fs::temp().expect("temp fs");
-            let pathbuf = fs.base().join("foo");
-            // does not exist
-
-            let path = fs.path(&pathbuf);
-
-            let_assert!(Err(Error::NotAFile { path: err_path }) = FileHandle::try_from(path));
-
-            assert_eq!(err_path, pathbuf);
-        }
-    }
-
     mod remove {
         use super::*;
         #[test]
@@ -789,61 +708,6 @@ mod file {
 mod dir {
     use super::*;
 
-    mod from_path {
-        use fs::{DirHandle, Error};
-
-        use super::*;
-
-        #[test]
-        fn display() {
-            let fs = fs::temp().expect("temp fs");
-            let path = fs.base().join("foo");
-            let dir_handle = fs.dir(&path);
-            assert_eq!(dir_handle.to_string(), format!("{}/", path.display()));
-        }
-
-        #[test]
-        fn path_is_dir() {
-            let fs = fs::temp().expect("temp fs");
-            let pathbuf = fs.base().join("foo");
-            let dir = fs.dir(&pathbuf);
-            dir.create().expect("create dir");
-
-            let path = fs.path(&pathbuf);
-
-            let_assert!(Ok(dir_result) = DirHandle::try_from(path));
-
-            assert_eq!(dir_result.as_pathbuf(), pathbuf);
-        }
-
-        #[test]
-        fn path_is_file() {
-            let fs = fs::temp().expect("temp fs");
-            let pathbuf = fs.base().join("foo");
-            let file = fs.file(&pathbuf);
-            file.write("contents").expect("write file");
-
-            let path = fs.path(&pathbuf);
-
-            let_assert!(Err(Error::NotADirectory { path: err_path }) = DirHandle::try_from(path));
-
-            assert_eq!(err_path, pathbuf);
-        }
-
-        #[test]
-        fn path_is_error() {
-            let fs = fs::temp().expect("temp fs");
-            let pathbuf = fs.base().join("foo");
-            // does not exist
-
-            let path = fs.path(&pathbuf);
-
-            let_assert!(Err(Error::NotADirectory { path: err_path }) = DirHandle::try_from(path));
-
-            assert_eq!(err_path, pathbuf);
-        }
-    }
-
     mod create {
         use super::*;
         #[test]

tests/net.rs

@@ -1,8 +1,5 @@
-use std::collections::HashMap;
-
-use http::StatusCode;
 //
-use kxio::net::{Error, MockNet, Net};
+use kxio::net::{Error, Method, MockNet, Net, Url};
 
 use assert2::let_assert;
 
@@ -10,163 +7,50 @@ use assert2::let_assert;
 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()
+        .on(Method::GET)
-        .get(url)
+        .url(Url::parse(url).expect("parse url"))
-        .respond(StatusCode::OK)
+        .respond(my_response);
-        .header("foo", "bar")
-        .headers(HashMap::new())
-        .body("Get OK")
-        .expect("mock");
 
     //when
-    let response = Net::from(mock_net).get(url).send().await.expect("response");
+    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_post_url() {
-    //given
-    let net = kxio::net::mock();
-    let client = net.client();
-
-    let url = "https://www.example.com";
-
-    net.on()
-        .post(url)
-        .respond(StatusCode::OK)
-        .body("post OK")
-        .expect("mock");
-
-    //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_put_url() {
-    //given
-    let net = kxio::net::mock();
-    let client = net.client();
-
-    let url = "https://www.example.com";
-
-    net.on()
-        .put(url)
-        .respond(StatusCode::OK)
-        .body("put OK")
-        .expect("mock");
-
-    //when
-    let response = Net::from(net).send(client.put(url)).await.expect("reponse");
-
-    //then
-    assert_eq!(response.status(), http::StatusCode::OK);
-    assert_eq!(response.bytes().await.expect("response body"), "put OK");
-}
-
-#[tokio::test]
-async fn test_delete_url() {
-    //given
-    let net = kxio::net::mock();
-    let client = net.client();
-
-    let url = "https://www.example.com";
-
-    net.on()
-        .delete(url)
-        .respond(StatusCode::OK)
-        .body("delete OK")
-        .expect("mock");
-
-    //when
-    let response = Net::from(net)
-        .send(client.delete(url))
-        .await
-        .expect("reponse");
-
-    //then
-    assert_eq!(response.status(), http::StatusCode::OK);
-    assert_eq!(response.bytes().await.expect("response body"), "delete OK");
-}
-
-#[tokio::test]
-async fn test_head_url() {
-    //given
-    let net = kxio::net::mock();
-    let client = net.client();
-
-    let url = "https://www.example.com";
-
-    net.on()
-        .head(url)
-        .respond(StatusCode::OK)
-        .body("head OK")
-        .expect("mock");
-
-    //when
-    let response = Net::from(net)
-        .send(client.head(url))
-        .await
-        .expect("reponse");
-
-    //then
-    assert_eq!(response.status(), http::StatusCode::OK);
-    assert_eq!(response.bytes().await.expect("response body"), "head OK");
-}
-
-#[tokio::test]
-async fn test_patch_url() {
-    //given
-    let net = kxio::net::mock();
-    let client = net.client();
-
-    let url = "https://www.example.com";
-
-    net.on()
-        .patch(url)
-        .respond(StatusCode::OK)
-        .body("patch OK")
-        .expect("mock");
-
-    //when
-    let response = Net::from(net)
-        .send(client.patch(url))
-        .await
-        .expect("reponse");
-
-    //then
-    assert_eq!(response.status(), http::StatusCode::OK);
-    assert_eq!(response.bytes().await.expect("response body"), "patch OK");
-}
-
 #[tokio::test]
 async fn test_get_wrong_url() {
     //given
-    let net = kxio::net::mock();
+    let mock_net = kxio::net::mock();
-    let client = net.client();
+    let client = mock_net.client();
 
     let url = "https://www.example.com";
-
+    let my_response = mock_net
-    net.on()
+        .response()
-        .get(url)
+        .status(200)
-        .respond(StatusCode::OK)
         .body("Get OK")
-        .expect("mock");
+        .expect("body");
 
-    let net = Net::from(net);
+    mock_net
+        .on(Method::GET)
+        .url(Url::parse(url).expect("parse url"))
+        .respond(my_response);
+
+    let net = Net::from(mock_net);
 
     //when
     let_assert!(
@@ -178,18 +62,45 @@ async fn test_get_wrong_url() {
     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).await.expect("recover net");
+    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();
 
-    // NOTE: No URL specified - so should match any URL
+    let my_response = net.response().status(200).body("").expect("response body");
-    net.on().respond(StatusCode::OK).body("").expect("mock");
+
+    net.on(Method::POST)
+        // NOTE: No URL specified - so shou∂ match any URL
+        .respond(my_response);
 
     //when
     let response = Net::from(net)
@@ -208,12 +119,16 @@ async fn test_post_by_body() {
     let net = kxio::net::mock();
     let client = net.client();
 
-    // No URL - so any POST with a matching body
+    let my_response = net
-    net.on()
+        .response()
-        .body("match on body")
+        .status(200)
-        .respond(StatusCode::OK)
         .body("response body")
-        .expect("mock");
+        .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)
@@ -235,11 +150,15 @@ async fn test_post_by_header() {
     let net = kxio::net::mock();
     let client = net.client();
 
-    net.on()
+    let my_response = net
-        .header("test", "match")
+        .response()
-        .respond(StatusCode::OK)
+        .status(200)
         .body("response body")
-        .expect("mock");
+        .expect("body");
+
+    net.on(Method::POST)
+        .header("test", "match")
+        .respond(my_response);
 
     //when
     let response = Net::from(net)
@@ -266,12 +185,16 @@ async fn test_post_by_header_wrong_value() {
     let mock_net = kxio::net::mock();
     let client = mock_net.client();
 
-    mock_net
+    let my_response = mock_net
-        .on()
+        .response()
-        .header("test", "match")
+        .status(200)
-        .respond(StatusCode::OK)
         .body("response body")
-        .expect("mock");
+        .expect("body");
+
+    mock_net
+        .on(Method::POST)
+        .header("test", "match")
+        .respond(my_response);
     let net = Net::from(mock_net);
 
     //when
@@ -287,7 +210,7 @@ async fn test_post_by_header_wrong_value() {
     //then
     let_assert!(Err(kxio::net::Error::UnexpectedMockRequest(_)) = response);
 
-    MockNet::try_from(net).await.expect("recover mock").reset();
+    MockNet::try_from(net).expect("recover mock").reset();
 }
 
 #[tokio::test]
@@ -297,13 +220,16 @@ 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()
+        .on(Method::POST)
-        .post(url)
+        .url(Url::parse(url).expect("prase url"))
-        .respond(StatusCode::OK)
+        .respond(my_response);
-        .body("Post OK")
-        .expect("mock");
 
     let _net = Net::from(mock_net);
 
@@ -322,13 +248,16 @@ 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()
+        .on(Method::POST)
-        .post(url)
+        .url(Url::parse(url).expect("parse url"))
-        .respond(StatusCode::OK)
+        .respond(my_response);
-        .body("Post OK")
-        .expect("mock");
 
     //when
     // don't send the planned request