Skip to content

Commit 947916d

Browse files
yoshuawuytsyoshuawuyts
authored
Merge pull request #434 from http-rs/pr/414
fix tests
2 parents 0fbff90 + b83acfb commit 947916d

File tree

3 files changed

+72
-55
lines changed

3 files changed

+72
-55
lines changed

‎Cargo.toml

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -24,15 +24,14 @@ rustdoc-args = ["--cfg", "feature=\"docs\""]
2424

2525
[features]
2626
default = ["h1-server"]
27-
hyper-server = ["futures", "hyper", "http", "tokio"]
2827
h1-server = ["http-service-h1"]
2928
docs = ["unstable"]
3029
unstable = []
3130

3231
[dependencies]
3332
http-types = "1.0.1"
34-
http-service = { git = "https://github.com/dignifiedquire/http-service-1", branch = "h1" }
35-
http-service-h1 = { git = "https://github.com/dignifiedquire/http-service-1", branch = "h1", optional = true }
33+
http-service = "0.5.0"
34+
http-service-h1 = { version = "0.1.0", optional = true }
3635
log = "0.4.8"
3736
route-recognizer = "0.1.13"
3837
serde = "1.0.102"
@@ -54,14 +53,14 @@ basic-cookies = "0.1.3"
5453
bytes = "0.4.12"
5554
futures-fs = "0.0.5"
5655
futures-util = { version = "0.3.0", features = ["compat"] }
57-
http-service-mock = { git = "https://github.com/dignifiedquire/http-service-1", branch = "h1" }
56+
http-service-mock = "0.5.0"
5857
juniper = "0.14.1"
5958
mime = "0.3.14"
6059
mime_guess = "2.0.1"
6160
percent-encoding = "2.1.0"
6261
serde = { version = "1.0.102", features = ["derive"] }
6362
structopt = "0.3.3"
64-
surf = { git = "https://github.com/dignifiedquire/surf-1", branch = "h1" }
63+
surf = "2.0.0-alpha.1"
6564
futures = "0.3.1"
6665

6766
[[test]]

‎examples/chunked.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,15 @@
11
use async_std::fs;
22
use async_std::io::BufReader;
33
use async_std::task;
4+
use http_types::StatusCode;
45
use tide::Response;
56

