diff --git a/tests/unit/net/http_loader.rs b/tests/unit/net/http_loader.rs index 5a24eda16aec..883db09c3e82 100644 --- a/tests/unit/net/http_loader.rs +++ b/tests/unit/net/http_loader.rs @@ -8,9 +8,11 @@ use devtools_traits::HttpResponse as DevtoolsHttpResponse; use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent}; use flate2::Compression; use flate2::write::{GzEncoder, DeflateEncoder}; -use hyper::header::{Headers, Location, ContentLength, Host}; +use hyper::header::{Accept, AcceptEncoding, ContentLength, Encoding, Headers, Host, Location, Quality}; +use hyper::header::{QualityItem, qitem, UserAgent}; use hyper::http::RawStatus; use hyper::method::Method; +use hyper::mime::{Mime, SubLevel, TopLevel}; use hyper::status::StatusCode; use net::cookie::Cookie; use net::cookie_storage::CookieStorage; @@ -149,6 +151,31 @@ impl HttpRequest for AssertRequestMustHaveHeaders { fn headers_mut(&mut self) -> &mut Headers { &mut self.request_headers } + fn send(self, _: &Option>) -> Result { + assert_eq!(self.request_headers, self.expected_headers); + + response_for_request_type(self.t) + } +} + +struct AssertRequestMustIncludeHeaders { + expected_headers: Headers, + request_headers: Headers, + t: ResponseType +} + +impl AssertRequestMustIncludeHeaders { + fn new(t: ResponseType, expected_headers: Headers) -> Self { + assert!(expected_headers.len() != 0); + AssertRequestMustIncludeHeaders { expected_headers: expected_headers, request_headers: Headers::new(), t: t } + } +} + +impl HttpRequest for AssertRequestMustIncludeHeaders { + type R = MockResponse; + + fn headers_mut(&mut self) -> &mut Headers { &mut self.request_headers } + fn send(self, _: &Option>) -> Result { for header in self.expected_headers.iter() { assert!(self.request_headers.get_raw(header.name()).is_some()); @@ -180,6 +207,25 @@ impl HttpRequestFactory for AssertMustHaveHeadersRequestFactory { } } + +struct AssertMustIncludeHeadersRequestFactory { + expected_headers: Headers, + body: Vec +} + +impl HttpRequestFactory for AssertMustIncludeHeadersRequestFactory { + type R = AssertRequestMustIncludeHeaders; + + fn create(&self, _: Url, _: Method) -> Result { + Ok( + AssertRequestMustIncludeHeaders::new( + ResponseType::Text(self.body.clone()), + self.expected_headers.clone() + ) + ) + } +} + fn assert_cookie_for_domain(cookie_jar: Arc>, domain: &str, cookie: &str) { let mut cookie_jar = cookie_jar.write().unwrap(); let url = Url::parse(&*domain).unwrap(); @@ -248,6 +294,48 @@ fn expect_devtools_http_response(devtools_port: &Receiver) - } } +#[test] +fn test_check_default_headers_loaded_in_every_request() { + let url = Url::parse("http://mozilla.com").unwrap(); + + let hsts_list = Arc::new(RwLock::new(HSTSList::new())); + let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); + + let mut load_data = LoadData::new(url.clone(), None); + load_data.data = None; + load_data.method = Method::Get; + + let mut headers = Headers::new(); + headers.set(AcceptEncoding(vec![qitem(Encoding::Gzip), qitem(Encoding::Deflate)])); + headers.set(Host { hostname: "mozilla.com".to_owned() , port: None }); + 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.set(UserAgent(DEFAULT_USER_AGENT.to_string())); + + // Testing for method.GET + let _ = load::(load_data.clone(), hsts_list.clone(), cookie_jar.clone(), None, + &AssertMustHaveHeadersRequestFactory { + expected_headers: headers.clone(), + body: <[_]>::to_vec(&[]) + }, DEFAULT_USER_AGENT.to_string()); + + // Testing for method.POST + load_data.method = Method::Post; + + headers.set(ContentLength(0 as u64)); + + let _ = load::(load_data.clone(), hsts_list, cookie_jar, None, + &AssertMustHaveHeadersRequestFactory { + expected_headers: headers, + body: <[_]>::to_vec(&[]) + }, DEFAULT_USER_AGENT.to_string()); +} + #[test] fn test_load_when_request_is_not_get_or_head_and_there_is_no_body_content_length_should_be_set_to_0() { let url = Url::parse("http://mozilla.com").unwrap(); @@ -262,9 +350,9 @@ fn test_load_when_request_is_not_get_or_head_and_there_is_no_body_content_length let mut content_length = Headers::new(); content_length.set_raw("Content-Length".to_owned(), vec![<[_]>::to_vec("0".as_bytes())]); - let _ = load::( + let _ = load::( load_data.clone(), hsts_list, cookie_jar, None, - &AssertMustHaveHeadersRequestFactory { + &AssertMustIncludeHeadersRequestFactory { expected_headers: content_length, body: <[_]>::to_vec(&[]) }, DEFAULT_USER_AGENT.to_string()); @@ -581,12 +669,11 @@ fn test_load_sets_requests_cookies_header_for_url_by_getting_cookies_from_the_re let mut cookie = Headers::new(); cookie.set_raw("Cookie".to_owned(), vec![<[_]>::to_vec("mozillaIs=theBest".as_bytes())]); - let _ = load::( - load_data.clone(), hsts_list, cookie_jar, None, - &AssertMustHaveHeadersRequestFactory { - expected_headers: cookie, - body: <[_]>::to_vec(&*load_data.data.unwrap()) - }, DEFAULT_USER_AGENT.to_string()); + let _ = load::(load_data.clone(), hsts_list, cookie_jar, None, + &AssertMustIncludeHeadersRequestFactory { + expected_headers: cookie, + body: <[_]>::to_vec(&*load_data.data.unwrap()) + }, DEFAULT_USER_AGENT.to_string()); } #[test] @@ -606,12 +693,11 @@ fn test_load_sets_content_length_to_length_of_request_body() { let hsts_list = Arc::new(RwLock::new(HSTSList::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); - let _ = load::( - load_data.clone(), hsts_list, cookie_jar, None, - &AssertMustHaveHeadersRequestFactory { - expected_headers: content_len_headers, - body: <[_]>::to_vec(&*load_data.data.unwrap()) - }, DEFAULT_USER_AGENT.to_string()); + let _ = load::(load_data.clone(), hsts_list, cookie_jar, + None, &AssertMustIncludeHeadersRequestFactory { + expected_headers: content_len_headers, + body: <[_]>::to_vec(&*load_data.data.unwrap()) + }, DEFAULT_USER_AGENT.to_string()); } #[test] @@ -627,14 +713,14 @@ fn test_load_uses_explicit_accept_from_headers_in_load_data() { let hsts_list = Arc::new(RwLock::new(HSTSList::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); - let _ = load::(load_data, - hsts_list, - cookie_jar, - None, - &AssertMustHaveHeadersRequestFactory { - expected_headers: accept_headers, - body: <[_]>::to_vec("Yay!".as_bytes()) - }, DEFAULT_USER_AGENT.to_string()); + let _ = load::(load_data, + hsts_list, + cookie_jar, + None, + &AssertMustIncludeHeadersRequestFactory { + expected_headers: accept_headers, + body: <[_]>::to_vec("Yay!".as_bytes()) + }, DEFAULT_USER_AGENT.to_string()); } #[test] @@ -651,14 +737,14 @@ fn test_load_sets_default_accept_to_html_xhtml_xml_and_then_anything_else() { let hsts_list = Arc::new(RwLock::new(HSTSList::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); - let _ = load::(load_data, - hsts_list, - cookie_jar, - None, - &AssertMustHaveHeadersRequestFactory { - expected_headers: accept_headers, - body: <[_]>::to_vec("Yay!".as_bytes()) - }, DEFAULT_USER_AGENT.to_string()); + let _ = load::(load_data, + hsts_list, + cookie_jar, + None, + &AssertMustIncludeHeadersRequestFactory { + expected_headers: accept_headers, + body: <[_]>::to_vec("Yay!".as_bytes()) + }, DEFAULT_USER_AGENT.to_string()); } #[test] @@ -674,14 +760,14 @@ fn test_load_uses_explicit_accept_encoding_from_load_data_headers() { let hsts_list = Arc::new(RwLock::new(HSTSList::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); - let _ = load::(load_data, - hsts_list, - cookie_jar, - None, - &AssertMustHaveHeadersRequestFactory { - expected_headers: accept_encoding_headers, - body: <[_]>::to_vec("Yay!".as_bytes()) - }, DEFAULT_USER_AGENT.to_string()); + let _ = load::(load_data, + hsts_list, + cookie_jar, + None, + &AssertMustIncludeHeadersRequestFactory { + expected_headers: accept_encoding_headers, + body: <[_]>::to_vec("Yay!".as_bytes()) + }, DEFAULT_USER_AGENT.to_string()); } #[test] @@ -696,14 +782,14 @@ fn test_load_sets_default_accept_encoding_to_gzip_and_deflate() { let hsts_list = Arc::new(RwLock::new(HSTSList::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); - let _ = load::(load_data, - hsts_list, - cookie_jar, - None, - &AssertMustHaveHeadersRequestFactory { - expected_headers: accept_encoding_headers, - body: <[_]>::to_vec("Yay!".as_bytes()) - }, DEFAULT_USER_AGENT.to_string()); + let _ = load::(load_data, + hsts_list, + cookie_jar, + None, + &AssertMustIncludeHeadersRequestFactory { + expected_headers: accept_encoding_headers, + body: <[_]>::to_vec("Yay!".as_bytes()) + }, DEFAULT_USER_AGENT.to_string()); } #[test]