reqwest/async_impl/
request.rs

1use std::convert::TryFrom;
2use std::fmt;
3use std::future::Future;
4use std::time::Duration;
5
6use super::body::Body;
7use super::client::{Client, Pending};
8#[cfg(feature = "multipart")]
9use super::multipart;
10use super::response::Response;
11use crate::config::{RequestConfig, TotalTimeout};
12#[cfg(feature = "multipart")]
13use crate::header::CONTENT_LENGTH;
14#[cfg(any(feature = "multipart", feature = "form", feature = "json"))]
15use crate::header::CONTENT_TYPE;
16use crate::header::{HeaderMap, HeaderName, HeaderValue};
17use crate::{Method, Url};
18use http::{request::Parts, Extensions, Request as HttpRequest, Version};
19#[cfg(any(feature = "query", feature = "form", feature = "json"))]
20use serde::Serialize;
21
22/// A request which can be executed with `Client::execute()`.
23pub struct Request {
24    method: Method,
25    url: Url,
26    headers: HeaderMap,
27    body: Option<Body>,
28    version: Version,
29    extensions: Extensions,
30}
31
32/// A builder to construct the properties of a `Request`.
33///
34/// To construct a `RequestBuilder`, refer to the `Client` documentation.
35#[must_use = "RequestBuilder does nothing until you 'send' it"]
36pub struct RequestBuilder {
37    client: Client,
38    request: crate::Result<Request>,
39}
40
41impl Request {
42    /// Constructs a new request.
43    #[inline]
44    pub fn new(method: Method, url: Url) -> Self {
45        Request {
46            method,
47            url,
48            headers: HeaderMap::new(),
49            body: None,
50            version: Version::default(),
51            extensions: Extensions::new(),
52        }
53    }
54
55    /// Get the method.
56    #[inline]
57    pub fn method(&self) -> &Method {
58        &self.method
59    }
60
61    /// Get a mutable reference to the method.
62    #[inline]
63    pub fn method_mut(&mut self) -> &mut Method {
64        &mut self.method
65    }
66
67    /// Get the url.
68    #[inline]
69    pub fn url(&self) -> &Url {
70        &self.url
71    }
72
73    /// Get a mutable reference to the url.
74    #[inline]
75    pub fn url_mut(&mut self) -> &mut Url {
76        &mut self.url
77    }
78
79    /// Get the headers.
80    #[inline]
81    pub fn headers(&self) -> &HeaderMap {
82        &self.headers
83    }
84
85    /// Get a mutable reference to the headers.
86    #[inline]
87    pub fn headers_mut(&mut self) -> &mut HeaderMap {
88        &mut self.headers
89    }
90
91    /// Get the body.
92    #[inline]
93    pub fn body(&self) -> Option<&Body> {
94        self.body.as_ref()
95    }
96
97    /// Get a mutable reference to the body.
98    #[inline]
99    pub fn body_mut(&mut self) -> &mut Option<Body> {
100        &mut self.body
101    }
102
103    /// Get the extensions.
104    #[inline]
105    pub(crate) fn extensions(&self) -> &Extensions {
106        &self.extensions
107    }
108
109    /// Get a mutable reference to the extensions.
110    #[inline]
111    pub(crate) fn extensions_mut(&mut self) -> &mut Extensions {
112        &mut self.extensions
113    }
114
115    /// Get the timeout.
116    #[inline]
117    pub fn timeout(&self) -> Option<&Duration> {
118        RequestConfig::<TotalTimeout>::get(&self.extensions)
119    }
120
121    /// Get a mutable reference to the timeout.
122    #[inline]
123    pub fn timeout_mut(&mut self) -> &mut Option<Duration> {
124        RequestConfig::<TotalTimeout>::get_mut(&mut self.extensions)
125    }
126
127    /// Get the http version.
128    #[inline]
129    pub fn version(&self) -> Version {
130        self.version
131    }
132
133    /// Get a mutable reference to the http version.
134    #[inline]
135    pub fn version_mut(&mut self) -> &mut Version {
136        &mut self.version
137    }
138
139    /// Attempt to clone the request.
140    ///
141    /// `None` is returned if the request can not be cloned, i.e. if the body is a stream.
142    pub fn try_clone(&self) -> Option<Request> {
143        let body = match self.body.as_ref() {
144            Some(body) => Some(body.try_clone()?),
145            None => None,
146        };
147        let mut req = Request::new(self.method().clone(), self.url().clone());
148        *req.timeout_mut() = self.timeout().copied();
149        *req.headers_mut() = self.headers().clone();
150        *req.version_mut() = self.version();
151        *req.extensions_mut() = self.extensions().clone();
152        req.body = body;
153        Some(req)
154    }
155
156    pub(super) fn pieces(self) -> (Method, Url, HeaderMap, Option<Body>, Version, Extensions) {
157        (
158            self.method,
159            self.url,
160            self.headers,
161            self.body,
162            self.version,
163            self.extensions,
164        )
165    }
166}
167
168impl RequestBuilder {
169    pub(super) fn new(client: Client, request: crate::Result<Request>) -> RequestBuilder {
170        let mut builder = RequestBuilder { client, request };
171
172        let auth = builder
173            .request
174            .as_mut()
175            .ok()
176            .and_then(|req| extract_authority(&mut req.url));
177
178        if let Some((username, password)) = auth {
179            builder.basic_auth(username, password)
180        } else {
181            builder
182        }
183    }
184
185    /// Assemble a builder starting from an existing `Client` and a `Request`.
186    pub fn from_parts(client: Client, request: Request) -> RequestBuilder {
187        RequestBuilder {
188            client,
189            request: crate::Result::Ok(request),
190        }
191    }
192
193    /// Add a `Header` to this Request.
194    pub fn header<K, V>(self, key: K, value: V) -> RequestBuilder
195    where
196        HeaderName: TryFrom<K>,
197        <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
198        HeaderValue: TryFrom<V>,
199        <HeaderValue as TryFrom<V>>::Error: Into<http::Error>,
200    {
201        self.header_sensitive(key, value, false)
202    }
203
204    /// Add a `Header` to this Request with ability to define if `header_value` is sensitive.
205    fn header_sensitive<K, V>(mut self, key: K, value: V, sensitive: bool) -> RequestBuilder
206    where
207        HeaderName: TryFrom<K>,
208        <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
209        HeaderValue: TryFrom<V>,
210        <HeaderValue as TryFrom<V>>::Error: Into<http::Error>,
211    {
212        let mut error = None;
213        if let Ok(ref mut req) = self.request {
214            match <HeaderName as TryFrom<K>>::try_from(key) {
215                Ok(key) => match <HeaderValue as TryFrom<V>>::try_from(value) {
216                    Ok(mut value) => {
217                        // We want to potentially make an non-sensitive header
218                        // to be sensitive, not the reverse. So, don't turn off
219                        // a previously sensitive header.
220                        if sensitive {
221                            value.set_sensitive(true);
222                        }
223                        req.headers_mut().append(key, value);
224                    }
225                    Err(e) => error = Some(crate::error::builder(e.into())),
226                },
227                Err(e) => error = Some(crate::error::builder(e.into())),
228            };
229        }
230        if let Some(err) = error {
231            self.request = Err(err);
232        }
233        self
234    }
235
236    /// Add a set of Headers to the existing ones on this Request.
237    ///
238    /// The headers will be merged in to any already set.
239    pub fn headers(mut self, headers: crate::header::HeaderMap) -> RequestBuilder {
240        if let Ok(ref mut req) = self.request {
241            crate::util::replace_headers(req.headers_mut(), headers);
242        }
243        self
244    }
245
246    /// Enable HTTP basic authentication.
247    ///
248    /// ```rust
249    /// # use reqwest::Error;
250    ///
251    /// # async fn run() -> Result<(), Error> {
252    /// let client = reqwest::Client::new();
253    /// let resp = client.delete("http://httpbin.org/delete")
254    ///     .basic_auth("admin", Some("good password"))
255    ///     .send()
256    ///     .await?;
257    /// # Ok(())
258    /// # }
259    /// ```
260    pub fn basic_auth<U, P>(self, username: U, password: Option<P>) -> RequestBuilder
261    where
262        U: fmt::Display,
263        P: fmt::Display,
264    {
265        let header_value = crate::util::basic_auth(username, password);
266        self.header_sensitive(crate::header::AUTHORIZATION, header_value, true)
267    }
268
269    /// Enable HTTP bearer authentication.
270    pub fn bearer_auth<T>(self, token: T) -> RequestBuilder
271    where
272        T: fmt::Display,
273    {
274        let header_value = format!("Bearer {token}");
275        self.header_sensitive(crate::header::AUTHORIZATION, header_value, true)
276    }
277
278    /// Set the request body.
279    pub fn body<T: Into<Body>>(mut self, body: T) -> RequestBuilder {
280        if let Ok(ref mut req) = self.request {
281            *req.body_mut() = Some(body.into());
282        }
283        self
284    }
285
286    /// Enables a request timeout.
287    ///
288    /// The timeout is applied from when the request starts connecting until the
289    /// response body has finished. It affects only this request and overrides
290    /// the timeout configured using `ClientBuilder::timeout()`.
291    pub fn timeout(mut self, timeout: Duration) -> RequestBuilder {
292        if let Ok(ref mut req) = self.request {
293            *req.timeout_mut() = Some(timeout);
294        }
295        self
296    }
297
298    /// Sends a multipart/form-data body.
299    ///
300    /// ```
301    /// # use reqwest::Error;
302    ///
303    /// # async fn run() -> Result<(), Error> {
304    /// let client = reqwest::Client::new();
305    /// let form = reqwest::multipart::Form::new()
306    ///     .text("key3", "value3")
307    ///     .text("key4", "value4");
308    ///
309    ///
310    /// let response = client.post("your url")
311    ///     .multipart(form)
312    ///     .send()
313    ///     .await?;
314    /// # Ok(())
315    /// # }
316    /// ```
317    ///
318    /// In additional the request's body, the Content-Type and Content-Length fields are
319    /// appropriately set.
320    #[cfg(feature = "multipart")]
321    #[cfg_attr(docsrs, doc(cfg(feature = "multipart")))]
322    pub fn multipart(self, mut multipart: multipart::Form) -> RequestBuilder {
323        let mut builder = self.header(
324            CONTENT_TYPE,
325            format!("multipart/form-data; boundary={}", multipart.boundary()).as_str(),
326        );
327
328        builder = match multipart.compute_length() {
329            Some(length) => builder.header(CONTENT_LENGTH, length),
330            None => builder,
331        };
332
333        if let Ok(ref mut req) = builder.request {
334            *req.body_mut() = Some(multipart.stream())
335        }
336        builder
337    }
338
339    /// Modify the query string of the URL.
340    ///
341    /// Modifies the URL of this request, adding the parameters provided.
342    /// This method appends and does not overwrite. This means that it can
343    /// be called multiple times and that existing query parameters are not
344    /// overwritten if the same key is used. The key will simply show up
345    /// twice in the query string.
346    /// Calling `.query(&[("foo", "a"), ("foo", "b")])` gives `"foo=a&foo=b"`.
347    ///
348    /// # Note
349    /// This method does not support serializing a single key-value
350    /// pair. Instead of using `.query(("key", "val"))`, use a sequence, such
351    /// as `.query(&[("key", "val")])`. It's also possible to serialize structs
352    /// and maps into a key-value pair.
353    ///
354    /// # Optional
355    ///
356    /// This requires the optional `query` feature to be enabled.
357    ///
358    /// # Errors
359    /// This method will fail if the object you provide cannot be serialized
360    /// into a query string.
361    #[cfg(feature = "query")]
362    #[cfg_attr(docsrs, doc(cfg(feature = "query")))]
363    pub fn query<T: Serialize + ?Sized>(mut self, query: &T) -> RequestBuilder {
364        let mut error = None;
365        if let Ok(ref mut req) = self.request {
366            let url = req.url_mut();
367            let mut pairs = url.query_pairs_mut();
368            let serializer = serde_urlencoded::Serializer::new(&mut pairs);
369
370            if let Err(err) = query.serialize(serializer) {
371                error = Some(crate::error::builder(err));
372            }
373        }
374        if let Ok(ref mut req) = self.request {
375            if let Some("") = req.url().query() {
376                req.url_mut().set_query(None);
377            }
378        }
379        if let Some(err) = error {
380            self.request = Err(err);
381        }
382        self
383    }
384
385    /// Set HTTP version
386    pub fn version(mut self, version: Version) -> RequestBuilder {
387        if let Ok(ref mut req) = self.request {
388            req.version = version;
389        }
390        self
391    }
392
393    /// Send a form body.
394    ///
395    /// Sets the body to the url encoded serialization of the passed value,
396    /// and also sets the `Content-Type: application/x-www-form-urlencoded`
397    /// header.
398    ///
399    /// ```rust
400    /// # use reqwest::Error;
401    /// # use std::collections::HashMap;
402    /// #
403    /// # async fn run() -> Result<(), Error> {
404    /// let mut params = HashMap::new();
405    /// params.insert("lang", "rust");
406    ///
407    /// let client = reqwest::Client::new();
408    /// let res = client.post("http://httpbin.org")
409    ///     .form(&params)
410    ///     .send()
411    ///     .await?;
412    /// # Ok(())
413    /// # }
414    /// ```
415    ///
416    /// # Optional
417    ///
418    /// This requires the optional `form` feature to be enabled.
419    ///
420    /// # Errors
421    ///
422    /// This method fails if the passed value cannot be serialized into
423    /// url encoded format
424    #[cfg(feature = "form")]
425    #[cfg_attr(docsrs, doc(cfg(feature = "form")))]
426    pub fn form<T: Serialize + ?Sized>(mut self, form: &T) -> RequestBuilder {
427        let mut error = None;
428        if let Ok(ref mut req) = self.request {
429            match serde_urlencoded::to_string(form) {
430                Ok(body) => {
431                    req.headers_mut()
432                        .entry(CONTENT_TYPE)
433                        .or_insert(HeaderValue::from_static(
434                            "application/x-www-form-urlencoded",
435                        ));
436                    *req.body_mut() = Some(body.into());
437                }
438                Err(err) => error = Some(crate::error::builder(err)),
439            }
440        }
441        if let Some(err) = error {
442            self.request = Err(err);
443        }
444        self
445    }
446
447    /// Send a JSON body.
448    ///
449    /// Serializes the value to JSON and sets resulting bytes as the body.
450    ///
451    /// Sets Content-Type header to application/json unless the header is already set.
452    ///
453    /// # Optional
454    ///
455    /// This requires the optional `json` feature enabled.
456    ///
457    /// # Errors
458    ///
459    /// Serialization can fail if `T`'s implementation of `Serialize` decides to
460    /// fail, or if `T` contains a map with non-string keys.
461    #[cfg(feature = "json")]
462    #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
463    pub fn json<T: Serialize + ?Sized>(mut self, json: &T) -> RequestBuilder {
464        let mut error = None;
465        if let Ok(ref mut req) = self.request {
466            match serde_json::to_vec(json) {
467                Ok(body) => {
468                    req.headers_mut()
469                        .entry(CONTENT_TYPE)
470                        .or_insert_with(|| HeaderValue::from_static("application/json"));
471                    *req.body_mut() = Some(body.into());
472                }
473                Err(err) => error = Some(crate::error::builder(err)),
474            }
475        }
476        if let Some(err) = error {
477            self.request = Err(err);
478        }
479        self
480    }
481
482    /// Build a `Request`, which can be inspected, modified and executed with
483    /// `Client::execute()`.
484    pub fn build(self) -> crate::Result<Request> {
485        self.request
486    }
487
488    /// Build a `Request`, which can be inspected, modified and executed with
489    /// `Client::execute()`.
490    ///
491    /// This is similar to [`RequestBuilder::build()`], but also returns the
492    /// embedded `Client`.
493    pub fn build_split(self) -> (Client, crate::Result<Request>) {
494        (self.client, self.request)
495    }
496
497    /// Constructs the Request and sends it to the target URL, returning a
498    /// future Response.
499    ///
500    /// # Errors
501    ///
502    /// This method fails if there was an error while sending request,
503    /// redirect loop was detected or redirect limit was exhausted.
504    ///
505    /// # Example
506    ///
507    /// ```no_run
508    /// # use reqwest::Error;
509    /// #
510    /// # async fn run() -> Result<(), Error> {
511    /// let response = reqwest::Client::new()
512    ///     .get("https://hyper.rs")
513    ///     .send()
514    ///     .await?;
515    /// # Ok(())
516    /// # }
517    /// ```
518    pub fn send(self) -> impl Future<Output = Result<Response, crate::Error>> {
519        match self.request {
520            Ok(req) => self.client.execute_request(req),
521            Err(err) => Pending::new_err(err),
522        }
523    }
524
525    /// Attempt to clone the RequestBuilder.
526    ///
527    /// `None` is returned if the RequestBuilder can not be cloned,
528    /// i.e. if the request body is a stream.
529    ///
530    /// # Examples
531    ///
532    /// ```
533    /// # use reqwest::Error;
534    /// #
535    /// # fn run() -> Result<(), Error> {
536    /// let client = reqwest::Client::new();
537    /// let builder = client.post("http://httpbin.org/post")
538    ///     .body("from a &str!");
539    /// let clone = builder.try_clone();
540    /// assert!(clone.is_some());
541    /// # Ok(())
542    /// # }
543    /// ```
544    pub fn try_clone(&self) -> Option<RequestBuilder> {
545        self.request
546            .as_ref()
547            .ok()
548            .and_then(|req| req.try_clone())
549            .map(|req| RequestBuilder {
550                client: self.client.clone(),
551                request: Ok(req),
552            })
553    }
554}
555
556impl fmt::Debug for Request {
557    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
558        fmt_request_fields(&mut f.debug_struct("Request"), self).finish()
559    }
560}
561
562impl fmt::Debug for RequestBuilder {
563    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
564        let mut builder = f.debug_struct("RequestBuilder");
565        match self.request {
566            Ok(ref req) => fmt_request_fields(&mut builder, req).finish(),
567            Err(ref err) => builder.field("error", err).finish(),
568        }
569    }
570}
571
572fn fmt_request_fields<'a, 'b>(
573    f: &'a mut fmt::DebugStruct<'a, 'b>,
574    req: &Request,
575) -> &'a mut fmt::DebugStruct<'a, 'b> {
576    f.field("method", &req.method)
577        .field("url", &req.url)
578        .field("headers", &req.headers)
579}
580
581/// Check the request URL for a "username:password" type authority, and if
582/// found, remove it from the URL and return it.
583pub(crate) fn extract_authority(url: &mut Url) -> Option<(String, Option<String>)> {
584    use percent_encoding::percent_decode;
585
586    if url.has_authority() {
587        let username: String = percent_decode(url.username().as_bytes())
588            .decode_utf8()
589            .ok()?
590            .into();
591        let password = url.password().and_then(|pass| {
592            percent_decode(pass.as_bytes())
593                .decode_utf8()
594                .ok()
595                .map(String::from)
596        });
597        if !username.is_empty() || password.is_some() {
598            url.set_username("")
599                .expect("has_authority means set_username shouldn't fail");
600            url.set_password(None)
601                .expect("has_authority means set_password shouldn't fail");
602            return Some((username, password));
603        }
604    }
605
606    None
607}
608
609impl<T> TryFrom<HttpRequest<T>> for Request
610where
611    T: Into<Body>,
612{
613    type Error = crate::Error;
614
615    fn try_from(req: HttpRequest<T>) -> crate::Result<Self> {
616        let (parts, body) = req.into_parts();
617        let Parts {
618            method,
619            uri,
620            headers,
621            version,
622            extensions,
623            ..
624        } = parts;
625        let url = Url::parse(&uri.to_string()).map_err(crate::error::builder)?;
626        Ok(Request {
627            method,
628            url,
629            headers,
630            body: Some(body.into()),
631            version,
632            extensions,
633        })
634    }
635}
636
637impl TryFrom<Request> for HttpRequest<Body> {
638    type Error = crate::Error;
639
640    fn try_from(req: Request) -> crate::Result<Self> {
641        let Request {
642            method,
643            url,
644            headers,
645            body,
646            version,
647            extensions,
648            ..
649        } = req;
650
651        let mut req = HttpRequest::builder()
652            .version(version)
653            .method(method)
654            .uri(url.as_str())
655            .body(body.unwrap_or_else(Body::empty))
656            .map_err(crate::error::builder)?;
657
658        *req.headers_mut() = headers;
659        *req.extensions_mut() = extensions;
660        Ok(req)
661    }
662}
663
664#[cfg(test)]
665mod tests {
666
667    use super::*;
668    #[cfg(feature = "query")]
669    use std::collections::BTreeMap;
670
671    #[test]
672    #[cfg(feature = "query")]
673    fn add_query_append() {
674        let client = Client::new();
675        let some_url = "https://google.com/";
676        let r = client.get(some_url);
677
678        let r = r.query(&[("foo", "bar")]);
679        let r = r.query(&[("qux", 3)]);
680
681        let req = r.build().expect("request is valid");
682        assert_eq!(req.url().query(), Some("foo=bar&qux=3"));
683    }
684
685    #[test]
686    #[cfg(feature = "query")]
687    fn add_query_append_same() {
688        let client = Client::new();
689        let some_url = "https://google.com/";
690        let r = client.get(some_url);
691
692        let r = r.query(&[("foo", "a"), ("foo", "b")]);
693
694        let req = r.build().expect("request is valid");
695        assert_eq!(req.url().query(), Some("foo=a&foo=b"));
696    }
697
698    #[test]
699    #[cfg(feature = "query")]
700    fn add_query_struct() {
701        #[derive(Serialize)]
702        struct Params {
703            foo: String,
704            qux: i32,
705        }
706
707        let client = Client::new();
708        let some_url = "https://google.com/";
709        let r = client.get(some_url);
710
711        let params = Params {
712            foo: "bar".into(),
713            qux: 3,
714        };
715
716        let r = r.query(&params);
717
718        let req = r.build().expect("request is valid");
719        assert_eq!(req.url().query(), Some("foo=bar&qux=3"));
720    }
721
722    #[test]
723    #[cfg(feature = "query")]
724    fn add_query_map() {
725        let mut params = BTreeMap::new();
726        params.insert("foo", "bar");
727        params.insert("qux", "three");
728
729        let client = Client::new();
730        let some_url = "https://google.com/";
731        let r = client.get(some_url);
732
733        let r = r.query(&params);
734
735        let req = r.build().expect("request is valid");
736        assert_eq!(req.url().query(), Some("foo=bar&qux=three"));
737    }
738
739    #[test]
740    fn test_replace_headers() {
741        use http::HeaderMap;
742
743        let mut headers = HeaderMap::new();
744        headers.insert("foo", "bar".parse().unwrap());
745        headers.append("foo", "baz".parse().unwrap());
746
747        let client = Client::new();
748        let req = client
749            .get("https://hyper.rs")
750            .header("im-a", "keeper")
751            .header("foo", "pop me")
752            .headers(headers)
753            .build()
754            .expect("request build");
755
756        assert_eq!(req.headers()["im-a"], "keeper");
757
758        let foo = req.headers().get_all("foo").iter().collect::<Vec<_>>();
759        assert_eq!(foo.len(), 2);
760        assert_eq!(foo[0], "bar");
761        assert_eq!(foo[1], "baz");
762    }
763
764    #[test]
765    #[cfg(feature = "query")]
766    fn normalize_empty_query() {
767        let client = Client::new();
768        let some_url = "https://google.com/";
769        let empty_query: &[(&str, &str)] = &[];
770
771        let req = client
772            .get(some_url)
773            .query(empty_query)
774            .build()
775            .expect("request build");
776
777        assert_eq!(req.url().query(), None);
778        assert_eq!(req.url().as_str(), "https://google.com/");
779    }
780
781    #[test]
782    fn try_clone_reusable() {
783        let client = Client::new();
784        let builder = client
785            .post("http://httpbin.org/post")
786            .header("foo", "bar")
787            .body("from a &str!");
788        let req = builder
789            .try_clone()
790            .expect("clone successful")
791            .build()
792            .expect("request is valid");
793        assert_eq!(req.url().as_str(), "http://httpbin.org/post");
794        assert_eq!(req.method(), Method::POST);
795        assert_eq!(req.headers()["foo"], "bar");
796    }
797
798    #[test]
799    fn try_clone_no_body() {
800        let client = Client::new();
801        let builder = client.get("http://httpbin.org/get");
802        let req = builder
803            .try_clone()
804            .expect("clone successful")
805            .build()
806            .expect("request is valid");
807        assert_eq!(req.url().as_str(), "http://httpbin.org/get");
808        assert_eq!(req.method(), Method::GET);
809        assert!(req.body().is_none());
810    }
811
812    #[test]
813    #[cfg(feature = "stream")]
814    fn try_clone_stream() {
815        let chunks: Vec<Result<_, ::std::io::Error>> = vec![Ok("hello"), Ok(" "), Ok("world")];
816        let stream = futures_util::stream::iter(chunks);
817        let client = Client::new();
818        let builder = client
819            .get("http://httpbin.org/get")
820            .body(super::Body::wrap_stream(stream));
821        let clone = builder.try_clone();
822        assert!(clone.is_none());
823    }
824
825    #[test]
826    fn convert_url_authority_into_basic_auth() {
827        let client = Client::new();
828        let some_url = "https://Aladdin:open sesame@localhost/";
829
830        let req = client.get(some_url).build().expect("request build");
831
832        assert_eq!(req.url().as_str(), "https://localhost/");
833        assert_eq!(
834            req.headers()["authorization"],
835            "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
836        );
837    }
838
839    #[test]
840    fn test_basic_auth_sensitive_header() {
841        let client = Client::new();
842        let some_url = "https://localhost/";
843
844        let req = client
845            .get(some_url)
846            .basic_auth("Aladdin", Some("open sesame"))
847            .build()
848            .expect("request build");
849
850        assert_eq!(req.url().as_str(), "https://localhost/");
851        assert_eq!(
852            req.headers()["authorization"],
853            "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
854        );
855        assert!(req.headers()["authorization"].is_sensitive());
856    }
857
858    #[test]
859    fn test_bearer_auth_sensitive_header() {
860        let client = Client::new();
861        let some_url = "https://localhost/";
862
863        let req = client
864            .get(some_url)
865            .bearer_auth("Hold my bear")
866            .build()
867            .expect("request build");
868
869        assert_eq!(req.url().as_str(), "https://localhost/");
870        assert_eq!(req.headers()["authorization"], "Bearer Hold my bear");
871        assert!(req.headers()["authorization"].is_sensitive());
872    }
873
874    #[test]
875    fn test_explicit_sensitive_header() {
876        let client = Client::new();
877        let some_url = "https://localhost/";
878
879        let mut header = http::HeaderValue::from_static("in plain sight");
880        header.set_sensitive(true);
881
882        let req = client
883            .get(some_url)
884            .header("hiding", header)
885            .build()
886            .expect("request build");
887
888        assert_eq!(req.url().as_str(), "https://localhost/");
889        assert_eq!(req.headers()["hiding"], "in plain sight");
890        assert!(req.headers()["hiding"].is_sensitive());
891    }
892
893    #[test]
894    fn convert_from_http_request() {
895        let http_request = HttpRequest::builder()
896            .method("GET")
897            .uri("http://localhost/")
898            .header("User-Agent", "my-awesome-agent/1.0")
899            .body("test test test")
900            .unwrap();
901        let req: Request = Request::try_from(http_request).unwrap();
902        assert!(req.body().is_some());
903        let test_data = b"test test test";
904        assert_eq!(req.body().unwrap().as_bytes(), Some(&test_data[..]));
905        let headers = req.headers();
906        assert_eq!(headers.get("User-Agent").unwrap(), "my-awesome-agent/1.0");
907        assert_eq!(req.method(), Method::GET);
908        assert_eq!(req.url().as_str(), "http://localhost/");
909    }
910
911    #[test]
912    fn set_http_request_version() {
913        let http_request = HttpRequest::builder()
914            .method("GET")
915            .uri("http://localhost/")
916            .header("User-Agent", "my-awesome-agent/1.0")
917            .version(Version::HTTP_11)
918            .body("test test test")
919            .unwrap();
920        let req: Request = Request::try_from(http_request).unwrap();
921        assert!(req.body().is_some());
922        let test_data = b"test test test";
923        assert_eq!(req.body().unwrap().as_bytes(), Some(&test_data[..]));
924        let headers = req.headers();
925        assert_eq!(headers.get("User-Agent").unwrap(), "my-awesome-agent/1.0");
926        assert_eq!(req.method(), Method::GET);
927        assert_eq!(req.url().as_str(), "http://localhost/");
928        assert_eq!(req.version(), Version::HTTP_11);
929    }
930
931    #[test]
932    fn builder_split_reassemble() {
933        let builder = {
934            let client = Client::new();
935            client.get("http://example.com")
936        };
937        let (client, inner) = builder.build_split();
938        let request = inner.unwrap();
939        let builder = RequestBuilder::from_parts(client, request);
940        builder.build().unwrap();
941    }
942
943    /*
944    use {body, Method};
945    use super::Client;
946    use header::{Host, Headers, ContentType};
947    use std::collections::HashMap;
948    use serde_urlencoded;
949    use serde_json;
950
951    #[test]
952    fn basic_get_request() {
953        let client = Client::new().unwrap();
954        let some_url = "https://google.com/";
955        let r = client.get(some_url).unwrap().build();
956
957        assert_eq!(r.method, Method::Get);
958        assert_eq!(r.url.as_str(), some_url);
959    }
960
961    #[test]
962    fn basic_head_request() {
963        let client = Client::new().unwrap();
964        let some_url = "https://google.com/";
965        let r = client.head(some_url).unwrap().build();
966
967        assert_eq!(r.method, Method::Head);
968        assert_eq!(r.url.as_str(), some_url);
969    }
970
971    #[test]
972    fn basic_post_request() {
973        let client = Client::new().unwrap();
974        let some_url = "https://google.com/";
975        let r = client.post(some_url).unwrap().build();
976
977        assert_eq!(r.method, Method::Post);
978        assert_eq!(r.url.as_str(), some_url);
979    }
980
981    #[test]
982    fn basic_put_request() {
983        let client = Client::new().unwrap();
984        let some_url = "https://google.com/";
985        let r = client.put(some_url).unwrap().build();
986
987        assert_eq!(r.method, Method::Put);
988        assert_eq!(r.url.as_str(), some_url);
989    }
990
991    #[test]
992    fn basic_patch_request() {
993        let client = Client::new().unwrap();
994        let some_url = "https://google.com/";
995        let r = client.patch(some_url).unwrap().build();
996
997        assert_eq!(r.method, Method::Patch);
998        assert_eq!(r.url.as_str(), some_url);
999    }
1000
1001    #[test]
1002    fn basic_delete_request() {
1003        let client = Client::new().unwrap();
1004        let some_url = "https://google.com/";
1005        let r = client.delete(some_url).unwrap().build();
1006
1007        assert_eq!(r.method, Method::Delete);
1008        assert_eq!(r.url.as_str(), some_url);
1009    }
1010
1011    #[test]
1012    fn add_header() {
1013        let client = Client::new().unwrap();
1014        let some_url = "https://google.com/";
1015        let mut r = client.post(some_url).unwrap();
1016
1017        let header = Host {
1018            hostname: "google.com".to_string(),
1019            port: None,
1020        };
1021
1022        // Add a copy of the header to the request builder
1023        let r = r.header(header.clone()).build();
1024
1025        // then check it was actually added
1026        assert_eq!(r.headers.get::<Host>(), Some(&header));
1027    }
1028
1029    #[test]
1030    fn add_headers() {
1031        let client = Client::new().unwrap();
1032        let some_url = "https://google.com/";
1033        let mut r = client.post(some_url).unwrap();
1034
1035        let header = Host {
1036            hostname: "google.com".to_string(),
1037            port: None,
1038        };
1039
1040        let mut headers = Headers::new();
1041        headers.set(header);
1042
1043        // Add a copy of the headers to the request builder
1044        let r = r.headers(headers.clone()).build();
1045
1046        // then make sure they were added correctly
1047        assert_eq!(r.headers, headers);
1048    }
1049
1050    #[test]
1051    fn add_headers_multi() {
1052        let client = Client::new().unwrap();
1053        let some_url = "https://google.com/";
1054        let mut r = client.post(some_url).unwrap();
1055
1056        let header = Host {
1057            hostname: "google.com".to_string(),
1058            port: None,
1059        };
1060
1061        let mut headers = Headers::new();
1062        headers.set(header);
1063
1064        // Add a copy of the headers to the request builder
1065        let r = r.headers(headers.clone()).build();
1066
1067        // then make sure they were added correctly
1068        assert_eq!(r.headers, headers);
1069    }
1070
1071    #[test]
1072    fn add_body() {
1073        let client = Client::new().unwrap();
1074        let some_url = "https://google.com/";
1075        let mut r = client.post(some_url).unwrap();
1076
1077        let body = "Some interesting content";
1078
1079        let r = r.body(body).build();
1080
1081        let buf = body::read_to_string(r.body.unwrap()).unwrap();
1082
1083        assert_eq!(buf, body);
1084    }
1085
1086    #[test]
1087    fn add_form() {
1088        let client = Client::new().unwrap();
1089        let some_url = "https://google.com/";
1090        let mut r = client.post(some_url).unwrap();
1091
1092        let mut form_data = HashMap::new();
1093        form_data.insert("foo", "bar");
1094
1095        let r = r.form(&form_data).unwrap().build();
1096
1097        // Make sure the content type was set
1098        assert_eq!(r.headers.get::<ContentType>(),
1099                   Some(&ContentType::form_url_encoded()));
1100
1101        let buf = body::read_to_string(r.body.unwrap()).unwrap();
1102
1103        let body_should_be = serde_urlencoded::to_string(&form_data).unwrap();
1104        assert_eq!(buf, body_should_be);
1105    }
1106
1107    #[test]
1108    fn add_json() {
1109        let client = Client::new().unwrap();
1110        let some_url = "https://google.com/";
1111        let mut r = client.post(some_url).unwrap();
1112
1113        let mut json_data = HashMap::new();
1114        json_data.insert("foo", "bar");
1115
1116        let r = r.json(&json_data).unwrap().build();
1117
1118        // Make sure the content type was set
1119        assert_eq!(r.headers.get::<ContentType>(), Some(&ContentType::json()));
1120
1121        let buf = body::read_to_string(r.body.unwrap()).unwrap();
1122
1123        let body_should_be = serde_json::to_string(&json_data).unwrap();
1124        assert_eq!(buf, body_should_be);
1125    }
1126
1127    #[test]
1128    fn add_json_fail() {
1129        use serde::{Serialize, Serializer};
1130        use serde::ser::Error;
1131        struct MyStruct;
1132        impl Serialize for MyStruct {
1133            fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
1134                where S: Serializer
1135                {
1136                    Err(S::Error::custom("nope"))
1137                }
1138        }
1139
1140        let client = Client::new().unwrap();
1141        let some_url = "https://google.com/";
1142        let mut r = client.post(some_url).unwrap();
1143        let json_data = MyStruct{};
1144        assert!(r.json(&json_data).unwrap_err().is_serialization());
1145    }
1146    */
1147}
reqwest/async_impl/request.rs

reqwest/async_impl/
request.rs
