use std::fmt;
use hyper::header::ContentType;
use serde::Serialize;
use serde_json;
use serde_urlencoded;
use body::{self, Body};
use header::Headers;
use {async_impl, Client, Method, Url};
pub struct Request {
body: Option<Body>,
inner: async_impl::Request,
}
pub struct RequestBuilder {
client: Client,
request: Option<Request>,
err: Option<::Error>,
}
impl Request {
#[inline]
pub fn new(method: Method, url: Url) -> Self {
Request {
body: None,
inner: async_impl::Request::new(method, url),
}
}
#[inline]
pub fn method(&self) -> &Method {
self.inner.method()
}
#[inline]
pub fn method_mut(&mut self) -> &mut Method {
self.inner.method_mut()
}
#[inline]
pub fn url(&self) -> &Url {
self.inner.url()
}
#[inline]
pub fn url_mut(&mut self) -> &mut Url {
self.inner.url_mut()
}
#[inline]
pub fn headers(&self) -> &Headers {
self.inner.headers()
}
#[inline]
pub fn headers_mut(&mut self) -> &mut Headers {
self.inner.headers_mut()
}
#[inline]
pub fn body(&self) -> Option<&Body> {
self.body.as_ref()
}
#[inline]
pub fn body_mut(&mut self) -> &mut Option<Body> {
&mut self.body
}
}
impl RequestBuilder {
pub fn header<H>(&mut self, header: H) -> &mut RequestBuilder
where
H: ::header::Header,
{
if let Some(req) = request_mut(&mut self.request, &self.err) {
req.headers_mut().set(header);
}
self
}
pub fn headers(&mut self, headers: ::header::Headers) -> &mut RequestBuilder {
if let Some(req) = request_mut(&mut self.request, &self.err) {
req.headers_mut().extend(headers.iter());
}
self
}
pub fn basic_auth<U, P>(&mut self, username: U, password: Option<P>) -> &mut RequestBuilder
where
U: Into<String>,
P: Into<String>,
{
self.header(::header::Authorization(::header::Basic {
username: username.into(),
password: password.map(|p| p.into()),
}))
}
pub fn body<T: Into<Body>>(&mut self, body: T) -> &mut RequestBuilder {
if let Some(req) = request_mut(&mut self.request, &self.err) {
*req.body_mut() = Some(body.into());
}
self
}
pub fn form<T: Serialize>(&mut self, form: &T) -> &mut RequestBuilder {
if let Some(req) = request_mut(&mut self.request, &self.err) {
match serde_urlencoded::to_string(form) {
Ok(body) => {
req.headers_mut().set(ContentType::form_url_encoded());
*req.body_mut() = Some(body.into());
},
Err(err) => self.err = Some(::error::from(err)),
}
}
self
}
pub fn json<T: Serialize>(&mut self, json: &T) -> &mut RequestBuilder {
if let Some(req) = request_mut(&mut self.request, &self.err) {
match serde_json::to_vec(json) {
Ok(body) => {
req.headers_mut().set(ContentType::json());
*req.body_mut() = Some(body.into());
},
Err(err) => self.err = Some(::error::from(err)),
}
}
self
}
pub fn multipart(&mut self, mut multipart: ::multipart::Form) -> &mut RequestBuilder {
if let Some(req) = request_mut(&mut self.request, &self.err) {
req.headers_mut().set(
::header::ContentType(format!("multipart/form-data; boundary={}", ::multipart_::boundary(&multipart))
.parse().unwrap()
)
);
*req.body_mut() = Some(match ::multipart_::compute_length(&mut multipart) {
Some(length) => Body::sized(::multipart_::reader(multipart), length),
None => Body::new(::multipart_::reader(multipart)),
})
}
self
}
pub fn build(&mut self) -> ::Result<Request> {
if let Some(err) = self.err.take() {
Err(err)
} else {
Ok(self.request
.take()
.expect("RequestBuilder cannot be reused after builder a Request"))
}
}
pub fn send(&mut self) -> ::Result<::Response> {
let request = self.build()?;
self.client.execute(request)
}
}
fn request_mut<'a>(req: &'a mut Option<Request>, err: &Option<::Error>) -> Option<&'a mut Request> {
if err.is_some() {
None
} else {
req.as_mut()
}
}
impl fmt::Debug for Request {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt_request_fields(&mut f.debug_struct("Request"), self)
.finish()
}
}
impl fmt::Debug for RequestBuilder {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(ref req) = self.request {
fmt_request_fields(&mut f.debug_struct("RequestBuilder"), req)
.finish()
} else {
f.debug_tuple("RequestBuilder")
.field(&"Consumed")
.finish()
}
}
}
fn fmt_request_fields<'a, 'b>(f: &'a mut fmt::DebugStruct<'a, 'b>, req: &Request) -> &'a mut fmt::DebugStruct<'a, 'b> {
f.field("method", req.method())
.field("url", req.url())
.field("headers", req.headers())
}
#[inline]
pub fn builder(client: Client, req: ::Result<Request>) -> RequestBuilder {
match req {
Ok(req) => RequestBuilder {
client: client,
request: Some(req),
err: None,
},
Err(err) => RequestBuilder {
client: client,
request: None,
err: Some(err)
},
}
}
#[inline]
pub fn async(req: Request) -> (async_impl::Request, Option<body::Sender>) {
use header::ContentLength;
let mut req_async = req.inner;
let body = req.body.and_then(|body| {
let (tx, body, len) = body::async(body);
if let Some(len) = len {
req_async.headers_mut().set(ContentLength(len));
}
*req_async.body_mut() = Some(body);
tx
});
(req_async, body)
}
#[cfg(test)]
mod tests {
use {body, Client, Method};
use header::{Host, Headers, ContentType};
use std::collections::HashMap;
use serde_urlencoded;
use serde_json;
#[test]
fn basic_get_request() {
let client = Client::new();
let some_url = "https://google.com/";
let r = client.get(some_url).build().unwrap();
assert_eq!(r.method(), &Method::Get);
assert_eq!(r.url().as_str(), some_url);
}
#[test]
fn basic_head_request() {
let client = Client::new();
let some_url = "https://google.com/";
let r = client.head(some_url).build().unwrap();
assert_eq!(r.method(), &Method::Head);
assert_eq!(r.url().as_str(), some_url);
}
#[test]
fn basic_post_request() {
let client = Client::new();
let some_url = "https://google.com/";
let r = client.post(some_url).build().unwrap();
assert_eq!(r.method(), &Method::Post);
assert_eq!(r.url().as_str(), some_url);
}
#[test]
fn basic_put_request() {
let client = Client::new();
let some_url = "https://google.com/";
let r = client.put(some_url).build().unwrap();
assert_eq!(r.method(), &Method::Put);
assert_eq!(r.url().as_str(), some_url);
}
#[test]
fn basic_patch_request() {
let client = Client::new();
let some_url = "https://google.com/";
let r = client.patch(some_url).build().unwrap();
assert_eq!(r.method(), &Method::Patch);
assert_eq!(r.url().as_str(), some_url);
}
#[test]
fn basic_delete_request() {
let client = Client::new();
let some_url = "https://google.com/";
let r = client.delete(some_url).build().unwrap();
assert_eq!(r.method(), &Method::Delete);
assert_eq!(r.url().as_str(), some_url);
}
#[test]
fn add_header() {
let client = Client::new();
let some_url = "https://google.com/";
let mut r = client.post(some_url);
let header = Host::new("google.com", None);
let r = r.header(header.clone()).build().unwrap();
assert_eq!(r.headers().get::<Host>(), Some(&header));
}
#[test]
fn add_headers() {
let client = Client::new();
let some_url = "https://google.com/";
let mut r = client.post(some_url);
let header = Host::new("google.com", None);
let mut headers = Headers::new();
headers.set(header);
let r = r.headers(headers.clone()).build().unwrap();
assert_eq!(r.headers(), &headers);
}
#[test]
fn add_body() {
let client = Client::new();
let some_url = "https://google.com/";
let mut r = client.post(some_url);
let body = "Some interesting content";
let mut r = r.body(body).build().unwrap();
let buf = body::read_to_string(r.body_mut().take().unwrap()).unwrap();
assert_eq!(buf, body);
}
#[test]
fn add_form() {
let client = Client::new();
let some_url = "https://google.com/";
let mut r = client.post(some_url);
let mut form_data = HashMap::new();
form_data.insert("foo", "bar");
let mut r = r.form(&form_data).build().unwrap();
assert_eq!(r.headers().get::<ContentType>(),
Some(&ContentType::form_url_encoded()));
let buf = body::read_to_string(r.body_mut().take().unwrap()).unwrap();
let body_should_be = serde_urlencoded::to_string(&form_data).unwrap();
assert_eq!(buf, body_should_be);
}
#[test]
fn add_json() {
let client = Client::new();
let some_url = "https://google.com/";
let mut r = client.post(some_url);
let mut json_data = HashMap::new();
json_data.insert("foo", "bar");
let mut r = r.json(&json_data).build().unwrap();
assert_eq!(r.headers().get::<ContentType>(), Some(&ContentType::json()));
let buf = body::read_to_string(r.body_mut().take().unwrap()).unwrap();
let body_should_be = serde_json::to_string(&json_data).unwrap();
assert_eq!(buf, body_should_be);
}
#[test]
fn add_json_fail() {
use serde::{Serialize, Serializer};
use serde::ser::Error;
struct MyStruct;
impl Serialize for MyStruct {
fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
{
Err(S::Error::custom("nope"))
}
}
let client = Client::new();
let some_url = "https://google.com/";
let mut r = client.post(some_url);
let json_data = MyStruct;
assert!(r.json(&json_data).build().unwrap_err().is_serialization());
}
}