use std::net::TcpStream;
use wiremock::matchers::{method, PathExactMatcher};
use wiremock::{Mock, MockServer, ResponseTemplate};
#[async_std::test]
async fn new_starts_the_server() {
let mock_server = MockServer::start().await;
assert!(TcpStream::connect(&mock_server.address()).is_ok())
}
#[async_std::test]
async fn returns_404_if_nothing_matches() {
let mock_server = MockServer::start().await;
let status = surf::get(&mock_server.uri()).await.unwrap().status();
assert_eq!(status, 404);
}
#[async_std::test]
#[should_panic]
async fn panics_if_the_expectation_is_not_satisfied() {
let mock_server = MockServer::start().await;
let response = ResponseTemplate::new(200);
Mock::given(method("GET"))
.respond_with(response)
.expect(1..)
.named("panics_if_the_expectation_is_not_satisfied expectation failed")
.mount(&mock_server)
.await;
}
#[async_std::test]
#[should_panic(expected = "Verifications failed:
- Mock #0.
\tExpected range of matching incoming requests: 1 <= x
\tNumber of matched incoming requests: 0
The server did not receive any request.")]
async fn no_received_request_line_is_printed_in_the_panic_message_if_expectations_are_not_verified()
{
let mock_server = MockServer::start().await;
let response = ResponseTemplate::new(200);
Mock::given(method("GET"))
.respond_with(response)
.expect(1..)
.mount(&mock_server)
.await;
}
#[async_std::test]
#[should_panic(expected = "Verifications failed:
- Mock #0.
\tExpected range of matching incoming requests: 1 <= x
\tNumber of matched incoming requests: 0
Received requests:
- Request #1
\tGET http://localhost/")]
async fn received_request_are_printed_as_panic_message_if_expectations_are_not_verified() {
let mock_server = MockServer::start().await;
let response = ResponseTemplate::new(200);
Mock::given(method("POST"))
.respond_with(response)
.expect(1..)
.mount(&mock_server)
.await;
surf::get(&mock_server.uri()).await.unwrap();
}
#[async_std::test]
#[should_panic]
async fn panic_during_expectation_does_not_crash() {
let mock_server = MockServer::start().await;
let response = ResponseTemplate::new(200);
Mock::given(method("GET"))
.respond_with(response)
.expect(1..)
.named("panic_during_expectation_does_not_crash expectation failed")
.mount(&mock_server)
.await;
assert!(false);
}
#[async_std::test]
async fn simple_route_mock() {
let mock_server = MockServer::start().await;
let response = ResponseTemplate::new(200).set_body_bytes("world");
let mock = Mock::given(method("GET"))
.and(PathExactMatcher::new("hello"))
.respond_with(response);
mock_server.register(mock).await;
let mut response = surf::get(format!("{}/hello", &mock_server.uri()))
.await
.unwrap();
assert_eq!(response.status(), 200);
assert_eq!(response.body_string().await.unwrap(), "world");
}
#[async_std::test]
async fn two_route_mocks() {
let mock_server = MockServer::start().await;
let response = ResponseTemplate::new(200).set_body_bytes("aaa");
Mock::given(method("GET"))
.and(PathExactMatcher::new("first"))
.respond_with(response)
.named("/first")
.mount(&mock_server)
.await;
let response = ResponseTemplate::new(200).set_body_bytes("bbb");
Mock::given(method("GET"))
.and(PathExactMatcher::new("second"))
.respond_with(response)
.named("/second")
.mount(&mock_server)
.await;
let mut first_response = surf::get(format!("{}/first", &mock_server.uri()))
.await
.unwrap();
let mut second_response = surf::get(format!("{}/second", &mock_server.uri()))
.await
.unwrap();
assert_eq!(first_response.status(), 200);
assert_eq!(second_response.status(), 200);
assert_eq!(first_response.body_string().await.unwrap(), "aaa");
assert_eq!(second_response.body_string().await.unwrap(), "bbb");
}