moved mod tests onto their own file; unsure if I like it but I'll give it a shot

Andres Medina · Andres Medina · commit 0008f5bf1960 · 2018-07-18T10:21:47.000-07:00
diff --git a/src/client/bus/mod.rs b/src/client/bus/mod.rs
@@ -1,8 +1,5 @@
 use reqwest;
 
-#[cfg(all(test, not(feature = "contract")))]
-use mocktopus::macros::mockable;
-
 #[derive(Debug, Clone, PartialEq, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StopsQuery {
@@ -13,16 +10,6 @@ pub struct StopsQuery {
     pub max_count: i8,
 }
 
-#[derive(Debug, Deserialize)]
-struct StopsListResponse {
-    data: StopsListData,
-}
-
-#[derive(Debug, Deserialize)]
-struct StopsListData {
-    list: Vec<Stop>,
-}
-
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Stop {
     pub id: String,
@@ -38,7 +25,6 @@ pub struct Client {
     http_client: reqwest::Client,
 }
 
-#[cfg_attr(all(test, not(feature = "contract")), mockable)]
 impl Client {
     pub fn new(http_client: reqwest::Client, host: String, key: String) -> Self {
         Client {
@@ -47,7 +33,14 @@ impl Client {
             key,
         }
     }
+}
+
+// allow users of Client to mock the requests in unit tests
+#[cfg(all(test, not(feature = "contract")))]
+use mocktopus::macros::mockable;
 
+#[cfg_attr(all(test, not(feature = "contract")), mockable)]
+impl Client {
     pub fn stops(&self, query: &StopsQuery) -> Result<Vec<Stop>, String> {
         let url = format!("{}/{}", self.host, "api/where/stops-for-location.json");
         self.http_client
@@ -61,62 +54,15 @@ impl Client {
     }
 }
 
-#[cfg(all(test, not(feature = "contract")))]
-mod test {
-    use super::*;
-
-    use mockito::{mock, SERVER_URL};
-    use serde_urlencoded;
-
-    #[test]
-    fn stops() {
-        let subject = Client::new(
-            reqwest::Client::new(),
-            String::from(SERVER_URL),
-            String::from("SOME_KEY"),
-        );
-        let query = StopsQuery {
-            lat: 32.3,
-            lon: 23.1,
-            lat_span: 0.01,
-            lon_span: 0.0002,
-            max_count: 9,
-        };
-        let query_path =
-            serde_urlencoded::to_string(query.clone()).expect("could not encode 'StopsQuery'");
-        let path = format!(
-            "/api/where/stops-for-location.json?{}&key=SOME_KEY",
-            query_path
-        );
-
-        let mock = mock("GET", path.as_str())
-            .with_status(200)
-            .with_body(include_str!("../fixtures/stop_list.json"))
-            .with_header("Content-Type", "application/json")
-            .create();
+#[derive(Debug, Deserialize)]
+struct StopsListResponse {
+    data: StopsListData,
+}
 
-        let actual = subject
-            .stops(&query)
-            .expect("expected a succesful stops response");
-        mock.assert();
-        assert_eq!(
-            actual,
-            vec![
-                Stop {
-                    id: String::from("1_75403"),
-                    direction: String::from("S"),
-                    name: String::from("Stevens Way & Benton Ln"),
-                    lat: 47.654365,
-                    lon: -122.305214,
-                },
-                Stop {
-                    id: String::from("1_75414"),
-                    direction: String::from("N"),
-                    name: String::from("Stevens Way & Benton Ln"),
-                    lat: 47.653713,
-                    lon: -122.305023,
-                },
-            ]
-        )
-    }
+#[derive(Debug, Deserialize)]
+struct StopsListData {
+    list: Vec<Stop>,
 }
+
+#[cfg(all(test, not(feature = "contract")))]
+mod test;
diff --git a/src/client/bus/test.rs b/src/client/bus/test.rs
@@ -0,0 +1,56 @@
+use super::*;
+
+use mockito::{mock, SERVER_URL};
+use serde_urlencoded;
+
+#[test]
+fn stops() {
+    let subject = Client::new(
+        reqwest::Client::new(),
+        String::from(SERVER_URL),
+        String::from("SOME_KEY"),
+    );
+    let query = StopsQuery {
+        lat: 32.3,
+        lon: 23.1,
+        lat_span: 0.01,
+        lon_span: 0.0002,
+        max_count: 9,
+    };
+    let query_path =
+        serde_urlencoded::to_string(query.clone()).expect("could not encode 'StopsQuery'");
+    let path = format!(
+        "/api/where/stops-for-location.json?{}&key=SOME_KEY",
+        query_path
+    );
+
+    let mock = mock("GET", path.as_str())
+        .with_status(200)
+        .with_body(include_str!("../fixtures/stop_list.json"))
+        .with_header("Content-Type", "application/json")
+        .create();
+
+    let actual = subject
+        .stops(&query)
+        .expect("expected a succesful stops response");
+    mock.assert();
+    assert_eq!(
+        actual,
+        vec![
+            Stop {
+                id: String::from("1_75403"),
+                direction: String::from("S"),
+                name: String::from("Stevens Way & Benton Ln"),
+                lat: 47.654365,
+                lon: -122.305214,
+            },
+            Stop {
+                id: String::from("1_75414"),
+                direction: String::from("N"),
+                name: String::from("Stevens Way & Benton Ln"),
+                lat: 47.653713,
+                lon: -122.305023,
+            },
+        ]
+    )
+}
diff --git a/src/client/mod.rs b/src/client/mod.rs
@@ -7,16 +7,14 @@ use api::{Area, Location};
 use chrono::{Duration, Local};
 use reqwest;
 
-#[cfg(all(test, not(feature = "contract")))]
-use mocktopus::macros::mockable;
-
 pub struct Client {
     seattle_client: seattle_data::Client,
     bus_client: bus::Client,
 }
 
+// in non-unit test get the secrets from the environment variables
+#[cfg(any(not(test), feature = "contract"))]
 impl Client {
-    #[cfg(any(not(test), feature = "contract"))]
     pub fn new(http_client: reqwest::Client) -> Self {
         fn expect_env(name: &str) -> String {
             use std::env;
@@ -38,33 +36,18 @@ impl Client {
             bus_client,
         }
     }
-
-    #[cfg(all(test, not(feature = "contract")))]
-    pub fn new(http_client: reqwest::Client) -> Self {
-        let seattle_client = seattle_data::Client::new(
-            http_client.clone(),
-            String::from("http://localhost"),
-            String::from("SEATTLE_TOKEN"),
-        );
-        let bus_client = bus::Client::new(
-            http_client,
-            String::from("http://localhost"),
-            String::from("BUS_KEY"),
-        );
-
-        Client {
-            seattle_client,
-            bus_client,
-        }
-    }
 }
 
+// allow users of Client to mock the requests in unit tests
+#[cfg(all(test, not(feature = "contract")))]
+use mocktopus::macros::mockable;
+
 #[cfg_attr(all(test, not(feature = "contract")), mockable)]
 impl Client {
     pub fn info(&self, location: Location) -> Result<String, String> {
         let start_date = Local::now() - Duration::days(180);
         let query = seattle_data::Query::new(location).and(start_date);
-        self.seattle_client.request(&query)
+        self.seattle_client.crime(&query)
     }
 
     pub fn bus_stops(&self, area: Area) -> Result<Vec<bus::Stop>, String> {
@@ -79,78 +62,4 @@ impl Client {
 }
 
 #[cfg(all(test, not(feature = "contract")))]
-mod test {
-    use super::*;
-
-    use mocktopus::mocking::{MockResult, Mockable};
-
-    #[test]
-    fn info() {
-        let subject = Client::new(reqwest::Client::new());
-        let expected = String::from("{}");
-
-        let mut query = None;
-        unsafe {
-            seattle_data::Client::request.mock_raw(|_, q| {
-                query = Some(q.clone());
-                MockResult::Return(Ok(expected.clone()))
-            })
-        }
-
-        let location = Location {
-            latitude: 32.2,
-            longitude: 67.23,
-        };
-        let actual = subject
-            .info(location)
-            .expect("expected a succesful crime response");
-
-        assert_eq!(actual, expected);
-        let query = query.expect("seattle_data::Client::request not called");
-        assert_eq!(
-            query,
-            seattle_data::Query::new(location).and(Local::now() - Duration::days(180))
-        );
-    }
-
-    #[test]
-    fn bus_stops() {
-        let subject = Client::new(reqwest::Client::new());
-        let mut query = None;
-        let expected_stops = vec![bus::Stop {
-            id: String::from("1_1234"),
-            direction: String::from("N"),
-            name: String::from("some bus"),
-            lat: 34.3199,
-            lon: 23.12005,
-        }];
-        unsafe {
-            bus::Client::stops.mock_raw(|_, q| {
-                query = Some(q.clone());
-                MockResult::Return(Ok(expected_stops.clone()))
-            });
-        }
-
-        let area = Area {
-            lat: 34.32,
-            lon: 23.12,
-            lat_span: 0.002,
-            lon_span: 0.0005,
-        };
-        let actual_stops = subject
-            .bus_stops(area)
-            .expect("expected a succesful bus stop response");
-        assert_eq!(actual_stops, expected_stops);
-        let query = query.expect("'bus::Client::stops' not called");
-        assert_eq!(
-            query,
-            bus::StopsQuery {
-                lat: 34.32,
-                lon: 23.12,
-                lat_span: 0.002,
-                lon_span: 0.0005,
-                max_count: 20,
-            }
-        )
-    }
-}
+mod test;
diff --git a/src/client/seattle_data/mod.rs b/src/client/seattle_data/mod.rs
@@ -4,9 +4,6 @@ pub use self::query::Query;
 
 use reqwest;
 
-#[cfg(all(test, not(feature = "contract")))]
-use mocktopus::macros::mockable;
-
 header! { (XAppToken, "X-App-Token") => [String]}
 
 pub struct Client {
@@ -15,7 +12,6 @@ pub struct Client {
     http_client: reqwest::Client,
 }
 
-#[cfg_attr(all(test, not(feature = "contract")), mockable)]
 impl Client {
     pub fn new(http_client: reqwest::Client, host: String, token: String) -> Self {
         Client {
@@ -24,8 +20,15 @@ impl Client {
             token: XAppToken(token),
         }
     }
+}
+
+// allow users of Client to mock the requests in unit tests
+#[cfg(all(test, not(feature = "contract")))]
+use mocktopus::macros::mockable;
 
-    pub fn request(&self, query: &Query) -> Result<String, String> {
+#[cfg_attr(all(test, not(feature = "contract")), mockable)]
+impl Client {
+    pub fn crime(&self, query: &Query) -> Result<String, String> {
         let url = format!("{}/{}", self.host, "resource/policereport.json");
         self.http_client
             .get(&url)
@@ -38,36 +41,4 @@ impl Client {
 }
 
 #[cfg(all(test, not(feature = "contract")))]
-mod test {
-    use super::*;
-    use api::Location;
-
-    use mockito::{mock, SERVER_URL};
-    use serde_urlencoded;
-
-    #[test]
-    fn request() {
-        let subject = Client::new(
-            reqwest::Client::new(),
-            String::from(SERVER_URL),
-            String::from("SOME_TOKEN"),
-        );
-
-        let location = Location {
-            latitude: 32.2,
-            longitude: 67.23,
-        };
-        let query = Query::new(location);
-        let query_path = serde_urlencoded::to_string(query.clone()).unwrap();
-        let path = format!("/resource/policereport.json?{}", query_path);
-        let mock = mock("GET", path.as_str())
-            .with_status(200)
-            .with_body("{}")
-            .with_header("Content-Type", "application/json")
-            .create();
-        let actual = subject.request(&query);
-        mock.assert();
-
-        assert_eq!(actual, Ok("{}".to_string()));
-    }
-}
+mod test;
diff --git a/src/client/seattle_data/test.rs b/src/client/seattle_data/test.rs
diff --git a/src/client/test.rs b/src/client/test.rs
