Merge pull request #90 from h1alexbel/74

74

cli/Cargo.toml

@@ -28,6 +28,9 @@ edition = "2021"
 name = "cli"
 path = "src/main.rs"
 
+[lints.clippy]
+unwrap_used = "deny"
+
 [dev-dependencies]
 assert_cmd = "2.0.14"
 

server/Cargo.toml

@@ -37,6 +37,12 @@ path = "src/lib.rs"
 [lints.rust]
 missing_docs = "deny"
 
+# @todo #74:30min\DEV Find way to spread clippy config
+#  We need to find way to spread clippy/rustfmt configuration
+#  through all workspaces to reduce duplications in child workspaces.
+[lints.clippy]
+unwrap_used = "deny"
+
 [dependencies]
 openapi = { path = "../github-mirror" }
 anyhow = "1.0.86"

server/src/handlers/home.rs

@@ -24,9 +24,10 @@ use axum::response::IntoResponse;
 use axum::Json;
 use log::debug;
 
-use crate::ServerConfig;
 use openapi::models::MetaRoot200Response;
 
+use crate::ServerConfig;
+
 /// Home handler.
 pub async fn home(State(config): State<ServerConfig>) -> impl IntoResponse {
     let response = Json(
@@ -188,8 +189,6 @@ pub async fn home(State(config): State<ServerConfig>) -> impl IntoResponse {
 
 #[cfg(test)]
 mod tests {
-    use crate::handlers::home::home;
-    use crate::ServerConfig;
     use anyhow::Result;
     use axum::body::to_bytes;
     use axum::extract::State;
@@ -198,6 +197,9 @@ mod tests {
     use serde_json::{from_str, Value};
     use tokio::fs;
 
+    use crate::handlers::home::home;
+    use crate::ServerConfig;
+
     const BYTES_READ_LIMIT: usize = 10000;
 
     #[tokio::test]
@@ -219,25 +221,21 @@ mod tests {
 
     #[tokio::test]
     async fn returns_root_response() -> Result<()> {
-        let actual: Value = from_str(
-            &String::from_utf8(
-                to_bytes(
-                    IntoResponse::into_response(
-                        home(State(ServerConfig {
-                            host: String::from("test"),
-                            port: 1234,
-                        }))
-                        .await,
-                    )
-                    .into_body(),
-                    BYTES_READ_LIMIT,
+        let actual: Value = from_str(&String::from_utf8(
+            to_bytes(
+                IntoResponse::into_response(
+                    home(State(ServerConfig {
+                        host: String::from("test"),
+                        port: 1234,
+                    }))
+                    .await,
                 )
-                .await
-                .unwrap()
-                .to_vec(),
+                .into_body(),
+                BYTES_READ_LIMIT,
             )
-            .unwrap(),
-        )
+            .await?
+            .to_vec(),
+        )?)
         .expect("Failed to parse JSON");
         assert_that!(
             actual.to_string(),

server/src/objects/user.rs

@@ -55,14 +55,11 @@ impl User {
 //  apply it to the storage. Keep in mind that application function in the
 //  storage should be thread-safe (as well as #xml function). Don't forget to
 //  create unit tests that prove that.
-// @todo #17:30min Configure clippy to reject code with #unwrap().
-//  We should prohibit to use #unwrap() function in our code. Let's configure
-//  clippy tool in the respective manner and get rid of all #unwrap() calls.
 impl User {
     /// Save user.
     pub async fn save(self) -> Result<()> {
         info!("saving user @{}", self.username);
-        let xml = to_string(&self).unwrap();
+        let xml = to_string(&self)?;
         debug!("XMLed user: {}", xml);
         Ok(())
     }

server/src/xml/storage.rs

@@ -109,7 +109,7 @@ mod tests {
         let temp = TempDir::new("temp")?;
         let path = temp.path().join("fakehub.xml");
         Storage::new(path.to_str());
-        let xml = fs::read_to_string(path).unwrap();
+        let xml = fs::read_to_string(path)?;
         let expected = "<root>\n<github><users/></github>\n</root>\n";
         assert_that!(xml, is(equal_to(String::from(expected))));
         Ok(())

server/tests/routes_it.rs

@@ -47,8 +47,7 @@ mod routes_its {
         let response = reqwest::Client::new()
             .get(format!("http://localhost:{}/", port))
             .send()
-            .await
-            .unwrap();
+            .await?;
         assert_that!(response.status().as_u16(), is(equal_to(200)));
         Ok(())
     }