Fix and Enforce Clippy Lints (#26)

msrd0 · Empty2k12 · commit 75429fd4c426 · 2019-10-09T21:59:43.000+02:00
diff --git a/.travis.yml b/.travis.yml
@@ -41,7 +41,7 @@ matrix:
               - rustup component add clippy-preview
           script:
               - cargo fmt --all -- --check
-              - cargo clippy
+              - cargo clippy --all-targets --all-features -- -D warnings
 
         - env: NAME='cargo-travis'
           sudo: required
diff --git a/src/client/mod.rs b/src/client/mod.rs
@@ -104,7 +104,7 @@ impl InfluxDbClient {
     ///
     /// let _client = InfluxDbClient::new("http://localhost:9086", "test").with_auth("admin", "password");
     /// ```
-    pub fn with_auth<'a, S1, S2>(mut self, username: S1, password: S2) -> Self
+    pub fn with_auth<S1, S2>(mut self, username: S1, password: S2) -> Self
     where
         S1: ToString,
         S2: ToString,
diff --git a/src/integrations/serde_integration.rs b/src/integrations/serde_integration.rs
@@ -173,9 +173,9 @@ impl InfluxDbClient {
                 .and_then(|body| {
                     // Try parsing InfluxDBs { "error": "error message here" }
                     if let Ok(error) = serde_json::from_slice::<_DatabaseError>(&body) {
-                        return futures::future::err(InfluxDbError::DatabaseError {
+                        futures::future::err(InfluxDbError::DatabaseError {
                             error: error.error.to_string(),
-                        });
+                        })
                     } else {
                         // Json has another structure, let's try actually parsing it to the type we're deserializing
                         let from_slice = serde_json::from_slice::<DatabaseQueryResult>(&body);
@@ -189,7 +189,7 @@ impl InfluxDbClient {
                             }
                         };
 
-                        return futures::future::result(Ok(deserialized));
+                        futures::future::result(Ok(deserialized))
                     }
                 }),
         )
diff --git a/src/query/mod.rs b/src/query/mod.rs
@@ -176,11 +176,11 @@ mod tests {
 
     #[test]
     fn test_format_for_timestamp_now() {
-        assert!(format!("{}", Timestamp::NOW) == String::from(""));
+        assert!(format!("{}", Timestamp::NOW) == "");
     }
 
     #[test]
     fn test_format_for_timestamp_else() {
-        assert!(format!("{}", Timestamp::NANOSECONDS(100)) == String::from("100"));
+        assert!(format!("{}", Timestamp::NANOSECONDS(100)) == "100");
     }
 }
diff --git a/src/query/read_query.rs b/src/query/read_query.rs
@@ -21,7 +21,7 @@ impl InfluxDbReadQuery {
     }
 
     /// Adds a query to the [`InfluxDbReadQuery`]
-    pub fn add<S>(mut self, query: S) -> Self
+    pub fn add_query<S>(mut self, query: S) -> Self
     where
         S: ToString,
     {
@@ -54,7 +54,7 @@ mod tests {
     #[test]
     fn test_read_builder_multi_query() {
         let query = InfluxDbQuery::raw_read_query("SELECT * FROM aachen")
-            .add("SELECT * FROM cologne")
+            .add_query("SELECT * FROM cologne")
             .build();
 
         assert_eq!(query.unwrap(), "SELECT * FROM aachen;SELECT * FROM cologne");
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs
@@ -6,6 +6,14 @@ use influxdb::error::InfluxDbError;
 use influxdb::query::{InfluxDbQuery, Timestamp};
 use tokio::runtime::current_thread::Runtime;
 
+fn assert_result_err<A: std::fmt::Debug, B: std::fmt::Debug>(result: &Result<A, B>) {
+    result.as_ref().expect_err("assert_result_err failed");
+}
+
+fn assert_result_ok<A: std::fmt::Debug, B: std::fmt::Debug>(result: &Result<A, B>) {
+    result.as_ref().expect("assert_result_ok failed");
+}
+
 fn get_runtime() -> Runtime {
     Runtime::new().expect("Unable to create a runtime")
 }
@@ -50,11 +58,7 @@ where
 fn test_ping_influx_db() {
     let client = create_client("notusedhere");
     let result = get_runtime().block_on(client.ping());
-    assert!(
-        result.is_ok(),
-        "Should be no error: {}",
-        result.unwrap_err()
-    );
+    assert_result_ok(&result);
 
     let (build, version) = result.unwrap();
     assert!(!build.is_empty(), "Build should not be empty");
@@ -73,19 +77,13 @@ fn test_connection_error() {
         .with_auth("nopriv_user", "password");
     let read_query = InfluxDbQuery::raw_read_query("SELECT * FROM weather");
     let read_result = get_runtime().block_on(client.query(&read_query));
-    assert!(
-        read_result.is_err(),
-        format!("Should be an error: {}", read_result.unwrap_err())
-    );
+    assert_result_err(&read_result);
     match read_result {
-        Err(InfluxDbError::ConnectionError { .. }) => assert!(true),
-        _ => assert!(
-            false,
-            format!(
-                "Should cause a ConnectionError: {}",
-                read_result.unwrap_err()
-            )
-        ),
+        Err(InfluxDbError::ConnectionError { .. }) => {}
+        _ => panic!(format!(
+            "Should cause a ConnectionError: {}",
+            read_result.unwrap_err()
+        )),
     }
 }
 
@@ -119,17 +117,11 @@ fn test_authed_write_and_read() {
     let write_query =
         InfluxDbQuery::write_query(Timestamp::HOURS(11), "weather").add_field("temperature", 82);
     let write_result = get_runtime().block_on(client.query(&write_query));
-    assert!(
-        write_result.is_ok(),
-        format!("Should be no error: {}", write_result.unwrap_err())
-    );
+    assert_result_ok(&write_result);
 
     let read_query = InfluxDbQuery::raw_read_query("SELECT * FROM weather");
     let read_result = get_runtime().block_on(client.query(&read_query));
-    assert!(
-        read_result.is_ok(),
-        format!("Should be no error: {}", read_result.unwrap_err())
-    );
+    assert_result_ok(&read_result);
     assert!(
         !read_result.unwrap().contains("error"),
         "Data contained a database error"
@@ -166,55 +158,37 @@ fn test_wrong_authed_write_and_read() {
     let write_query =
         InfluxDbQuery::write_query(Timestamp::HOURS(11), "weather").add_field("temperature", 82);
     let write_result = get_runtime().block_on(client.query(&write_query));
-    assert!(
-        write_result.is_err(),
-        format!("Should be an error: {}", write_result.unwrap_err())
-    );
+    assert_result_err(&write_result);
     match write_result {
-        Err(InfluxDbError::AuthorizationError) => assert!(true),
-        _ => assert!(
-            false,
-            format!(
-                "Should be an AuthorizationError: {}",
-                write_result.unwrap_err()
-            )
-        ),
+        Err(InfluxDbError::AuthorizationError) => {}
+        _ => panic!(format!(
+            "Should be an AuthorizationError: {}",
+            write_result.unwrap_err()
+        )),
     }
 
     let read_query = InfluxDbQuery::raw_read_query("SELECT * FROM weather");
     let read_result = get_runtime().block_on(client.query(&read_query));
-    assert!(
-        read_result.is_err(),
-        format!("Should be an error: {}", read_result.unwrap_err())
-    );
+    assert_result_err(&read_result);
     match read_result {
-        Err(InfluxDbError::AuthorizationError) => assert!(true),
-        _ => assert!(
-            false,
-            format!(
-                "Should be an AuthorizationError: {}",
-                read_result.unwrap_err()
-            )
-        ),
+        Err(InfluxDbError::AuthorizationError) => {}
+        _ => panic!(format!(
+            "Should be an AuthorizationError: {}",
+            read_result.unwrap_err()
+        )),
     }
 
     let client = InfluxDbClient::new("http://localhost:9086", test_name)
         .with_auth("nopriv_user", "password");
     let read_query = InfluxDbQuery::raw_read_query("SELECT * FROM weather");
     let read_result = get_runtime().block_on(client.query(&read_query));
-    assert!(
-        read_result.is_err(),
-        format!("Should be an error: {}", read_result.unwrap_err())
-    );
+    assert_result_err(&read_result);
     match read_result {
-        Err(InfluxDbError::AuthenticationError) => assert!(true),
-        _ => assert!(
-            false,
-            format!(
-                "Should be an AuthenticationError: {}",
-                read_result.unwrap_err()
-            )
-        ),
+        Err(InfluxDbError::AuthenticationError) => {}
+        _ => panic!(format!(
+            "Should be an AuthenticationError: {}",
+            read_result.unwrap_err()
+        )),
     }
 }
 
@@ -246,36 +220,24 @@ fn test_non_authed_write_and_read() {
     let write_query =
         InfluxDbQuery::write_query(Timestamp::HOURS(11), "weather").add_field("temperature", 82);
     let write_result = get_runtime().block_on(non_authed_client.query(&write_query));
-    assert!(
-        write_result.is_err(),
-        format!("Should be an error: {}", write_result.unwrap_err())
-    );
+    assert_result_err(&write_result);
     match write_result {
-        Err(InfluxDbError::AuthorizationError) => assert!(true),
-        _ => assert!(
-            false,
-            format!(
-                "Should be an AuthorizationError: {}",
-                write_result.unwrap_err()
-            )
-        ),
+        Err(InfluxDbError::AuthorizationError) => {}
+        _ => panic!(format!(
+            "Should be an AuthorizationError: {}",
+            write_result.unwrap_err()
+        )),
     }
 
     let read_query = InfluxDbQuery::raw_read_query("SELECT * FROM weather");
     let read_result = get_runtime().block_on(non_authed_client.query(&read_query));
-    assert!(
-        read_result.is_err(),
-        format!("Should be an error: {}", read_result.unwrap())
-    );
+    assert_result_err(&read_result);
     match read_result {
-        Err(InfluxDbError::AuthorizationError) => assert!(true),
-        _ => assert!(
-            false,
-            format!(
-                "Should be an AuthorizationError: {}",
-                read_result.unwrap_err()
-            )
-        ),
+        Err(InfluxDbError::AuthorizationError) => {}
+        _ => panic!(format!(
+            "Should be an AuthorizationError: {}",
+            read_result.unwrap_err()
+        )),
     }
 }
 
@@ -296,17 +258,11 @@ fn test_write_and_read_field() {
     let write_query =
         InfluxDbQuery::write_query(Timestamp::HOURS(11), "weather").add_field("temperature", 82);
     let write_result = get_runtime().block_on(client.query(&write_query));
-    assert!(
-        write_result.is_ok(),
-        format!("Should be no error: {}", write_result.unwrap_err())
-    );
+    assert_result_ok(&write_result);
 
     let read_query = InfluxDbQuery::raw_read_query("SELECT * FROM weather");
     let read_result = get_runtime().block_on(client.query(&read_query));
-    assert!(
-        read_result.is_ok(),
-        format!("Should be no error: {}", read_result.unwrap_err())
-    );
+    assert_result_ok(&read_result);
     assert!(
         !read_result.unwrap().contains("error"),
         "Data contained a database error"
@@ -338,10 +294,7 @@ fn test_json_query() {
     let write_query =
         InfluxDbQuery::write_query(Timestamp::HOURS(11), "weather").add_field("temperature", 82);
     let write_result = get_runtime().block_on(client.query(&write_query));
-    assert!(
-        write_result.is_ok(),
-        format!("Should be no error: {}", write_result.unwrap_err())
-    );
+    assert_result_ok(&write_result);
 
     #[derive(Deserialize, Debug, PartialEq)]
     struct Weather {
@@ -354,11 +307,7 @@ fn test_json_query() {
         .json_query(query)
         .and_then(|mut db_result| db_result.deserialize_next::<Weather>());
     let result = get_runtime().block_on(future);
-
-    assert!(
-        result.is_ok(),
-        format!("We couldn't read from the DB: {}", result.unwrap_err())
-    );
+    assert_result_ok(&result);
 
     assert_eq!(
         result.unwrap().series[0].values[0],
@@ -411,12 +360,7 @@ fn test_json_query_vec() {
         .json_query(query)
         .and_then(|mut db_result| db_result.deserialize_next::<Weather>());
     let result = get_runtime().block_on(future);
-
-    assert!(
-        result.is_ok(),
-        format!("We couldn't read from the DB: {}", result.unwrap_err())
-    );
-
+    assert_result_ok(&result);
     assert_eq!(result.unwrap().series[0].values.len(), 3);
 
     delete_db(test_name).expect("could not clean up db");
@@ -458,21 +402,13 @@ fn test_serde_multi_query() {
 
     let write_result = get_runtime().block_on(client.query(&write_query));
     let write_result2 = get_runtime().block_on(client.query(&write_query2));
-
-    assert!(
-        write_result.is_ok(),
-        format!("Write Query 1 failed: {}", write_result.unwrap_err())
-    );
-
-    assert!(
-        write_result2.is_ok(),
-        format!("Write Query 2 failed: {}", write_result2.unwrap_err())
-    );
+    assert_result_ok(&write_result);
+    assert_result_ok(&write_result2);
 
     let future = client
         .json_query(
             InfluxDbQuery::raw_read_query("SELECT * FROM temperature")
-                .add("SELECT * FROM humidity"),
+                .add_query("SELECT * FROM humidity"),
         )
         .and_then(|mut db_result| {
             let temp = db_result.deserialize_next::<Temperature>();
@@ -481,22 +417,16 @@ fn test_serde_multi_query() {
             (temp, humidity)
         });
     let result = get_runtime().block_on(future);
-
-    assert!(
-        result.is_ok(),
-        format!("No problems should be had: {}", result.unwrap_err())
-    );
+    assert_result_ok(&result);
 
     let (temp, humidity) = result.unwrap();
-
     assert_eq!(
         temp.series[0].values[0],
         Temperature {
             time: "1970-01-01T11:00:00Z".to_string(),
             temperature: 16
         },
     );
-
     assert_eq!(
         humidity.series[0].values[0],
         Humidity {

Original file line number	Diff line number	Diff line change
`@@ -173,9 +173,9 @@ impl InfluxDbClient {`
`173`	`173`	`.and_then(\|body\| {`
`174`	`174`	`// Try parsing InfluxDBs { "error": "error message here" }`
`175`	`175`	`if let Ok(error) = serde_json::from_slice::<_DatabaseError>(&body) {`
`176`		`- return futures::future::err(InfluxDbError::DatabaseError {`
	`176`	`+ futures::future::err(InfluxDbError::DatabaseError {`
`177`	`177`	`error: error.error.to_string(),`
`178`		`- });`
	`178`	`+ })`
`179`	`179`	`} else {`
`180`	`180`	`// Json has another structure, let's try actually parsing it to the type we're deserializing`
`181`	`181`	`let from_slice = serde_json::from_slice::<DatabaseQueryResult>(&body);`
`@@ -189,7 +189,7 @@ impl InfluxDbClient {`
`189`	`189`	`}`
`190`	`190`	`};`
`191`	`191`
`192`		`- return futures::future::result(Ok(deserialized));`
	`192`	`+ futures::future::result(Ok(deserialized))`
`193`	`193`	`}`
`194`	`194`	`}),`
`195`	`195`	`)`
Original file line number	Diff line number	Diff line change
`@@ -176,11 +176,11 @@ mod tests {`
`176`	`176`
`177`	`177`	`#[test]`
`178`	`178`	`fn test_format_for_timestamp_now() {`
`179`		`- assert!(format!("{}", Timestamp::NOW) == String::from(""));`
	`179`	`+ assert!(format!("{}", Timestamp::NOW) == "");`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`#[test]`
`183`	`183`	`fn test_format_for_timestamp_else() {`
`184`		`- assert!(format!("{}", Timestamp::NANOSECONDS(100)) == String::from("100"));`
	`184`	`+ assert!(format!("{}", Timestamp::NANOSECONDS(100)) == "100");`
`185`	`185`	`}`
`186`	`186`	`}`