Refactor AuthMonitor tests

Author: FastAlien

src/auth_monitor_tests.rs

@@ -7,50 +7,35 @@ use crate::auth_monitor_options::AuthMonitorOptions;
 use crate::auth_monitor_params::AuthMonitorParams;
 use crate::test_utils::test_file::TestFile;
 
-struct AuthMonitorTest {
-    auth_monitor: AuthMonitor,
-}
-
-impl AuthMonitorTest {
-    pub fn new(path: &str, options: AuthMonitorOptions) -> AuthMonitorTest {
-        println!("Creating AuthMonitor with options: {}", options);
-        let auth_monitor = AuthMonitor::new(AuthMonitorParams {
-            filepath: String::from(path),
-            options,
-        })
-        .expect("Error creating AuthMonitor");
-        return AuthMonitorTest { auth_monitor };
-    }
-
-    pub fn expect_auth_failure_limit_not_reached(&mut self) {
-        assert_eq!(self.auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
-    }
+const MAX_FAILED_ATTEMPTS_TEST_RANGE: Range<i32> = 2..15;
 
-    pub fn expect_auth_failure_limit_reached(&mut self) {
-        assert_eq!(self.auth_monitor.update(), AuthState::AuthFailureLimitReached);
-    }
+fn create_auth_monitor(path: &str, options: AuthMonitorOptions) -> AuthMonitor {
+    println!("Creating AuthMonitor with options: {}", options);
+    return AuthMonitor::new(AuthMonitorParams {
+        filepath: String::from(path),
+        options,
+    })
+    .expect("Error creating AuthMonitor");
 }
 
-const MAX_FAILED_ATTEMPTS_TEST_RANGE: Range<i32> = 2..15;
-
 #[test]
-fn when_file_does_not_exist_then_changes_are_monitored_after_it_is_created() {
+pub fn when_file_does_not_exist_then_changes_are_monitored_after_it_is_created() {
     let mut file = TestFile::empty();
     file.remove();
 
     let options = AuthMonitorOptions::default();
-    let mut test = AuthMonitorTest::new(file.path(), options);
-    test.expect_auth_failure_limit_not_reached();
+    let mut auth_monitor = create_auth_monitor(file.path(), options);
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
     file.create();
 
     for i in 0usize..(options.max_failed_attempts - 1) as usize {
         file.write_auth_failed_message(i);
-        test.expect_auth_failure_limit_not_reached();
+        assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
     }
 
     file.write_auth_failed_message(0);
-    test.expect_auth_failure_limit_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitReached);
 }
 
 #[test]
@@ -61,21 +46,21 @@ pub fn when_auth_failure_limit_is_reached_then_update_callback_is_invoked() {
             max_failed_attempts,
             ..AuthMonitorOptions::default()
         };
-        let mut test = AuthMonitorTest::new(file.path(), options);
-        test.expect_auth_failure_limit_not_reached();
+        let mut auth_monitor = create_auth_monitor(file.path(), options);
+        assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
         for i in 0usize..(max_failed_attempts - 1) as usize {
             file.write_auth_failed_message(i);
-            test.expect_auth_failure_limit_not_reached();
+            assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
         }
 
         for i in 0usize..(max_failed_attempts * 2) as usize {
             file.write_other_message(i);
-            test.expect_auth_failure_limit_not_reached();
+            assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
         }
 
         file.write_auth_failed_message(0);
-        test.expect_auth_failure_limit_reached();
+        assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitReached);
     }
 }
 
@@ -87,13 +72,13 @@ pub fn when_auth_failure_limit_is_reached_between_updates_then_next_update_invok
             max_failed_attempts,
             ..AuthMonitorOptions::default()
         };
-        let mut test = AuthMonitorTest::new(file.path(), options);
-        test.expect_auth_failure_limit_not_reached();
+        let mut auth_monitor = create_auth_monitor(file.path(), options);
+        assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
         file.write_auth_failed_messages(max_failed_attempts as usize);
         file.write_other_messages(max_failed_attempts as usize);
 
-        test.expect_auth_failure_limit_reached();
+        assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitReached);
     }
 }
 
@@ -104,14 +89,14 @@ pub fn when_reset_time_has_passed_then_reset_failed_attempt_counter() {
         reset_after_seconds: 5,
         ..AuthMonitorOptions::default()
     };
-    let mut test = AuthMonitorTest::new(file.path(), options);
-    test.expect_auth_failure_limit_not_reached();
+    let mut auth_monitor = create_auth_monitor(file.path(), options);
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
     let failed_attempts_safe_limit = (options.max_failed_attempts - 1) as usize;
 
     for i in 0usize..failed_attempts_safe_limit {
         file.write_auth_failed_message(i);
-        test.expect_auth_failure_limit_not_reached();
+        assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
     }
 
     let sleep_duration = Duration::from_secs((options.reset_after_seconds + 1) as u64);
