forked/reqwest-impersonate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
add query method to unstable api
This commit is contained in:
Sean McArthur
2018-01-23 09:57:38 -08:00
committed by GitHub
parent c06d3d4028 5672791ad0
commit f71504c15d
1 changed files with 100 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
src/async_impl/request.rs
View File

@@ -126,6 +126,37 @@ impl RequestBuilder {
self 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. /// Send a form body.
pub fn form<T: Serialize>(&mut self, form: &T) -> &mut RequestBuilder { pub fn form<T: Serialize>(&mut self, form: &T) -> &mut RequestBuilder {
if let Some(req) = request_mut(&mut self.request, &self.err) { 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)] #[cfg(test)]
mod tests { 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 {body, Method};
use super::Client; use super::Client;