Struct http_test_server::resource::Resource
source · pub struct Resource { /* private fields */ }
Expand description
Responsible for configuring a resource and interacting with it.
Must be created through TestServer
.
By default a resource’s method is GET
and response is 200 Ok
with empty body.
use http_test_server::TestServer;
use http_test_server::http::{Method, Status};
let server = TestServer::new().unwrap();
let resource = server.create_resource("/i-am-a-resource");
resource
.status(Status::PartialContent)
.method(Method::POST)
.body("All good!");
To create resources with variable parts in the URL, you may use path and query parameters:
// matches /user/*/details?filter=*
let resource = server.create_resource("/user/{userId}/details?filter=*");
resource.body("All good for {path.userId} with filter {query.filter}!");
Note: I don’t think it’s a good idea to write mocks with complex behaviours. Usually, they are less maintainable and harder to track.
Instead, I would suggest creating one resource for each behaviour expected. Having said that, I’m not here to judge. Do whatever floats your boat! :)
Implementations§
source§impl Resource
impl Resource
sourcepub fn status(&self, status_code: Status) -> &Resource
pub fn status(&self, status_code: Status) -> &Resource
Defines response’s HTTP Status .
Refer to custom_status
for Statuses not covered by Status
.
resource.status(Status::PartialContent);
sourcepub fn custom_status(&self, status_code: u16, description: &str) -> &Resource
pub fn custom_status(&self, status_code: u16, description: &str) -> &Resource
Defines a custom HTTP Status to response.
Use it to return HTTP statuses that are not covered by Status
.
resource.custom_status(333, "Only Half Beast");
sourcepub fn header(&self, header_name: &str, header_value: &str) -> &Resource
pub fn header(&self, header_name: &str, header_value: &str) -> &Resource
Defines response headers.
Call it multiple times to add multiple headers. If a header is defined twice only the late value is returned.
resource
.header("Content-Type", "application/json")
.header("Connection", "Keep-Alive");
sourcepub fn query(&self, name: &str, value: &str) -> &Resource
pub fn query(&self, name: &str, value: &str) -> &Resource
Defines query parameters.
resource
.query("filter", "*") // wildcard, matches any value
.query("version", "1"); // only matches request with version == 1
This is equivalent to:
let resource = server.create_resource("/?filter=*&version=1");
sourcepub fn body(&self, content: &'static str) -> &Resource
pub fn body(&self, content: &'static str) -> &Resource
Defines response’s body.
If the response is a stream this value will be sent straight after connection.
Calling multiple times will overwrite the previous value.
resource.body("this is important!");
It’s possible to use path and query parameters in the response body by defining {path.<parameter_name>}
or {query.<parameter_name>}
:
let resource = server.create_resource("/user/{userId}?filter=*");
resource.body("Response for user: {path.userId} filter: {query.filter}");
sourcepub fn body_fn(
&self,
builder: impl Fn(RequestParameters) -> String + Send + 'static
) -> &Resource
pub fn body_fn( &self, builder: impl Fn(RequestParameters) -> String + Send + 'static ) -> &Resource
Defines function used to build the response’s body.
If the response is a stream value will be sent straight after connection.
Calling multiple times will overwrite the previous value.
let resource = server.create_resource("/character/{id}?version=*");
resource.body_fn(|params| {
println!("version: {}", params.query.get("version").unwrap());
match params.path.get("id").unwrap().as_str() {
"Balrog" => r#"{ "message": "YOU SHALL NOT PASS!" }"#.to_string(),
_ => r#"{ "message": "Fly, you fools!" }"#.to_string()
}
});
sourcepub fn method(&self, method: Method) -> &Resource
pub fn method(&self, method: Method) -> &Resource
Defines HTTP method.
A resource will only respond to one method, however multiple resources with same URL and different methods can be created.
use http_test_server::http::Method;
let resource_put = server.create_resource("/i-am-a-resource");
let resource_post = server.create_resource("/i-am-a-resource");
resource_put.method(Method::PUT);
resource_post.method(Method::POST);
sourcepub fn delay(&self, delay: Duration) -> &Resource
pub fn delay(&self, delay: Duration) -> &Resource
Defines delay to response after client connected
use std::time::Duration;
resource.delay(Duration::from_millis(500));
sourcepub fn stream(&self) -> &Resource
pub fn stream(&self) -> &Resource
Set response as stream, this means clients won’t be disconnected after body is sent and updates can be sent and received.
See also: send
, send_line
, stream_receiver
.
let resource = server.create_resource("/stream");
resource.stream();
resource
.send_line("some")
.send_line("data")
.close_open_connections();
sourcepub fn close_open_connections(&self)
pub fn close_open_connections(&self)
Close all connections with clients.
See also: stream
let resource = server.create_resource("/stream");
resource.stream();
resource.close_open_connections();
sourcepub fn open_connections_count(&self) -> usize
pub fn open_connections_count(&self) -> usize
Number of clients connected to stream.
See also: stream
let resource = server.create_resource("/stream");
resource
.stream()
.close_open_connections();
assert_eq!(resource.open_connections_count(), 0);
sourcepub fn stream_receiver(&self) -> Receiver<String>
pub fn stream_receiver(&self) -> Receiver<String>
Receives data sent from clients through stream.
See also: stream
let resource = server.create_resource("/stream");
let receiver = resource.stream().stream_receiver();
let new_message = receiver.recv().unwrap();
for message in receiver.iter() {
println!("Client message: {}", message);
}
sourcepub fn request_count(&self) -> u32
pub fn request_count(&self) -> u32
Number of requests received
assert_eq!(resource.request_count(), 0);