@@ -120,11 +105,11 @@ pub fn when_reset_time_has_passed_then_reset_failed_attempt_counter() {
 
     for i in 0usize..failed_attempts_safe_limit {
         file.write_auth_failed_message(i);
-        test.expect_auth_failure_limit_not_reached();
+        assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
     }
 
     file.write_auth_failed_message(0);
-    test.expect_auth_failure_limit_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitReached);
 }
 
 #[test]
@@ -134,17 +119,17 @@ pub fn when_ignore_subsequent_fails_duration_has_not_elapsed_then_update_callbac
         ignore_subsequent_fails_ms: 10,
         ..AuthMonitorOptions::default()
     };
-    let mut test = AuthMonitorTest::new(file.path(), options);
-    test.expect_auth_failure_limit_not_reached();
+    let mut auth_monitor = create_auth_monitor(file.path(), options);
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
     let max_failed_attempts = options.max_failed_attempts as usize;
 
     for i in 0usize..max_failed_attempts {
         file.write_auth_failed_message(i);
-        test.expect_auth_failure_limit_not_reached();
+        assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
     }
 
-    test.expect_auth_failure_limit_not_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 }
 
 #[test]
@@ -154,8 +139,8 @@ pub fn when_ignore_subsequent_fails_duration_has_elapsed_then_update_callback_is
         ignore_subsequent_fails_ms: 10,
         ..AuthMonitorOptions::default()
     };
-    let mut test = AuthMonitorTest::new(file.path(), options);
-    test.expect_auth_failure_limit_not_reached();
+    let mut auth_monitor = create_auth_monitor(file.path(), options);
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
     let max_failed_attempts = options.max_failed_attempts as usize;
     let sleep_duration = Duration::from_millis((options.ignore_subsequent_fails_ms + 1) as u64);
@@ -166,52 +151,52 @@ pub fn when_ignore_subsequent_fails_duration_has_elapsed_then_update_callback_is
         sleep(sleep_duration);
     }
 
-    test.expect_auth_failure_limit_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitReached);
 }
 
 #[test]
-fn when_file_is_deleted_and_new_one_is_created_then_changes_are_still_monitored() {
+pub fn when_file_is_deleted_and_new_one_is_created_then_changes_are_still_monitored() {
     let mut file = TestFile::not_empty();
     let options = AuthMonitorOptions::default();
-    let mut test = AuthMonitorTest::new(file.path(), options);
+    let mut auth_monitor = create_auth_monitor(file.path(), options);
     file.remove();
-    test.expect_auth_failure_limit_not_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
     file.create();
-    test.expect_auth_failure_limit_not_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
     file.write_auth_failed_messages(options.max_failed_attempts as usize);
-    test.expect_auth_failure_limit_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitReached);
 }
 
 #[test]
-fn when_file_is_renamed_and_new_one_is_created_then_changes_are_still_monitored() {
+pub fn when_file_is_renamed_and_new_one_is_created_then_changes_are_still_monitored() {
     let mut file = TestFile::not_empty();
     let options = AuthMonitorOptions::default();
-    let mut test = AuthMonitorTest::new(file.path(), options);
+    let mut auth_monitor = create_auth_monitor(file.path(), options);
 
     let filepath = String::from(file.path());
     let new_filepath = format!("{}.bak", file.path());
     file.rename(&new_filepath);
-    test.expect_auth_failure_limit_not_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
     let mut new_file = TestFile::new(&filepath);
-    test.expect_auth_failure_limit_not_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
     new_file.write_auth_failed_messages(options.max_failed_attempts as usize);
-    test.expect_auth_failure_limit_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitReached);
 }
 
 #[test]
-fn when_file_is_truncated_then_changes_are_still_monitored() {
+pub fn when_file_is_truncated_then_changes_are_still_monitored() {
     let mut file = TestFile::not_empty();
     file.write_other_messages(5);
 
     let options = AuthMonitorOptions::default();
-    let mut test = AuthMonitorTest::new(file.path(), options);
+    let mut auth_monitor = create_auth_monitor(file.path(), options);
 
     file.truncate();
-    test.expect_auth_failure_limit_not_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitNotReached);
 
     file.write_auth_failed_messages(options.max_failed_attempts as usize);
-    test.expect_auth_failure_limit_reached();
+    assert_eq!(auth_monitor.update(), AuthState::AuthFailureLimitReached);
 }