1.0.1

• Fixed an issue where futures::future::join_all would block the server pool.
• Server::reset_async has been deprecated in favour of Server::reset since the former doesn't have an async implementation any more.

1.0.0

🎈 7 years and 63 releases later, it's finally time for the 1.0 🎈

Changes

• [Breaking] The legacy interface was removed in this version
• [Breaking] Mock::with_body_from_fn was renamed to Mock::with_chunked_body - the former is still supported with a deprecation warning
• Mocks are only cleared when the server is dropped, not when the mock is dropped - this means you don't have to assign mocks to variables any more (unless you want to call other methods on them)
• Introduced the Mock::remove and Mock::remove_async methods to remove mocks on demand

Major changes since 0.31

• Tests can now run in parallel
• Support for HTTP2
• An async interface for all actions (though the sync interface is also available)
• Mock multiple server/hosts at the same time

For a list of all the changes please check the release log.

Migrating to the new API

Legacy API:

let m1 = mockito::mock("GET", "/hello").with_body("hello").create();
let m2 = mockito::mock("GET", "/bye").with_body("bye").create();

// Use one of these to configure your client
let host = mockito:server_address();
let url = mockito::server_url();

New API:

let mut server = mockito::Server::new();
server.mock("GET", "/hello").with_body("hello").create();
server.mock("GET", "/bye").with_body("bye").create();

// Use one of these to configure your client
let host = server.host_with_port();
let url = server.url();

If you can't migrate to the new API in one go, consider using version 0.32.5, which supports both the legacy API as well as the new API.

Migrating to the async API

In order to write async tests, you'll need to use the _async methods:

• Server::new_async
• Mock::create_async
• Mock::assert_async
• Mock::matched_async
• Mock::remove_async
• Server::reset_async

...otherwise your tests will not compile and you'll see this error:

Cannot block the current thread from within a runtime. This happens because a function attempted 
to block the current thread while the thread is being used to drive asynchronous tasks.

Example:

#[tokio::test]
async fn test_simple_route_mock_async() {
    let mut server = Server::new_async().await;
    let m1 = server.mock("GET", "/a").with_body("aaa").create_async().await;
    let m2 = server.mock("GET", "/b").with_body("bbb").create_async().await;

    let (m1, m2) = futures::join!(m1, m2);

    // You can use `Mock::assert_async` to verify that your mock was called
    // m1.assert_async().await;
    // m2.assert_async().await;
}

0.32.5

• Implement and enable a new server pool and get rid of the deadpool dependency
• Replace the mpsc mock/server communication with Arc (more reliable in this case)
• Split sync & async paths more clearly

0.32.4

• Introduce Mock::with_body_from_request which allows setting the response body dynamically, based on the Request object
• Small performance improvement: replace the state Mutex with an RwLock
• Small fixes to the documentation (thanks @konstin)

0.32.3

• Various fixes addressing hanging/flickering tests
• Server::new and Server::new_async now return a ServerGuard object which dereferences to Server - this is only relevant if you need to assign a type to your server
• The server pool has been disabled and will be brought back in a future release

0.32.2

• Prevent the Mock destructor from hanging in some cases
• Updates to the docs, clarifying the usage of _async methods

0.32.0

This is a major re-write, introducing a bunch of long awaited features:

• [Breaking] The minimum supported Rust version was bumped to 1.65.0

• Tests can now run in parallel as long as you use the new mockito::Server API:

  let mut server = mockito::Server::new();
  let mock = server.mock("GET", "/").with_body("test").create();
  
  // Use one of these to configure your client
  let host = server.host_with_port();
  let url = server.url();

• You can run multiple servers/hosts at the same time:

  let mut twitter = mockito::Server::new();
  let twitter_mock = server.mock("GET", "/api").with_body("tweet").create();
  let twitter_host = twitter.host_with_port();
  
  let mut github = mockito::Server::new();
  let github_mock = server.mock("GET", "/api").with_body("repo").create();
  let github_host = github.host_with_port();

• Support for HTTP2

• An async interface for all actions (though the sync interface is also available):

  let mut server = Server::new_async().await;
  let mock = s
      .mock("GET", "/hello")
      .with_body("world")
      .create_async()
      .await;
  
  mock.assert_async().await;

• The backend has been rewritten to use Hyper

This version will be backwards compatible with the previous version, but deprecation warnings have been introduced and you are encouraged to migrate, since the old API still requires running tests sequentially. Migrating to the new API is quite straighforward:

Migrating to the new API

Legacy API:

let m = mockito::mock("GET", "/").with_body("hello").create();

// Use one of these to configure your client
let host = mockito:server_address();
let url = mockito::server_url();

New API:

let mut server = mockito::Server::new();
let m = sever.mock("GET", "/").with_body("hello").create();

// Use one of these to configure your client
let host = server.host_with_port();
let url = server.url();

Migrating to the async API

In order to write async tests, you'll need to use the _async methods:

• Server::new_async
• Mock::create_async
• Mock::assert_async
• Mock::matched_async
• Server::reset_async

...otherwise your tests will not compile and you'll see this error: Cannot start a runtime from within a runtime.

When using tokio, prefer the single-threaded runtime over the multi-threaded one.

Example:

#[tokio::test]
async fn test_simple_route_mock_async() {
    let mut server = Server::new_async().await;
    let m1 = server.mock("GET", "/a").with_body("aaa").create_async().await;
    let m2 = server.mock("GET", "/b").with_body("bbb").create_async().await;

    let (m1, m2) = futures::join!(m1, m2);

    // You can use `Mock::assert_async` to verify that your mock was called
    // m1.assert_async().await;
    // m2.assert_async().await;
}

0.31.1

• Prevent tests from blocking endlessly when encountering HTTP parsing errors.

Thanks to @chantra

0.31.0

• Replaced the unmaintained difference crate with the similar crate.

Thanks to @ameliabradley

0.30.0

• Update the assert-json-diff dependency.

Thanks to @davidpdrsn