Refactor quite a bit, add initial tests for logging in successfully

Author: daboross

Diff for: .gitignore

@@ -40,3 +40,4 @@ nb-configuration.xml
 *.sublime-project
 *.sublime-workspace
 Cargo.lock
+.env

Diff for: Cargo.toml

@@ -5,7 +5,10 @@ authors = ["Dabo Ross <[email protected]>"]
 
 [dependencies]
 hyper = "0.10"
-hyper-rustls = "0.3"
 serde_derive = "0.9"
 serde = "0.9"
 serde_json = "0.9"
+
+[dev-dependencies]
+hyper-rustls = "0.3"
+dotenv = "*"

Diff for: README.md

@@ -8,3 +8,5 @@ The API provided for screeps.com is unofficial, and not officially documented, b
 Documentation for the API calls that rust-screeps-api makes can be found at https://github.com/screepers/python-screeps/blob/master/docs/Endpoints.md.
 
 When this library is relatively stable, I will post the rust docs online and provide some example usages. For now, the library does not do enough to warrant this.
+
+To run tests, provide SCREEPS_API_USERNAME and SCREEPS_API_PASSWORD in .env or as environmental variables. These variables are only ever used when running tests, and are never included in the compiled library.

Diff for: src/error.rs

@@ -1,58 +1,114 @@
 extern crate hyper;
 extern crate serde_json;
 
+use std::error::Error as StdError;
 use std::fmt;
 use std::io;
-use std::error::Error as StdError;
-use self::Error::*;
+use self::ErrorType::*;
 
 #[derive(Debug)]
