reqwest/async_impl/
request.rs

1use std::convert::TryFrom;
2use std::fmt;
3use std::future::Future;
4use std::time::Duration;
5
6use serde::Serialize;
7#[cfg(feature = "json")]
8use serde_json;
9
10use super::body::Body;
11use super::client::{Client, Pending};
12#[cfg(feature = "multipart")]
13use super::multipart;
14use super::response::Response;
15use crate::config::{RequestConfig, RequestTimeout};
16#[cfg(feature = "multipart")]
17use crate::header::CONTENT_LENGTH;
18use crate::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
19use crate::{Method, Url};
20use http::{request::Parts, Extensions, Request as HttpRequest, Version};
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::<RequestTimeout>::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::<RequestTimeout>::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    /// # Errors
355    /// This method will fail if the object you provide cannot be serialized
356    /// into a query string.
357    pub fn query<T: Serialize + ?Sized>(mut self, query: &T) -> RequestBuilder {
358        let mut error = None;
359        if let Ok(ref mut req) = self.request {
360            let url = req.url_mut();
361            let mut pairs = url.query_pairs_mut();
362            let serializer = serde_urlencoded::Serializer::new(&mut pairs);
363
364            if let Err(err) = query.serialize(serializer) {
365                error = Some(crate::error::builder(err));
366            }
367        }
368        if let Ok(ref mut req) = self.request {
369            if let Some("") = req.url().query() {
370                req.url_mut().set_query(None);
371            }
372        }
373        if let Some(err) = error {
374            self.request = Err(err);
375        }
376        self
377    }
378
379    /// Set HTTP version
380    pub fn version(mut self, version: Version) -> RequestBuilder {
381        if let Ok(ref mut req) = self.request {
382            req.version = version;
383        }
384        self
385    }
386
387    /// Send a form body.
388    ///
389    /// Sets the body to the url encoded serialization of the passed value,
390    /// and also sets the `Content-Type: application/x-www-form-urlencoded`
391    /// header.
392    ///
393    /// ```rust
394    /// # use reqwest::Error;
395    /// # use std::collections::HashMap;
396    /// #
397    /// # async fn run() -> Result<(), Error> {
398    /// let mut params = HashMap::new();
399    /// params.insert("lang", "rust");
400    ///
401    /// let client = reqwest::Client::new();
402    /// let res = client.post("http://httpbin.org")
403    ///     .form(&params)
404    ///     .send()
405    ///     .await?;
406    /// # Ok(())
407    /// # }
408    /// ```
409    ///
410    /// # Errors
411    ///
412    /// This method fails if the passed value cannot be serialized into
413    /// url encoded format
414    pub fn form<T: Serialize + ?Sized>(mut self, form: &T) -> RequestBuilder {
415        let mut error = None;
416        if let Ok(ref mut req) = self.request {
417            match serde_urlencoded::to_string(form) {
418                Ok(body) => {
419                    req.headers_mut()
420                        .entry(CONTENT_TYPE)
421                        .or_insert(HeaderValue::from_static(
422                            "application/x-www-form-urlencoded",
423                        ));
424                    *req.body_mut() = Some(body.into());
425                }
426                Err(err) => error = Some(crate::error::builder(err)),
427            }
428        }
429        if let Some(err) = error {
430            self.request = Err(err);
431        }
432        self
433    }
434
435    /// Send a JSON body.
436    ///
437    /// # Optional
438    ///
439    /// This requires the optional `json` feature enabled.
440    ///
441    /// # Errors
442    ///
443    /// Serialization can fail if `T`'s implementation of `Serialize` decides to
444    /// fail, or if `T` contains a map with non-string keys.
445    #[cfg(feature = "json")]
446    #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
447    pub fn json<T: Serialize + ?Sized>(mut self, json: &T) -> RequestBuilder {
448        let mut error = None;
449        if let Ok(ref mut req) = self.request {
450            match serde_json::to_vec(json) {
451                Ok(body) => {
452                    if !req.headers().contains_key(CONTENT_TYPE) {
453                        req.headers_mut()
454                            .insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
455                    }
456                    *req.body_mut() = Some(body.into());
457                }
458                Err(err) => error = Some(crate::error::builder(err)),
459            }
460        }
461        if let Some(err) = error {
462            self.request = Err(err);
463        }
464        self
465    }
466
467    // This was a shell only meant to help with rendered documentation.
468    // However, docs.rs can now show the docs for the wasm platforms, so this
469    // is no longer needed.
470    //
471    // You should not otherwise depend on this function. It's deprecation
472    // is just to nudge people to reduce breakage. It may be removed in a
473    // future patch version.
474    #[doc(hidden)]
475    #[cfg_attr(target_arch = "wasm32", deprecated)]
476    pub fn fetch_mode_no_cors(self) -> RequestBuilder {
477        self
478    }
479
480    /// Build a `Request`, which can be inspected, modified and executed with
481    /// `Client::execute()`.
482    pub fn build(self) -> crate::Result<Request> {
483        self.request
484    }
485
486    /// Build a `Request`, which can be inspected, modified and executed with
487    /// `Client::execute()`.
488    ///
489    /// This is similar to [`RequestBuilder::build()`], but also returns the
490    /// embedded `Client`.
491    pub fn build_split(self) -> (Client, crate::Result<Request>) {
492        (self.client, self.request)
493    }
494
495    /// Constructs the Request and sends it to the target URL, returning a
496    /// future Response.
497    ///
498    /// # Errors
499    ///
500    /// This method fails if there was an error while sending request,
501    /// redirect loop was detected or redirect limit was exhausted.
502    ///
503    /// # Example
504    ///
505    /// ```no_run
506    /// # use reqwest::Error;
507    /// #
508    /// # async fn run() -> Result<(), Error> {
509    /// let response = reqwest::Client::new()
510    ///     .get("https://hyper.rs")
511    ///     .send()
512    ///     .await?;
513    /// # Ok(())
514    /// # }
515    /// ```
516    pub fn send(self) -> impl Future<Output = Result<Response, crate::Error>> {
517        match self.request {
518            Ok(req) => self.client.execute_request(req),
519            Err(err) => Pending::new_err(err),
520        }
521    }
522
523    /// Attempt to clone the RequestBuilder.
524    ///
525    /// `None` is returned if the RequestBuilder can not be cloned,
526    /// i.e. if the request body is a stream.
527    ///
528    /// # Examples
529    ///
530    /// ```
531    /// # use reqwest::Error;
532    /// #
533    /// # fn run() -> Result<(), Error> {
534    /// let client = reqwest::Client::new();
535    /// let builder = client.post("http://httpbin.org/post")
536    ///     .body("from a &str!");
537    /// let clone = builder.try_clone();
538    /// assert!(clone.is_some());
539    /// # Ok(())
540    /// # }
541    /// ```
542    pub fn try_clone(&self) -> Option<RequestBuilder> {
543        self.request
544            .as_ref()
545            .ok()
546            .and_then(|req| req.try_clone())
547            .map(|req| RequestBuilder {
548                client: self.client.clone(),
549                request: Ok(req),
550            })
551    }
552}
553
554impl fmt::Debug for Request {
555    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
556        fmt_request_fields(&mut f.debug_struct("Request"), self).finish()
557    }
558}
559
560impl fmt::Debug for RequestBuilder {
561    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
562        let mut builder = f.debug_struct("RequestBuilder");
563        match self.request {
564            Ok(ref req) => fmt_request_fields(&mut builder, req).finish(),
565            Err(ref err) => builder.field("error", err).finish(),
566        }
567    }
568}
569
570fn fmt_request_fields<'a, 'b>(
571    f: &'a mut fmt::DebugStruct<'a, 'b>,
572    req: &Request,
573) -> &'a mut fmt::DebugStruct<'a, 'b> {
574    f.field("method", &req.method)
575        .field("url", &req.url)
576        .field("headers", &req.headers)
577}
578
579/// Check the request URL for a "username:password" type authority, and if
580/// found, remove it from the URL and return it.
581pub(crate) fn extract_authority(url: &mut Url) -> Option<(String, Option<String>)> {
582    use percent_encoding::percent_decode;
583
584    if url.has_authority() {
585        let username: String = percent_decode(url.username().as_bytes())
586            .decode_utf8()
587            .ok()?
588            .into();
589        let password = url.password().and_then(|pass| {
590            percent_decode(pass.as_bytes())
591                .decode_utf8()
592                .ok()
593                .map(String::from)
594        });
595        if !username.is_empty() || password.is_some() {
596            url.set_username("")
597                .expect("has_authority means set_username shouldn't fail");
598            url.set_password(None)
599                .expect("has_authority means set_password shouldn't fail");
600            return Some((username, password));
601        }
602    }
603
604    None
605}
606
607impl<T> TryFrom<HttpRequest<T>> for Request
608where
609    T: Into<Body>,
610{
611    type Error = crate::Error;
612
613    fn try_from(req: HttpRequest<T>) -> crate::Result<Self> {
614        let (parts, body) = req.into_parts();
615        let Parts {
616            method,
617            uri,
618            headers,
619            version,
620            extensions,
621            ..
622        } = parts;
623        let url = Url::parse(&uri.to_string()).map_err(crate::error::builder)?;
624        Ok(Request {
625            method,
626            url,
627            headers,
628            body: Some(body.into()),
629            version,
630            extensions,
631        })
632    }
633}
634
635impl TryFrom<Request> for HttpRequest<Body> {
636    type Error = crate::Error;
637
638    fn try_from(req: Request) -> crate::Result<Self> {
639        let Request {
640            method,
641            url,
642            headers,
643            body,
644            version,
645            extensions,
646            ..
647        } = req;
648
649        let mut req = HttpRequest::builder()
650            .version(version)
651            .method(method)
652            .uri(url.as_str())
653            .body(body.unwrap_or_else(Body::empty))
654            .map_err(crate::error::builder)?;
655
656        *req.headers_mut() = headers;
657        *req.extensions_mut() = extensions;
658        Ok(req)
659    }
660}
661
662#[cfg(test)]
663mod tests {
664    #![cfg(not(feature = "rustls-tls-manual-roots-no-provider"))]
665
666    use super::{Client, HttpRequest, Request, RequestBuilder, Version};
667    use crate::Method;
668    use serde::Serialize;
669    use std::collections::BTreeMap;
670    use std::convert::TryFrom;
671
672    #[test]
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    fn add_query_append_same() {
687        let client = Client::new();
688        let some_url = "https://google.com/";
689        let r = client.get(some_url);
690
691        let r = r.query(&[("foo", "a"), ("foo", "b")]);
692
693        let req = r.build().expect("request is valid");
694        assert_eq!(req.url().query(), Some("foo=a&foo=b"));
695    }
696
697    #[test]
698    fn add_query_struct() {
699        #[derive(Serialize)]
700        struct Params {
701            foo: String,
702            qux: i32,
703        }
704
705        let client = Client::new();
706        let some_url = "https://google.com/";
707        let r = client.get(some_url);
708
709        let params = Params {
710            foo: "bar".into(),
711            qux: 3,
712        };
713
714        let r = r.query(&params);
715
716        let req = r.build().expect("request is valid");
717        assert_eq!(req.url().query(), Some("foo=bar&qux=3"));
718    }
719
720    #[test]
721    fn add_query_map() {
722        let mut params = BTreeMap::new();
723        params.insert("foo", "bar");
724        params.insert("qux", "three");
725
726        let client = Client::new();
727        let some_url = "https://google.com/";
728        let r = client.get(some_url);
729
730        let r = r.query(&params);
731
732        let req = r.build().expect("request is valid");
733        assert_eq!(req.url().query(), Some("foo=bar&qux=three"));
734    }
735
736    #[test]
737    fn test_replace_headers() {
738        use http::HeaderMap;
739
740        let mut headers = HeaderMap::new();
741        headers.insert("foo", "bar".parse().unwrap());
742        headers.append("foo", "baz".parse().unwrap());
743
744        let client = Client::new();
745        let req = client
746            .get("https://hyper.rs")
747            .header("im-a", "keeper")
748            .header("foo", "pop me")
749            .headers(headers)
750            .build()
751            .expect("request build");
752
753        assert_eq!(req.headers()["im-a"], "keeper");
754
755        let foo = req.headers().get_all("foo").iter().collect::<Vec<_>>();
756        assert_eq!(foo.len(), 2);
757        assert_eq!(foo[0], "bar");
758        assert_eq!(foo[1], "baz");
759    }
760
761    #[test]
762    fn normalize_empty_query() {
763        let client = Client::new();
764        let some_url = "https://google.com/";
765        let empty_query: &[(&str, &str)] = &[];
766
767        let req = client
768            .get(some_url)
769            .query(empty_query)
770            .build()
771            .expect("request build");
772
773        assert_eq!(req.url().query(), None);
774        assert_eq!(req.url().as_str(), "https://google.com/");
775    }
776
777    #[test]
778    fn try_clone_reusable() {
779        let client = Client::new();
780        let builder = client
781            .post("http://httpbin.org/post")
782            .header("foo", "bar")
783            .body("from a &str!");
784        let req = builder
785            .try_clone()
786            .expect("clone successful")
787            .build()
788            .expect("request is valid");
789        assert_eq!(req.url().as_str(), "http://httpbin.org/post");
790        assert_eq!(req.method(), Method::POST);
791        assert_eq!(req.headers()["foo"], "bar");
792    }
793
794    #[test]
795    fn try_clone_no_body() {
796        let client = Client::new();
797        let builder = client.get("http://httpbin.org/get");
798        let req = builder
799            .try_clone()
800            .expect("clone successful")
801            .build()
802            .expect("request is valid");
803        assert_eq!(req.url().as_str(), "http://httpbin.org/get");
804        assert_eq!(req.method(), Method::GET);
805        assert!(req.body().is_none());
806    }
807
808    #[test]
809    #[cfg(feature = "stream")]
810    fn try_clone_stream() {
811        let chunks: Vec<Result<_, ::std::io::Error>> = vec![Ok("hello"), Ok(" "), Ok("world")];
812        let stream = futures_util::stream::iter(chunks);
813        let client = Client::new();
814        let builder = client
815            .get("http://httpbin.org/get")
816            .body(super::Body::wrap_stream(stream));
817        let clone = builder.try_clone();
818        assert!(clone.is_none());
819    }
820
821    #[test]
822    fn convert_url_authority_into_basic_auth() {
823        let client = Client::new();
824        let some_url = "https://Aladdin:open sesame@localhost/";
825
826        let req = client.get(some_url).build().expect("request build");
827
828        assert_eq!(req.url().as_str(), "https://localhost/");
829        assert_eq!(
830            req.headers()["authorization"],
831            "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
832        );
833    }
834
835    #[test]
836    fn test_basic_auth_sensitive_header() {
837        let client = Client::new();
838        let some_url = "https://localhost/";
839
840        let req = client
841            .get(some_url)
842            .basic_auth("Aladdin", Some("open sesame"))
843            .build()
844            .expect("request build");
845
846        assert_eq!(req.url().as_str(), "https://localhost/");
847        assert_eq!(
848            req.headers()["authorization"],
849            "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
850        );
851        assert!(req.headers()["authorization"].is_sensitive());
852    }
853
854    #[test]
855    fn test_bearer_auth_sensitive_header() {
856        let client = Client::new();
857        let some_url = "https://localhost/";
858
859        let req = client
860            .get(some_url)
861            .bearer_auth("Hold my bear")
862            .build()
863            .expect("request build");
864
865        assert_eq!(req.url().as_str(), "https://localhost/");
866        assert_eq!(req.headers()["authorization"], "Bearer Hold my bear");
867        assert!(req.headers()["authorization"].is_sensitive());
868    }
869
870    #[test]
871    fn test_explicit_sensitive_header() {
872        let client = Client::new();
873        let some_url = "https://localhost/";
874
875        let mut header = http::HeaderValue::from_static("in plain sight");
876        header.set_sensitive(true);
877
878        let req = client
879            .get(some_url)
880            .header("hiding", header)
881            .build()
882            .expect("request build");
883
884        assert_eq!(req.url().as_str(), "https://localhost/");
885        assert_eq!(req.headers()["hiding"], "in plain sight");
886        assert!(req.headers()["hiding"].is_sensitive());
887    }
888
889    #[test]
890    fn convert_from_http_request() {
891        let http_request = HttpRequest::builder()
892            .method("GET")
893            .uri("http://localhost/")
894            .header("User-Agent", "my-awesome-agent/1.0")
895            .body("test test test")
896            .unwrap();
897        let req: Request = Request::try_from(http_request).unwrap();
898        assert!(req.body().is_some());
899        let test_data = b"test test test";
900        assert_eq!(req.body().unwrap().as_bytes(), Some(&test_data[..]));
901        let headers = req.headers();
902        assert_eq!(headers.get("User-Agent").unwrap(), "my-awesome-agent/1.0");
903        assert_eq!(req.method(), Method::GET);
904        assert_eq!(req.url().as_str(), "http://localhost/");
905    }
906
907    #[test]
908    fn set_http_request_version() {
909        let http_request = HttpRequest::builder()
910            .method("GET")
911            .uri("http://localhost/")
912            .header("User-Agent", "my-awesome-agent/1.0")
913            .version(Version::HTTP_11)
914            .body("test test test")
915            .unwrap();
916        let req: Request = Request::try_from(http_request).unwrap();
917        assert!(req.body().is_some());
918        let test_data = b"test test test";
919        assert_eq!(req.body().unwrap().as_bytes(), Some(&test_data[..]));
920        let headers = req.headers();
921        assert_eq!(headers.get("User-Agent").unwrap(), "my-awesome-agent/1.0");
922        assert_eq!(req.method(), Method::GET);
923        assert_eq!(req.url().as_str(), "http://localhost/");
924        assert_eq!(req.version(), Version::HTTP_11);
925    }
926
927    #[test]
928    fn builder_split_reassemble() {
929        let builder = {
930            let client = Client::new();
931            client.get("http://example.com")
932        };
933        let (client, inner) = builder.build_split();
934        let request = inner.unwrap();
935        let builder = RequestBuilder::from_parts(client, request);
936        builder.build().unwrap();
937    }
938
939    /*
940    use {body, Method};
941    use super::Client;
942    use header::{Host, Headers, ContentType};
943    use std::collections::HashMap;
944    use serde_urlencoded;
945    use serde_json;
946
947    #[test]
948    fn basic_get_request() {
949        let client = Client::new().unwrap();
950        let some_url = "https://google.com/";
951        let r = client.get(some_url).unwrap().build();
952
953        assert_eq!(r.method, Method::Get);
954        assert_eq!(r.url.as_str(), some_url);
955    }
956
957    #[test]
958    fn basic_head_request() {
959        let client = Client::new().unwrap();
960        let some_url = "https://google.com/";
961        let r = client.head(some_url).unwrap().build();
962
963        assert_eq!(r.method, Method::Head);
964        assert_eq!(r.url.as_str(), some_url);
965    }
966
967    #[test]
968    fn basic_post_request() {
969        let client = Client::new().unwrap();
970        let some_url = "https://google.com/";
971        let r = client.post(some_url).unwrap().build();
972
973        assert_eq!(r.method, Method::Post);
974        assert_eq!(r.url.as_str(), some_url);
975    }
976
977    #[test]
978    fn basic_put_request() {
979        let client = Client::new().unwrap();
980        let some_url = "https://google.com/";
981        let r = client.put(some_url).unwrap().build();
982
983        assert_eq!(r.method, Method::Put);
984        assert_eq!(r.url.as_str(), some_url);
985    }
986
987    #[test]
988    fn basic_patch_request() {
989        let client = Client::new().unwrap();
990        let some_url = "https://google.com/";
991        let r = client.patch(some_url).unwrap().build();
992
993        assert_eq!(r.method, Method::Patch);
994        assert_eq!(r.url.as_str(), some_url);
995    }
996
997    #[test]
998    fn basic_delete_request() {
999        let client = Client::new().unwrap();
1000        let some_url = "https://google.com/";
1001        let r = client.delete(some_url).unwrap().build();
1002
1003        assert_eq!(r.method, Method::Delete);
1004        assert_eq!(r.url.as_str(), some_url);
1005    }
1006
1007    #[test]
1008    fn add_header() {
1009        let client = Client::new().unwrap();
1010        let some_url = "https://google.com/";
1011        let mut r = client.post(some_url).unwrap();
1012
1013        let header = Host {
1014            hostname: "google.com".to_string(),
1015            port: None,
1016        };
1017
1018        // Add a copy of the header to the request builder
1019        let r = r.header(header.clone()).build();
1020
1021        // then check it was actually added
1022        assert_eq!(r.headers.get::<Host>(), Some(&header));
1023    }
1024
1025    #[test]
1026    fn add_headers() {
1027        let client = Client::new().unwrap();
1028        let some_url = "https://google.com/";
1029        let mut r = client.post(some_url).unwrap();
1030
1031        let header = Host {
1032            hostname: "google.com".to_string(),
1033            port: None,
1034        };
1035
1036        let mut headers = Headers::new();
1037        headers.set(header);
1038
1039        // Add a copy of the headers to the request builder
1040        let r = r.headers(headers.clone()).build();
1041
1042        // then make sure they were added correctly
1043        assert_eq!(r.headers, headers);
1044    }
1045
1046    #[test]
1047    fn add_headers_multi() {
1048        let client = Client::new().unwrap();
1049        let some_url = "https://google.com/";
1050        let mut r = client.post(some_url).unwrap();
1051
1052        let header = Host {
1053            hostname: "google.com".to_string(),
1054            port: None,
1055        };
1056
1057        let mut headers = Headers::new();
1058        headers.set(header);
1059
1060        // Add a copy of the headers to the request builder
1061        let r = r.headers(headers.clone()).build();
1062
1063        // then make sure they were added correctly
1064        assert_eq!(r.headers, headers);
1065    }
1066
1067    #[test]
1068    fn add_body() {
1069        let client = Client::new().unwrap();
1070        let some_url = "https://google.com/";
1071        let mut r = client.post(some_url).unwrap();
1072
1073        let body = "Some interesting content";
1074
1075        let r = r.body(body).build();
1076
1077        let buf = body::read_to_string(r.body.unwrap()).unwrap();
1078
1079        assert_eq!(buf, body);
1080    }
1081
1082    #[test]
1083    fn add_form() {
1084        let client = Client::new().unwrap();
1085        let some_url = "https://google.com/";
1086        let mut r = client.post(some_url).unwrap();
1087
1088        let mut form_data = HashMap::new();
1089        form_data.insert("foo", "bar");
1090
1091        let r = r.form(&form_data).unwrap().build();
1092
1093        // Make sure the content type was set
1094        assert_eq!(r.headers.get::<ContentType>(),
1095                   Some(&ContentType::form_url_encoded()));
1096
1097        let buf = body::read_to_string(r.body.unwrap()).unwrap();
1098
1099        let body_should_be = serde_urlencoded::to_string(&form_data).unwrap();
1100        assert_eq!(buf, body_should_be);
1101    }
1102
1103    #[test]
1104    fn add_json() {
1105        let client = Client::new().unwrap();
1106        let some_url = "https://google.com/";
1107        let mut r = client.post(some_url).unwrap();
1108
1109        let mut json_data = HashMap::new();
1110        json_data.insert("foo", "bar");
1111
1112        let r = r.json(&json_data).unwrap().build();
1113
1114        // Make sure the content type was set
1115        assert_eq!(r.headers.get::<ContentType>(), Some(&ContentType::json()));
1116
1117        let buf = body::read_to_string(r.body.unwrap()).unwrap();
1118
1119        let body_should_be = serde_json::to_string(&json_data).unwrap();
1120        assert_eq!(buf, body_should_be);
1121    }
1122
1123    #[test]
1124    fn add_json_fail() {
1125        use serde::{Serialize, Serializer};
1126        use serde::ser::Error;
1127        struct MyStruct;
1128        impl Serialize for MyStruct {
1129            fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
1130                where S: Serializer
1131                {
1132                    Err(S::Error::custom("nope"))
1133                }
1134        }
1135
1136        let client = Client::new().unwrap();
1137        let some_url = "https://google.com/";
1138        let mut r = client.post(some_url).unwrap();
1139        let json_data = MyStruct{};
1140        assert!(r.json(&json_data).unwrap_err().is_serialization());
1141    }
1142    */
1143}
reqwest/async_impl/request.rs

reqwest/async_impl/
request.rs
