Whenever I try to run my test in a debugger, I get the following error

running 1 test
thread 'metadata::tests::test_fetching_src' panicked at 'Cannot create absolute path from string '/var/folders/hf/phjl9q7501gb5wt_qr4ltn3m0000gn/T/.tmpIrQDOX/fake-crate.tar.gz': "environment variable not found"', /Users/user/.cargo/registry/src/github.com-1ecc6299db9ec823/httpmock-0.5.0-beta.1/src/api/mock.rs:1115:63
stack backtrace:
   0: rust_begin_unwind
             at /rustc/18bf6b4f01a6feaf7259ba7cdae58031af1b7b39/library/std/src/panicking.rs:475
   1: core::panicking::panic_fmt
             at /rustc/18bf6b4f01a6feaf7259ba7cdae58031af1b7b39/library/core/src/panicking.rs:85
   2: core::option::expect_none_failed
             at /rustc/18bf6b4f01a6feaf7259ba7cdae58031af1b7b39/library/core/src/option.rs:1221
   3: core::result::Result<T,E>::expect
             at /Users/user/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/src/rust/library/core/src/result.rs:933
   4: httpmock::api::mock::Mock::return_body_from_file
             at /Users/user/.cargo/registry/src/github.com-1ecc6299db9ec823/httpmock-0.5.0-beta.1/src/api/mock.rs:1115
   5: httpmock::Responders::body_from_file
             at /Users/user/.cargo/registry/src/github.com-1ecc6299db9ec823/httpmock-0.5.0-beta.1/src/lib.rs:1185
   6: cargo_raze::metadata::tests::test_fetching_src::{{closure}}
             at ./src/metadata.rs:389
   7: httpmock::MockServer::mock_async::{{closure}}
             at /Users/user/.cargo/registry/src/github.com-1ecc6299db9ec823/httpmock-0.5.0-beta.1/src/lib.rs:481
   8: <core::future::from_generator::GenFuture<T> as core::future::future::Future>::poll
             at /Users/user/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/src/rust/library/core/src/future/mod.rs:79
   9: <F as httpmock::util::Join>::join
             at /Users/user/.cargo/registry/src/github.com-1ecc6299db9ec823/httpmock-0.5.0-beta.1/src/util.rs:71
  10: httpmock::MockServer::mock
             at /Users/user/.cargo/registry/src/github.com-1ecc6299db9ec823/httpmock-0.5.0-beta.1/src/lib.rs:456
  11: cargo_raze::metadata::tests::test_fetching_src
             at ./src/metadata.rs:385
  12: cargo_raze::metadata::tests::test_fetching_src::{{closure}}
             at ./src/metadata.rs:342
  13: core::ops::function::FnOnce::call_once
             at /Users/user/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs:227
  14: core::ops::function::FnOnce::call_once
             at /rustc/18bf6b4f01a6feaf7259ba7cdae58031af1b7b39/library/core/src/ops/function.rs:227
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

Repro

I created an example workspace that outlines this issue. repro.zip

I'm using Vscode and by simply clicking the debug button that appears over tests from the rust-analyzer plugin, I hit this panic.

I'm using 0.5.0-beta.1.

It seems the library fails on multipart/form-data uploads. It works fine with regular requests with json body.

Requests to real server upload files without any issues. I'm using ureq as HTTP client:

    fn request_with_form_data<T1: serde::ser::Serialize, T2: serde::de::DeserializeOwned>(
        &self,
        method: &str,
        params: T1,
        parameter_name: &str,
        file_path: PathBuf,
    ) -> Result<T2, ureq::Error> {
        let json_string = serde_json::to_string(&params).unwrap();
        let json_struct: Value = serde_json::from_str(&json_string).unwrap();

        let mut form = Multipart::new();
        for (key, val) in json_struct.as_object().unwrap().iter() {
            if key != parameter_name {
                let val = match val {
                    &Value::String(ref val) => format!("{}", val),
                    etc => format!("{}", etc),
                };

                form.add_text(key, val);
            }
        }

        let file = std::fs::File::open(&file_path).unwrap();
        let file_extension = file_path.extension().and_then(|s| s.to_str()).unwrap_or("");
        let mime = mime_guess::from_ext(&file_extension).first_or_octet_stream();

        form.add_stream(
            parameter_name,
            file,
            file_path.file_name().unwrap().to_str(),
            Some(mime),
        );

        let url = format!("{}/{}", self.api_url, method);
        let form_data = form.prepare().unwrap();

        let response = ureq::post(&url)
            .set(
                "Content-Type",
                &format!("multipart/form-data; boundary={}", form_data.boundary()),
            )
            .send(form_data)?;

        let parsed_response: T2 = serde_json::from_reader(response.into_reader()).unwrap();

        Ok(parsed_response)
    }

