Stop using unwrap

gifnksm · Dec 19, 2015 · 8cf5172 · 8cf5172
1 parent b3942bc
commit 8cf5172
Show file tree

Hide file tree

Showing 3 changed files with 79 additions and 33 deletions.
diff --git a/examples/test_get.rs b/examples/test_get.rs
@@ -28,15 +28,17 @@ fn split_query<'a>(query: &'a str) -> HashMap<Cow<'a, str>, Cow<'a, str>> {
 }
 
 fn get_request_token(consumer: &Token) -> Token<'static> {
-    let resp = oauth::get(api::REQUEST_TOKEN, consumer, None, None);
+    let bytes = oauth::get(api::REQUEST_TOKEN, consumer, None, None).unwrap();
+    let resp = String::from_utf8(bytes).unwrap();
     println!("get_request_token response: {:?}", resp);
     let param = split_query(&resp);
     Token::new(param.get("oauth_token").unwrap().to_string(),
                param.get("oauth_token_secret").unwrap().to_string())
 }
 
 fn get_access_token(consumer: &Token, request: &Token) -> Token<'static> {
-    let resp = oauth::get(api::ACCESS_TOKEN, consumer, Some(request), None);
+    let bytes = oauth::get(api::ACCESS_TOKEN, consumer, Some(request), None).unwrap();
+    let resp = String::from_utf8(bytes).unwrap();
     println!("get_access_token response: {:?}", resp);
     let param = split_query(&resp);
     Token::new(param.get("oauth_token").unwrap().to_string(),
@@ -51,10 +53,11 @@ fn echo(consumer: &Token, access: &Token) {
                              rng.gen_ascii_chars().take(32).collect::<String>().into());
     let _ = req_param.insert(rng.gen_ascii_chars().take(32).collect::<String>().into(),
                              rng.gen_ascii_chars().take(32).collect::<String>().into());
-    let resp = oauth::get(api::ECHO, consumer, Some(access), Some(&req_param));
+    let bytes = oauth::get(api::ECHO, consumer, Some(access), Some(&req_param)).unwrap();
+    let resp = String::from_utf8(bytes).unwrap();
     println!("echo response: {:?}", resp);
-    // let resp_param = split_query(&resp);
-    // assert_eq!(req_param, resp_param);
+    let resp_param = split_query(&resp);
+    assert_eq!(req_param, resp_param);
 }
 
 fn main() {

diff --git a/examples/test_post.rs b/examples/test_post.rs
@@ -28,15 +28,17 @@ fn split_query<'a>(query: &'a str) -> HashMap<Cow<'a, str>, Cow<'a, str>> {
 }
 
 fn get_request_token(consumer: &Token) -> Token<'static> {
-    let resp = oauth::post(api::REQUEST_TOKEN, consumer, None, None);
+    let bytes = oauth::post(api::REQUEST_TOKEN, consumer, None, None).unwrap();
+    let resp = String::from_utf8(bytes).unwrap();
     println!("get_request_token response: {:?}", resp);
     let param = split_query(&resp[..]);
     Token::new(param.get("oauth_token").unwrap().to_string(),
                param.get("oauth_token_secret").unwrap().to_string())
 }
 
 fn get_access_token(consumer: &Token, request: &Token) -> Token<'static> {
