From 499dc90e85adb86a01219556276ebd4e79f436b1 Mon Sep 17 00:00:00 2001 From: brightly-salty Date: Sat, 19 Dec 2020 09:40:46 -0600 Subject: [PATCH 1/3] Add error handling to Request methods Make all associated Request methods return a Result instead of Self and panicking. Change docs and doc-tests to reflect this, and remove manual parsing in doc-tests and unit tests --- src/lib.rs | 6 +- src/proxies/forwarded.rs | 23 +++--- src/request.rs | 143 ++++++++++++++++++------------------- src/trace/trace_context.rs | 4 +- src/trailers.rs | 2 +- tests/querystring.rs | 17 ++--- tests/req_res_body.rs | 6 +- 7 files changed, 96 insertions(+), 105 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index c332fb54..fc42c736 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,11 +6,11 @@ //! # Example //! //! ``` -//! # fn main() -> Result<(), http_types::url::ParseError> { +//! # fn main() -> Result<(), http_types::Error> { //! # -//! use http_types::{Url, Method, Request, Response, StatusCode}; +//! use http_types::{Method, Request, Response, StatusCode}; //! -//! let mut req = Request::new(Method::Get, Url::parse("https://example.com")?); +//! let mut req = Request::new(Method::Get, "https://example.com")?; //! req.set_body("Hello, Nori!"); //! //! let mut res = Response::new(StatusCode::Ok); diff --git a/src/proxies/forwarded.rs b/src/proxies/forwarded.rs index 79b95442..6d140fb2 100644 --- a/src/proxies/forwarded.rs +++ b/src/proxies/forwarded.rs @@ -44,7 +44,7 @@ impl<'a> Forwarded<'a> { /// ```rust /// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result}; /// # fn main() -> Result<()> { - /// let mut request = Request::new(Get, Url::parse("http://_/")?); + /// let mut request = Request::new(Get, "http://_/")?; /// request.insert_header( /// "Forwarded", /// r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown;proto=https"# @@ -58,7 +58,7 @@ impl<'a> Forwarded<'a> { /// ```rust /// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result}; /// # fn main() -> Result<()> { - /// let mut request = Request::new(Get, Url::parse("http://_/")?); + /// let mut request = Request::new(Get, "http://_/")?; /// request.insert_header("X-Forwarded-For", "192.0.2.43, 2001:db8:cafe::17, unknown"); /// request.insert_header("X-Forwarded-Proto", "https"); /// let forwarded = Forwarded::from_headers(&request)?.unwrap(); @@ -85,7 +85,7 @@ impl<'a> Forwarded<'a> { /// ```rust /// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result}; /// # fn main() -> Result<()> { - /// let mut request = Request::new(Get, Url::parse("http://_/")?); + /// let mut request = Request::new(Get, "http://_/")?; /// request.insert_header( /// "Forwarded", /// r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown;proto=https"# @@ -98,7 +98,7 @@ impl<'a> Forwarded<'a> { /// ```rust /// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result}; /// # fn main() -> Result<()> { - /// let mut request = Request::new(Get, Url::parse("http://_/")?); + /// let mut request = Request::new(Get, "http://_/")?; /// request.insert_header("X-Forwarded-For", "192.0.2.43, 2001:db8:cafe::17"); /// assert!(Forwarded::from_forwarded_header(&request)?.is_none()); /// # Ok(()) } @@ -121,7 +121,7 @@ impl<'a> Forwarded<'a> { /// ```rust /// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result}; /// # fn main() -> Result<()> { - /// let mut request = Request::new(Get, Url::parse("http://_/")?); + /// let mut request = Request::new(Get, "http://_/")?; /// request.insert_header("X-Forwarded-For", "192.0.2.43, 2001:db8:cafe::17"); /// let forwarded = Forwarded::from_headers(&request)?.unwrap(); /// assert_eq!(forwarded.forwarded_for(), vec!["192.0.2.43", "[2001:db8:cafe::17]"]); @@ -130,7 +130,7 @@ impl<'a> Forwarded<'a> { /// ```rust /// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result}; /// # fn main() -> Result<()> { - /// let mut request = Request::new(Get, Url::parse("http://_/")?); + /// let mut request = Request::new(Get, "http://_/")?; /// request.insert_header( /// "Forwarded", /// r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown;proto=https"# @@ -492,7 +492,6 @@ impl<'a> TryFrom<&'a str> for Forwarded<'a> { mod tests { use super::*; use crate::{Method::Get, Request, Response, Result}; - use url::Url; #[test] fn parsing_for() -> Result<()> { @@ -545,7 +544,7 @@ mod tests { assert_eq!(forwarded.forwarded_for(), vec!["client.com"]); assert_eq!(forwarded.host(), Some("host.com")); assert_eq!(forwarded.proto(), Some("https")); - assert!(matches!(forwarded, Forwarded{..})); + assert!(matches!(forwarded, Forwarded { .. })); Ok(()) } @@ -599,7 +598,7 @@ mod tests { #[test] fn from_x_headers() -> Result<()> { - let mut request = Request::new(Get, Url::parse("http://_/")?); + let mut request = Request::new(Get, "http://_/")?; request.append_header(X_FORWARDED_FOR, "192.0.2.43, 2001:db8:cafe::17"); request.append_header(X_FORWARDED_PROTO, "gopher"); let forwarded = Forwarded::from_headers(&request)?.unwrap(); @@ -644,13 +643,13 @@ mod tests { assert_eq!(forwarded.forwarded_for(), vec!["client"]); assert_eq!(forwarded.host(), Some("example.com")); assert_eq!(forwarded.proto(), Some("https")); - assert!(matches!(forwarded, Forwarded{..})); + assert!(matches!(forwarded, Forwarded { .. })); Ok(()) } #[test] fn from_request() -> Result<()> { - let mut request = Request::new(Get, Url::parse("http://_/")?); + let mut request = Request::new(Get, "http://_/")?; request.append_header("Forwarded", "for=for"); let forwarded = Forwarded::from_headers(&request)?.unwrap(); @@ -662,7 +661,7 @@ mod tests { #[test] fn owned_can_outlive_request() -> Result<()> { let forwarded = { - let mut request = Request::new(Get, Url::parse("http://_/")?); + let mut request = Request::new(Get, "http://_/")?; request.append_header("Forwarded", "for=for;by=by;host=host;proto=proto"); Forwarded::from_headers(&request)?.unwrap().into_owned() }; diff --git a/src/request.rs b/src/request.rs index a0ff58c5..b5953ec1 100644 --- a/src/request.rs +++ b/src/request.rs @@ -13,7 +13,7 @@ use crate::headers::{ }; use crate::mime::Mime; use crate::trailers::{self, Trailers}; -use crate::{Body, Extensions, Method, StatusCode, Url, Version}; +use crate::{Body, Error, Extensions, Method, StatusCode, Url, Version}; pin_project_lite::pin_project! { /// An HTTP request. @@ -21,9 +21,9 @@ pin_project_lite::pin_project! { /// # Examples /// /// ``` - /// use http_types::{Url, Method, Request}; + /// use http_types::{Method, Request}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com").unwrap(); /// req.set_body("Hello, Nori!"); /// ``` #[derive(Debug)] @@ -45,14 +45,14 @@ pin_project_lite::pin_project! { impl Request { /// Create a new request. - pub fn new(method: Method, url: U) -> Self + pub fn new(method: Method, url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { - let url = url.try_into().expect("Could not convert into a valid url"); + let url = url.try_into().map_err(|e| Error::new(500, e))?; let (trailers_sender, trailers_receiver) = async_channel::bounded(1); - Self { + Ok(Self { method, url, headers: Headers::new(), @@ -64,7 +64,7 @@ impl Request { trailers_receiver: Some(trailers_receiver), trailers_sender: Some(trailers_sender), has_trailers: false, - } + }) } /// Sets a string representation of the peer address of this @@ -158,7 +158,7 @@ impl Request { /// # fn main() -> Result<(), http_types::Error> { /// # /// use http_types::{Method, Request, Response, StatusCode, Url}; - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com")?); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// assert_eq!(req.url().scheme(), "https"); /// # /// # Ok(()) } @@ -175,7 +175,7 @@ impl Request { /// # fn main() -> Result<(), http_types::Error> { /// # /// use http_types::{Method, Request, Response, StatusCode, Url}; - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com")?); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.url_mut().set_scheme("http"); /// assert_eq!(req.url().scheme(), "http"); /// # @@ -190,9 +190,9 @@ impl Request { /// # Examples /// /// ``` - /// use http_types::{Method, Request, Url}; + /// use http_types::{Method, Request}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com").unwrap(); /// req.set_body("Hello, Nori!"); /// ``` pub fn set_body(&mut self, body: impl Into) { @@ -208,9 +208,9 @@ impl Request { /// # use async_std::io::prelude::*; /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async { /// # - /// use http_types::{Body, Method, Request, Url}; + /// use http_types::{Body, Method, Request}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.set_body("Hello, Nori!"); /// let mut body: Body = req.replace_body("Hello, Chashu!"); /// @@ -236,7 +236,7 @@ impl Request { /// # /// use http_types::{Body, Method, Request, Url}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com").unwrap(); /// req.set_body("Hello, Nori!"); /// let mut body = "Hello, Chashu!".into(); /// req.swap_body(&mut body); @@ -260,9 +260,9 @@ impl Request { /// # use async_std::io::prelude::*; /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async { /// # - /// use http_types::{Body, Method, Request, Url}; + /// use http_types::{Body, Method, Request}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.set_body("Hello, Nori!"); /// let mut body: Body = req.take_body(); /// @@ -295,7 +295,7 @@ impl Request { /// use async_std::io::Cursor; /// use http_types::{Body, Method, Request, Url}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com").unwrap(); /// /// let cursor = Cursor::new("Hello Nori"); /// let body = Body::from_reader(cursor, None); @@ -319,10 +319,10 @@ impl Request { /// /// ``` /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async { - /// use http_types::{Body, Method, Request, Url}; + /// use http_types::{Body, Method, Request}; /// /// let bytes = vec![1, 2, 3]; - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.set_body(Body::from_bytes(bytes)); /// /// let bytes = req.body_bytes().await?; @@ -356,7 +356,7 @@ impl Request { /// let cat = Cat { /// name: String::from("chashu"), /// }; - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com").unwrap(); /// req.set_body(Body::from_json(&cat)?); /// /// let cat: Cat = req.body_json().await?; @@ -380,7 +380,7 @@ impl Request { /// ``` /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async { /// use http_types::convert::{Deserialize, Serialize}; - /// use http_types::{Body, Method, Request, Url}; + /// use http_types::{Body, Method, Request}; /// /// #[derive(Debug, Serialize, Deserialize)] /// struct Cat { @@ -390,7 +390,7 @@ impl Request { /// let cat = Cat { /// name: String::from("chashu"), /// }; - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.set_body(Body::from_form(&cat)?); /// /// let cat: Cat = req.body_form().await?; @@ -426,7 +426,7 @@ impl Request { /// # /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com")?); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.insert_header("Content-Type", "text/plain"); /// # /// # Ok(()) } @@ -452,7 +452,7 @@ impl Request { /// # /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com")?); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.append_header("Content-Type", "text/plain"); /// # /// # Ok(()) } @@ -507,7 +507,7 @@ impl Request { /// /// # fn main() -> Result<(), http_types::Error> { /// # - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com")?); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// assert_eq!(req.version(), None); /// /// req.set_version(Some(Version::Http2_0)); @@ -528,7 +528,7 @@ impl Request { /// /// # fn main() -> Result<(), http_types::Error> { /// # - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com")?); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.set_version(Some(Version::Http2_0)); /// # /// # Ok(()) } @@ -596,7 +596,7 @@ impl Request { /// # /// use http_types::{Method, Request, Url, Version}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com")?); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.ext_mut().insert("hello from the extension"); /// assert_eq!(req.ext().get(), Some(&"hello from the extension")); /// # @@ -612,7 +612,7 @@ impl Request { /// /// ``` /// use http_types::convert::Deserialize; - /// use http_types::{Method, Request, Url}; + /// use http_types::{Method, Request}; /// use std::collections::HashMap; /// /// #[derive(Deserialize)] @@ -623,8 +623,7 @@ impl Request { /// /// let req = Request::new( /// Method::Get, - /// Url::parse("https://httpbin.org/get?page=2&selections[width]=narrow&selections[height]=tall").unwrap(), - /// ); + /// "https://httpbin.org/get?page=2&selections[width]=narrow&selections[height]=tall").unwrap(); /// let Index { page, selections } = req.query().unwrap(); /// assert_eq!(page, 2); /// assert_eq!(selections["width"], "narrow"); @@ -648,7 +647,7 @@ impl Request { /// /// ``` /// use http_types::convert::Serialize; - /// use http_types::{Method, Request, Url}; + /// use http_types::{Method, Request}; /// use std::collections::HashMap; /// /// #[derive(Serialize)] @@ -660,8 +659,7 @@ impl Request { /// let query = Index { page: 2, topics: vec!["rust", "crabs", "crustaceans"] }; /// let mut req = Request::new( /// Method::Get, - /// Url::parse("https://httpbin.org/get").unwrap(), - /// ); + /// "https://httpbin.org/get").unwrap(); /// req.set_query(&query).unwrap(); /// assert_eq!(req.url().query(), Some("page=2&topics[0]=rust&topics[1]=crabs&topics[2]=crustaceans")); /// ``` @@ -682,14 +680,14 @@ impl Request { /// ``` /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::get("https://example.com"); + /// let mut req = Request::get("https://example.com").unwrap(); /// req.set_body("Hello, Nori!"); /// assert_eq!(req.method(), Method::Get); /// ``` - pub fn get(url: U) -> Self + pub fn get(url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { Request::new(Method::Get, url) } @@ -704,13 +702,13 @@ impl Request { /// ``` /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::head("https://example.com"); + /// let mut req = Request::head("https://example.com").unwrap(); /// assert_eq!(req.method(), Method::Head); /// ``` - pub fn head(url: U) -> Self + pub fn head(url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { Request::new(Method::Head, url) } @@ -725,13 +723,13 @@ impl Request { /// ``` /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::post("https://example.com"); + /// let mut req = Request::post("https://example.com").unwrap(); /// assert_eq!(req.method(), Method::Post); /// ``` - pub fn post(url: U) -> Self + pub fn post(url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { Request::new(Method::Post, url) } @@ -746,13 +744,13 @@ impl Request { /// ``` /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::put("https://example.com"); + /// let mut req = Request::put("https://example.com").unwrap(); /// assert_eq!(req.method(), Method::Put); /// ``` - pub fn put(url: U) -> Self + pub fn put(url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { Request::new(Method::Put, url) } @@ -766,13 +764,13 @@ impl Request { /// ``` /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::delete("https://example.com"); + /// let mut req = Request::delete("https://example.com").unwrap(); /// assert_eq!(req.method(), Method::Delete); /// ``` - pub fn delete(url: U) -> Self + pub fn delete(url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { Request::new(Method::Delete, url) } @@ -787,13 +785,13 @@ impl Request { /// ``` /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::connect("https://example.com"); + /// let mut req = Request::connect("https://example.com").unwrap(); /// assert_eq!(req.method(), Method::Connect); /// ``` - pub fn connect(url: U) -> Self + pub fn connect(url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { Request::new(Method::Connect, url) } @@ -808,13 +806,13 @@ impl Request { /// ``` /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::options("https://example.com"); + /// let mut req = Request::options("https://example.com").unwrap(); /// assert_eq!(req.method(), Method::Options); /// ``` - pub fn options(url: U) -> Self + pub fn options(url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { Request::new(Method::Options, url) } @@ -827,15 +825,15 @@ impl Request { /// # Examples /// /// ``` - /// use http_types::{Method, Request, Url}; + /// use http_types::{Method, Request}; /// - /// let mut req = Request::trace("https://example.com"); + /// let mut req = Request::trace("https://example.com").unwrap(); /// assert_eq!(req.method(), Method::Trace); /// ``` - pub fn trace(url: U) -> Self + pub fn trace(url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { Request::new(Method::Trace, url) } @@ -849,13 +847,13 @@ impl Request { /// ``` /// use http_types::{Method, Request, Url}; /// - /// let mut req = Request::patch("https://example.com"); + /// let mut req = Request::patch("https://example.com").unwrap(); /// assert_eq!(req.method(), Method::Patch); /// ``` - pub fn patch(url: U) -> Self + pub fn patch(url: U) -> Result where U: TryInto, - U::Error: std::fmt::Debug, + U::Error: std::fmt::Debug + Into, { Request::new(Method::Patch, url) } @@ -1035,63 +1033,63 @@ mod tests { #[test] fn when_using_shorthand_with_valid_url_to_create_request_get() { let url = Url::parse("https://example.com").unwrap(); - let req = Request::get(url); + let req = Request::get(url).unwrap(); assert_eq!(req.method(), Method::Get); } #[test] fn when_using_shorthand_with_valid_url_to_create_request_head() { let url = Url::parse("https://example.com").unwrap(); - let req = Request::head(url); + let req = Request::head(url).unwrap(); assert_eq!(req.method(), Method::Head); } #[test] fn when_using_shorthand_with_valid_url_to_create_request_post() { let url = Url::parse("https://example.com").unwrap(); - let req = Request::post(url); + let req = Request::post(url).unwrap(); assert_eq!(req.method(), Method::Post); } #[test] fn when_using_shorthand_with_valid_url_to_create_request_put() { let url = Url::parse("https://example.com").unwrap(); - let req = Request::put(url); + let req = Request::put(url).unwrap(); assert_eq!(req.method(), Method::Put); } #[test] fn when_using_shorthand_with_valid_url_to_create_request_delete() { let url = Url::parse("https://example.com").unwrap(); - let req = Request::delete(url); + let req = Request::delete(url).unwrap(); assert_eq!(req.method(), Method::Delete); } #[test] fn when_using_shorthand_with_valid_url_to_create_request_connect() { let url = Url::parse("https://example.com").unwrap(); - let req = Request::connect(url); + let req = Request::connect(url).unwrap(); assert_eq!(req.method(), Method::Connect); } #[test] fn when_using_shorthand_with_valid_url_to_create_request_options() { let url = Url::parse("https://example.com").unwrap(); - let req = Request::options(url); + let req = Request::options(url).unwrap(); assert_eq!(req.method(), Method::Options); } #[test] fn when_using_shorthand_with_valid_url_to_create_request_trace() { let url = Url::parse("https://example.com").unwrap(); - let req = Request::trace(url); + let req = Request::trace(url).unwrap(); assert_eq!(req.method(), Method::Trace); } #[test] fn when_using_shorthand_with_valid_url_to_create_request_patch() { let url = Url::parse("https://example.com").unwrap(); - let req = Request::patch(url); + let req = Request::patch(url).unwrap(); assert_eq!(req.method(), Method::Patch); } } @@ -1162,8 +1160,7 @@ mod tests { } fn build_test_request() -> Request { - let url = Url::parse("http://async.rs/").unwrap(); - Request::new(Method::Get, url) + Request::new(Method::Get, "http://async.rs/").unwrap() } fn set_x_forwarded_for(request: &mut Request, client: &'static str) { diff --git a/src/trace/trace_context.rs b/src/trace/trace_context.rs index 74a4ebd7..063c3fae 100644 --- a/src/trace/trace_context.rs +++ b/src/trace/trace_context.rs @@ -129,9 +129,9 @@ impl TraceContext { /// # fn main() -> http_types::Result<()> { /// # /// use http_types::trace::TraceContext; - /// use http_types::{Request, Response, Url, Method}; + /// use http_types::{Method, Request, Response}; /// - /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); + /// let mut req = Request::new(Method::Get, "https://example.com")?; /// req.insert_header( /// "traceparent", /// "00-0af7651916cd43dd8448eb211c80319c-00f067aa0ba902b7-01" diff --git a/src/trailers.rs b/src/trailers.rs index e1099a1f..37300cbf 100644 --- a/src/trailers.rs +++ b/src/trailers.rs @@ -27,7 +27,7 @@ //! use async_std::task; //! use std::str::FromStr; //! -//! let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap()); +//! let mut req = Request::new(Method::Get, "https://example.com")?; //! //! let sender = req.send_trailers(); //! let mut trailers = Trailers::new(); diff --git a/tests/querystring.rs b/tests/querystring.rs index 2503b743..0053e2c0 100644 --- a/tests/querystring.rs +++ b/tests/querystring.rs @@ -1,4 +1,4 @@ -use http_types::{url::Url, Method}; +use http_types::Method; use serde::Deserialize; #[derive(Deserialize)] @@ -14,10 +14,7 @@ struct OptionalParams { #[test] fn successfully_deserialize_query() { - let req = http_types::Request::new( - Method::Get, - Url::parse("http://example.com/?msg=Hello").unwrap(), - ); + let req = http_types::Request::new(Method::Get, "http://example.com/?msg=Hello").unwrap(); let params = req.query::(); assert!(params.is_ok()); @@ -26,7 +23,7 @@ fn successfully_deserialize_query() { #[test] fn unsuccessfully_deserialize_query() { - let req = http_types::Request::new(Method::Get, Url::parse("http://example.com/").unwrap()); + let req = http_types::Request::new(Method::Get, "http://example.com/").unwrap(); let params = req.query::(); assert!(params.is_err()); @@ -38,10 +35,8 @@ fn unsuccessfully_deserialize_query() { #[test] fn malformatted_query() { - let req = http_types::Request::new( - Method::Get, - Url::parse("http://example.com/?error=should_fail").unwrap(), - ); + let req = + http_types::Request::new(Method::Get, "http://example.com/?error=should_fail").unwrap(); let params = req.query::(); assert!(params.is_err()); @@ -53,7 +48,7 @@ fn malformatted_query() { #[test] fn empty_query_string_for_struct_with_no_required_fields() { - let req = http_types::Request::new(Method::Get, Url::parse("http://example.com").unwrap()); + let req = http_types::Request::new(Method::Get, "http://example.com").unwrap(); let params = req.query::(); assert!(params.is_ok()); diff --git a/tests/req_res_body.rs b/tests/req_res_body.rs index 97067b92..908ade1f 100644 --- a/tests/req_res_body.rs +++ b/tests/req_res_body.rs @@ -1,9 +1,9 @@ use futures_lite::{future, AsyncReadExt}; -use http_types::{Body, Method, Request, Response, StatusCode, Url}; +use http_types::{Body, Method, Request, Response, StatusCode}; #[test] fn test_req_res_set_body() { - let mut req = Request::new(Method::Get, Url::parse("http://example.com/").unwrap()); + let mut req = Request::new(Method::Get, "http://example.com/").unwrap(); req.set_body(Body::empty()); let mut res = Response::new(StatusCode::Ok); res.set_body(req); @@ -17,7 +17,7 @@ fn test_req_res_set_body() { #[test] fn test_req_res_take_replace_body() { - let mut req = Request::new(Method::Get, Url::parse("http://example.com/").unwrap()); + let mut req = Request::new(Method::Get, "http://example.com/").unwrap(); req.take_body(); let mut res = Response::new(StatusCode::Ok); res.replace_body(req); From fb24563ff7f5d55a8133246a301bd0696aafc51a Mon Sep 17 00:00:00 2001 From: brightly-salty Date: Sat, 19 Dec 2020 09:45:09 -0600 Subject: [PATCH 2/3] Update hyperium_http.rs --- src/hyperium_http.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hyperium_http.rs b/src/hyperium_http.rs index 3f8a3779..877ffeab 100644 --- a/src/hyperium_http.rs +++ b/src/hyperium_http.rs @@ -96,7 +96,7 @@ impl TryFrom> for Request { let (parts, body) = req.into_parts(); let method = parts.method.into(); let url = from_uri_to_url(parts.uri)?; - let mut req = Request::new(method, url); + let mut req = Request::new(method, url)?; req.set_body(body); req.set_version(Some(parts.version.into())); hyperium_headers_to_headers(parts.headers, req.as_mut()); From 3b6cdadb5eca0d39a74a41670029a32f34d142eb Mon Sep 17 00:00:00 2001 From: brightly-salty Date: Sat, 19 Dec 2020 09:47:11 -0600 Subject: [PATCH 3/3] Update hyperium_http.rs --- src/hyperium_http.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hyperium_http.rs b/src/hyperium_http.rs index 877ffeab..75ed1cf7 100644 --- a/src/hyperium_http.rs +++ b/src/hyperium_http.rs @@ -90,7 +90,7 @@ fn from_url_to_uri(url: &Url) -> http::Uri { } impl TryFrom> for Request { - type Error = crate::url::ParseError; + type Error = crate::Error; fn try_from(req: http::Request) -> Result { let (parts, body) = req.into_parts();