Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 21:50:18 +01:00
Code Issues Projects Releases Packages Wiki Activity

renaming AssertRequstMustHaveHeaders to AssertRequestMustIncludeHeaders

Browse source
This commit is contained in:
Prabhjyot Singh Sodhi 2015-09-29 01:37:39 +05:30
parent 076f44a02d
commit d27c126013
1 changed files with 133 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

180
tests/unit/net/http_loader.rs
View file

@ -8,9 +8,11 @@ use devtools_traits::HttpResponse as DevtoolsHttpResponse;
use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent}; use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent};
use flate2::Compression; use flate2::Compression;
use flate2::write::{GzEncoder, DeflateEncoder}; 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::http::RawStatus;
use hyper::method::Method; use hyper::method::Method;
use hyper::mime::{Mime, SubLevel, TopLevel};
use hyper::status::StatusCode; use hyper::status::StatusCode;
use net::cookie::Cookie; use net::cookie::Cookie;
use net::cookie_storage::CookieStorage; 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 headers_mut(&mut self) -> &mut Headers { &mut self.request_headers }
fn send(self, _: &Option<Vec<u8>>) -> Result<MockResponse, LoadError> {
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<Vec<u8>>) -> Result<MockResponse, LoadError> { fn send(self, _: &Option<Vec<u8>>) -> Result<MockResponse, LoadError> {
for header in self.expected_headers.iter() { for header in self.expected_headers.iter() {
assert!(self.request_headers.get_raw(header.name()).is_some()); 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<u8>
}
impl HttpRequestFactory for AssertMustIncludeHeadersRequestFactory {
type R = AssertRequestMustIncludeHeaders;
fn create(&self, _: Url, _: Method) -> Result<AssertRequestMustIncludeHeaders, LoadError> {
Ok(
AssertRequestMustIncludeHeaders::new(
ResponseType::Text(self.body.clone()),
self.expected_headers.clone()
)
)
}
}
fn assert_cookie_for_domain(cookie_jar: Arc<RwLock<CookieStorage>>, domain: &str, cookie: &str) { fn assert_cookie_for_domain(cookie_jar: Arc<RwLock<CookieStorage>>, domain: &str, cookie: &str) {
let mut cookie_jar = cookie_jar.write().unwrap(); let mut cookie_jar = cookie_jar.write().unwrap();
let url = Url::parse(&*domain).unwrap(); let url = Url::parse(&*domain).unwrap();
@ -248,6 +294,48 @@ fn expect_devtools_http_response(devtools_port: &Receiver<DevtoolsControlMsg>) -
} }
} }
#[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::<AssertRequestMustHaveHeaders>(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::<AssertRequestMustHaveHeaders>(load_data.clone(), hsts_list, cookie_jar, None,
&AssertMustHaveHeadersRequestFactory {
expected_headers: headers,
body: <[_]>::to_vec(&[])
}, DEFAULT_USER_AGENT.to_string());
}
#[test] #[test]
fn test_load_when_request_is_not_get_or_head_and_there_is_no_body_content_length_should_be_set_to_0() { 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(); 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(); let mut content_length = Headers::new();
content_length.set_raw("Content-Length".to_owned(), vec![<[_]>::to_vec("0".as_bytes())]); content_length.set_raw("Content-Length".to_owned(), vec![<[_]>::to_vec("0".as_bytes())]);
let _ = load::<AssertRequestMustHaveHeaders>( let _ = load::<AssertRequestMustIncludeHeaders>(
load_data.clone(), hsts_list, cookie_jar, None, load_data.clone(), hsts_list, cookie_jar, None,
&AssertMustHaveHeadersRequestFactory { &AssertMustIncludeHeadersRequestFactory {
expected_headers: content_length, expected_headers: content_length,
body: <[_]>::to_vec(&[]) body: <[_]>::to_vec(&[])
}, DEFAULT_USER_AGENT.to_string()); }, 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(); let mut cookie = Headers::new();
cookie.set_raw("Cookie".to_owned(), vec![<[_]>::to_vec("mozillaIs=theBest".as_bytes())]); cookie.set_raw("Cookie".to_owned(), vec![<[_]>::to_vec("mozillaIs=theBest".as_bytes())]);
let _ = load::<AssertRequestMustHaveHeaders>( let _ = load::<AssertRequestMustIncludeHeaders>(load_data.clone(), hsts_list, cookie_jar, None,
load_data.clone(), hsts_list, cookie_jar, None, &AssertMustIncludeHeadersRequestFactory {
&AssertMustHaveHeadersRequestFactory { expected_headers: cookie,
expected_headers: cookie, body: <[_]>::to_vec(&*load_data.data.unwrap())
body: <[_]>::to_vec(&*load_data.data.unwrap()) }, DEFAULT_USER_AGENT.to_string());
}, DEFAULT_USER_AGENT.to_string());
} }
#[test] #[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 hsts_list = Arc::new(RwLock::new(HSTSList::new()));
let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new()));
let _ = load::<AssertRequestMustHaveHeaders>( let _ = load::<AssertRequestMustIncludeHeaders>(load_data.clone(), hsts_list, cookie_jar,
load_data.clone(), hsts_list, cookie_jar, None, None, &AssertMustIncludeHeadersRequestFactory {
&AssertMustHaveHeadersRequestFactory { expected_headers: content_len_headers,
expected_headers: content_len_headers, body: <[_]>::to_vec(&*load_data.data.unwrap())
body: <[_]>::to_vec(&*load_data.data.unwrap()) }, DEFAULT_USER_AGENT.to_string());
}, DEFAULT_USER_AGENT.to_string());
} }
#[test] #[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 hsts_list = Arc::new(RwLock::new(HSTSList::new()));
let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new()));
let _ = load::<AssertRequestMustHaveHeaders>(load_data, let _ = load::<AssertRequestMustIncludeHeaders>(load_data,
hsts_list, hsts_list,
cookie_jar, cookie_jar,
None, None,
&AssertMustHaveHeadersRequestFactory { &AssertMustIncludeHeadersRequestFactory {
expected_headers: accept_headers, expected_headers: accept_headers,
body: <[_]>::to_vec("Yay!".as_bytes()) body: <[_]>::to_vec("Yay!".as_bytes())
}, DEFAULT_USER_AGENT.to_string()); }, DEFAULT_USER_AGENT.to_string());
} }
#[test] #[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 hsts_list = Arc::new(RwLock::new(HSTSList::new()));
let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new()));
let _ = load::<AssertRequestMustHaveHeaders>(load_data, let _ = load::<AssertRequestMustIncludeHeaders>(load_data,
hsts_list, hsts_list,
cookie_jar, cookie_jar,
None, None,
&AssertMustHaveHeadersRequestFactory { &AssertMustIncludeHeadersRequestFactory {
expected_headers: accept_headers, expected_headers: accept_headers,
body: <[_]>::to_vec("Yay!".as_bytes()) body: <[_]>::to_vec("Yay!".as_bytes())
}, DEFAULT_USER_AGENT.to_string()); }, DEFAULT_USER_AGENT.to_string());
} }
#[test] #[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 hsts_list = Arc::new(RwLock::new(HSTSList::new()));
let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new()));
let _ = load::<AssertRequestMustHaveHeaders>(load_data, let _ = load::<AssertRequestMustIncludeHeaders>(load_data,
hsts_list, hsts_list,
cookie_jar, cookie_jar,
None, None,
&AssertMustHaveHeadersRequestFactory { &AssertMustIncludeHeadersRequestFactory {
expected_headers: accept_encoding_headers, expected_headers: accept_encoding_headers,
body: <[_]>::to_vec("Yay!".as_bytes()) body: <[_]>::to_vec("Yay!".as_bytes())
}, DEFAULT_USER_AGENT.to_string()); }, DEFAULT_USER_AGENT.to_string());
} }
#[test] #[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 hsts_list = Arc::new(RwLock::new(HSTSList::new()));
let cookie_jar = Arc::new(RwLock::new(CookieStorage::new())); let cookie_jar = Arc::new(RwLock::new(CookieStorage::new()));
let _ = load::<AssertRequestMustHaveHeaders>(load_data, let _ = load::<AssertRequestMustIncludeHeaders>(load_data,
hsts_list, hsts_list,
cookie_jar, cookie_jar,
None, None,
&AssertMustHaveHeadersRequestFactory { &AssertMustIncludeHeadersRequestFactory {
expected_headers: accept_encoding_headers, expected_headers: accept_encoding_headers,
body: <[_]>::to_vec("Yay!".as_bytes()) body: <[_]>::to_vec("Yay!".as_bytes())
}, DEFAULT_USER_AGENT.to_string()); }, DEFAULT_USER_AGENT.to_string());
} }
#[test] #[test]