reqwest/blocking/
request.rs

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

reqwest/blocking/
request.rs
