diff options
Diffstat (limited to 'components/net/tests')
| -rw-r--r-- | components/net/tests/cookie.rs | 12 | ||||
| -rw-r--r-- | components/net/tests/cookie_http_state.rs | 12 | ||||
| -rw-r--r-- | components/net/tests/data_loader.rs | 37 | ||||
| -rw-r--r-- | components/net/tests/fetch.rs | 412 | ||||
| -rw-r--r-- | components/net/tests/http_loader.rs | 626 | ||||
| -rw-r--r-- | components/net/tests/main.rs | 112 | ||||
| -rw-r--r-- | components/net/tests/mime_classifier.rs | 305 |
7 files changed, 733 insertions, 783 deletions
diff --git a/components/net/tests/cookie.rs b/components/net/tests/cookie.rs index 68149736680..3702f93fee2 100644 --- a/components/net/tests/cookie.rs +++ b/components/net/tests/cookie.rs @@ -3,7 +3,6 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use cookie_rs; -use hyper::header::{Header, SetCookie}; use net::cookie::Cookie; use net::cookie_storage::CookieStorage; use net_traits::CookieSource; @@ -90,7 +89,7 @@ fn fn_cookie_constructor() { let cookie = Cookie::new_wrapped(cookie, url, CookieSource::HTTP).unwrap(); assert_eq!(cookie.cookie.value(), "bar"); assert_eq!(cookie.cookie.name(), "baz"); - assert!(cookie.cookie.secure()); + assert!(cookie.cookie.secure().unwrap_or(false)); assert_eq!(&cookie.cookie.path().as_ref().unwrap()[..], "/foo/bar/"); assert_eq!(&cookie.cookie.domain().as_ref().unwrap()[..], "example.com"); assert!(cookie.host_only); @@ -324,13 +323,8 @@ fn add_retrieve_cookies(set_location: &str, // Add all cookies to the store for str_cookie in set_cookies { - let bytes = str_cookie.to_string().into_bytes(); - let header = Header::parse_header(&[bytes]).unwrap(); - let SetCookie(cookies) = header; - for bare_cookie in cookies { - let cookie = Cookie::from_cookie_string(bare_cookie, &url, source).unwrap(); - storage.push(cookie, &url, source); - } + let cookie = Cookie::from_cookie_string(str_cookie.to_owned(), &url, source).unwrap(); + storage.push(cookie, &url, source); } // Get cookies for the test location diff --git a/components/net/tests/cookie_http_state.rs b/components/net/tests/cookie_http_state.rs index 30cec8b26b2..ab310f6a35e 100644 --- a/components/net/tests/cookie_http_state.rs +++ b/components/net/tests/cookie_http_state.rs @@ -2,13 +2,11 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use hyper::header::{Header, SetCookie}; use net::cookie::Cookie; use net::cookie_storage::CookieStorage; use net_traits::CookieSource; use servo_url::ServoUrl; - fn run(set_location: &str, set_cookies: &[&str], final_location: &str) -> String { let mut storage = CookieStorage::new(150); let url = ServoUrl::parse(set_location).unwrap(); @@ -16,14 +14,8 @@ fn run(set_location: &str, set_cookies: &[&str], final_location: &str) -> String // Add all cookies to the store for str_cookie in set_cookies { - let bytes = str_cookie.to_string().into_bytes(); - let header = Header::parse_header(&[bytes]); - if let Ok(SetCookie(cookies)) = header { - for bare_cookie in cookies { - if let Some(cookie) = Cookie::from_cookie_string(bare_cookie, &url, source) { - storage.push(cookie, &url, source); - } - } + if let Some(cookie) = Cookie::from_cookie_string(str_cookie.to_owned().into(), &url, source) { + storage.push(cookie, &url, source); } } diff --git a/components/net/tests/data_loader.rs b/components/net/tests/data_loader.rs index 4ad73dee080..56b70af9e99 100644 --- a/components/net/tests/data_loader.rs +++ b/components/net/tests/data_loader.rs @@ -3,9 +3,10 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use fetch; -use hyper::header::ContentType; -use hyper::mime::{Attr, Mime, SubLevel, TopLevel, Value}; +use headers_core::HeaderMapExt; +use headers_ext::ContentType; use hyper_serde::Serde; +use mime::{self, Mime}; use net_traits::{FetchMetadata, FilteredMetadata, NetworkError}; use net_traits::request::{Origin, Request}; use net_traits::response::ResponseBody; @@ -28,8 +29,8 @@ fn assert_parse(url: &'static str, assert!(!response.is_network_error()); assert_eq!(response.headers.len(), 1); - let header_content_type = response.headers.get::<ContentType>(); - assert_eq!(header_content_type, content_type.as_ref()); + let header_content_type = response.headers.typed_get::<ContentType>(); + assert_eq!(header_content_type, content_type); let metadata = match response.metadata() { Ok(FetchMetadata::Filtered { filtered: FilteredMetadata::Basic(m), .. }) => m, @@ -62,9 +63,8 @@ fn empty_invalid() { fn plain() { assert_parse( "data:,hello%20world", - Some(ContentType(Mime(TopLevel::Text, SubLevel::Plain, - vec!((Attr::Charset, Value::Ext("US-ASCII".to_owned())))))), - Some("US-ASCII"), + Some(ContentType::from("text/plain; charset=US-ASCII".parse::<Mime>().unwrap())), + Some("us-ascii"), Some(b"hello world")); } @@ -72,7 +72,7 @@ fn plain() { fn plain_ct() { assert_parse( "data:text/plain,hello", - Some(ContentType(Mime(TopLevel::Text, SubLevel::Plain, vec!()))), + Some(ContentType::from(mime::TEXT_PLAIN)), None, Some(b"hello")); } @@ -81,7 +81,7 @@ fn plain_ct() { fn plain_html() { assert_parse( "data:text/html,<p>Servo</p>", - Some(ContentType(Mime(TopLevel::Text, SubLevel::Html, vec!()))), + Some(ContentType::from(mime::TEXT_HTML)), None, Some(b"<p>Servo</p>")); } @@ -90,9 +90,7 @@ fn plain_html() { fn plain_charset() { assert_parse( "data:text/plain;charset=latin1,hello", - Some(ContentType(Mime(TopLevel::Text, - SubLevel::Plain, - vec!((Attr::Charset, Value::Ext("latin1".to_owned())))))), + Some(ContentType::from("text/plain; charset=latin1".parse::<Mime>().unwrap())), Some("latin1"), Some(b"hello")); } @@ -101,9 +99,7 @@ fn plain_charset() { fn plain_only_charset() { assert_parse( "data:;charset=utf-8,hello", - Some(ContentType(Mime(TopLevel::Text, - SubLevel::Plain, - vec!((Attr::Charset, Value::Utf8))))), + Some(ContentType::from(mime::TEXT_PLAIN_UTF_8)), Some("utf-8"), Some(b"hello")); } @@ -112,10 +108,8 @@ fn plain_only_charset() { fn base64() { assert_parse( "data:;base64,C62+7w==", - Some(ContentType(Mime(TopLevel::Text, - SubLevel::Plain, - vec!((Attr::Charset, Value::Ext("US-ASCII".to_owned())))))), - Some("US-ASCII"), + Some(ContentType::from("text/plain; charset=US-ASCII".parse::<Mime>().unwrap())), + Some("us-ascii"), Some(&[0x0B, 0xAD, 0xBE, 0xEF])); } @@ -123,7 +117,7 @@ fn base64() { fn base64_ct() { assert_parse( "data:application/octet-stream;base64,C62+7w==", - Some(ContentType(Mime(TopLevel::Application, SubLevel::Ext("octet-stream".to_owned()), vec!()))), + Some(ContentType::from(mime::APPLICATION_OCTET_STREAM)), None, Some(&[0x0B, 0xAD, 0xBE, 0xEF])); } @@ -132,8 +126,7 @@ fn base64_ct() { fn base64_charset() { assert_parse( "data:text/plain;charset=koi8-r;base64,8PLl9+XkIO3l5Pfl5A==", - Some(ContentType(Mime(TopLevel::Text, SubLevel::Plain, - vec!((Attr::Charset, Value::Ext("koi8-r".to_owned())))))), + Some(ContentType::from("text/plain; charset=koi8-r".parse::<Mime>().unwrap())), Some("koi8-r"), Some(&[0xF0, 0xF2, 0xE5, 0xF7, 0xE5, 0xE4, 0x20, 0xED, 0xE5, 0xE4, 0xF7, 0xE5, 0xE4])); } diff --git a/components/net/tests/fetch.rs b/components/net/tests/fetch.rs index 2e33727e37f..d0d472614f9 100644 --- a/components/net/tests/fetch.rs +++ b/components/net/tests/fetch.rs @@ -2,27 +2,24 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use {DEFAULT_USER_AGENT, new_fetch_context, create_embedder_proxy, fetch, make_server}; +use {DEFAULT_USER_AGENT, new_fetch_context, create_embedder_proxy, fetch, make_server, make_ssl_server}; use devtools_traits::HttpRequest as DevtoolsHttpRequest; use devtools_traits::HttpResponse as DevtoolsHttpResponse; use fetch_with_context; use fetch_with_cors_cache; +use headers_core::HeaderMapExt; +use headers_ext::{AccessControlAllowCredentials, AccessControlAllowHeaders, AccessControlAllowOrigin}; +use headers_ext::{AccessControlAllowMethods, AccessControlMaxAge}; +use headers_ext::{CacheControl, ContentLength, ContentType, Expires, Host, LastModified, Pragma, UserAgent}; +use http::{Method, StatusCode}; +use http::header::{self, HeaderMap, HeaderName, HeaderValue}; +use http::uri::Authority; use http_loader::{expect_devtools_http_request, expect_devtools_http_response}; -use hyper::LanguageTag; -use hyper::header::{Accept, AccessControlAllowCredentials, AccessControlAllowHeaders, AccessControlAllowOrigin}; -use hyper::header::{AcceptEncoding, AcceptLanguage, AccessControlAllowMethods, AccessControlMaxAge}; -use hyper::header::{AccessControlRequestHeaders, AccessControlRequestMethod, Date, UserAgent}; -use hyper::header::{CacheControl, ContentLanguage, ContentLength, ContentType, Expires, LastModified}; -use hyper::header::{Encoding, Location, Pragma, Quality, QualityItem, SetCookie, qitem}; -use hyper::header::{Headers, Host, HttpDate, Referer as HyperReferer}; -use hyper::method::Method; -use hyper::mime::{Mime, SubLevel, TopLevel}; -use hyper::server::{Request as HyperRequest, Response as HyperResponse, Server}; -use hyper::status::StatusCode; -use hyper::uri::RequestUri; -use hyper_openssl; +use hyper::{Request as HyperRequest, Response as HyperResponse}; +use hyper::body::Body; +use mime::{self, Mime}; use msg::constellation_msg::TEST_PIPELINE_ID; -use net::connector::create_ssl_client; +use net::connector::create_ssl_connector_builder; use net::fetch::cors_cache::CorsCache; use net::fetch::methods::{CancellationListener, FetchContext}; use net::filemanager_thread::FileManager; @@ -37,21 +34,21 @@ use servo_channel::{channel, Sender}; use servo_url::{ImmutableOrigin, ServoUrl}; use std::fs::File; use std::io::Read; +use std::iter::FromIterator; use std::path::Path; use std::sync::{Arc, Mutex}; use std::sync::atomic::{AtomicUsize, Ordering}; -use time::{self, Duration}; -use unicase::UniCase; +use std::time::{SystemTime, Duration}; // TODO write a struct that impls Handler for storing test values #[test] fn test_fetch_response_is_not_network_error() { static MESSAGE: &'static [u8] = b""; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -79,10 +76,10 @@ fn test_fetch_on_bad_port_is_network_error() { #[test] fn test_fetch_response_body_matches_const_message() { static MESSAGE: &'static [u8] = b"Hello World!"; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -142,11 +139,11 @@ fn test_fetch_blob() { assert_eq!(fetch_response.headers.len(), 2); - let content_type: &ContentType = fetch_response.headers.get().unwrap(); - assert_eq!(**content_type, Mime(TopLevel::Text, SubLevel::Plain, vec![])); + let content_type: Mime = fetch_response.headers.typed_get::<ContentType>().unwrap().into(); + assert_eq!(content_type, mime::TEXT_PLAIN); - let content_length: &ContentLength = fetch_response.headers.get().unwrap(); - assert_eq!(**content_length, bytes.len() as u64); + let content_length: ContentLength = fetch_response.headers.typed_get().unwrap(); + assert_eq!(content_length.0, bytes.len() as u64); assert_eq!(*fetch_response.body.lock().unwrap(), ResponseBody::Done(bytes.to_vec())); @@ -162,8 +159,8 @@ fn test_fetch_file() { let fetch_response = fetch(&mut request, None); assert!(!fetch_response.is_network_error()); assert_eq!(fetch_response.headers.len(), 1); - let content_type: &ContentType = fetch_response.headers.get().unwrap(); - assert_eq!(**content_type, Mime(TopLevel::Text, SubLevel::Css, vec![])); + let content_type: Mime = fetch_response.headers.typed_get::<ContentType>().unwrap().into(); + assert_eq!(content_type, mime::TEXT_CSS); let resp_body = fetch_response.body.lock().unwrap(); let mut file = File::open(path).unwrap(); @@ -202,20 +199,20 @@ fn test_fetch_bogus_scheme() { fn test_cors_preflight_fetch() { static ACK: &'static [u8] = b"ACK"; let state = Arc::new(AtomicUsize::new(0)); - let handler = move |request: HyperRequest, mut response: HyperResponse| { - if request.method == Method::Options && state.clone().fetch_add(1, Ordering::SeqCst) == 0 { - assert!(request.headers.has::<AccessControlRequestMethod>()); - assert!(!request.headers.has::<AccessControlRequestHeaders>()); - assert!(!request.headers.get::<HyperReferer>().unwrap().contains("a.html")); - response.headers_mut().set(AccessControlAllowOrigin::Any); - response.headers_mut().set(AccessControlAllowCredentials); - response.headers_mut().set(AccessControlAllowMethods(vec![Method::Get])); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + if request.method() == Method::OPTIONS && state.clone().fetch_add(1, Ordering::SeqCst) == 0 { + assert!(request.headers().contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)); + assert!(!request.headers().contains_key(header::ACCESS_CONTROL_REQUEST_HEADERS)); + assert!(!request.headers().get(header::REFERER).unwrap().to_str().unwrap().contains("a.html")); + response.headers_mut().typed_insert(AccessControlAllowOrigin::ANY); + response.headers_mut().typed_insert(AccessControlAllowCredentials); + response.headers_mut().typed_insert(AccessControlAllowMethods::from_iter(vec![Method::GET])); } else { - response.headers_mut().set(AccessControlAllowOrigin::Any); - response.send(ACK).unwrap(); + response.headers_mut().typed_insert(AccessControlAllowOrigin::ANY); + *response.body_mut() = ACK.to_vec().into(); } }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let target_url = url.clone().join("a.html").unwrap(); @@ -241,20 +238,20 @@ fn test_cors_preflight_cache_fetch() { let state = Arc::new(AtomicUsize::new(0)); let counter = state.clone(); let mut cache = CorsCache::new(); - let handler = move |request: HyperRequest, mut response: HyperResponse| { - if request.method == Method::Options && state.clone().fetch_add(1, Ordering::SeqCst) == 0 { - assert!(request.headers.has::<AccessControlRequestMethod>()); - assert!(!request.headers.has::<AccessControlRequestHeaders>()); - response.headers_mut().set(AccessControlAllowOrigin::Any); - response.headers_mut().set(AccessControlAllowCredentials); - response.headers_mut().set(AccessControlAllowMethods(vec![Method::Get])); - response.headers_mut().set(AccessControlMaxAge(6000)); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + if request.method() == Method::OPTIONS && state.clone().fetch_add(1, Ordering::SeqCst) == 0 { + assert!(request.headers().contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)); + assert!(!request.headers().contains_key(header::ACCESS_CONTROL_REQUEST_HEADERS)); + response.headers_mut().typed_insert(AccessControlAllowOrigin::ANY); + response.headers_mut().typed_insert(AccessControlAllowCredentials); + response.headers_mut().typed_insert(AccessControlAllowMethods::from_iter(vec![Method::GET])); + response.headers_mut().typed_insert(AccessControlMaxAge::from(Duration::new(6000, 0))); } else { - response.headers_mut().set(AccessControlAllowOrigin::Any); - response.send(ACK).unwrap(); + response.headers_mut().typed_insert(AccessControlAllowOrigin::ANY); + *response.body_mut() = ACK.to_vec().into(); } }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(ImmutableOrigin::new_opaque()); let mut request = Request::new(url.clone(), Some(origin.clone()), None); @@ -274,8 +271,8 @@ fn test_cors_preflight_cache_fetch() { assert_eq!(1, counter.load(Ordering::SeqCst)); // The entry exists in the CORS-preflight cache - assert_eq!(true, cache.match_method(&wrapped_request0, Method::Get)); - assert_eq!(true, cache.match_method(&wrapped_request1, Method::Get)); + assert_eq!(true, cache.match_method(&wrapped_request0, Method::GET)); + assert_eq!(true, cache.match_method(&wrapped_request1, Method::GET)); match *fetch_response0.body.lock().unwrap() { ResponseBody::Done(ref body) => assert_eq!(&**body, ACK), @@ -291,23 +288,23 @@ fn test_cors_preflight_cache_fetch() { fn test_cors_preflight_fetch_network_error() { static ACK: &'static [u8] = b"ACK"; let state = Arc::new(AtomicUsize::new(0)); - let handler = move |request: HyperRequest, mut response: HyperResponse| { - if request.method == Method::Options && state.clone().fetch_add(1, Ordering::SeqCst) == 0 { - assert!(request.headers.has::<AccessControlRequestMethod>()); - assert!(!request.headers.has::<AccessControlRequestHeaders>()); - response.headers_mut().set(AccessControlAllowOrigin::Any); - response.headers_mut().set(AccessControlAllowCredentials); - response.headers_mut().set(AccessControlAllowMethods(vec![Method::Get])); + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + if request.method() == Method::OPTIONS && state.clone().fetch_add(1, Ordering::SeqCst) == 0 { + assert!(request.headers().contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)); + assert!(!request.headers().contains_key(header::ACCESS_CONTROL_REQUEST_HEADERS)); + response.headers_mut().typed_insert(AccessControlAllowOrigin::ANY); + response.headers_mut().typed_insert(AccessControlAllowCredentials); + response.headers_mut().typed_insert(AccessControlAllowMethods::from_iter(vec![Method::GET])); } else { - response.headers_mut().set(AccessControlAllowOrigin::Any); - response.send(ACK).unwrap(); + response.headers_mut().typed_insert(AccessControlAllowOrigin::ANY); + *response.body_mut() = ACK.to_vec().into(); } }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(ImmutableOrigin::new_opaque()); let mut request = Request::new(url, Some(origin), None); - request.method = Method::Extension("CHICKEN".to_owned()); + request.method = Method::from_bytes(b"CHICKEN").unwrap(); request.referrer = Referrer::NoReferrer; request.use_cors_preflight = true; request.mode = RequestMode::CorsMode; @@ -320,14 +317,17 @@ fn test_cors_preflight_fetch_network_error() { #[test] fn test_fetch_response_is_basic_filtered() { static MESSAGE: &'static [u8] = b""; - let handler = move |_: HyperRequest, mut response: HyperResponse| { - response.headers_mut().set(SetCookie(vec![])); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + response.headers_mut().insert(header::SET_COOKIE, HeaderValue::from_static("")); // this header is obsoleted, so hyper doesn't implement it, but it's still covered by the spec - response.headers_mut().set_raw("Set-Cookie2", vec![]); + response.headers_mut().insert( + HeaderName::from_static("set-cookie2"), + HeaderValue::from_bytes(&vec![]).unwrap() + ); - response.send(MESSAGE).unwrap(); + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -339,39 +339,42 @@ fn test_fetch_response_is_basic_filtered() { assert_eq!(fetch_response.response_type, ResponseType::Basic); let headers = fetch_response.headers; - assert!(!headers.has::<SetCookie>()); - assert!(headers.get_raw("Set-Cookie2").is_none()); + assert!(!headers.contains_key(header::SET_COOKIE)); + assert!(headers.get(HeaderName::from_static("set-cookie2")).is_none()); } #[test] fn test_fetch_response_is_cors_filtered() { static MESSAGE: &'static [u8] = b""; - let handler = move |_: HyperRequest, mut response: HyperResponse| { + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { // this is mandatory for the Cors Check to pass // TODO test using different url encodings with this value ie. punycode - response.headers_mut().set(AccessControlAllowOrigin::Any); + response.headers_mut().typed_insert(AccessControlAllowOrigin::ANY); // these are the headers that should be kept after filtering - response.headers_mut().set(CacheControl(vec![])); - response.headers_mut().set(ContentLanguage(vec![])); - response.headers_mut().set(ContentType::html()); - response.headers_mut().set(Expires(HttpDate(time::now() + Duration::days(1)))); - response.headers_mut().set(LastModified(HttpDate(time::now()))); - response.headers_mut().set(Pragma::NoCache); + response.headers_mut().typed_insert(CacheControl::new()); + response.headers_mut().insert(header::CONTENT_LANGUAGE, HeaderValue::from_bytes(&vec![]).unwrap()); + response.headers_mut().typed_insert(ContentType::from(mime::TEXT_HTML)); + response.headers_mut().typed_insert(Expires::from(SystemTime::now() + Duration::new(86400, 0))); + response.headers_mut().typed_insert(LastModified::from(SystemTime::now())); + response.headers_mut().typed_insert(Pragma::no_cache()); // these headers should not be kept after filtering, even though they are given a pass - response.headers_mut().set(SetCookie(vec![])); - response.headers_mut().set_raw("Set-Cookie2", vec![]); - response.headers_mut().set( - AccessControlAllowHeaders(vec![ - UniCase("set-cookie".to_owned()), - UniCase("set-cookie2".to_owned()) + response.headers_mut().insert(header::SET_COOKIE, HeaderValue::from_static("")); + response.headers_mut().insert( + HeaderName::from_static("set-cookie2"), + HeaderValue::from_bytes(&vec![]).unwrap() + ); + response.headers_mut().typed_insert( + AccessControlAllowHeaders::from_iter(vec![ + HeaderName::from_static("set-cookie"), + HeaderName::from_static("set-cookie2") ]) ); - response.send(MESSAGE).unwrap(); + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); // an origin mis-match will stop it from defaulting to a basic filtered response let origin = Origin::Origin(ImmutableOrigin::new_opaque()); @@ -385,25 +388,25 @@ fn test_fetch_response_is_cors_filtered() { assert_eq!(fetch_response.response_type, ResponseType::Cors); let headers = fetch_response.headers; - assert!(headers.has::<CacheControl>()); - assert!(headers.has::<ContentLanguage>()); - assert!(headers.has::<ContentType>()); - assert!(headers.has::<Expires>()); - assert!(headers.has::<LastModified>()); - assert!(headers.has::<Pragma>()); - - assert!(!headers.has::<AccessControlAllowOrigin>()); - assert!(!headers.has::<SetCookie>()); - assert!(headers.get_raw("Set-Cookie2").is_none()); + assert!(headers.contains_key(header::CACHE_CONTROL)); + assert!(headers.contains_key(header::CONTENT_LANGUAGE)); + assert!(headers.contains_key(header::CONTENT_TYPE)); + assert!(headers.contains_key(header::EXPIRES)); + assert!(headers.contains_key(header::LAST_MODIFIED)); + assert!(headers.contains_key(header::PRAGMA)); + + assert!(!headers.contains_key(header::ACCESS_CONTROL_ALLOW_ORIGIN)); + assert!(!headers.contains_key(header::SET_COOKIE)); + assert!(headers.get(HeaderName::from_static("set-cookie2")).is_none()); } #[test] fn test_fetch_response_is_opaque_filtered() { static MESSAGE: &'static [u8] = b""; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); // an origin mis-match will fall through to an Opaque filtered response let origin = Origin::Origin(ImmutableOrigin::new_opaque()); @@ -419,7 +422,7 @@ fn test_fetch_response_is_opaque_filtered() { assert!(fetch_response.url_list.is_empty()); // this also asserts that status message is "the empty byte sequence" assert!(fetch_response.status.is_none()); - assert_eq!(fetch_response.headers, Headers::new()); + assert_eq!(fetch_response.headers, HeaderMap::new()); match *fetch_response.body.lock().unwrap() { ResponseBody::Empty => { }, _ => panic!() @@ -433,25 +436,18 @@ fn test_fetch_response_is_opaque_filtered() { #[test] fn test_fetch_response_is_opaque_redirect_filtered() { static MESSAGE: &'static [u8] = b""; - let handler = move |request: HyperRequest, mut response: HyperResponse| { - let redirects = match request.uri { - RequestUri::AbsolutePath(url) => - url.split("/").collect::<String>().parse::<u32>().unwrap_or(0), - RequestUri::AbsoluteUri(url) => - url.path_segments().unwrap().next_back().unwrap().parse::<u32>().unwrap_or(0), - _ => panic!() - }; + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + let redirects = request.uri().path().split("/").collect::<String>().parse::<u32>().unwrap_or(0); if redirects == 1 { - response.send(MESSAGE).unwrap(); + *response.body_mut() = MESSAGE.to_vec().into(); } else { - *response.status_mut() = StatusCode::Found; - let url = format!("{}", 1); - response.headers_mut().set(Location(url.to_owned())); + *response.status_mut() = StatusCode::FOUND; + response.headers_mut().insert(header::LOCATION, HeaderValue::from_static("1")); } }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -465,7 +461,7 @@ fn test_fetch_response_is_opaque_redirect_filtered() { // this also asserts that status message is "the empty byte sequence" assert!(fetch_response.status.is_none()); - assert_eq!(fetch_response.headers, Headers::new()); + assert_eq!(fetch_response.headers, HeaderMap::new()); match *fetch_response.body.lock().unwrap() { ResponseBody::Empty => { }, _ => panic!() @@ -481,10 +477,10 @@ fn test_fetch_with_local_urls_only() { // If flag `local_urls_only` is set, fetching a non-local URL must result in network error. static MESSAGE: &'static [u8] = b""; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, server_url) = make_server(handler); + let (server, server_url) = make_server(handler); let do_fetch = |url: ServoUrl| { let origin = Origin::Origin(url.origin()); @@ -506,7 +502,6 @@ fn test_fetch_with_local_urls_only() { assert!(!local_response.is_network_error()); assert!(server_response.is_network_error()); } - // NOTE(emilio): If this test starts failing: // // openssl req -x509 -nodes -days 3650 -newkey rsa:2048 \ @@ -517,22 +512,17 @@ fn test_fetch_with_local_urls_only() { #[test] fn test_fetch_with_hsts() { static MESSAGE: &'static [u8] = b""; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; let cert_path = Path::new("../../resources/self_signed_certificate_for_testing.crt").canonicalize().unwrap(); let key_path = Path::new("../../resources/privatekey_for_testing.key").canonicalize().unwrap(); - - let ssl = hyper_openssl::OpensslServer::from_files(key_path, cert_path.clone()) - .unwrap(); - - //takes an address and something that implements hyper::net::Ssl - let mut server = Server::https("0.0.0.0:0", ssl).unwrap().handle_threads(handler, 1).unwrap(); + let (server, url) = make_ssl_server(handler, cert_path.clone(), key_path.clone()); let mut ca_content = String::new(); File::open(cert_path).unwrap().read_to_string(&mut ca_content).unwrap(); - let ssl_client = create_ssl_client(&ca_content); + let ssl_client = create_ssl_connector_builder(&ca_content); let context = FetchContext { state: Arc::new(HttpState::new(ssl_client)), @@ -547,15 +537,13 @@ fn test_fetch_with_hsts() { list.push(HstsEntry::new("localhost".to_owned(), IncludeSubdomains::NotIncluded, None) .unwrap()); } - let url_string = format!("http://localhost:{}", server.socket.port()); - let url = ServoUrl::parse(&url_string).unwrap(); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); request.referrer = Referrer::NoReferrer; // Set the flag. request.local_urls_only = false; let response = fetch_with_context(&mut request, &context); - let _ = server.close(); + server.close(); assert_eq!(response.internal_response.unwrap().url().unwrap().scheme(), "https"); } @@ -563,10 +551,10 @@ fn test_fetch_with_hsts() { #[test] fn test_fetch_with_sri_network_error() { static MESSAGE: &'static [u8] = b"alert('Hello, Network Error');"; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -587,10 +575,10 @@ fn test_fetch_with_sri_network_error() { #[test] fn test_fetch_with_sri_sucess() { static MESSAGE: &'static [u8] = b"alert('Hello, world.');"; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -616,20 +604,20 @@ fn test_fetch_blocked_nosniff() { mime: Mime, should_error: bool) { const MESSAGE: &'static [u8] = b""; - const HEADER: &'static str = "X-Content-Type-Options"; + const HEADER: &'static str = "x-content-type-options"; const VALUE: &'static [u8] = b"nosniff"; - let handler = move |_: HyperRequest, mut response: HyperResponse| { - let mime_header = ContentType(mime.clone()); - response.headers_mut().set(mime_header); - assert!(response.headers().has::<ContentType>()); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + let mime_header = ContentType::from(mime.clone()); + response.headers_mut().typed_insert(mime_header); + assert!(response.headers().contains_key(header::CONTENT_TYPE)); // Add the nosniff header - response.headers_mut().set_raw(HEADER, vec![VALUE.to_vec()]); + response.headers_mut().insert(HeaderName::from_static(HEADER), HeaderValue::from_bytes(VALUE).unwrap()); - response.send(MESSAGE).unwrap(); + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -641,9 +629,9 @@ fn test_fetch_blocked_nosniff() { } let tests = vec![ - (Destination::Script, Mime(TopLevel::Text, SubLevel::Javascript, vec![]), false), - (Destination::Script, Mime(TopLevel::Text, SubLevel::Css, vec![]), true), - (Destination::Style, Mime(TopLevel::Text, SubLevel::Css, vec![]), false), + (Destination::Script, mime::TEXT_JAVASCRIPT, false), + (Destination::Script, mime::TEXT_CSS, true), + (Destination::Style, mime::TEXT_CSS, false), ]; for test in tests { @@ -653,25 +641,19 @@ fn test_fetch_blocked_nosniff() { } fn setup_server_and_fetch(message: &'static [u8], redirect_cap: u32) -> Response { - let handler = move |request: HyperRequest, mut response: HyperResponse| { - let redirects = match request.uri { - RequestUri::AbsolutePath(url) => - url.split("/").collect::<String>().parse::<u32>().unwrap_or(0), - RequestUri::AbsoluteUri(url) => - url.path_segments().unwrap().next_back().unwrap().parse::<u32>().unwrap_or(0), - _ => panic!() - }; + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + let redirects = request.uri().path().split("/").collect::<String>().parse::<u32>().unwrap_or(0); if redirects >= redirect_cap { - response.send(message).unwrap(); + *response.body_mut() = message.to_vec().into(); } else { - *response.status_mut() = StatusCode::Found; + *response.status_mut() = StatusCode::FOUND; let url = format!("{redirects}", redirects = redirects + 1); - response.headers_mut().set(Location(url.to_owned())); + response.headers_mut().insert(header::LOCATION, HeaderValue::from_str(&url).unwrap()); } }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -720,30 +702,24 @@ fn test_fetch_redirect_updates_method_runner(tx: Sender<bool>, status_code: Stat let handler_method = method.clone(); let handler_tx = Arc::new(Mutex::new(tx)); - let handler = move |request: HyperRequest, mut response: HyperResponse| { - let redirects = match request.uri { - RequestUri::AbsolutePath(url) => - url.split("/").collect::<String>().parse::<u32>().unwrap_or(0), - RequestUri::AbsoluteUri(url) => - url.path_segments().unwrap().next_back().unwrap().parse::<u32>().unwrap_or(0), - _ => panic!() - }; + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + let redirects = request.uri().path().split("/").collect::<String>().parse::<u32>().unwrap_or(0); let mut test_pass = true; if redirects == 0 { - *response.status_mut() = StatusCode::TemporaryRedirect; - response.headers_mut().set(Location("1".to_owned())); + *response.status_mut() = StatusCode::TEMPORARY_REDIRECT; + response.headers_mut().insert(header::LOCATION, HeaderValue::from_static("1")); } else if redirects == 1 { // this makes sure that the request method does't change from the wrong status code - if handler_method != Method::Get && request.method == Method::Get { + if handler_method != Method::GET && request.method() == Method::GET { test_pass = false; } *response.status_mut() = status_code; - response.headers_mut().set(Location("2".to_owned())); + response.headers_mut().insert(header::LOCATION, HeaderValue::from_static("2")); - } else if request.method != Method::Get { + } else if request.method() != Method::GET { test_pass = false; } @@ -754,7 +730,7 @@ fn test_fetch_redirect_updates_method_runner(tx: Sender<bool>, status_code: Stat }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -769,36 +745,36 @@ fn test_fetch_redirect_updates_method_runner(tx: Sender<bool>, status_code: Stat fn test_fetch_redirect_updates_method() { let (tx, rx) = channel(); - test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::MovedPermanently, Method::Post); + test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::MOVED_PERMANENTLY, Method::POST); assert_eq!(rx.recv().unwrap(), true); assert_eq!(rx.recv().unwrap(), true); // make sure the test doesn't send more data than expected assert_eq!(rx.try_recv().is_none(), true); - test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::Found, Method::Post); + test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::FOUND, Method::POST); assert_eq!(rx.recv().unwrap(), true); assert_eq!(rx.recv().unwrap(), true); assert_eq!(rx.try_recv().is_none(), true); - test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::SeeOther, Method::Get); + test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::SEE_OTHER, Method::GET); assert_eq!(rx.recv().unwrap(), true); assert_eq!(rx.recv().unwrap(), true); assert_eq!(rx.try_recv().is_none(), true); - let extension = Method::Extension("FOO".to_owned()); + let extension = Method::from_bytes(b"FOO").unwrap(); - test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::MovedPermanently, extension.clone()); + test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::MOVED_PERMANENTLY, extension.clone()); assert_eq!(rx.recv().unwrap(), true); // for MovedPermanently and Found, Method should only be changed if it was Post assert_eq!(rx.recv().unwrap(), false); assert_eq!(rx.try_recv().is_none(), true); - test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::Found, extension.clone()); + test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::FOUND, extension.clone()); assert_eq!(rx.recv().unwrap(), true); assert_eq!(rx.recv().unwrap(), false); assert_eq!(rx.try_recv().is_none(), true); - test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::SeeOther, extension.clone()); + test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::SEE_OTHER, extension.clone()); assert_eq!(rx.recv().unwrap(), true); // for SeeOther, Method should always be changed, so this should be true assert_eq!(rx.recv().unwrap(), true); @@ -826,10 +802,10 @@ fn response_is_done(response: &Response) -> bool { #[test] fn test_fetch_async_returns_complete_response() { static MESSAGE: &'static [u8] = b"this message should be retrieved in full"; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -844,10 +820,10 @@ fn test_fetch_async_returns_complete_response() { #[test] fn test_opaque_filtered_fetch_async_returns_complete_response() { static MESSAGE: &'static [u8] = b""; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); // an origin mis-match will fall through to an Opaque filtered response let origin = Origin::Origin(ImmutableOrigin::new_opaque()); @@ -865,25 +841,18 @@ fn test_opaque_filtered_fetch_async_returns_complete_response() { #[test] fn test_opaque_redirect_filtered_fetch_async_returns_complete_response() { static MESSAGE: &'static [u8] = b""; - let handler = move |request: HyperRequest, mut response: HyperResponse| { - let redirects = match request.uri { - RequestUri::AbsolutePath(url) => - url.split("/").collect::<String>().parse::<u32>().unwrap_or(0), - RequestUri::AbsoluteUri(url) => - url.path_segments().unwrap().last().unwrap().parse::<u32>().unwrap_or(0), - _ => panic!() - }; + let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + let redirects = request.uri().path().split("/").collect::<String>().parse::<u32>().unwrap_or(0); if redirects == 1 { - response.send(MESSAGE).unwrap(); + *response.body_mut() = MESSAGE.to_vec().into(); } else { - *response.status_mut() = StatusCode::Found; - let url = format!("{}", 1); - response.headers_mut().set(Location(url.to_owned())); + *response.status_mut() = StatusCode::FOUND; + response.headers_mut().insert(header::LOCATION, HeaderValue::from_static("1")); } }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url, Some(origin), None); @@ -901,11 +870,11 @@ fn test_opaque_redirect_filtered_fetch_async_returns_complete_response() { #[test] fn test_fetch_with_devtools() { static MESSAGE: &'static [u8] = b"Yay!"; - let handler = move |_: HyperRequest, response: HyperResponse| { - response.send(MESSAGE).unwrap(); + let handler = move |_: HyperRequest<Body>, response: &mut HyperResponse<Body>| { + *response.body_mut() = MESSAGE.to_vec().into(); }; - let (mut server, url) = make_server(handler); + let (server, url) = make_server(handler); let origin = Origin::Origin(url.origin()); let mut request = Request::new(url.clone(), Some(origin), Some(TEST_PIPELINE_ID)); @@ -921,36 +890,23 @@ fn test_fetch_with_devtools() { let mut 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())) - ])); + let mut headers = HeaderMap::new(); - headers.set(Host { hostname: url.host_str().unwrap().to_owned() , port: url.port().to_owned() }); + 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())); - let accept = Accept(vec![qitem(Mime(TopLevel::Star, SubLevel::Star, vec![]))]); - headers.set(accept); + headers.insert(header::ACCEPT, HeaderValue::from_static("*/*")); - 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()); let httprequest = DevtoolsHttpRequest { url: url, - method: Method::Get, + method: Method::GET, headers: headers, - body: None, + body: Some(vec![]), pipeline_id: TEST_PIPELINE_ID, startedDateTime: devhttprequest.startedDateTime, timeStamp: devhttprequest.timeStamp, @@ -960,9 +916,9 @@ fn test_fetch_with_devtools() { }; let content = "Yay!"; - let mut response_headers = Headers::new(); - response_headers.set(ContentLength(content.len() as u64)); - devhttpresponse.headers.as_mut().unwrap().remove::<Date>(); + let mut response_headers = HeaderMap::new(); + response_headers.typed_insert(ContentLength(content.len() as u64)); + devhttpresponse.headers.as_mut().unwrap().remove(header::DATE); let httpresponse = DevtoolsHttpResponse { headers: Some(response_headers), 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(); } diff --git a/components/net/tests/main.rs b/components/net/tests/main.rs index aeddb5105d1..ad666198a07 100644 --- a/components/net/tests/main.rs +++ b/components/net/tests/main.rs @@ -8,19 +8,27 @@ extern crate cookie as cookie_rs; extern crate devtools_traits; extern crate embedder_traits; extern crate flate2; +extern crate futures; +extern crate headers_core; +extern crate headers_ext; +extern crate http; extern crate hyper; -extern crate hyper_openssl; extern crate hyper_serde; extern crate ipc_channel; +#[macro_use] +extern crate lazy_static; +extern crate mime; extern crate msg; extern crate net; extern crate net_traits; +extern crate openssl; extern crate profile_traits; extern crate servo_channel; extern crate servo_config; extern crate servo_url; extern crate time; -extern crate unicase; +extern crate tokio; +extern crate tokio_openssl; extern crate url; mod cookie; @@ -38,8 +46,12 @@ mod subresource_integrity; use devtools_traits::DevtoolsControlMsg; use embedder_traits::{EmbedderProxy, EventLoopWaker}; use embedder_traits::resources::{self, Resource}; -use hyper::server::{Handler, Listening, Server}; -use net::connector::create_ssl_client; +use futures::{Future, Stream}; +use hyper::{Body, Request as HyperRequest, Response as HyperResponse}; +use hyper::server::Server as HyperServer; +use hyper::server::conn::Http; +use hyper::service::service_fn_ok; +use net::connector::create_ssl_connector_builder; use net::fetch::cors_cache::CorsCache; use net::fetch::methods::{self, CancellationListener, FetchContext}; use net::filemanager_thread::FileManager; @@ -47,9 +59,21 @@ use net::test::HttpState; use net_traits::FetchTaskTarget; use net_traits::request::Request; use net_traits::response::Response; +use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod}; use servo_channel::{channel, Sender}; use servo_url::ServoUrl; +use std::net::TcpListener as StdTcpListener; +use std::path::PathBuf; use std::sync::{Arc, Mutex}; +use tokio::net::TcpListener; +use tokio::runtime::Runtime; +use tokio_openssl::SslAcceptorExt; + +lazy_static! { + pub static ref HANDLE: Mutex<Runtime> = { + Mutex::new(Runtime::new().unwrap()) + }; +} const DEFAULT_USER_AGENT: &'static str = "Such Browser. Very Layout. Wow."; @@ -84,10 +108,10 @@ fn create_embedder_proxy() -> EmbedderProxy { } fn new_fetch_context(dc: Option<Sender<DevtoolsControlMsg>>, fc: Option<EmbedderProxy>) -> FetchContext { - let ssl_client = create_ssl_client(&resources::read_string(Resource::SSLCertificates)); + let ssl_connector = create_ssl_connector_builder(&resources::read_string(Resource::SSLCertificates)); let sender = fc.unwrap_or_else(|| create_embedder_proxy()); FetchContext { - state: Arc::new(HttpState::new(ssl_client)), + state: Arc::new(HttpState::new(ssl_connector)), user_agent: DEFAULT_USER_AGENT.into(), devtools_chan: dc, filemanager: FileManager::new(sender), @@ -131,10 +155,78 @@ fn fetch_with_cors_cache(request: &mut Request, cache: &mut CorsCache) -> Respon receiver.recv().unwrap() } -fn make_server<H: Handler + 'static>(handler: H) -> (Listening, ServoUrl) { - // this is a Listening server because of handle_threads() - let server = Server::http("0.0.0.0:0").unwrap().handle_threads(handler, 2).unwrap(); - let url_string = format!("http://localhost:{}", server.socket.port()); +pub(crate) struct Server { + pub close_channel: futures::sync::oneshot::Sender<()>, +} + +impl Server { + fn close(self) { + self.close_channel.send(()).unwrap(); + } +} + +fn make_server<H>(handler: H) -> (Server, ServoUrl) + where + H: Fn(HyperRequest<Body>, &mut HyperResponse<Body>) + Send + Sync + 'static, +{ + let handler = Arc::new(handler); + let listener = StdTcpListener::bind("0.0.0.0:0").unwrap(); + let url_string = format!("http://localhost:{}", listener.local_addr().unwrap().port()); let url = ServoUrl::parse(&url_string).unwrap(); + let (tx, rx) = futures::sync::oneshot::channel::<()>(); + let server = HyperServer::from_tcp(listener).unwrap().serve( + move || { + let handler = handler.clone(); + service_fn_ok(move |req: HyperRequest<Body>| { + let mut response = HyperResponse::new(Vec::<u8>::new().into()); + handler(req, &mut response); + response + }) + } + ) + .with_graceful_shutdown(rx) + .map_err(|_|()); + + HANDLE.lock().unwrap().spawn(server); + let server = Server { close_channel: tx }; + (server, url) +} + +fn make_ssl_server<H>(handler: H, cert_path: PathBuf, key_path: PathBuf) -> (Server, ServoUrl) + where + H: Fn(HyperRequest<Body>, &mut HyperResponse<Body>) + Send + Sync + 'static, +{ + let handler = Arc::new(handler); + let listener = StdTcpListener::bind("[::0]:0").unwrap(); + let listener = TcpListener::from_std(listener, &HANDLE.lock().unwrap().reactor()).unwrap(); + let url_string = format!("http://localhost:{}", listener.local_addr().unwrap().port()); + let url = ServoUrl::parse(&url_string).unwrap(); + + let server = listener.incoming() + .map_err(|_| ()) + .for_each(move |sock| { + let mut ssl_builder = SslAcceptor::mozilla_modern(SslMethod::tls()).unwrap(); + ssl_builder.set_certificate_file(&cert_path, SslFiletype::PEM).unwrap(); + ssl_builder.set_private_key_file(&key_path, SslFiletype::PEM).unwrap(); + + let handler = handler.clone(); + ssl_builder.build().accept_async(sock).map_err(|_| ()).and_then(move |ssl| { + Http::new().serve_connection(ssl, + service_fn_ok(move |req: HyperRequest<Body>| { + let mut response = HyperResponse::new(Vec::<u8>::new().into()); + handler(req, &mut response); + response + }) + ) + .map_err(|_|()) + }) + }); + + let (tx, rx) = futures::sync::oneshot::channel::<()>(); + let server = server.select(rx.map_err(|_| ())).map(|_| ()).map_err(|_| ()); + + HANDLE.lock().unwrap().spawn(server); + + let server = Server { close_channel: tx }; (server, url) } diff --git a/components/net/tests/mime_classifier.rs b/components/net/tests/mime_classifier.rs index 1a4757ded5f..593017c7f2c 100644 --- a/components/net/tests/mime_classifier.rs +++ b/components/net/tests/mime_classifier.rs @@ -2,8 +2,8 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +use mime::{self, Mime}; use net::mime_classifier::{ApacheBugFlag, MimeClassifier, Mp4Matcher, NoSniffFlag}; -use net::mime_classifier::as_string_option; use net_traits::LoadContext; use std::env; use std::fs::File; @@ -58,11 +58,10 @@ fn test_validate_classifier() { #[cfg(test)] fn test_sniff_with_flags(filename_orig: &path::Path, - type_string: &str, - subtype_string: &str, - supplied_type: Option<(&'static str, &'static str)>, - no_sniff_flag: NoSniffFlag, - apache_bug_flag: ApacheBugFlag) { + expected_mime: Mime, + supplied_type: Option<Mime>, + no_sniff_flag: NoSniffFlag, + apache_bug_flag: ApacheBugFlag) { let current_working_directory = env::current_dir().unwrap(); println!("The current directory is {}", current_working_directory.display()); @@ -75,17 +74,15 @@ fn test_sniff_with_flags(filename_orig: &path::Path, match read_result { Ok(data) => { - let supplied_type = supplied_type.map(|(x, y)| (x.parse().unwrap(), y)); - let (parsed_type, parsed_subtp) = classifier.classify(LoadContext::Browsing, - no_sniff_flag, - apache_bug_flag, - &as_string_option(supplied_type), - &data); - if (&parsed_type[..] != type_string) || - (&parsed_subtp[..] != subtype_string) { - panic!("File {:?} parsed incorrectly should be {}/{}, parsed as {}/{}", - filename, type_string, subtype_string, - parsed_type, parsed_subtp); + let parsed_mime = classifier.classify(LoadContext::Browsing, + no_sniff_flag, + apache_bug_flag, + &supplied_type, + &data); + if (parsed_mime.type_() != expected_mime.type_()) || + (parsed_mime.subtype() != expected_mime.subtype()) { + panic!("File {:?} parsed incorrectly should be {:?}, parsed as {:?}", + filename, expected_mime, parsed_mime); } } Err(e) => panic!("Couldn't read from file {:?} with error {}", @@ -94,407 +91,407 @@ fn test_sniff_with_flags(filename_orig: &path::Path, } #[cfg(test)] -fn test_sniff_full(filename_orig: &path::Path, type_string: &str, subtype_string: &str, - supplied_type: Option<(&'static str, &'static str)>) { +fn test_sniff_full(filename_orig: &path::Path, expected_mime: Mime, + supplied_type: Option<Mime>) { test_sniff_with_flags(filename_orig, - type_string, - subtype_string, + expected_mime, supplied_type, NoSniffFlag::Off, ApacheBugFlag::Off) } #[cfg(test)] -fn test_sniff_classification(file: &str, type_string: &str, subtype_string: &str, - supplied_type: Option<(&'static str, &'static str)>) { +fn test_sniff_classification(file: &str, expected_mime: Mime, supplied_type: Option<Mime>) { let mut x = PathBuf::from("./"); - x.push(type_string); - x.push(subtype_string); + x.push(expected_mime.type_().as_str()); + x.push(expected_mime.subtype().as_str()); x.push(file); - test_sniff_full(&x, type_string, subtype_string, supplied_type); + test_sniff_full(&x, expected_mime, supplied_type); } #[cfg(test)] -fn test_sniff_classification_sup(file: &str, type_string: &'static str, subtype_string: &str) { - test_sniff_classification(file, type_string, subtype_string, None); - let class_type = Some((type_string, "")); - test_sniff_classification(file, type_string, subtype_string, class_type); +fn test_sniff_classification_sup(file: &str, expected_mime: Mime) { + test_sniff_classification(file, expected_mime.clone(), None); + let no_sub = format!("{}/", expected_mime.type_()).parse().unwrap(); + test_sniff_classification(file, expected_mime, Some(no_sub)); } #[test] fn test_sniff_x_icon() { - test_sniff_classification_sup("test.ico", "image", "x-icon"); + test_sniff_classification_sup("test.ico", "image/x-icon".parse().unwrap()); } #[test] fn test_sniff_x_icon_cursor() { - test_sniff_classification_sup("test_cursor.ico", "image", "x-icon"); + test_sniff_classification_sup("test_cursor.ico", "image/x-icon".parse().unwrap()); } #[test] fn test_sniff_bmp() { - test_sniff_classification_sup("test.bmp", "image", "bmp"); + test_sniff_classification_sup("test.bmp", mime::IMAGE_BMP); } #[test] fn test_sniff_gif87a() { - test_sniff_classification_sup("test87a", "image", "gif"); + test_sniff_classification_sup("test87a", mime::IMAGE_GIF); } #[test] fn test_sniff_gif89a() { - test_sniff_classification_sup("test89a.gif", "image", "gif"); + test_sniff_classification_sup("test89a.gif", mime::IMAGE_GIF); } #[test] fn test_sniff_webp() { - test_sniff_classification_sup("test.webp", "image", "webp"); + test_sniff_classification_sup("test.webp", "image/webp".parse().unwrap()); } #[test] fn test_sniff_png() { - test_sniff_classification_sup("test.png", "image", "png"); + test_sniff_classification_sup("test.png", mime::IMAGE_PNG); } #[test] fn test_sniff_jpg() { - test_sniff_classification_sup("test.jpg", "image", "jpeg"); + test_sniff_classification_sup("test.jpg", mime::IMAGE_JPEG); } #[test] fn test_sniff_webm() { - test_sniff_classification_sup("test.webm", "video", "webm"); + test_sniff_classification_sup("test.webm", "video/webm".parse().unwrap()); } #[test] fn test_sniff_mp4() { - test_sniff_classification_sup("test.mp4", "video", "mp4"); + test_sniff_classification_sup("test.mp4", "video/mp4".parse().unwrap()); } #[test] fn test_sniff_avi() { - test_sniff_classification_sup("test.avi", "video", "avi"); + test_sniff_classification_sup("test.avi", "video/avi".parse().unwrap()); } #[test] fn test_sniff_basic() { - test_sniff_classification_sup("test.au", "audio", "basic"); + test_sniff_classification_sup("test.au", "audio/basic".parse().unwrap()); } #[test] fn test_sniff_aiff() { - test_sniff_classification_sup("test.aif", "audio", "aiff"); + test_sniff_classification_sup("test.aif", "audio/aiff".parse().unwrap()); } #[test] fn test_sniff_mpeg() { - test_sniff_classification_sup("test.mp3", "audio", "mpeg"); + test_sniff_classification_sup("test.mp3", "audio/mpeg".parse().unwrap()); } #[test] fn test_sniff_midi() { - test_sniff_classification_sup("test.mid", "audio", "midi"); + test_sniff_classification_sup("test.mid", "audio/midi".parse().unwrap()); } #[test] fn test_sniff_wave() { - test_sniff_classification_sup("test.wav", "audio", "wave"); + test_sniff_classification_sup("test.wav", "audio/wave".parse().unwrap()); } #[test] fn test_sniff_ogg() { - test_sniff_classification("small.ogg", "application", "ogg", None); - test_sniff_classification("small.ogg", "application", "ogg", Some(("audio", ""))); + test_sniff_classification("small.ogg", "application/ogg".parse().unwrap(), None); + test_sniff_classification("small.ogg", "application/ogg".parse().unwrap(), Some("audio/".parse().unwrap())); } #[test] #[should_panic] fn test_sniff_vsn_ms_fontobject() { - test_sniff_classification_sup("vnd.ms-fontobject", "application", "vnd.ms-fontobject"); + test_sniff_classification_sup("vnd.ms-fontobject", "application/vnd.ms-fontobject".parse().unwrap()); } #[test] #[should_panic] fn test_sniff_true_type() { - test_sniff_full(&PathBuf::from("unknown/true_type.ttf"), "(TrueType)", "", None); + test_sniff_full(&PathBuf::from("unknown/true_type.ttf"), "(TrueType)/".parse().unwrap(), None); } #[test] #[should_panic] fn test_sniff_open_type() { - test_sniff_full(&PathBuf::from("unknown/open_type"), "(OpenType)", "", None); + test_sniff_full(&PathBuf::from("unknown/open_type"), "(OpenType)/".parse().unwrap(), None); } #[test] #[should_panic] fn test_sniff_true_type_collection() { - test_sniff_full(&PathBuf::from("unknown/true_type_collection.ttc"), "(TrueType Collection)", "", None); + test_sniff_full(&PathBuf::from("unknown/true_type_collection.ttc"), "(TrueType Collection)/".parse().unwrap(), + None); } #[test] #[should_panic] fn test_sniff_woff() { - test_sniff_classification_sup("test.wof", "application", "font-woff"); + test_sniff_classification_sup("test.wof", "application/font-woff".parse().unwrap()); } #[test] fn test_sniff_gzip() { - test_sniff_classification("test.gz", "application", "x-gzip", None); + test_sniff_classification("test.gz", "application/x-gzip".parse().unwrap(), None); } #[test] fn test_sniff_zip() { - test_sniff_classification("test.zip", "application", "zip", None); + test_sniff_classification("test.zip", "application/zip".parse().unwrap(), None); } #[test] fn test_sniff_rar() { - test_sniff_classification("test.rar", "application", "x-rar-compressed", None); + test_sniff_classification("test.rar", "application/x-rar-compressed".parse().unwrap(), None); } #[test] fn test_sniff_text_html_doctype_20() { - test_sniff_classification("text_html_doctype_20.html", "text", "html", None); - test_sniff_classification("text_html_doctype_20_u.html", "text", "html", None); + test_sniff_classification("text_html_doctype_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_doctype_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_doctype_3e() { - test_sniff_classification("text_html_doctype_3e.html", "text", "html", None); - test_sniff_classification("text_html_doctype_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_doctype_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_doctype_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_page_20() { - test_sniff_classification("text_html_page_20.html", "text", "html", None); - test_sniff_classification("text_html_page_20_u.html", "text", "html", None); + test_sniff_classification("text_html_page_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_page_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_page_3e() { - test_sniff_classification("text_html_page_3e.html", "text", "html", None); - test_sniff_classification("text_html_page_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_page_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_page_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_head_20() { - test_sniff_classification("text_html_head_20.html", "text", "html", None); - test_sniff_classification("text_html_head_20_u.html", "text", "html", None); + test_sniff_classification("text_html_head_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_head_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_head_3e() { - test_sniff_classification("text_html_head_3e.html", "text", "html", None); - test_sniff_classification("text_html_head_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_head_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_head_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_script_20() { - test_sniff_classification("text_html_script_20.html", "text", "html", None); - test_sniff_classification("text_html_script_20_u.html", "text", "html", None); + test_sniff_classification("text_html_script_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_script_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_script_3e() { - test_sniff_classification("text_html_script_3e.html", "text", "html", None); - test_sniff_classification("text_html_script_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_script_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_script_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_iframe_20() { - test_sniff_classification("text_html_iframe_20.html", "text", "html", None); - test_sniff_classification("text_html_iframe_20_u.html", "text", "html", None); + test_sniff_classification("text_html_iframe_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_iframe_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_iframe_3e() { - test_sniff_classification("text_html_iframe_3e.html", "text", "html", None); - test_sniff_classification("text_html_iframe_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_iframe_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_iframe_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_h1_20() { - test_sniff_classification("text_html_h1_20.html", "text", "html", None); - test_sniff_classification("text_html_h1_20_u.html", "text", "html", None); + test_sniff_classification("text_html_h1_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_h1_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_h1_3e() { - test_sniff_classification("text_html_h1_3e.html", "text", "html", None); - test_sniff_classification("text_html_h1_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_h1_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_h1_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_div_20() { - test_sniff_classification("text_html_div_20.html", "text", "html", None); - test_sniff_classification("text_html_div_20_u.html", "text", "html", None); + test_sniff_classification("text_html_div_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_div_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_div_3e() { - test_sniff_classification("text_html_div_3e.html", "text", "html", None); - test_sniff_classification("text_html_div_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_div_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_div_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_font_20() { - test_sniff_classification("text_html_font_20.html", "text", "html", None); - test_sniff_classification("text_html_font_20_u.html", "text", "html", None); + test_sniff_classification("text_html_font_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_font_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_font_3e() { - test_sniff_classification("text_html_font_3e.html", "text", "html", None); - test_sniff_classification("text_html_font_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_font_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_font_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_table_20() { - test_sniff_classification("text_html_table_20.html", "text", "html", None); - test_sniff_classification("text_html_table_20_u.html", "text", "html", None); + test_sniff_classification("text_html_table_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_table_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_table_3e() { - test_sniff_classification("text_html_table_3e.html", "text", "html", None); - test_sniff_classification("text_html_table_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_table_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_table_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_a_20() { - test_sniff_classification("text_html_a_20.html", "text", "html", None); - test_sniff_classification("text_html_a_20_u.html", "text", "html", None); + test_sniff_classification("text_html_a_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_a_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_a_3e() { - test_sniff_classification("text_html_a_3e.html", "text", "html", None); - test_sniff_classification("text_html_a_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_a_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_a_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_style_20() { - test_sniff_classification("text_html_style_20.html", "text", "html", None); - test_sniff_classification("text_html_style_20_u.html", "text", "html", None); + test_sniff_classification("text_html_style_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_style_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_style_3e() { - test_sniff_classification("text_html_style_3e.html", "text", "html", None); - test_sniff_classification("text_html_style_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_style_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_style_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_title_20() { - test_sniff_classification("text_html_title_20.html", "text", "html", None); - test_sniff_classification("text_html_title_20_u.html", "text", "html", None); + test_sniff_classification("text_html_title_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_title_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_title_3e() { - test_sniff_classification("text_html_title_3e.html", "text", "html", None); - test_sniff_classification("text_html_title_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_title_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_title_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_b_20() { - test_sniff_classification("text_html_b_20.html", "text", "html", None); - test_sniff_classification("text_html_b_20_u.html", "text", "html", None); + test_sniff_classification("text_html_b_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_b_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_b_3e() { - test_sniff_classification("text_html_b_3e.html", "text", "html", None); - test_sniff_classification("text_html_b_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_b_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_b_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_body_20() { - test_sniff_classification("text_html_body_20.html", "text", "html", None); - test_sniff_classification("text_html_body_20_u.html", "text", "html", None); + test_sniff_classification("text_html_body_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_body_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_body_3e() { - test_sniff_classification("text_html_body_3e.html", "text", "html", None); - test_sniff_classification("text_html_body_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_body_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_body_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_br_20() { - test_sniff_classification("text_html_br_20.html", "text", "html", None); - test_sniff_classification("text_html_br_20_u.html", "text", "html", None); + test_sniff_classification("text_html_br_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_br_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_br_3e() { - test_sniff_classification("text_html_br_3e.html", "text", "html", None); - test_sniff_classification("text_html_br_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_br_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_br_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_p_20() { - test_sniff_classification("text_html_p_20.html", "text", "html", None); - test_sniff_classification("text_html_p_20_u.html", "text", "html", None); + test_sniff_classification("text_html_p_20.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_p_20_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_p_3e() { - test_sniff_classification("text_html_p_3e.html", "text", "html", None); - test_sniff_classification("text_html_p_3e_u.html", "text", "html", None); + test_sniff_classification("text_html_p_3e.html", mime::TEXT_HTML, None); + test_sniff_classification("text_html_p_3e_u.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_comment_20() { - test_sniff_classification("text_html_comment_20.html", "text", "html", None); + test_sniff_classification("text_html_comment_20.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_text_html_comment_3e() { - test_sniff_classification("text_html_comment_3e.html", "text", "html", None); + test_sniff_classification("text_html_comment_3e.html", mime::TEXT_HTML, None); } #[test] fn test_sniff_xml() { - test_sniff_classification("test.xml", "text", "xml", None); + test_sniff_classification("test.xml", mime::TEXT_XML, None); } #[test] fn test_sniff_pdf() { - test_sniff_classification("test.pdf", "application", "pdf", None); + test_sniff_classification("test.pdf", mime::APPLICATION_PDF, None); } #[test] fn test_sniff_postscript() { - test_sniff_classification("test.ps", "application", "postscript", None); + test_sniff_classification("test.ps", "application/postscript".parse().unwrap(), None); } #[test] fn test_sniff_utf_16be_bom() { - test_sniff_classification("utf16bebom.txt", "text", "plain", None); + test_sniff_classification("utf16bebom.txt", mime::TEXT_PLAIN, None); } #[test] fn test_sniff_utf_16le_bom() { - test_sniff_classification("utf16lebom.txt", "text", "plain", None); + test_sniff_classification("utf16lebom.txt", mime::TEXT_PLAIN, None); } #[test] fn test_sniff_utf_8_bom() { - test_sniff_classification("utf8bom.txt", "text", "plain", None); + test_sniff_classification("utf8bom.txt", mime::TEXT_PLAIN, None); } #[test] fn test_sniff_rss_feed() { // RSS feeds - test_sniff_full(&PathBuf::from("text/xml/feed.rss"), "application", "rss+xml", Some(("text", "html"))); - test_sniff_full(&PathBuf::from("text/xml/rdf_rss.xml"), "application", "rss+xml", Some(("text", "html"))); + test_sniff_full(&PathBuf::from("text/xml/feed.rss"), "application/rss+xml".parse().unwrap(), Some(mime::TEXT_HTML)); + test_sniff_full(&PathBuf::from("text/xml/rdf_rss.xml"), "application/rss+xml".parse().unwrap(), + Some(mime::TEXT_HTML)); // Not RSS feeds - test_sniff_full(&PathBuf::from("text/xml/rdf_rss_ko_1.xml"), "text", "html", Some(("text", "html"))); - test_sniff_full(&PathBuf::from("text/xml/rdf_rss_ko_2.xml"), "text", "html", Some(("text", "html"))); - test_sniff_full(&PathBuf::from("text/xml/rdf_rss_ko_3.xml"), "text", "html", Some(("text", "html"))); - test_sniff_full(&PathBuf::from("text/xml/rdf_rss_ko_4.xml"), "text", "html", Some(("text", "html"))); + test_sniff_full(&PathBuf::from("text/xml/rdf_rss_ko_1.xml"), mime::TEXT_HTML, Some(mime::TEXT_HTML)); + test_sniff_full(&PathBuf::from("text/xml/rdf_rss_ko_2.xml"), mime::TEXT_HTML, Some(mime::TEXT_HTML)); + test_sniff_full(&PathBuf::from("text/xml/rdf_rss_ko_3.xml"), mime::TEXT_HTML, Some(mime::TEXT_HTML)); + test_sniff_full(&PathBuf::from("text/xml/rdf_rss_ko_4.xml"), mime::TEXT_HTML, Some(mime::TEXT_HTML)); } #[test] fn test_sniff_atom_feed() { - test_sniff_full(&PathBuf::from("text/xml/feed.atom"), "application", "atom+xml", Some(("text", "html"))); + test_sniff_full(&PathBuf::from("text/xml/feed.atom"), "application/atom+xml".parse().unwrap(), + Some(mime::TEXT_HTML)); } #[test] fn test_sniff_binary_file() { - test_sniff_full(&PathBuf::from("unknown/binary_file"), "application", "octet-stream", None); + test_sniff_full(&PathBuf::from("unknown/binary_file"), mime::APPLICATION_OCTET_STREAM, None); } #[test] fn test_sniff_atom_feed_with_no_sniff_flag_on() { test_sniff_with_flags(&PathBuf::from("text/xml/feed.atom"), - "text", - "html", - Some(("text", "html")), + mime::TEXT_HTML, + Some(mime::TEXT_HTML), NoSniffFlag::On, ApacheBugFlag::Off); } @@ -502,9 +499,8 @@ fn test_sniff_atom_feed_with_no_sniff_flag_on() { #[test] fn test_sniff_with_no_sniff_flag_on_and_apache_flag_on() { test_sniff_with_flags(&PathBuf::from("text/xml/feed.atom"), - "text", - "html", - Some(("text", "html")), + mime::TEXT_HTML, + Some(mime::TEXT_HTML), NoSniffFlag::On, ApacheBugFlag::On); } @@ -512,9 +508,8 @@ fn test_sniff_with_no_sniff_flag_on_and_apache_flag_on() { #[test] fn test_sniff_utf_8_bom_with_apache_flag_on() { test_sniff_with_flags(&PathBuf::from("text/plain/utf8bom.txt"), - "text", - "plain", - Some(("dummy", "text")), + mime::TEXT_PLAIN, + Some("dummy/text".parse().unwrap()), NoSniffFlag::Off, ApacheBugFlag::On); } @@ -522,9 +517,8 @@ fn test_sniff_utf_8_bom_with_apache_flag_on() { #[test] fn test_sniff_utf_16be_bom_with_apache_flag_on() { test_sniff_with_flags(&PathBuf::from("text/plain/utf16bebom.txt"), - "text", - "plain", - Some(("dummy", "text")), + mime::TEXT_PLAIN, + Some("dummy/text".parse().unwrap()), NoSniffFlag::Off, ApacheBugFlag::On); } @@ -532,9 +526,8 @@ fn test_sniff_utf_16be_bom_with_apache_flag_on() { #[test] fn test_sniff_utf_16le_bom_with_apache_flag_on() { test_sniff_with_flags(&PathBuf::from("text/plain/utf16lebom.txt"), - "text", - "plain", - Some(("dummy", "text")), + mime::TEXT_PLAIN, + Some("dummy/text".parse().unwrap()), NoSniffFlag::Off, ApacheBugFlag::On); } @@ -542,9 +535,8 @@ fn test_sniff_utf_16le_bom_with_apache_flag_on() { #[test] fn test_sniff_octet_stream_apache_flag_on() { test_sniff_with_flags(&PathBuf::from("unknown/binary_file"), - "application", - "octet-stream", - Some(("dummy", "binary")), + mime::APPLICATION_OCTET_STREAM, + Some("dummy/binary".parse().unwrap()), NoSniffFlag::Off, ApacheBugFlag::On); } @@ -552,9 +544,8 @@ fn test_sniff_octet_stream_apache_flag_on() { #[test] fn test_sniff_mp4_video_apache_flag_on() { test_sniff_with_flags(&PathBuf::from("video/mp4/test.mp4"), - "application", - "octet-stream", - Some(("video", "mp4")), + mime::APPLICATION_OCTET_STREAM, + Some("video/mp4".parse().unwrap()), NoSniffFlag::Off, ApacheBugFlag::On); } |