mock:

        let server = MockServer::start();

        server.mock(|when, then| {
            when.method(POST).path(path);
            then.status(200).body(response);
        });

Hi,

I'm trying to write a non-trivial mock server. To do so I'd need to store both the MockServer object and a bunch of MockRef<'a> in the same struct (the one representing my mock server). Unfortunately it's pretty hard to do as MockRef is itself keeping a ref on Server, introducing the well-known self-referential problem.

It is possible to workaround it with tricks such as rental or owning_ref but it greatly increase the code complexity. An easier approach would be to remove the server borrow in MockRef by wrapping it around a Rc or Arc. Would you be opened to such change?

If I set up a mock for a GET request:

    pub async fn provision_api(&self) {
        let _get_colo_info = self
            .server
            .mock_async(|when, then| {
                when.method("GET");
                then.body("hi").status(200);
            })
            .await;
    }
    ```
Then send a GET using reqwest:
    ```
    let body = reqwest::get()?
    .text()?;
    ```
I see:
`WARN  httpmock::server::matchers::targets] Cannot parse json value: EOF while parsing a value at line 1 column 0`
It appears this is because it thinks there is a body on the GET request and tries to parse it has json.  Everything appears to work as intended except for the warning prints.

Can you actually not hard pin everything? I didn't realize what affect this would have downstream when you first mentioned it in #21

error: failed to select a version for `regex`.
    ... required by package `httpmock v0.5.1`
    ... which is depended on by `cargo-raze v0.6.1 (/Users/user/Code/cargo-raze/impl)`
versions that meet the requirements `=1.3.9` are: 1.3.9

all possible versions conflict with previously selected packages.

  previously selected package `regex v1.4.1`
    ... which is depended on by `cargo-clone-crate v0.1.4`
    ... which is depended on by `cargo-raze v0.6.1 (/Users/user/Code/cargo-raze/impl)`

I feel like futures-rs messed up by making that update a patch version change only but alas, It would be great to have this fixed.

httpmock % cargo test

   Compiling httpmock v0.5.1-alpha.0 (/Users/user/Code/httpmock)
error[E0433]: failed to resolve: could not find `core_reexport` in `futures_util`
   --> src/lib.rs:202:19
    |
202 | use futures_util::core_reexport::time::Duration;
    |                   ^^^^^^^^^^^^^ could not find `core_reexport` in `futures_util`

error[E0433]: failed to resolve: could not find `core_reexport` in `futures_util`
   --> src/lib.rs:202:19
    |
202 | use futures_util::core_reexport::time::Duration;
    |                   ^^^^^^^^^^^^^ could not find `core_reexport` in `futures_util`

error[E0412]: cannot find type `Duration` in this scope
    --> src/lib.rs:1407:26
     |
1407 |     pub fn delay<D: Into<Duration>>(self, duration: D) -> Self {
     |                          ^^^^^^^^ not found in this scope
     |
help: consider importing one of these items
     |
196  | use core::time::Duration;
     |
196  | use crate::data::Duration;
     |
196  | use std::time::Duration;
     |
196  | use tokio::time::Duration;
     |

error[E0412]: cannot find type `Duration` in this scope
    --> src/lib.rs:1407:26
     |
1407 |     pub fn delay<D: Into<Duration>>(self, duration: D) -> Self {
     |                          ^^^^^^^^ not found in this scope
     |
help: consider importing one of these items
     |
196  | use core::time::Duration;
     |
196  | use crate::data::Duration;
     |
196  | use std::time::Duration;
     |
196  | use tokio::time::Duration;
     |

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0412, E0433.
For more information about an error, try `rustc --explain E0412`.
error: could not compile `httpmock`.

To learn more, run the command again with --verbose.
warning: build failed, waiting for other jobs to finish...
error: aborting due to 2 previous errors

Some errors have detailed explanations: E0412, E0433.
For more information about an error, try `rustc --explain E0412`.
error: build failed

I also noticed a BUNCH of packages are out of date. Do you think it'd be possible to update them and as a check for any lingering uses of "deprecated" code?

This PR does a couple of things:

• Allow for keeping mocks after runs by setting the HTTPMOCK_KEEP_MOCKS variable
• Allow for serving all existing mocks by accessing __mocks/

I'm trying to use the library to test some code that uses a Google API. The endpoint will return a pagination token in each response until there are no more resources to fetch. I was trying to test some code to see if the pagination was working and came across this unexpected behavior. In my test, I have two mocks with the same path, but different query string parameters -- here is a simplified version.

#[test]
fn test_different_qs_responses() -> Result<(), Box<dyn std::error::Error>> {
    let server = MockServer::start();

    let mock_first = server.mock(|when, then| {
        when.method(GET)
            .path("/v1/mediaItems")
            .query_param("pageSize", "3");
        then.status(200)
            .header("Content-Type", "application/json")
            .json_body(json!({
                "mediaItems": [],
                "nextPageToken": "the_next_page"
                }));
    });

    let mock_last = server.mock(|when, then| {
        when.method(GET)
            .path("/v1/mediaItems")
            .query_param("pageSize", "3")
            .query_param("pageToken", "the_next_page");
        then.status(200)
            .header("Content-Type", "application/json")
            .json_body(json!({
                "mediaItems": [],
                }));
    });

    let client = reqwest::blocking::Client::new();
    let mut query = vec![("pageSize", "3")];
    
    // first
    client.get(&server.url("/v1/mediaItems"))
          .query(&query)
          .send()?;
    
    query.push(("pageToken", "the_next_page"));

    // last
    client.get(&server.url("/v1/mediaItems"))
    .query(&query)
    .send()?;
    
    mock_first.assert();
    mock_last.assert();
    Ok(())
}

I'd expect mock_first to match the first request and mock_last to match the last since the query parameters specified in the match and in each request are different, but that doesn't appear to be the case. When I run the code I get this error:

thread 'test_different_qs_responses' panicked at 'assertion failed: `(left == right)`
  left: `2`,
 right: `1`: The number of matching requests was higher than expected (expected 1 but was 2)', C:\Users\likar\.cargo\registry\src\github.com-1ecc6299db9ec823\httpmock-0.6.5\src\api\mock.rs:207:13

Do I have a misunderstanding of how multiple mocks can be used or is this a bug in how mocks match requests?

Hi, first of all, thanks for the great library. We found an issue with query_param. According to the documentation, it's not necessary to encode the query value.

Sets a query parameter that needs to be provided. Attention!: The request query keys and values are implicitly allowed, but is not required to be urlencoded! The value you pass here, however, must be in plain text (i.e. not encoded)!

In order to match, we need to replace spaces with +. I'd expect that this library can handle it for me so I don't need to care about encoding internals.

Reference: https://url.spec.whatwg.org/#url-parsing (spaceAsPlus)

let m = server.mock(|when, then|{
    when.query_param("query", "Metallica is cool".replace(" ", "+"));
    then.status(200);
});

let req = hyper::Request::builder()
    .method(Method::GET)
    .uri(
        Url::parse_with_params(
            "http://example.com/",
            &[
                ("query", "Metallica is cool")
            ],
        )
        .unwrap()
        .to_string(),
    )
    .header("content-type", "application/json")
    .body(Body::empty())
    .unwrap();

I've done very little investigation here so I don't know the scope of this request but it'd be nice to update the version of tokio used here to help shrink my build graph. Hopefully this is as easy as changing the number 😅

Hi, I want to be able to test a function that does not have the server's url as one of it's arguments. For example - if I have a function like eval_code(code: String) which uses (directly or through yet another function) e.g reqwests POST requests in its body, and let's say the requests are being sent to https://example.com/endpoint - then I want to be able to redirect those requests to the mock server in my tests, automatically. So theoretically what I want to have is define a mock server on some real address - and then, each time a request/response is being sent to/from that address it will automatically be redirected to my mock server, allowing me to test the functions that interact with that address. I hope my explanation was clear enough, and maybe that's even possible right now - I just couldn't find a way to do it.

I was wondering whether it is currently possible to simulate a MockServer being unreachable so client functionality that deals with such issues can be tested.

I can kind of replicate this by just starting the server whenever I'd like it to be reachable, but stopping it and starting it again using the same address / port is what seems tricky.

I've noticed something missing that would be, IMHO, pretty useful for testing external clients agains mocked servers.

That's sharing variables between requests and responses. For instance, let's say we have a client posting some JSON data to a server, and the server may reply based on that data. The when clause should be able to expose the request data so the then clase can read it and act accordingly.

With my team we are evaluating httpmock; it really looks like a great project. Anyway, our test compile-time increased substantially due to its number of dependencies. Would it maybe be possible to reduce the dependencies using cargo features? For example, I guess isahc and some other "client-side" libraries are used only with a remote server; could they be made optional and enabled with a remote feature?

Error and/or Documentation Error and/or Relative Path Handling Error

I was using a relative path for the fn call directly per doc example for Then::body_from_file

But environment variable not found error popped up instead:

Cannot create absolute path from string 'x':  "environment variable not found"

I tried to look whether the doc said much about environment variables but nothing to evaluate.

However Looking into I can find the call to crate::util::get_test_resource_file_path() when path.is_absolute is false:

match env::var("CARGO_MANIFEST_DIR") {

Problem is this env may not be visible to cargo sub-commands as I found the hard way with tarpaulin:

env RUN_MODE=development cargo +nightly tarpaulin --run-types Tests,Doctests,Benchmarks,Examples,Lib,Bins -v

• Works okay with cargo test but tarpaulin sub-command seems to omit that environment variable.
• Omitting the env seems to be the case with cargo sub-command.
• Cargo documentation only lists one env passed down without explicitly ruling out others.

Doc wise Mock::return_body_from_file says explicitly either relative/absolute:

resource_file_path - The file path to the file with the response body content. The file path can either be absolute or relative to the project root directory.

As for relative path definition, I would expect this to be the OsStr<> from the Current working directory (CWD) which may be set to be elsewhere than the directory holding the cargo manifest.

For backwards compatibility the document probably should say that the environment variable is used for relative path or behavior could be changed some way to rely on CWD that would break things relying on it to be the manifest path

Plus CWD typically is not UTF-8 guaranteed path if Into is relied (not absolutely sure whether CARGO_MANIFEST_DIR is guaranteed to be either for lossless conversion Into either if it's allowed to be non UTF-8 :1234: ?)

I personally use this pattern and document the var_os OssStr returning environment variable use for my app:

  let mut path_locator = match env::var_os("APP_CONFIG_PATH") {
      Some(val) => PathBuf::from(val),
      None => env::current_dir().unwrap()
};

If I feel I need to enforce UTF-8 paths like Rust ecosystem like cargo does I use camino Utf8Path to see if I can upgrade from Path and match appropriate error.

Happy to submit a PR to fix doc and automatically check the truth whatever is decided when/if there is a decision what to do with this.

Code Blocks Involved

Then::body_from_file(httpmock/0.5.8/source/src/lib.rs)

pub fn body_from_file<S: Into<String>>(self, body: S) -> Self {
        self.mock.set(self.mock.take().return_body_from_file(body));

Mock::return_body_from_file(httpmock/0.5.8/source/src/api/mock.rs):around 1317

 pub fn return_body_from_file<S: Into<String>>(mut self, resource_file_path: S) -> Self {
        let resource_file_path = resource_file_path.into();
        let path = Path::new(&resource_file_path);
        let absolute_path = match path.is_absolute() {
            true => path.to_path_buf(),
            false => get_test_resource_file_path(&resource_file_path).expect(&format!(
                "Cannot create absolute path from string '{}'",
     //--snip--

Dilemma

• Documentation advertises/promises both the relative and absolute path use
• Relative path is implicitly derived from documentation as current working directory (CWD)
• If relative path is used CARGO_MANIFEST_DIR is used as base path which may or may not be lossless Into
• Cargo may or may not pass this env down to sub-command
• std::String is always UTF-8
• std::ffi::OsString implements Into String type but is lossy and breaks relative path guarantee
• OsString and Path is supposed to work everywhere safely abstracting it
• Environmental variable etc. can be non-UTF8 and requires appropriate handling boilerplate before it hits Then::body_from_file
• Lossy conversion is due to POSIX filenames allowing anything except \0
• Requires conversion to String for the whole path (if I read the code right:ok_woman:)
• String/std::path::Path conversion has been always a pain
• Many OS allows wide array of bytes in OsStr

Solution 1: Allow From &std::path::Path without using CARGO env

Pros:

• Straightforward pattern is to pass std::path::Path directly e.g. with config::from
• Allows relative path handling at ease over "somebody else handles it" abstraction
• Library already uses std::Path internally despite Into String
• Library using this can handle easily cross-platform TEST_DATA path which may contain "" or "/" path separators etc.
• The world is not perfect problem is easier - less friction to use the library esp re: relative path
• Documentation is the source of truth, though implicit Type impl loses (String is only UTF-8)
• Doesn't rely on cargo env

Cons:

• Rust configured paths are UTF-8
• Lossy Display/Debug
• Either confusing implementation if String is still allowed
• Libs using may/will break if on same method - needs new method
• Current working directory derived from var_os needs to be used instead of CARGO env

Example is using config::File::from

impl<'a> From<&'a Path> for File<source::file::FileSourceFile> {
    fn from(path: &'a Path) -> Self {
        File {
            source: source::file::FileSourceFile::new(path.to_path_buf()),
            //--snip--

Where I can easily construct and pass the full Path natively and use relative path if I want

let mut path_locator = match env::var_os("CONFIG_PATH") {
  Some(val) => PathBuf::from(val),
  None => env::current_dir().unwrap()
};

path_locator.push("subdir");

// And then finally merge the file I want with full POSIX compatible Path

s.merge(File::from(path_locator.join("default")).required(false))?;

Solution 2: Enforce and be explicit about UTF-8 and handle Error thru camino

Pros:

• Proper taint check and error
• Lossless Display/Debug
• Less friction for anyone who uses the library as it's checked for validity
• Does not need new method as it was always UTF-8
• Document implicit Type impl wins to some degree (String is only UTF-8 and we are just enforcing that)

Cons:

• Relative path use is a pattern sadly good or bad.
• Friction for anyone who uses the library
• Library using this have to handle cross platform paths for TEST_DATA path which may contain "" or "/" path separators etc.
• Adds camino crate that handles sanity on Utf8Paths
• Documentation which advertised flexibility between relative/absolute loses

Solution 3: New fn pass by Buffer/Stream/Channel oneshot etc.

Pros:

• Many async libs just wait-read the whole buffer internally and then process/pass the whole of it
• Would allow timing and replaying a server behaviour in timeline basis for writing into kernel buffer out
• Implementation could say replay sequence from libpcap file the near timing packets were either sent/recvd
• Could differentiate between Content-Length, gzip stream, chunked modes
• WebSocket etc. streaming
• Can serve as building block for HTTP/2 or gRPC/Protobuffers
• More fun than simple singular delay :)

Cons:

• Library using this have to handle cross platform paths for TEST_DATA path which may contain "" or "/" path separators etc.
• Library was never intended for buffer/stream handling?
• Complexity

Solution 4: Status quo

Pros:

• Supposed to have less burden for library

Cons:

• Friction to use the library
• Library using this have to handle cross platform paths for TEST_DATA path which may contain "" or "/" path separators etc.
• Misleading error (library is not using environment variable, the full path is passed to it)
• Still using lossy Display/Debug as it is using Path internally

Solution is probably somekind combination?

I usually do both integration / units along my /// docs or even on README.md that gets included in test run and tarpaulin --run-types DocTests takes those into account

#[cfg(doctest)]
doc_comment::doctest!("../README.md");

I will check with tarpaulin too to expose the environment var but it would be nice to get some clarity as it caused a bit confusion initially for me and not sure if there is anyone doing things without cargo env :)

• pinkforest(she/her/hers)

I would like to assert that my HTTP request body is empty or that a certain header doesn't exist. Is this something that httpmock supports at the moment?

Currently, I can see there the following functions exist:

• header_exists()
• query_params_exists()
• cookie_exists()

It would be nice if an opposite version of them existed plus one for checking if the body is empty.