diff options
Diffstat (limited to 'components/net/tests/http_loader.rs')
| -rw-r--r-- | components/net/tests/http_loader.rs | 626 |
1 files changed, 279 insertions, 347 deletions
diff --git a/components/net/tests/http_loader.rs b/components/net/tests/http_loader.rs index 96c424469d1..4d327029ccd 100644 --- a/components/net/tests/http_loader.rs +++ b/components/net/tests/http_loader.rs @@ -10,16 +10,15 @@ use fetch; use fetch_with_context; use flate2::Compression; use flate2::write::{DeflateEncoder, GzEncoder}; -use hyper::LanguageTag; -use hyper::header::{Accept, AcceptEncoding, ContentEncoding, ContentLength, Cookie as CookieHeader}; -use hyper::header::{AcceptLanguage, AccessControlAllowOrigin, Authorization, Basic, Date}; -use hyper::header::{Encoding, Headers, Host, Location, Origin, Quality, QualityItem, SetCookie, qitem}; -use hyper::header::{StrictTransportSecurity, UserAgent}; -use hyper::method::Method; -use hyper::mime::{Mime, SubLevel, TopLevel}; -use hyper::server::{Request as HyperRequest, Response as HyperResponse}; -use hyper::status::StatusCode; -use hyper::uri::RequestUri; +use futures::{self, Future, Stream}; +use headers_core::HeaderMapExt; +use headers_ext::{Authorization, Basic, AccessControlAllowOrigin, ContentLength, Date, Host, Origin}; +use headers_ext::{StrictTransportSecurity, UserAgent}; +use http::{Method, StatusCode}; +use http::header::{self, HeaderMap, HeaderValue}; +use http::uri::Authority; +use hyper::{Request as HyperRequest, Response as HyperResponse}; +use hyper::body::Body; use make_server; use msg::constellation_msg::TEST_PIPELINE_ID; use net::cookie::Cookie; @@ -33,25 +32,21 @@ use new_fetch_context; use servo_channel::{channel, Receiver}; use servo_url::{ServoUrl, ImmutableOrigin}; use std::collections::HashMap; -use std::io::{Read, Write}; -use std::str::FromStr; +use std::io::Write; +use std::str; use std::sync::{Arc, Mutex, RwLock}; use std::sync::atomic::{AtomicBool, Ordering}; +use std::time::Duration; fn mock_origin() -> ImmutableOrigin { ServoUrl::parse("http://servo.org").unwrap().origin() } -fn read_response(reader: &mut Read) -> String { - let mut buf = vec![0; 1024]; - match reader.read(&mut buf) { - Ok(len) if len > 0 => { - unsafe { buf.set_len(len); } - String::from_utf8(buf).unwrap() - }, - Ok(_) => "".to_owned(), - Err(e) => panic!("problem reading response {}", e) - } +fn read_response(req: HyperRequest<Body>) -> impl Future<Item=String, Error=()> { + req.into_body() + .concat2() + .and_then(|body| futures::future::ok(str::from_utf8(&body).unwrap().to_owned())) + .map_err(|_| ()) } fn assert_cookie_for_domain(cookie_jar: &RwLock<CookieStorage>, domain: &str, cookie: Option<&str>) { @@ -97,90 +92,71 @@ pub fn expect_devtools_http_response(devtools_port: &Receiver<DevtoolsControlMsg fn test_check_default_headers_loaded_in_every_request() { let expected_headers = Arc::new(Mutex::new(None)); let expected_headers_clone = expected_headers.clone(); - let handler = move |request: HyperRequest, _: HyperResponse| { - assert_eq!(request.headers, expected_headers_clone.lock().unwrap().take().unwrap()); + let handler = move |request: HyperRequest<Body>, _: &mut HyperResponse<Body>| { + assert_eq!(request.headers().clone(), expected_headers_clone.lock().unwrap().take().unwrap()); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); - let mut headers = Headers::new(); + let mut headers = HeaderMap::new(); - headers.set(AcceptEncoding(vec![qitem(Encoding::Gzip), - qitem(Encoding::Deflate), - qitem(Encoding::EncodingExt("br".to_owned()))])); - - let hostname = match url.host_str() { - Some(hostname) => hostname.to_owned(), - _ => panic!() - }; + headers.insert(header::ACCEPT_ENCODING, HeaderValue::from_static("gzip, deflate, br")); - headers.set(Host { hostname: hostname, port: url.port() }); + headers.typed_insert( + Host::from(format!("{}:{}", url.host_str().unwrap(), url.port().unwrap()).parse::<Authority>().unwrap())); - let accept = Accept(vec![ - qitem(Mime(TopLevel::Text, SubLevel::Html, vec![])), - qitem(Mime(TopLevel::Application, SubLevel::Ext("xhtml+xml".to_owned()), vec![])), - QualityItem::new(Mime(TopLevel::Application, SubLevel::Xml, vec![]), Quality(900u16)), - QualityItem::new(Mime(TopLevel::Star, SubLevel::Star, vec![]), Quality(800u16)), - ]); - headers.set(accept); + headers.insert(header::ACCEPT, + HeaderValue::from_static("text/html, application/xhtml+xml, application/xml; q=0.9, */*; q=0.8")); - let mut en_us: LanguageTag = Default::default(); - en_us.language = Some("en".to_owned()); - en_us.region = Some("US".to_owned()); - let mut en: LanguageTag = Default::default(); - en.language = Some("en".to_owned()); - headers.set(AcceptLanguage(vec![ - qitem(en_us), - QualityItem::new(en, Quality(500)), - ])); + headers.insert(header::ACCEPT_LANGUAGE, HeaderValue::from_static("en-US, en; q=0.5")); - headers.set(UserAgent(::DEFAULT_USER_AGENT.to_owned())); + headers.typed_insert::<UserAgent>(::DEFAULT_USER_AGENT.parse().unwrap()); *expected_headers.lock().unwrap() = Some(headers.clone()); // Testing for method.GET let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, destination: Destination::Document, origin: url.clone().origin(), pipeline_id: Some(TEST_PIPELINE_ID), .. RequestInit::default() }); let response = fetch(&mut request, None); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); // Testing for method.POST let mut post_headers = headers.clone(); - post_headers.set(ContentLength(0 as u64)); + post_headers.typed_insert(ContentLength(0 as u64)); let url_str = url.as_str(); // request gets header "Origin: http://example.com" but expected_headers has // "Origin: http://example.com/" which do not match for equality so strip trailing '/' - post_headers.set(Origin::from_str(&url_str[..url_str.len()-1]).unwrap()); + post_headers.insert(header::ORIGIN, HeaderValue::from_str(&url_str[..url_str.len()-1]).unwrap()); *expected_headers.lock().unwrap() = Some(post_headers); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Post, + method: Method::POST, destination: Destination::Document, origin: url.clone().origin(), pipeline_id: Some(TEST_PIPELINE_ID), .. RequestInit::default() }); let response = fetch(&mut request, None); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); let _ = server.close(); } #[test] fn test_load_when_request_is_not_get_or_head_and_there_is_no_body_content_length_should_be_set_to_0() { - let handler = move |request: HyperRequest, _: HyperResponse| { - assert_eq!(request.headers.get::<ContentLength>(), Some(&ContentLength(0))); + let handler = move |request: HyperRequest<Body>, _: &mut HyperResponse<Body>| { + assert_eq!(request.headers().typed_get::<ContentLength>(), Some(ContentLength(0))); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Post, + method: Method::POST, body: None, destination: Destination::Document, origin: mock_origin(), @@ -188,24 +164,24 @@ fn test_load_when_request_is_not_get_or_head_and_there_is_no_body_content_length .. RequestInit::default() }); let response = fetch(&mut request, None); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); let _ = server.close(); } #[test] fn test_request_and_response_data_with_network_messages() { - let handler = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(Host { hostname: "foo.bar".to_owned(), port: None }); - response.send(b"Yay!").unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().typed_insert(Host::from("foo.bar".parse::<Authority>().unwrap())); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); - let mut request_headers = Headers::new(); - request_headers.set(Host { hostname: "bar.foo".to_owned(), port: None }); + let mut request_headers = HeaderMap::new(); + request_headers.typed_insert(Host::from("bar.foo".parse::<Authority>().unwrap())); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, headers: request_headers, body: None, destination: Destination::Document, @@ -215,7 +191,7 @@ fn test_request_and_response_data_with_network_messages() { }); let (devtools_chan, devtools_port) = channel(); let response = fetch(&mut request, Some(devtools_chan)); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); let _ = server.close(); @@ -224,41 +200,23 @@ fn test_request_and_response_data_with_network_messages() { let devhttpresponse = expect_devtools_http_response(&devtools_port); //Creating default headers for request - let mut headers = Headers::new(); - - headers.set(AcceptEncoding(vec![ - qitem(Encoding::Gzip), - qitem(Encoding::Deflate), - qitem(Encoding::EncodingExt("br".to_owned())) - ])); - - headers.set(Host { hostname: url.host_str().unwrap().to_owned() , port: url.port() }); - - let accept = Accept(vec![ - qitem(Mime(TopLevel::Text, SubLevel::Html, vec![])), - qitem(Mime(TopLevel::Application, SubLevel::Ext("xhtml+xml".to_owned()), vec![])), - QualityItem::new(Mime(TopLevel::Application, SubLevel::Xml, vec![]), Quality(900u16)), - QualityItem::new(Mime(TopLevel::Star, SubLevel::Star, vec![]), Quality(800u16)), - ]); - headers.set(accept); - - let mut en_us: LanguageTag = Default::default(); - en_us.language = Some("en".to_owned()); - en_us.region = Some("US".to_owned()); - let mut en: LanguageTag = Default::default(); - en.language = Some("en".to_owned()); - headers.set(AcceptLanguage(vec![ - qitem(en_us), - QualityItem::new(en, Quality(500)), - ])); - - headers.set(UserAgent(::DEFAULT_USER_AGENT.to_owned())); + let mut headers = HeaderMap::new(); + + headers.insert(header::ACCEPT_ENCODING, HeaderValue::from_static("gzip, deflate, br")); + headers.typed_insert( + Host::from(format!("{}:{}", url.host_str().unwrap(), url.port().unwrap()).parse::<Authority>().unwrap())); + + headers.insert(header::ACCEPT, + HeaderValue::from_static("text/html, application/xhtml+xml, application/xml; q=0.9, */*; q=0.8")); + + headers.insert(header::ACCEPT_LANGUAGE, HeaderValue::from_static("en-US, en; q=0.5")); + headers.typed_insert::<UserAgent>(::DEFAULT_USER_AGENT.parse().unwrap()); let httprequest = DevtoolsHttpRequest { url: url, - method: Method::Get, + method: Method::GET, headers: headers, - body: None, + body: Some(b"".to_vec()), pipeline_id: TEST_PIPELINE_ID, startedDateTime: devhttprequest.startedDateTime, timeStamp: devhttprequest.timeStamp, @@ -268,10 +226,10 @@ fn test_request_and_response_data_with_network_messages() { }; let content = "Yay!"; - let mut response_headers = Headers::new(); - response_headers.set(ContentLength(content.len() as u64)); - response_headers.set(Host { hostname: "foo.bar".to_owned(), port: None }); - response_headers.set(devhttpresponse.headers.as_ref().unwrap().get::<Date>().unwrap().clone()); + let mut response_headers = HeaderMap::new(); + response_headers.typed_insert(ContentLength(content.len() as u64)); + response_headers.typed_insert(Host::from("foo.bar".parse::<Authority>().unwrap())); + response_headers.typed_insert(devhttpresponse.headers.as_ref().unwrap().typed_get::<Date>().unwrap().clone()); let httpresponse = DevtoolsHttpResponse { headers: Some(response_headers), @@ -286,15 +244,15 @@ fn test_request_and_response_data_with_network_messages() { #[test] fn test_request_and_response_message_from_devtool_without_pipeline_id() { - let handler = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(Host { hostname: "foo.bar".to_owned(), port: None }); - response.send(b"Yay!").unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().typed_insert(Host::from("foo.bar".parse::<Authority>().unwrap())); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, destination: Destination::Document, origin: mock_origin(), pipeline_id: None, @@ -302,7 +260,7 @@ fn test_request_and_response_message_from_devtool_without_pipeline_id() { }); let (devtools_chan, devtools_port) = channel(); let response = fetch(&mut request, Some(devtools_chan)); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); let _ = server.close(); @@ -312,24 +270,23 @@ fn test_request_and_response_message_from_devtool_without_pipeline_id() { #[test] fn test_redirected_request_to_devtools() { - let post_handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.method, Method::Get); - response.send(b"Yay!").unwrap(); + let post_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.method(), Method::GET); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut post_server, post_url) = make_server(post_handler); + let (post_server, post_url) = make_server(post_handler); let post_redirect_url = post_url.clone(); - let pre_handler = move |request: HyperRequest, mut response: HyperResponse| { - assert_eq!(request.method, Method::Post); - response.headers_mut().set(Location(post_redirect_url.to_string())); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + let pre_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.method(), Method::POST); + response.headers_mut().insert(header::LOCATION, HeaderValue::from_str(&post_redirect_url.to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; }; - let (mut pre_server, pre_url) = make_server(pre_handler); + let (pre_server, pre_url) = make_server(pre_handler); let mut request = Request::from_init(RequestInit { url: pre_url.clone(), - method: Method::Post, + method: Method::POST, destination: Destination::Document, pipeline_id: Some(TEST_PIPELINE_ID), .. RequestInit::default() @@ -343,14 +300,14 @@ fn test_redirected_request_to_devtools() { let devhttprequest = expect_devtools_http_request(&devtools_port); let devhttpresponse = expect_devtools_http_response(&devtools_port); - assert_eq!(devhttprequest.method, Method::Post); + assert_eq!(devhttprequest.method, Method::POST); assert_eq!(devhttprequest.url, pre_url); assert_eq!(devhttpresponse.status, Some((301, b"Moved Permanently".to_vec()))); let devhttprequest = expect_devtools_http_request(&devtools_port); let devhttpresponse = expect_devtools_http_response(&devtools_port); - assert_eq!(devhttprequest.method, Method::Get); + assert_eq!(devhttprequest.method, Method::GET); assert_eq!(devhttprequest.url, post_url); assert_eq!(devhttpresponse.status, Some((200, b"OK".to_vec()))); } @@ -359,24 +316,23 @@ fn test_redirected_request_to_devtools() { #[test] fn test_load_when_redirecting_from_a_post_should_rewrite_next_request_as_get() { - let post_handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.method, Method::Get); - response.send(b"Yay!").unwrap(); + let post_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.method(), Method::GET); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut post_server, post_url) = make_server(post_handler); + let (post_server, post_url) = make_server(post_handler); let post_redirect_url = post_url.clone(); - let pre_handler = move |request: HyperRequest, mut response: HyperResponse| { - assert_eq!(request.method, Method::Post); - response.headers_mut().set(Location(post_redirect_url.to_string())); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + let pre_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.method(), Method::POST); + response.headers_mut().insert(header::LOCATION, HeaderValue::from_str(&post_redirect_url.to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; }; - let (mut pre_server, pre_url) = make_server(pre_handler); + let (pre_server, pre_url) = make_server(pre_handler); let mut request = Request::from_init(RequestInit { url: pre_url.clone(), - method: Method::Post, + method: Method::POST, destination: Destination::Document, origin: mock_origin(), pipeline_id: Some(TEST_PIPELINE_ID), @@ -387,23 +343,23 @@ fn test_load_when_redirecting_from_a_post_should_rewrite_next_request_as_get() { let _ = pre_server.close(); let _ = post_server.close(); - assert!(response.to_actual().status.unwrap().is_success()); + assert!(response.to_actual().status.unwrap().0.is_success()); } #[test] fn test_load_should_decode_the_response_as_deflate_when_response_headers_have_content_encoding_deflate() { - let handler = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(ContentEncoding(vec![Encoding::Deflate])); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().insert(header::CONTENT_ENCODING, HeaderValue::from_static("deflate")); let mut e = DeflateEncoder::new(Vec::new(), Compression::default()); e.write(b"Yay!").unwrap(); let encoded_content = e.finish().unwrap(); - response.send(&encoded_content).unwrap(); + *response.body_mut() = encoded_content.into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -415,25 +371,25 @@ fn test_load_should_decode_the_response_as_deflate_when_response_headers_have_co let _ = server.close(); let internal_response = response.internal_response.unwrap(); - assert!(internal_response.status.unwrap().is_success()); + assert!(internal_response.status.clone().unwrap().0.is_success()); assert_eq!(*internal_response.body.lock().unwrap(), ResponseBody::Done(b"Yay!".to_vec())); } #[test] fn test_load_should_decode_the_response_as_gzip_when_response_headers_have_content_encoding_gzip() { - let handler = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(ContentEncoding(vec![Encoding::Gzip])); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().insert(header::CONTENT_ENCODING, HeaderValue::from_static("gzip")); let mut e = GzEncoder::new(Vec::new(), Compression::default()); e.write(b"Yay!").unwrap(); let encoded_content = e.finish().unwrap(); - response.send(&encoded_content).unwrap(); + *response.body_mut() = encoded_content.into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -445,35 +401,36 @@ fn test_load_should_decode_the_response_as_gzip_when_response_headers_have_conte let _ = server.close(); let internal_response = response.internal_response.unwrap(); - assert!(internal_response.status.unwrap().is_success()); + assert!(internal_response.status.clone().unwrap().0.is_success()); assert_eq!(*internal_response.body.lock().unwrap(), ResponseBody::Done(b"Yay!".to_vec())); } #[test] fn test_load_doesnt_send_request_body_on_any_redirect() { - let post_handler = move |mut request: HyperRequest, response: HyperResponse| { - assert_eq!(request.method, Method::Get); - let data = read_response(&mut request); - assert_eq!(data, ""); - response.send(b"Yay!").unwrap(); + let post_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.method(), Method::GET); + read_response(request).and_then(|data| { + assert_eq!(data, ""); futures::future::ok(()) + }).poll().unwrap(); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut post_server, post_url) = make_server(post_handler); + let (post_server, post_url) = make_server(post_handler); let post_redirect_url = post_url.clone(); - let pre_handler = move |mut request: HyperRequest, mut response: HyperResponse| { - let data = read_response(&mut request); - assert_eq!(data, "Body on POST!"); - response.headers_mut().set(Location(post_redirect_url.to_string())); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + let pre_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + read_response(request).and_then(|data| { + assert_eq!(data, "Body on POST"); futures::future::ok(()) + }).poll().unwrap(); + response.headers_mut().insert(header::LOCATION, HeaderValue::from_str(&post_redirect_url.to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; }; - let (mut pre_server, pre_url) = make_server(pre_handler); + let (pre_server, pre_url) = make_server(pre_handler); let mut request = Request::from_init(RequestInit { url: pre_url.clone(), body: Some(b"Body on POST!".to_vec()), - method: Method::Post, + method: Method::POST, destination: Destination::Document, origin: mock_origin(), pipeline_id: Some(TEST_PIPELINE_ID), @@ -484,20 +441,21 @@ fn test_load_doesnt_send_request_body_on_any_redirect() { let _ = pre_server.close(); let _ = post_server.close(); - assert!(response.to_actual().status.unwrap().is_success()); + assert!(response.to_actual().status.unwrap().0.is_success()); } #[test] fn test_load_doesnt_add_host_to_sts_list_when_url_is_http_even_if_sts_headers_are_present() { - let handler = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(StrictTransportSecurity::excluding_subdomains(31536000)); - response.send(b"Yay!").unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().typed_insert( + StrictTransportSecurity::excluding_subdomains(Duration::from_secs(31536000))); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -509,17 +467,17 @@ fn test_load_doesnt_add_host_to_sts_list_when_url_is_http_even_if_sts_headers_ar let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); assert_eq!(context.state.hsts_list.read().unwrap().is_host_secure(url.host_str().unwrap()), false); } #[test] fn test_load_sets_cookies_in_the_resource_manager_when_it_get_set_cookie_header_in_response() { - let handler = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(SetCookie(vec!["mozillaIs=theBest".to_owned()])); - response.send(b"Yay!").unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().insert(header::SET_COOKIE, HeaderValue::from_static("mozillaIs=theBest")); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let context = new_fetch_context(None, None); @@ -527,7 +485,7 @@ fn test_load_sets_cookies_in_the_resource_manager_when_it_get_set_cookie_header_ let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -539,19 +497,18 @@ fn test_load_sets_cookies_in_the_resource_manager_when_it_get_set_cookie_header_ let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), Some("mozillaIs=theBest")); } #[test] fn test_load_sets_requests_cookies_header_for_url_by_getting_cookies_from_the_resource_manager() { - let handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.headers.get::<CookieHeader>(), - Some(&CookieHeader(vec!["mozillaIs=theBest".to_owned()]))); - response.send(b"Yay!").unwrap(); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.headers().get(header::COOKIE).unwrap().as_bytes(), b"mozillaIs=theBest"); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let context = new_fetch_context(None, None); @@ -567,7 +524,7 @@ fn test_load_sets_requests_cookies_header_for_url_by_getting_cookies_from_the_re let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -579,17 +536,16 @@ fn test_load_sets_requests_cookies_header_for_url_by_getting_cookies_from_the_re let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); } #[test] fn test_load_sends_cookie_if_nonhttp() { - let handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.headers.get::<CookieHeader>(), - Some(&CookieHeader(vec!["mozillaIs=theBest".to_owned()]))); - response.send(b"Yay!").unwrap(); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.headers().get(header::COOKIE).unwrap().as_bytes(), b"mozillaIs=theBest"); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let context = new_fetch_context(None, None); @@ -605,7 +561,7 @@ fn test_load_sends_cookie_if_nonhttp() { let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -617,17 +573,16 @@ fn test_load_sends_cookie_if_nonhttp() { let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); } #[test] fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl() { - let handler = move |_: HyperRequest, mut response: HyperResponse| { - let pair = vec!["mozillaIs=theBest; HttpOnly".to_owned()]; - response.headers_mut().set(SetCookie(pair)); - response.send(b"Yay!").unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().insert(header::SET_COOKIE, HeaderValue::from_static("mozillaIs=theBest; HttpOnly")); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let context = new_fetch_context(None, None); @@ -635,7 +590,7 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl( let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -647,7 +602,7 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl( let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), Some("mozillaIs=theBest")); let mut cookie_jar = context.state.cookie_jar.write().unwrap(); @@ -656,12 +611,11 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl( #[test] fn test_when_cookie_received_marked_secure_is_ignored_for_http() { - let handler = move |_: HyperRequest, mut response: HyperResponse| { - let pair = vec!["mozillaIs=theBest; Secure".to_owned()]; - response.headers_mut().set(SetCookie(pair)); - response.send(b"Yay!").unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().insert(header::SET_COOKIE, HeaderValue::from_static("mozillaIs=theBest; Secure")); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let context = new_fetch_context(None, None); @@ -669,7 +623,7 @@ fn test_when_cookie_received_marked_secure_is_ignored_for_http() { let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -681,7 +635,7 @@ fn test_when_cookie_received_marked_secure_is_ignored_for_http() { let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None); } @@ -689,16 +643,16 @@ fn test_when_cookie_received_marked_secure_is_ignored_for_http() { #[test] fn test_load_sets_content_length_to_length_of_request_body() { let content = b"This is a request body"; - let content_length = ContentLength(content.len() as u64); - let handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.headers.get::<ContentLength>(), Some(&content_length)); - response.send(content).unwrap(); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + let content_length = ContentLength(content.len() as u64); + assert_eq!(request.headers().typed_get::<ContentLength>(), Some(content_length)); + *response.body_mut() = content.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Post, + method: Method::POST, body: Some(content.to_vec()), destination: Destination::Document, origin: mock_origin(), @@ -709,24 +663,22 @@ fn test_load_sets_content_length_to_length_of_request_body() { let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); } #[test] fn test_load_uses_explicit_accept_from_headers_in_load_data() { - let accept = Accept(vec![qitem(Mime(TopLevel::Text, SubLevel::Html, vec![]))]); - let expected_accept = accept.clone(); - let handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.headers.get::<Accept>(), Some(&expected_accept)); - response.send(b"Yay!").unwrap(); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.headers().get(header::ACCEPT).unwrap().to_str().unwrap(), "text/html"); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); - let mut accept_headers = Headers::new(); - accept_headers.set(accept); + let mut accept_headers = HeaderMap::new(); + accept_headers.insert(header::ACCEPT, HeaderValue::from_static("text/html")); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, headers: accept_headers, destination: Destination::Document, origin: mock_origin(), @@ -737,25 +689,21 @@ fn test_load_uses_explicit_accept_from_headers_in_load_data() { let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); } #[test] fn test_load_sets_default_accept_to_html_xhtml_xml_and_then_anything_else() { - let handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.headers.get::<Accept>(), Some(&Accept(vec![ - qitem(Mime(TopLevel::Text, SubLevel::Html, vec![])), - qitem(Mime(TopLevel::Application, SubLevel::Ext("xhtml+xml".to_owned()), vec![])), - QualityItem::new(Mime(TopLevel::Application, SubLevel::Xml, vec![]), Quality(900)), - QualityItem::new(Mime(TopLevel::Star, SubLevel::Star, vec![]), Quality(800)), - ]))); - response.send(b"Yay!").unwrap(); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.headers().get(header::ACCEPT).unwrap().to_str().unwrap(), + "text/html, application/xhtml+xml, application/xml; q=0.9, */*; q=0.8"); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, destination: Destination::Document, origin: mock_origin(), pipeline_id: Some(TEST_PIPELINE_ID), @@ -765,24 +713,22 @@ fn test_load_sets_default_accept_to_html_xhtml_xml_and_then_anything_else() { let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); } #[test] fn test_load_uses_explicit_accept_encoding_from_load_data_headers() { - let accept_encoding = AcceptEncoding(vec![qitem(Encoding::Chunked)]); - let expected_accept_encoding = accept_encoding.clone(); - let handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.headers.get::<AcceptEncoding>(), Some(&expected_accept_encoding)); - response.send(b"Yay!").unwrap(); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.headers().get(header::ACCEPT_ENCODING).unwrap().to_str().unwrap(), "chunked"); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); - let mut accept_encoding_headers = Headers::new(); - accept_encoding_headers.set(accept_encoding); + let mut accept_encoding_headers = HeaderMap::new(); + accept_encoding_headers.insert(header::ACCEPT_ENCODING, HeaderValue::from_static("chunked")); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, headers: accept_encoding_headers, destination: Destination::Document, origin: mock_origin(), @@ -793,24 +739,20 @@ fn test_load_uses_explicit_accept_encoding_from_load_data_headers() { let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); } #[test] fn test_load_sets_default_accept_encoding_to_gzip_and_deflate() { - let handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.headers.get::<AcceptEncoding>(), Some(&AcceptEncoding(vec![ - qitem(Encoding::Gzip), - qitem(Encoding::Deflate), - qitem(Encoding::EncodingExt("br".to_owned())) - ]))); - response.send(b"Yay!").unwrap(); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.headers().get(header::ACCEPT_ENCODING).unwrap().to_str().unwrap(), "gzip, deflate, br"); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, destination: Destination::Document, origin: mock_origin(), pipeline_id: Some(TEST_PIPELINE_ID), @@ -820,33 +762,32 @@ fn test_load_sets_default_accept_encoding_to_gzip_and_deflate() { let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); } #[test] fn test_load_errors_when_there_a_redirect_loop() { let url_b_for_a = Arc::new(Mutex::new(None::<ServoUrl>)); let url_b_for_a_clone = url_b_for_a.clone(); - let handler_a = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(Location(url_b_for_a_clone.lock().unwrap().as_ref().unwrap().to_string())); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + let handler_a = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().insert(header::LOCATION, + HeaderValue::from_str(&url_b_for_a_clone.lock().unwrap().as_ref().unwrap().to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; }; - let (mut server_a, url_a) = make_server(handler_a); + let (server_a, url_a) = make_server(handler_a); let url_a_for_b = url_a.clone(); - let handler_b = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(Location(url_a_for_b.to_string())); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + let handler_b = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().insert(header::LOCATION, HeaderValue::from_str(&url_a_for_b.to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; }; - let (mut server_b, url_b) = make_server(handler_b); + let (server_b, url_b) = make_server(handler_b); *url_b_for_a.lock().unwrap() = Some(url_b.clone()); let mut request = Request::from_init(RequestInit { url: url_a.clone(), - method: Method::Get, + method: Method::GET, destination: Destination::Document, origin: mock_origin(), pipeline_id: Some(TEST_PIPELINE_ID), @@ -866,30 +807,29 @@ fn test_load_succeeds_with_a_redirect_loop() { let url_b_for_a = Arc::new(Mutex::new(None::<ServoUrl>)); let url_b_for_a_clone = url_b_for_a.clone(); let handled_a = AtomicBool::new(false); - let handler_a = move |_: HyperRequest, mut response: HyperResponse| { + let handler_a = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { if !handled_a.swap(true, Ordering::SeqCst) { - response.headers_mut().set(Location(url_b_for_a_clone.lock().unwrap().as_ref().unwrap().to_string())); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + response.headers_mut().insert(header::LOCATION, + HeaderValue::from_str(&url_b_for_a_clone.lock().unwrap().as_ref().unwrap().to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; } else { - response.send(b"Success").unwrap(); + *response.body_mut() = b"Success".to_vec().into() } }; - let (mut server_a, url_a) = make_server(handler_a); + let (server_a, url_a) = make_server(handler_a); let url_a_for_b = url_a.clone(); - let handler_b = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(Location(url_a_for_b.to_string())); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + let handler_b = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().insert(header::LOCATION, HeaderValue::from_str(&url_a_for_b.to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; }; - let (mut server_b, url_b) = make_server(handler_b); + let (server_b, url_b) = make_server(handler_b); *url_b_for_a.lock().unwrap() = Some(url_b.clone()); let mut request = Request::from_init(RequestInit { url: url_a.clone(), - method: Method::Get, + method: Method::GET, destination: Destination::Document, origin: mock_origin(), pipeline_id: Some(TEST_PIPELINE_ID), @@ -908,24 +848,23 @@ fn test_load_succeeds_with_a_redirect_loop() { #[test] fn test_load_follows_a_redirect() { - let post_handler = move |request: HyperRequest, response: HyperResponse| { - assert_eq!(request.method, Method::Get); - response.send(b"Yay!").unwrap(); + let post_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.method(), Method::GET); + *response.body_mut() = b"Yay!".to_vec().into(); }; - let (mut post_server, post_url) = make_server(post_handler); + let (post_server, post_url) = make_server(post_handler); let post_redirect_url = post_url.clone(); - let pre_handler = move |request: HyperRequest, mut response: HyperResponse| { - assert_eq!(request.method, Method::Get); - response.headers_mut().set(Location(post_redirect_url.to_string())); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + let pre_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + assert_eq!(request.method(), Method::GET); + response.headers_mut().insert(header::LOCATION, HeaderValue::from_str(&post_redirect_url.to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; }; - let (mut pre_server, pre_url) = make_server(pre_handler); + let (pre_server, pre_url) = make_server(pre_handler); let mut request = Request::from_init(RequestInit { url: pre_url.clone(), - method: Method::Get, + method: Method::GET, destination: Destination::Document, origin: mock_origin(), pipeline_id: Some(TEST_PIPELINE_ID), @@ -937,7 +876,7 @@ fn test_load_follows_a_redirect() { let _ = post_server.close(); let internal_response = response.internal_response.unwrap(); - assert!(internal_response.status.unwrap().is_success()); + assert!(internal_response.status.clone().unwrap().0.is_success()); assert_eq!(*internal_response.body.lock().unwrap(), ResponseBody::Done(b"Yay!".to_vec())); } @@ -946,27 +885,21 @@ fn test_load_follows_a_redirect() { fn test_redirect_from_x_to_y_provides_y_cookies_from_y() { let shared_url_y = Arc::new(Mutex::new(None::<ServoUrl>)); let shared_url_y_clone = shared_url_y.clone(); - let handler = move |request: HyperRequest, mut response: HyperResponse| { - let path = match request.uri { - RequestUri::AbsolutePath(path) => path, - uri => panic!("Unexpected uri: {:?}", uri), - }; + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + let path = request.uri().path(); if path == "/com/" { - assert_eq!(request.headers.get(), - Some(&CookieHeader(vec!["mozillaIsNot=dotOrg".to_owned()]))); + assert_eq!(request.headers().get(header::COOKIE).unwrap().as_bytes(), b"mozillaIsNot=dotOrg"); let location = shared_url_y.lock().unwrap().as_ref().unwrap().to_string(); - response.headers_mut().set(Location(location)); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + response.headers_mut().insert(header::LOCATION, HeaderValue::from_str(&location.to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; } else if path == "/org/" { - assert_eq!(request.headers.get(), - Some(&CookieHeader(vec!["mozillaIs=theBest".to_owned()]))); - response.send(b"Yay!").unwrap(); + assert_eq!(request.headers().get(header::COOKIE).unwrap().as_bytes(), b"mozillaIs=theBest"); + *response.body_mut() = b"Yay!".to_vec().into(); } else { panic!("unexpected path {:?}", path) } }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let port = url.port().unwrap(); assert_eq!(url.host_str(), Some("localhost")); @@ -1002,7 +935,7 @@ fn test_redirect_from_x_to_y_provides_y_cookies_from_y() { let mut request = Request::from_init(RequestInit { url: url_x.clone(), - method: Method::Get, + method: Method::GET, destination: Destination::Document, origin: mock_origin(), pipeline_id: Some(TEST_PIPELINE_ID), @@ -1014,39 +947,34 @@ fn test_redirect_from_x_to_y_provides_y_cookies_from_y() { let _ = server.close(); let internal_response = response.internal_response.unwrap(); - assert!(internal_response.status.unwrap().is_success()); + assert!(internal_response.status.clone().unwrap().0.is_success()); assert_eq!(*internal_response.body.lock().unwrap(), ResponseBody::Done(b"Yay!".to_vec())); } #[test] fn test_redirect_from_x_to_x_provides_x_with_cookie_from_first_response() { - let handler = move |request: HyperRequest, mut response: HyperResponse| { - let path = match request.uri { - ::hyper::uri::RequestUri::AbsolutePath(path) => path, - uri => panic!("Unexpected uri: {:?}", uri), - }; + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + let path = request.uri().path(); if path == "/initial/" { - response.headers_mut().set_raw("set-cookie", vec![b"mozillaIs=theBest; path=/;".to_vec()]); + response.headers_mut().insert(header::SET_COOKIE, HeaderValue::from_static("mozillaIs=theBest; path=/;")); let location = "/subsequent/".to_string(); - response.headers_mut().set(Location(location)); - *response.status_mut() = StatusCode::MovedPermanently; - response.send(b"").unwrap(); + response.headers_mut().insert(header::LOCATION, HeaderValue::from_str(&location.to_string()).unwrap()); + *response.status_mut() = StatusCode::MOVED_PERMANENTLY; } else if path == "/subsequent/" { - assert_eq!(request.headers.get(), - Some(&CookieHeader(vec!["mozillaIs=theBest".to_owned()]))); - response.send(b"Yay!").unwrap(); + assert_eq!(request.headers().get(header::COOKIE).unwrap().as_bytes(), b"mozillaIs=theBest"); + *response.body_mut() = b"Yay!".to_vec().into(); } else { panic!("unexpected path {:?}", path) } }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let url = url.join("/initial/").unwrap(); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, destination: Destination::Document, origin: mock_origin(), pipeline_id: Some(TEST_PIPELINE_ID), @@ -1058,26 +986,22 @@ fn test_redirect_from_x_to_x_provides_x_with_cookie_from_first_response() { let _ = server.close(); let internal_response = response.internal_response.unwrap(); - assert!(internal_response.status.unwrap().is_success()); + assert!(internal_response.status.clone().unwrap().0.is_success()); assert_eq!(*internal_response.body.lock().unwrap(), ResponseBody::Done(b"Yay!".to_vec())); } #[test] fn test_if_auth_creds_not_in_url_but_in_cache_it_sets_it() { - let handler = move |request: HyperRequest, response: HyperResponse| { - let expected = Authorization(Basic { - username: "username".to_owned(), - password: Some("test".to_owned()) - }); - assert_eq!(request.headers.get(), Some(&expected)); - response.send(b"").unwrap(); + let handler = move |request: HyperRequest<Body>, _response: &mut HyperResponse<Body>| { + let expected = Authorization::basic("username", "test"); + assert_eq!(request.headers().typed_get::<Authorization<Basic>>(), Some(expected)); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -1098,20 +1022,19 @@ fn test_if_auth_creds_not_in_url_but_in_cache_it_sets_it() { let _ = server.close(); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); } #[test] fn test_auth_ui_needs_www_auth() { - let handler = move |_: HyperRequest, mut response: HyperResponse| { - *response.status_mut() = StatusCode::Unauthorized; - response.send(b"").unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.status_mut() = StatusCode::UNAUTHORIZED; }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, body: None, destination: Destination::Document, origin: mock_origin(), @@ -1124,41 +1047,50 @@ fn test_auth_ui_needs_www_auth() { let _ = server.close(); - assert_eq!(response.internal_response.unwrap().status.unwrap(), StatusCode::Unauthorized); + assert_eq!(response.internal_response.unwrap().status.unwrap().0, StatusCode::UNAUTHORIZED); } #[test] fn test_origin_set() { let origin_header = Arc::new(Mutex::new(None)); let origin_header_clone = origin_header.clone(); - let handler = move |request: HyperRequest, mut resp: HyperResponse| { + let handler = move |request: HyperRequest<Body>, resp: &mut HyperResponse<Body>| { let origin_header_clone = origin_header.clone(); - resp.headers_mut().set(AccessControlAllowOrigin::Any); - match request.headers.get::<Origin>() { + resp.headers_mut().typed_insert(AccessControlAllowOrigin::ANY); + match request.headers().typed_get::<Origin>() { None => assert_eq!(origin_header_clone.lock().unwrap().take(), None), - Some(h) => assert_eq!(*h, origin_header_clone.lock().unwrap().take().unwrap()), + Some(h) => assert_eq!(h, origin_header_clone.lock().unwrap().take().unwrap()), } }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); - let mut origin = Origin::new(url.scheme(), url.host_str().unwrap(), url.port()); + let mut origin = Origin::try_from_parts( + url.scheme(), + url.host_str().unwrap(), + url.port() + ).unwrap(); *origin_header_clone.lock().unwrap() = Some(origin.clone()); let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Post, + method: Method::POST, body: None, origin: url.clone().origin(), .. RequestInit::default() }); let response = fetch(&mut request, None); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); let origin_url = ServoUrl::parse("http://example.com").unwrap(); - origin = Origin::new(origin_url.scheme(), origin_url.host_str().unwrap(), origin_url.port()); + // XXX: Not sure about the Some(80) here. origin_url.origin() returns 80 for the port but origin_url returns None. + origin = Origin::try_from_parts( + origin_url.scheme(), + origin_url.host_str().unwrap(), + Some(80) + ).unwrap(); // Test Origin header is set on Get request with CORS mode let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Get, + method: Method::GET, mode: RequestMode::CorsMode, body: None, origin: origin_url.clone().origin(), @@ -1167,12 +1099,12 @@ fn test_origin_set() { *origin_header_clone.lock().unwrap() = Some(origin.clone()); let response = fetch(&mut request, None); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); // Test Origin header is not set on method Head let mut request = Request::from_init(RequestInit { url: url.clone(), - method: Method::Head, + method: Method::HEAD, body: None, origin: url.clone().origin(), .. RequestInit::default() @@ -1180,7 +1112,7 @@ fn test_origin_set() { *origin_header_clone.lock().unwrap() = None; let response = fetch(&mut request, None); - assert!(response.internal_response.unwrap().status.unwrap().is_success()); + assert!(response.internal_response.unwrap().status.unwrap().0.is_success()); let _ = server.close(); } |