67
fn main() -> Result<(), std::io::Error> {
78
task::block_on(async {
89
let mut app = tide::new();
910
app.at("/").get(|_| async move {
1011
let file = fs::File::open(file!()).await.unwrap();
11-
let res = Response::new(200).body(BufReader::new(file));
12+
let res = Response::new(StatusCode::Ok).body(BufReader::new(file));
1213
res
1314
});
1415
app.listen("127.0.0.1:8080").await?;

‎tests/nested.rs

Lines changed: 66 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
1-
use async_std::io::prelude::*;
2-
use futures::executor::block_on;
31
use futures::future::BoxFuture;
4-
use http_service::Body;
52
use http_service_mock::make_server;
3+
use http_types::headers::{HeaderName, HeaderValue};
4+
use http_types::{Method, Request, Url};
5+
use std::str::FromStr;
66

7-
#[test]
8-
fn nested() {
7+
#[async_std::test]
8+
async fn nested() {
99
let mut inner = tide::new();
1010
inner.at("/foo").get(|_| async { "foo" });
1111
inner.at("/bar").get(|_| async { "bar" });
@@ -16,31 +16,36 @@ fn nested() {
1616

1717
let mut server = make_server(outer.into_http_service()).unwrap();
1818

19-
let mut buf = Vec::new();
20-
let req = http::Request::get("/foo/foo").body(Body::empty()).unwrap();
19+
let req = Request::new(
20+
Method::Get,
21+
Url::parse("http://example.com/foo/foo").unwrap(),
22+
);
2123
let res = server.simulate(req).unwrap();
2224
assert_eq!(res.status(), 200);
23-
block_on(res.into_body().read_to_end(&mut buf)).unwrap();
24-
assert_eq!(&*buf, &*b"foo");
25+
assert_eq!(res.body_string().await.unwrap(), "foo");
2526

26-
buf.clear();
27-
let req = http::Request::get("/foo/bar").body(Body::empty()).unwrap();
27+
let req = Request::new(
28+
Method::Get,
29+
Url::parse("http://example.com/foo/bar").unwrap(),
30+
);
2831
let res = server.simulate(req).unwrap();
2932
assert_eq!(res.status(), 200);
30-
block_on(res.into_body().read_to_end(&mut buf)).unwrap();
31-
assert_eq!(&*buf, &*b"bar");
33+
assert_eq!(res.body_string().await.unwrap(), "bar");
3234
}
3335

34-
#[test]
35-
fn nested_middleware() {
36+
#[async_std::test]
37+
async fn nested_middleware() {
3638
let echo_path = |req: tide::Request<()>| async move { req.uri().path().to_string() };
3739
fn test_middleware(
3840
req: tide::Request<()>,
3941
next: tide::Next<'_, ()>,
4042
) -> BoxFuture<'_, tide::Response> {
4143
Box::pin(async move {
4244
let res = next.run(req).await;
43-
res.set_header("X-Tide-Test", "1")
45+
res.set_header(
46+
HeaderName::from_ascii("X-Tide-Test".to_owned().into_bytes()).unwrap(),
47+
"1",
48+
)
4449
})
4550
}
4651

@@ -56,41 +61,33 @@ fn nested_middleware() {
5661

5762
let mut server = make_server(app.into_http_service()).unwrap();
5863

59-
let mut buf = Vec::new();
60-
let req = http::Request::get("/foo/echo").body(Body::empty()).unwrap();
61-
let res = server.simulate(req).unwrap();
62-
assert_eq!(
63-
res.headers().get("X-Tide-Test"),
64-
Some(&"1".parse().unwrap())
64+
let req = Request::new(
65+
Method::Get,
66+
Url::parse("http://example.com/foo/echo").unwrap(),
6567
);
68+
let res = server.simulate(req).unwrap();
69+
assert_header(&res, "X-Tide-Test", Some("1"));
6670
assert_eq!(res.status(), 200);
67-
block_on(res.into_body().read_to_end(&mut buf)).unwrap();
68-
assert_eq!(&*buf, &*b"/echo");
71+
assert_eq!(res.body_string().await.unwrap(), "/echo");
6972

70-
buf.clear();
71-
let req = http::Request::get("/foo/x/bar")
72-
.body(Body::empty())
73-
.unwrap();
74-
let res = server.simulate(req).unwrap();
75-
assert_eq!(
76-
res.headers().get("X-Tide-Test"),
77-
Some(&"1".parse().unwrap())
73+
let req = Request::new(
74+
Method::Get,
75+
Url::parse("http://example.com/foo/x/bar").unwrap(),
7876
);
77+
let res = server.simulate(req).unwrap();
78+
assert_header(&res, "X-Tide-Test", Some("1"));
7979
assert_eq!(res.status(), 200);
80-
block_on(res.into_body().read_to_end(&mut buf)).unwrap();
81-
assert_eq!(&*buf, &*b"/");
80+
assert_eq!(res.body_string().await.unwrap(), "/");
8281

83-
buf.clear();
84-
let req = http::Request::get("/bar").body(Body::empty()).unwrap();
82+
let req = Request::new(Method::Get, Url::parse("http://example.com/bar").unwrap());
8583
let res = server.simulate(req).unwrap();
86-
assert_eq!(res.headers().get("X-Tide-Test"), None);
84+
assert_header(&res, "X-Tide-Test", None);
8785
assert_eq!(res.status(), 200);
88-
block_on(res.into_body().read_to_end(&mut buf)).unwrap();
89-
assert_eq!(&*buf, &*b"/bar");
86+
assert_eq!(res.body_string().await.unwrap(), "/bar");
9087
}
9188

92-
#[test]
93-
fn nested_with_different_state() {
89+
#[async_std::test]
90+
async fn nested_with_different_state() {
9491
let mut outer = tide::new();
9592
let mut inner = tide::with_state(42);
9693
inner.at("/").get(|req: tide::Request<i32>| async move {
@@ -102,17 +99,37 @@ fn nested_with_different_state() {
10299

103100
let mut server = make_server(outer.into_http_service()).unwrap();
104101

105-
let mut buf = Vec::new();
106-
let req = http::Request::get("/foo").body(Body::empty()).unwrap();
102+
let req = Request::new(Method::Get, Url::parse("http://example.com/foo").unwrap());
107103
let res = server.simulate(req).unwrap();
108104
assert_eq!(res.status(), 200);
109-
block_on(res.into_body().read_to_end(&mut buf)).unwrap();
110-
assert_eq!(&*buf, &*b"the number is 42");
105+
assert_eq!(res.body_string().await.unwrap(), "the number is 42");
111106

112-
buf.clear();
113-
let req = http::Request::get("/").body(Body::empty()).unwrap();
107+
let req = Request::new(Method::Get, Url::parse("http://example.com/").unwrap());
114108
let res = server.simulate(req).unwrap();
115109
assert_eq!(res.status(), 200);
116-
block_on(res.into_body().read_to_end(&mut buf)).unwrap();
117-
assert_eq!(&*buf, &*b"Hello, world!");
110+
assert_eq!(res.body_string().await.unwrap(), "Hello, world!");
111+
}
112+
113+
// See https://github.com/http-rs/http-types/issues/89 for a proposed fix to this boilerplate.
114+
fn assert_header(headers: impl AsRef<http_types::Headers>, lhs: &str, rhs: Option<&str>) {
115+
match rhs {
116+
Some(s) => {
117+
let header = headers
118+
.as_ref()
119+
.get(
120+
&http_types::headers::HeaderName::from_ascii(lhs.to_owned().into_bytes())
121+
.unwrap(),
122+
)
123+
.unwrap()
124+
.iter()
125+
.next();
126+
assert_eq!(header, Some(&HeaderValue::from_str(s).unwrap()));
127+
}
128+
None => {
129+
let header = headers.as_ref().get(
130+
&http_types::headers::HeaderName::from_ascii(lhs.to_owned().into_bytes()).unwrap(),
131+
);
132+
assert_eq!(header, None);
133+
}
134+
}
118135
}

0 commit comments

Comments
 (0)