fire-http 0.5.0

Http async library based on hyper and tokio
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

#![allow(dead_code, unused_macros)]

use fire::Body;
use fire_http as fire;
use hyper_util::rt::TokioExecutor;
use types::body::BodyHttp;

use std::io;

macro_rules! spawn_server {
	(|$builder:ident| $block:block) => {{
		use std::net::{Ipv4Addr, SocketAddr};

		let socket_addr = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), 0);
		let mut $builder = fire::build(socket_addr).await.unwrap();
		let _ = $block;
		let fire = $builder.build().await.unwrap();
		let addr = fire.local_addr().unwrap();
		tokio::task::spawn(fire.ignite());

		addr
	}};
}

macro_rules! other_err {
	($e:expr) => {
		io::Error::new(io::ErrorKind::Other, $e)
	};
}

pub async fn send_request(
	req: hyper::Request<BodyHttp>,
) -> io::Result<hyper::Response<hyper::body::Incoming>> {
	let client =
		hyper_util::client::legacy::Client::builder(TokioExecutor::new())
			.build_http();

	client
		.request(req.map(Box::pin))
		.await
		.map_err(|e| other_err!(e))
}

macro_rules! make_request {
	(
		$method:expr, $srv_addr:expr, $uri:expr,
		|$builder:ident| $block:block
	) => {
		async {
			let addr = $srv_addr.to_string();
			let uri = format!("http://{addr}{}", $uri);
			let $builder = hyper::Request::builder()
				.method($method)
				.uri(uri)
				.header("host", &addr);
			let resp = util::send_request($block)
				.await
				.expect("failed to send request")
				.map(fire::Body::from_hyper);

			util::TestResponse::new(resp)
		}
	};
	($method:expr, $srv_addr:expr, $uri:expr, $body:expr) => {
		make_request!($method, $srv_addr, $uri, |builder| {
			builder
				.body(fire::Body::into_http_body($body.into()))
				.expect("could not build request")
		})
	};
	($method:expr, $srv_addr:expr, $uri:expr) => {
		make_request!($method, $srv_addr, $uri, fire::Body::new())
	};
}

#[derive(Debug)]
pub struct TestResponse {
	inner: hyper::Response<Body>,
}

impl TestResponse {
	pub fn new(inner: hyper::Response<Body>) -> Self {
		Self { inner }
	}

	#[track_caller]
	pub fn assert_status(self, other: u16) -> Self {
		assert_eq!(
			self.inner.status().as_u16(),
			other,
			"status code doens't match"
		);
		self
	}

	#[track_caller]
	pub fn assert_header(self, key: &str, value: impl AsRef<str>) -> Self {
		let v = self
			.inner
			.headers()
			.get(key)
			.expect(&format!("header with key {:?} not found", key))
			.to_str()
			.expect("header does not only contain visible ASCII chars");
		assert_eq!(v, value.as_ref(), "value does not match");
		self
	}

	#[track_caller]
	pub fn assert_not_header(self, key: &str) -> Self {
		if self.inner.headers().get(key).is_some() {
			panic!("expected no header named {}", key);
		}
		self
	}

	pub fn header(&self, key: &str) -> Option<&str> {
		self.inner.headers().get(key).and_then(|v| v.to_str().ok())
	}

	pub async fn assert_body_str(mut self, value: &str) -> Self {
		let body = self
			.inner
			.body_mut()
			.take()
			.into_string()
			.await
			.expect("could not convert response body to string");
		assert_eq!(body, value, "body does not match value");
		self
	}

	pub async fn assert_body_vec(mut self, value: &[u8]) -> Self {
		let body = self
			.inner
			.body_mut()
			.take()
			.into_bytes()
			.await
			.expect("could not convert response body to vec");
		assert_eq!(body, value, "body does not match value");
		self
	}
}