-pub enum Error {
+pub enum ErrorType {
+    Unauthorized,
     SerdeJson(serde_json::error::Error),
     Hyper(hyper::error::Error),
     Io(io::Error),
     StatusCode(hyper::status::StatusCode),
     Api(ApiError),
 }
 
-pub type Result<T> = ::std::result::Result<T, Error>;
+#[derive(Debug)]
+pub struct Error {
+    pub err: ErrorType,
+    pub url: Option<hyper::Url>,
+}
+
+impl Error {
+    pub fn new<T: Into<Error>>(err: T, url: Option<hyper::Url>) -> Error {
+        Error {
+            err: err.into().err,
+            url: url,
+        }
+    }
+}
 
+pub type Result<T> = ::std::result::Result<T, Error>;
 
 impl From<serde_json::error::Error> for Error {
-    fn from(err: serde_json::error::Error) -> Error { Error::SerdeJson(err) }
+    fn from(err: serde_json::error::Error) -> Error {
+        Error {
+            err: ErrorType::SerdeJson(err),
+            url: None,
+            }
+        }
 }
 
 impl From<hyper::error::Error> for Error {
-    fn from(err: hyper::error::Error) -> Error { Error::Hyper(err) }
+    fn from(err: hyper::error::Error) -> Error {
+        Error {
+            err: ErrorType::Hyper(err),
+            url: None,
+        }
+    }
+}
+
+impl From<hyper::error::ParseError> for Error {
+    fn from(err: hyper::error::ParseError) -> Error {
+        Error {
+            err: ErrorType::Hyper(hyper::Error::Uri(err)),
+            url: None,
+        }
+    }
 }
 
 impl From<io::Error> for Error {
-    fn from(err: io::Error) -> Error { Error::Io(err) }
+    fn from(err: io::Error) -> Error {
+        Error {
+            err: ErrorType::Io(err),
+            url: None,
+        }
+    }
 }
 
 impl From<hyper::status::StatusCode> for Error {
-    fn from(code: hyper::status::StatusCode) -> Error { Error::StatusCode(code) }
+    fn from(code: hyper::status::StatusCode) -> Error {
+        Error {
+            err: {
+                if code == hyper::status::StatusCode::Unauthorized {
+                    ErrorType::Unauthorized
+                } else {
+                    ErrorType::StatusCode(code)
+                }
+            },
+            url: None,
+        }
+    }
 }
 
 impl From<ApiError> for Error {
-    fn from(err: ApiError) -> Error { Error::Api(err) }
+    fn from(err: ApiError) -> Error {
+        Error {
+            err: ErrorType::Api(err),
+            url: None,
+        }
+    }
 }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
+        match self.err {
             SerdeJson(ref err) => fmt::Display::fmt(err, f),
             Hyper(ref err) => fmt::Display::fmt(err, f),
             Io(ref err) => fmt::Display::fmt(err, f),
             StatusCode(ref status) => fmt::Display::fmt(status, f),
             Api(ref err) => fmt::Display::fmt(err, f),
+            Unauthorized => write!(f, "access not authorized: token expired, username/password incorrect or no login provided"),
         }
     }
 }
 
 impl StdError for Error {
     fn description(&self) -> &str {
-        match *self {
+        match self.err {
             SerdeJson(ref err) => err.description(),
             Hyper(ref err) => err.description(),
             Io(ref err) => err.description(),
@@ -81,16 +137,18 @@ impl StdError for Error {
                 return "status code error";
             },
             Api(ref err) => err.description(),
+            Unauthorized => "access not authorized: token expired, username/password incorrect or no login provided",
         }
     }
 
     fn cause(&self) -> Option<&StdError> {
-        match *self {
+        match self.err {
             SerdeJson(ref err) => Some(err),
             Hyper(ref err) => Some(err),
             Io(ref err) => Some(err),
             StatusCode(_) => None,
             Api(ref err) => Some(err),
+            Unauthorized => None,
         }
     }
 }

Diff for: src/lib.rs

@@ -22,7 +22,7 @@ pub struct LoginDetails<'a> {
 
 impl<'a> LoginDetails<'a> {
     /// Create a new login details with the given username and password
-    pub fn new<'b, T: Into<Cow<'b, str>>>(email: T, password: T) -> LoginDetails<'b> {
+    pub fn new<'b, T1: Into<Cow<'b, str>>, T2: Into<Cow<'b, str>>>(email: T1, password: T2) -> LoginDetails<'b> {
         LoginDetails {
             email: email.into(),
             password: password.into()
@@ -36,40 +36,63 @@ struct LoginResponse {
     token: Option<String>,
 }
 
+/// API Object, stores the current API token and allows access to making requests.
 #[derive(Debug)]
 pub struct API<'a> {
-    token: Option<Cow<'a, str>>,
+    pub url: hyper::Url,
+    client: &'a hyper::Client,
+    pub token: Option<String>,
 }
 
 impl<'a> API<'a> {
-    pub fn new_anonymous() -> API<'static> {
-        API { token: None }
+    pub fn new<'b>(client: &'b hyper::Client) -> API<'b> {
+        API {
+            //"https://httpbin.org/post"
+            url: hyper::Url::parse("https://screeps.com/api").expect("expected pre-set url to parse, parsing failed"),
+            client: client,
+            token: None,
+        }
     }
 
-    pub fn new_logged_in<'b>(client: &hyper::Client, login_details: &LoginDetails) -> Result<API<'b>> {
-        let mut api = API::new_anonymous();
-
-        api.get_token(client, login_details)?;
-
-        Ok(api)
+    pub fn with_url<'b, T: hyper::client::IntoUrl>(client: &'b hyper::Client, url: T) -> Result<API<'b>> {
+        Ok(API {
+            url: url.into_url()?,
+            client: client,
+            token: None,
+        })
     }
 
-    fn get_token(&mut self, client: &hyper::Client, login_details: &LoginDetails) -> Result<()> {
-        let body = serde_json::to_string(&login_details)?;
+    fn make_request<T: serde::Serialize, R: serde::Deserialize>(&mut self, endpoint: &str, request_text: &T) -> Result<R> {
+        let body = serde_json::to_string(request_text)?;
 
         let mut headers = Headers::new();
         headers.set(ContentType::json());
+        if let Some(ref token) = self.token {
+            headers.set_raw("X-Token", vec![token.as_bytes().to_vec()]);
+            headers.set_raw("X-Username", vec![token.as_bytes().to_vec()]);
+        }
 
-        let mut response = client.post("https://screeps.com/api/auth/signin")
+        let mut response = self.client.post(self.url.join(endpoint)?)
             .body(&body)
             .headers(headers)
             .send()?;
 
         if !response.status.is_success() {
-            return Err(response.status.into());
+            return Err(Error::new(response.status, Some(response.url.clone())));
         }
 
-        let result: LoginResponse = serde_json::from_reader(&mut response)?;
+        let result: R = match serde_json::from_reader(&mut response) {
+            Ok(v) => v,
+            Err(e) => {
+                return Err(Error::new(e, Some(response.url.clone())))
+            }
+        };
+
+        Ok(result)
+    }
+
+    pub fn login(&mut self, login_details: &LoginDetails) -> Result<()> {
+        let result: LoginResponse = self.make_request("/api/auth/signin", login_details)?;
 
         if result.ok != 1 {
             return Err(ApiError::NotOk(result.ok).into());
@@ -87,24 +110,27 @@ impl<'a> API<'a> {
 #[cfg(test)]
 mod tests {
     use ::{API, LoginDetails};
+    use ::error::{Error, ErrorType};
     extern crate hyper;
     extern crate hyper_rustls;
     use hyper::client::Client;
     use hyper::net::HttpsConnector;
 
     #[test]
     fn anonymous_creation() {
-        let _unused = API::new_anonymous();
+        let client = Client::with_connector(HttpsConnector::new(hyper_rustls::TlsClient::new()));
+        let _unused = API::new(&client);
     }
 
     #[test]
     fn login_creation_auth_failure() {
         let client = Client::with_connector(HttpsConnector::new(hyper_rustls::TlsClient::new()));
         let login = LoginDetails::new("username", "password");
-        let result = API::new_logged_in(&client, &login);
+        let mut api = API::new(&client);
+        let result = api.login(&login);
 
         match result {
-            Err(::error::Error::StatusCode(hyper::status::StatusCode::Unauthorized)) => println!("Success!"),
+            Err(Error { err: ErrorType::Unauthorized, .. }) => println!("Success!"),
             other => panic!("Expected unauthorized error, found {:?}", other),
         }
     }

Diff for: tests/authenticated_tests.rs

@@ -0,0 +1,37 @@
+extern crate screeps_api;
+extern crate hyper;
+extern crate hyper_rustls;
+extern crate dotenv;
+
+use hyper::client::Client;
+use hyper::net::HttpsConnector;
+
+fn env(var: &str) -> String {
+    dotenv::dotenv().ok();
+    match ::std::env::var(var) {
+        Ok(value) => value,
+        Err(_) => panic!("must have `{}` defined", var),
+    }
+}
+
+fn create_secure_client() -> hyper::Client {
+    Client::with_connector(HttpsConnector::new(hyper_rustls::TlsClient::new()))
+}
+
+fn logged_in<'a>(client: &'a hyper::Client) -> screeps_api::API<'a> {
+    let username = env("SCREEPS_API_USERNAME");
+    let password = env("SCREEPS_API_PASSWORD");
+    let mut api = screeps_api::API::new(client);
+
+    if let Err(err) = api.login(&screeps_api::LoginDetails::new(username, password)) {
+        panic!("Error logging in: {:?}", err);
+    }
+
+    api
+}
+
+#[test]
+fn test_logging_in() {
+    let client = create_secure_client();
+    let _api = logged_in(&client);
+}