Merge pull request #248 from sbstp/query-build-async

add query method to unstable api
2018-01-23 09:57:38 -08:00
parent c06d3d4028 5672791ad0
commit f71504c15d
1 changed files with 100 additions and 0 deletions
--- 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<T: Serialize>(&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<T: Serialize>(&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<Body>) {

 #[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(&params);
+
+        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(&params);
+
+        let req = r.build().expect("request is valid");
+        assert_eq!(req.url().query(), Some("foo=bar&qux=three"));
+    }
+
    /*
    use {body, Method};
    use super::Client;