Refactor test result handling to separate mutation from evaluation

1 files changed, 93 insertions, 33 deletions

diff --git a/rust/src/web.rs b/rust/src/web.rs
index 7e03249..8ee3075 100644
--- a/rust/src/web.rs
+++ b/rust/src/web.rs
@@ -135,8 +135,28 @@ impl Client {
         )
     }
 
-    fn check_result(&mut self, expected: &String, response: &Result<String, TestResult>) -> Test {
-        let timestamp = chrono::offset::Utc::now();
+    /// Applies a `Test` to update client's state
+    fn apply(&mut self, test: &Test) {
+        match test.result {
+            TestResult::TestSucceeded => {
+                self.grade = self.grade.saturating_add(1);
+                self.delay = Duration::from_secs_f64(self.delay.as_secs_f64() * 0.8);
+                if self.delay.as_millis() < 500 {
+                    self.delay = Duration::from_millis(500);
+                }
+            }
+            TestResult::TestFailed(_) => {
+                self.delay = Duration::from_secs_f64(self.delay.as_secs_f64() * 1.2);
+                if self.delay.as_secs() > 30 {
+                    self.delay = Duration::from_secs(30);
+                }
+            }
+            _ => (),
+        }
+        self.results.push(test.clone());
+    }
+
+    fn check_result(&self, expected: &String, response: &Result<String, TestResult>) -> Test {
         let result = match response {
             Ok(expr) => {
                 let vals = parse(expr);
@@ -146,25 +166,17 @@ impl Client {
                     .collect::<Vec<_>>()
                     .join("\n");
                 if actual == *expected {
-                    self.grade = self.grade.saturating_add(1);
-                    self.delay = Duration::from_secs_f64(self.delay.as_secs_f64() * 0.8);
-                    if self.delay.as_millis() < 500 {
-                        self.delay = Duration::from_millis(500);
-                    }
                     TestResult::TestSucceeded
                 } else {
-                    self.delay = Duration::from_secs_f64(self.delay.as_secs_f64() * 1.2);
-                    if self.delay.as_secs() > 30 {
-                        self.delay = Duration::from_secs(30);
-                    }
                     TestResult::TestFailed(actual)
                 }
             }
             Err(res) => res.clone(),
         };
-        let test = Test { result, timestamp };
-        self.results.push(test.clone());
-        test
+        Test {
+            result,
+            timestamp: chrono::offset::Utc::now(),
+        }
     }
 }
 
@@ -319,7 +331,8 @@ async fn send_tests(client_m: Arc<Mutex<Client>>) {
             let (input, expected) = client.generate_expr();
             let response = send_test(&input, &client.url).await;
 
-            client.check_result(&expected, &response);
+            let test = client.check_result(&expected, &response);
+            client.apply(&test);
         }
     }
 }
@@ -681,24 +694,61 @@ mod app_tests {
     #[test]
     async fn client_increases_grade_on_successful_test() {
         let mut client = client();
+        let test = Test {
+            timestamp: chrono::offset::Utc::now(),
+            result: TestResult::TestSucceeded,
+        };
+
+        client.apply(&test);
+
+        assert_eq!(2, client.grade);
+    }
+
+    #[test]
+    async fn client_stores_test_results() {
+        let mut client = client();
+        let test = Test {
+            timestamp: chrono::offset::Utc::now(),
+            result: TestResult::TestSucceeded,
+        };
+
+        client.apply(&test);
+
+        assert_eq!(test, client.results.first().unwrap().clone());
+    }
+
+    #[test]
+    async fn client_returns_test_successful_if_result_match() {
+        let client = client();
         let expected = "1".to_string();
         let response = Ok("1".to_string());
 
         let test = client.check_result(&expected, &response);
 
         assert_eq!(TestResult::TestSucceeded, test.result);
-        assert_eq!(2, client.grade);
     }
 
     #[test]
-    async fn client_does_not_increase_grade_on_failed_test() {
-        let mut client = client();
+    async fn client_returns_test_failed_given_result_do_not_match() {
+        let client = client();
         let expected = "1".to_string();
         let response = Ok("2".to_string());
 
         let test = client.check_result(&expected, &response);
 
         assert_eq!(TestResult::TestFailed("2".to_string()), test.result);
+    }
+
+    #[test]
+    async fn client_does_not_increase_grade_on_failed_test() {
+        let mut client = client();
+        let test = Test {
+            timestamp: chrono::offset::Utc::now(),
+            result: TestResult::TestFailed("2".to_string()),
+        };
+
+        client.apply(&test);
+
         assert_eq!(1, client.grade);
     }
 
@@ -714,11 +764,13 @@ mod app_tests {
     #[test]
     async fn client_increases_delay_to_next_upon_failed_test() {
         let mut client = client();
-        let expected = "1".to_string();
-        let response = Ok("2".to_string());
+        let test = Test {
+            timestamp: chrono::offset::Utc::now(),
+            result: TestResult::TestFailed("2".to_string()),
+        };
         let delay_before = client.time_to_next_test();
 
-        client.check_result(&expected, &response);
+        client.apply(&test);
 
         assert!(delay_before < client.time_to_next_test());
     }
@@ -726,11 +778,13 @@ mod app_tests {
     #[test]
     async fn client_increases_delay_to_maximum_of_30s() {
         let mut client = client();
-        let expected = "1".to_string();
-        let response = Ok("2".to_string());
+        let test = Test {
+            timestamp: chrono::offset::Utc::now(),
+            result: TestResult::TestFailed("2".to_string()),
+        };
 
         for _ in 0..100 {
-            client.check_result(&expected, &response);
+            client.apply(&test);
         }
 
         assert_eq!(Duration::from_secs(30), client.time_to_next_test());
@@ -739,11 +793,13 @@ mod app_tests {
     #[test]
     async fn client_score_cannot_go_beyond_255() {
         let mut client = client();
-        let expected = "1".to_string();
-        let response = Ok("1".to_string());
+        let test = Test {
+            timestamp: chrono::offset::Utc::now(),
+            result: TestResult::TestSucceeded,
+        };
 
         for _ in 0..256 {
-            client.check_result(&expected, &response);
+            client.apply(&test);
         }
 
         assert_eq!(255, client.grade);
@@ -752,11 +808,13 @@ mod app_tests {
     #[test]
     async fn client_decreases_delay_to_next_upon_successful_test() {
         let mut client = client();
-        let expected = "1".to_string();
-        let response = Ok("1".to_string());
+        let test = Test {
+            timestamp: chrono::offset::Utc::now(),
+            result: TestResult::TestSucceeded,
+        };
         let delay_before = client.time_to_next_test();
 
-        client.check_result(&expected, &response);
+        client.apply(&test);
 
         assert!(delay_before > client.time_to_next_test());
     }
@@ -764,11 +822,13 @@ mod app_tests {
     #[test]
     async fn client_decreases_delay_to_minimum_of_500ms() {
         let mut client = client();
-        let expected = "1".to_string();
-        let response = Ok("1".to_string());
+        let test = Test {
+            timestamp: chrono::offset::Utc::now(),
+            result: TestResult::TestSucceeded,
+        };
 
         for _ in 0..100 {
-            client.check_result(&expected, &response);
+            client.apply(&test);
         }
 
         assert_eq!(Duration::from_millis(500), client.time_to_next_test());