src/main.rs

 use rocket::{get, launch, post, routes, serde::json::Json};
-use serde::{Deserialize, Serialize};
 
 const INDEX_TEXT: &str = r#"\
 Cette application permet d'executer des calculs simple. 
@@ -30,16 +29,8 @@ Pour envoyer une requête avec curl:
 curl -X POST http://monurl -H 'Content-Type: application/json' -d '{"Plus", [3, 4]}'
 "#;
 
-#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
-enum Operation {
-    Plus(i32,i32),
-}
-
-#[derive(Deserialize, Serialize, PartialEq, Debug)]
-struct OperationResult {
-    operation: String,
-    resultat: i32,
-}
+mod operations;
+use operations::{Operation, OperationResult};
 
 #[get("/")]
 fn index() -> &'static str {
@@ -48,12 +39,7 @@ fn index() -> &'static str {
 
 #[post("/", data = "<operation>")]
 fn do_calc(operation: Json<Operation>) -> Json<OperationResult> {
-    match operation.into_inner() {
-        Operation::Plus(op1, op2) => OperationResult {
-            operation: format!("{op1} + {op2}"),
-            resultat: op1 + op2,
-        }.into()
-    }
+    OperationResult::from(operation.into_inner()).into()
 }
 
 #[get("/test")]
@@ -74,6 +60,13 @@ mod tests {
     use rocket::uri;
     use super::*;
 
+    fn build_response<'r>(operation: Operation)  -> (Status, OperationResult) {
+        let client = Client::tracked(launch()).expect("valid rocket instance");
+        let req = client.post(uri!(super::index)).json(&operation);
+        let response = req.dispatch();
+        (response.status(), response.into_json::<OperationResult>().unwrap())
+    }
+    
     #[test]
     fn index() {
         let client = Client::tracked(launch()).expect("valid rocket instance");
@@ -85,16 +78,20 @@ mod tests {
 
     #[test]
     fn plus() {
-        let client = Client::tracked(launch()).expect("valid rocket instance");
-        let operation = Operation::Plus(3, 8);
-        let req = client.post(uri!(super::index)).json(&operation);
-        let response = req.dispatch();
-        assert_eq!(response.status(), Status::Ok);
+        let (status, response) = build_response(Operation::Plus(3, 8));
+        assert_eq!(status, Status::Ok);
+
+        let expected = OperationResult::new("3 + 8", 11);
+        assert_eq!(response, expected); 
+    }
+
+    #[test]
+    fn moins() {
+        let (status, response) = build_response(Operation::Moins(10, 20));
+        assert_eq!(status, Status::Ok);
 
-        let expected = OperationResult {
-            operation: "3 + 8".into(),
-            resultat: 11,
-        };
-        assert_eq!(response.into_json::<OperationResult>().unwrap(), expected); 
+        let expected = OperationResult::new("10 - 20", -10);
+        assert_eq!(response, expected); 
     }
+
 }

src/operations.rs

+//! This modules defines the possible operation and provide methods
+//! to do the actual computation
+
+use serde::{Deserialize, Serialize};
+
+
+#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
+pub enum Operation {
+    Plus(i32,i32),
+    Moins(i32,i32),
+}
+
+#[derive(Deserialize, Serialize, PartialEq, Debug)]
+pub struct OperationResult {
+    operation: String,
+    resultat: i32,
+}
+
+impl OperationResult {
+    /// Creates a new operation result from a [`&str`] and a value.
+    pub fn new(s: &str, value: i32) -> Self {
+        Self {
+            operation: String::from(s),
+            resultat: value,
+        }
+    }
+}
+
+impl From<&Operation> for OperationResult {
+    fn from(value: &Operation) -> Self {
+        match value {
+            Operation::Plus(op1, op2) => OperationResult {
+                operation: format!("{op1} + {op2}"),
+                resultat: op1 + op2,
+            },
+            Operation::Moins(op1, op2) => OperationResult {
+                operation: format!("{op1} - {op2}"),
+                resultat: op1 - op2,
+            },
+        }
+    }
+}
+
+impl From<Operation> for OperationResult {
+    fn from(value: Operation) -> Self {
+        OperationResult::from(&value)
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    #[test]
+    fn plus() {
+        let operation = Operation::Plus(4, 5);
+        let result = OperationResult::from(operation);
+        let expected = OperationResult::new("4 + 5", 9);
+
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn moins() {
+        let operation = Operation::Moins(4, 5);
+        let result = OperationResult::from(operation);
+        let expected = OperationResult::new("4 - 5", -1);
+
+        assert_eq!(result, expected);
+    }
+    
+}