-    let resp = oauth::post(api::ACCESS_TOKEN, consumer, Some(request), None);
+    let bytes = oauth::post(api::ACCESS_TOKEN, consumer, Some(request), None).unwrap();
+    let resp = String::from_utf8(bytes).unwrap();
     println!("get_access_token response: {:?}", resp);
     let param = split_query(&resp[..]);
     Token::new(param.get("oauth_token").unwrap().to_string(),
@@ -51,10 +53,11 @@ fn echo(consumer: &Token, access: &Token) {
                              rng.gen_ascii_chars().take(32).collect::<String>().into());
     let _ = req_param.insert(rng.gen_ascii_chars().take(32).collect::<String>().into(),
                              rng.gen_ascii_chars().take(32).collect::<String>().into());
-    let resp = oauth::post(api::ECHO, consumer, Some(access), Some(&req_param));
+    let bytes = oauth::post(api::ECHO, consumer, Some(access), Some(&req_param)).unwrap();
+    let resp = String::from_utf8(bytes).unwrap();
     println!("echo response: {:?}", resp);
-    // let resp_param = split_query(&resp[..]);
-    // assert_eq!(req_param, split_query(&resp[..]));
+    let resp_param = split_query(&resp[..]);
+    assert_eq!(req_param, resp_param);
 }
 
 fn main() {

diff --git a/src/lib.rs b/src/lib.rs
@@ -17,16 +17,53 @@ extern crate url;
 
 use std::borrow::Cow;
 use std::collections::HashMap;
-use std::str;
+use std::{error, fmt};
 use rand::Rng;
 use rustc_serialize::base64::{self, ToBase64};
 use crypto::hmac::Hmac;
 use crypto::mac::{Mac, MacResult};
 use crypto::sha1::Sha1;
-use curl::http;
+use curl::http::{self, Response};
 use curl::http::handle::Method;
 use url::percent_encoding;
 
+#[derive(Debug)]
+pub enum Error {
+    Curl(curl::ErrCode),
+    HttpStatus(Response),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Error::Curl(ref err) => write!(f, "Curl error: {}", err),
+            Error::HttpStatus(ref resp) => write!(f, "HTTP status error: {}", resp),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        match *self {
+            Error::Curl(ref err) => err.description(),
+            Error::HttpStatus(_) => "HTTP status error",
+        }
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        match *self {
+            Error::Curl(ref err) => Some(err),
+            Error::HttpStatus(_) => None,
+        }
+    }
+}
+
+impl From<curl::ErrCode> for Error {
+    fn from(err: curl::ErrCode) -> Error {
+        Error::Curl(err)
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct Token<'a> {
     pub key: Cow<'a, str>,
@@ -171,37 +208,40 @@ pub fn get(uri: &str,
            consumer: &Token,
            token: Option<&Token>,
            other_param: Option<&ParamList>)
-           -> String {
+           -> Result<Vec<u8>, Error> {
     let (header, body) = get_header(Method::Get, uri, consumer, token, other_param);
-    let resp = http::handle()
-                   .get(if body.len() > 0 {
-                       format!("{}?{}", uri, body)
-                   } else {
-                       format!("{}", uri)
-                   })
-                   .header("Authorization", header.as_ref())
-                   .exec()
-                   .unwrap();
+    let req_uri = if body.len() > 0 {
+        format!("{}?{}", uri, body)
+    } else {
+        format!("{}", uri)
+    };
+    let resp = try!(http::handle()
+                        .get(req_uri)
+                        .header("Authorization", header.as_ref())
+                        .exec());
     debug!("{}", resp);
-    assert_eq!(200, resp.get_code());
-    str::from_utf8(resp.get_body()).unwrap().to_string()
+    if resp.get_code() != 200 {
+        return Err(Error::HttpStatus(resp));
+    }
+    Ok(resp.move_body())
 }
 
 pub fn post(uri: &str,
             consumer: &Token,
             token: Option<&Token>,
             other_param: Option<&ParamList>)
-            -> String {
+            -> Result<Vec<u8>, Error> {
     let (header, body) = get_header(Method::Post, uri, consumer, token, other_param);
-    let resp = http::handle()
-                   .post(uri, &body)
-                   .header("Authorization", header.as_ref())
-                   .content_type("application/x-www-form-urlencoded")
-                   .exec()
-                   .unwrap();
+    let resp = try!(http::handle()
+                        .post(uri, &body)
+                        .header("Authorization", header.as_ref())
+                        .content_type("application/x-www-form-urlencoded")
+                        .exec());
     debug!("{}", resp);
-    assert_eq!(200, resp.get_code());
-    str::from_utf8(resp.get_body()).unwrap().to_string()
+    if resp.get_code() != 200 {
+        return Err(Error::HttpStatus(resp));
+    }
+    Ok(resp.move_body())
 }