From 5672791ad08d8d9a867bca05d50010a8332af095 Mon Sep 17 00:00:00 2001 From: Simon Bernier St-Pierre Date: Mon, 22 Jan 2018 17:47:59 -0500 Subject: [PATCH] add query method to unstable api --- src/async_impl/request.rs | 100 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) diff --git a/src/async_impl/request.rs b/src/async_impl/request.rs index 74a91bb..0c2e359 100644 --- a/src/async_impl/request.rs +++ b/src/async_impl/request.rs @@ -126,6 +126,37 @@ impl RequestBuilder { self } + /// Modify the query string of the URL. + /// + /// Modifies the URL of this request, adding the parameters provided. + /// This method appends and does not overwrite. This means that it can + /// be called multiple times and that existing query parameters are not + /// overwritten if the same key is used. The key will simply show up + /// twice in the query string. + /// Calling `.query([("foo", "a"), ("foo", "b")])` gives `"foo=a&boo=b"`. + /// + /// # Note + /// This method does not support serializing a single key-value + /// pair. Instead of using `.query(("key", "val"))`, use a sequence, such + /// as `.query(&[("key", "val")])`. It's also possible to serialize structs + /// and maps into a key-value pair. + /// + /// # Errors + /// This method will fail if the object you provide cannot be serialized + /// into a query string. + pub fn query(&mut self, query: &T) -> &mut RequestBuilder { + if let Some(req) = request_mut(&mut self.request, &self.err) { + let url = req.url_mut(); + let mut pairs = url.query_pairs_mut(); + let serializer = serde_urlencoded::Serializer::new(&mut pairs); + + if let Err(err) = query.serialize(serializer) { + self.err = Some(::error::from(err)); + } + } + self + } + /// Send a form body. pub fn form(&mut self, form: &T) -> &mut RequestBuilder { if let Some(req) = request_mut(&mut self.request, &self.err) { @@ -249,6 +280,75 @@ pub fn pieces(req: Request) -> (Method, Url, Headers, Option) { #[cfg(test)] mod tests { + use super::Client; + use std::collections::BTreeMap; + use tokio_core::reactor::Core; + + #[test] + fn add_query_append() { + let mut core = Core::new().unwrap(); + let client = Client::new(&core.handle()); + let some_url = "https://google.com/"; + let mut r = client.get(some_url); + + r.query(&[("foo", "bar")]); + r.query(&[("qux", 3)]); + + let req = r.build().expect("request is valid"); + assert_eq!(req.url().query(), Some("foo=bar&qux=3")); + } + + #[test] + fn add_query_append_same() { + let mut core = Core::new().unwrap(); + let client = Client::new(&core.handle()); + let some_url = "https://google.com/"; + let mut r = client.get(some_url); + + r.query(&[("foo", "a"), ("foo", "b")]); + + let req = r.build().expect("request is valid"); + assert_eq!(req.url().query(), Some("foo=a&foo=b")); + } + + #[test] + fn add_query_struct() { + #[derive(Serialize)] + struct Params { + foo: String, + qux: i32, + } + + let mut core = Core::new().unwrap(); + let client = Client::new(&core.handle()); + let some_url = "https://google.com/"; + let mut r = client.get(some_url); + + let params = Params { foo: "bar".into(), qux: 3 }; + + r.query(¶ms); + + let req = r.build().expect("request is valid"); + assert_eq!(req.url().query(), Some("foo=bar&qux=3")); + } + + #[test] + fn add_query_map() { + let mut params = BTreeMap::new(); + params.insert("foo", "bar"); + params.insert("qux", "three"); + + let mut core = Core::new().unwrap(); + let client = Client::new(&core.handle()); + let some_url = "https://google.com/"; + let mut r = client.get(some_url); + + r.query(¶ms); + + let req = r.build().expect("request is valid"); + assert_eq!(req.url().query(), Some("foo=bar&qux=three")); + } + /* use {body, Method}; use super::Client;