Refactor and extend AuthMonitor unit tests

FastAlien · FastAlien · commit 58550248c4c1 · 2024-02-29T20:02:06.000+01:00
diff --git a/src/auth_monitor.test.rs b/src/auth_monitor.test.rs
@@ -1,169 +1,181 @@
+use std::ops::Range;
 use std::thread::sleep;
 use std::time::Duration;
 
 use crate::auth_monitor::AuthMonitor;
 use crate::auth_monitor_options::AuthMonitorOptions;
 use crate::auth_monitor_params::AuthMonitorParams;
-use crate::test_utils::test_file::{create_log_line, TestFile};
+use crate::test_utils::test_file::TestFile;
 
-const AUTH_FAILED_TEST_MESSAGES: [&str; 2] = [
-    "workstation sudo: pam_unix(sudo:auth): authentication failure; logname=john uid=1000 euid=0 tty=/dev/pts/7 ruser=john rhost=  user=john",
-    "workstation kscreenlocker_greet: pam_unix(kde:auth): authentication failure; logname= uid=1000 euid=1000 tty= ruser= rhost=  user=john",
-];
-
-const OTHER_TEST_MESSAGES: [&str; 4] = [
-    "workstation dbus-daemon[1988]: [system] Failed to activate service 'org.bluez': timed out (service_start_timeout=25000ms)",
-    "workstation CRON[9419]: pam_unix(cron:session): session opened for user root(uid=0) by (uid=0)",
-    "workstation CRON[9419]: pam_unix(cron:session): session closed for user root",
-    "workstation PackageKit: uid 1000 is trying to obtain org.freedesktop.packagekit.system-sources-refresh auth (only_trusted:0)",
-];
+struct AuthMonitorTest {
+    auth_monitor: AuthMonitor,
+}
 
-#[test]
-pub fn when_max_failed_attempts_limit_is_reached_then_update_callback_is_called() {
-    for max_failed_attempts in 2..10 {
-        let mut file = TestFile::with_unique_name();
-        let mut auth_monitor = AuthMonitor::new(AuthMonitorParams {
-            filepath: String::from(file.path()),
-            options: AuthMonitorOptions {
-                max_failed_attempts,
-                ..AuthMonitorOptions::default()
-            },
+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 };
+    }
 
-        expect_no_update_callback_call(&mut auth_monitor);
-        expect_update_callback_is_not_called_after_writing_auth_failed_messages(
-            &mut auth_monitor,
-            &mut file,
-            (max_failed_attempts - 1) as usize,
-        );
-
-        expect_update_callback_is_not_called_after_writing_other_messages(
-            &mut auth_monitor,
-            &mut file,
-        );
-
-        expect_update_callback_is_called_after_writing_auth_failed_message(
-            &mut auth_monitor,
-            &mut file,
-        );
+    pub fn expect_no_update_callback_call(&mut self) {
+        self.auth_monitor.update(|| {
+            panic!("Callback call was not expected");
+        });
     }
-}
 
-fn expect_no_update_callback_call(auth_monitor: &mut AuthMonitor) {
-    auth_monitor.update(|| {
-        panic!("Callback call was not expected");
-    });
+    pub fn expect_update_callback_is_called_once(&mut self) {
+        let mut call_count = 0;
+        self.auth_monitor.update(|| {
+            call_count += 1;
+        });
+        assert_eq!(call_count, 1, "One callback call was expected")
+    }
 }
 
-fn expect_update_callback_is_not_called_after_writing_auth_failed_messages(
-    auth_monitor: &mut AuthMonitor,
-    file: &mut TestFile,
-    message_count: usize,
-) {
-    for i in 0usize..message_count {
-        let message_index = i % AUTH_FAILED_TEST_MESSAGES.len();
-        let message = create_log_line(AUTH_FAILED_TEST_MESSAGES[message_index]);
-        file.write(&message);
-        expect_no_update_callback_call(auth_monitor);
+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() {
+    let mut file = TestFile::with_unique_name();
+    file.remove();
+
+    let options = AuthMonitorOptions::default();
+    let mut test = AuthMonitorTest::new(file.path(), options);
+    test.expect_no_update_callback_call();
+
+    file.create();
+
+    for i in 0usize..(options.max_failed_attempts - 1) as usize {
+        file.write_auth_failed_message(i);
+        test.expect_no_update_callback_call();
     }
+
+    file.write_auth_failed_message(0);
+    test.expect_update_callback_is_called_once();
 }
 
-fn expect_update_callback_is_not_called_after_writing_other_messages(
-    auth_monitor: &mut AuthMonitor,
-    file: &mut TestFile,
-) {
-    for other_message in OTHER_TEST_MESSAGES {
-        let message = create_log_line(other_message);
-        file.write(&message);
-        expect_no_update_callback_call(auth_monitor);
+#[test]
+pub fn when_auth_failure_limit_is_reached_then_update_callback_is_invoked() {
+    for max_failed_attempts in MAX_FAILED_ATTEMPTS_TEST_RANGE {
+        let mut file = TestFile::with_unique_name();
+        let options = AuthMonitorOptions {
+            max_failed_attempts,
+            ..AuthMonitorOptions::default()
+        };
+        let mut test = AuthMonitorTest::new(file.path(), options);
+        test.expect_no_update_callback_call();
+
+        for i in 0usize..(max_failed_attempts - 1) as usize {
+            file.write_auth_failed_message(i);
+            test.expect_no_update_callback_call();
+        }
+
+        for i in 0usize..(max_failed_attempts * 2) as usize {
+            file.write_other_message(i);
+            test.expect_no_update_callback_call();
+        }
+
+        file.write_auth_failed_message(0);
+        test.expect_update_callback_is_called_once();
     }
 }
 
-fn expect_update_callback_is_called_after_writing_auth_failed_message(
-    auth_monitor: &mut AuthMonitor,
-    file: &mut TestFile,
-) {
-    let message = create_log_line(AUTH_FAILED_TEST_MESSAGES[0]);
-    file.write(&message);
-    expect_update_callback_is_called_once(auth_monitor);
-}
+#[test]
+pub fn when_auth_failure_limit_is_reached_between_updates_then_next_update_invokes_callback() {
+    for max_failed_attempts in MAX_FAILED_ATTEMPTS_TEST_RANGE {
+        let mut file = TestFile::with_unique_name();
+        let options = AuthMonitorOptions {
+            max_failed_attempts,
+            ..AuthMonitorOptions::default()
+        };
+        let mut test = AuthMonitorTest::new(file.path(), options);
+        test.expect_no_update_callback_call();
 
-fn expect_update_callback_is_called_once(auth_monitor: &mut AuthMonitor) {
-    let mut call_count = 0;
-    auth_monitor.update(|| call_count += 1);
-    assert_eq!(call_count, 1, "One callback call was expected")
+        file.write_auth_failed_messages(max_failed_attempts as usize);
+        file.write_other_messages(max_failed_attempts as usize);
+
+        test.expect_update_callback_is_called_once();
+    }
 }
 
 #[test]
-pub fn when_reset_after_seconds_passed_then_failed_attempts_count_is_reset() {
+pub fn when_reset_time_has_passed_then_reset_failed_attempt_counter() {
+    let mut file = TestFile::with_unique_name();
     let options = AuthMonitorOptions {
-        max_failed_attempts: 3,
         reset_after_seconds: 5,
+        ..AuthMonitorOptions::default()
     };
-    let mut file = TestFile::with_unique_name();
-    let mut auth_monitor = AuthMonitor::new(AuthMonitorParams {
-        filepath: String::from(file.path()),
-        options,
-    })
-    .expect("Error creating AuthMonitor");
-
-    expect_no_update_callback_call(&mut auth_monitor);
-    expect_update_callback_is_not_called_after_writing_auth_failed_messages(
-        &mut auth_monitor,
-        &mut file,
-        (options.max_failed_attempts - 1) as usize,
-    );
+    let mut test = AuthMonitorTest::new(file.path(), options);
+    test.expect_no_update_callback_call();
+
+    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_no_update_callback_call();
+    }
 
     let sleep_duration = Duration::from_secs((options.reset_after_seconds + 1) as u64);
     println!("Sleeping for {} sec", sleep_duration.as_secs());
     sleep(sleep_duration);
 
-    expect_update_callback_is_not_called_after_writing_auth_failed_messages(
-        &mut auth_monitor,
-        &mut file,
-        (options.max_failed_attempts - 1) as usize,
-    );
+    for i in 0usize..failed_attempts_safe_limit {
+        file.write_auth_failed_message(i);
+        test.expect_no_update_callback_call();
+    }
 
-    expect_update_callback_is_called_after_writing_auth_failed_message(
-        &mut auth_monitor,
-        &mut file,
-    );
+    file.write_auth_failed_message(0);
+    test.expect_update_callback_is_called_once();
 }
 
 #[test]
-pub fn when_max_failed_attempts_limit_is_reached_before_update_is_called_then_update_callback_is_called(
-) {
-    for max_failed_attempts in 2..10 {
-        let mut file = TestFile::with_unique_name();
-        let mut auth_monitor = AuthMonitor::new(AuthMonitorParams {
-            filepath: String::from(file.path()),
-            options: AuthMonitorOptions {
-                max_failed_attempts,
-                ..AuthMonitorOptions::default()
-            },
-        })
-        .expect("Error creating AuthMonitor");
+fn when_file_is_deleted_and_new_one_is_created_then_changes_are_still_monitored() {
+    let mut file = TestFile::with_unique_name();
+    let options = AuthMonitorOptions::default();
+    let mut test = AuthMonitorTest::new(file.path(), options);
+    file.remove();
+    test.expect_no_update_callback_call();
 
-        expect_no_update_callback_call(&mut auth_monitor);
-        write_auth_failed_messages(&mut file, max_failed_attempts as usize);
-        write_other_messages(&mut file, max_failed_attempts as usize);
-        expect_update_callback_is_called_once(&mut auth_monitor);
-    }
-}
+    file.create();
+    test.expect_no_update_callback_call();
 
-fn write_auth_failed_messages(file: &mut TestFile, count: usize) {
-    write_messages(file, &AUTH_FAILED_TEST_MESSAGES, count);
+    file.write_auth_failed_messages(options.max_failed_attempts as usize);
+    test.expect_update_callback_is_called_once();
 }
 
-fn write_other_messages(file: &mut TestFile, count: usize) {
-    write_messages(file, &OTHER_TEST_MESSAGES, count);
+#[test]
+fn when_file_is_renamed_and_new_one_is_created_then_changes_are_still_monitored() {
+    let mut file = TestFile::with_unique_name();
+    let options = AuthMonitorOptions::default();
+    let mut test = AuthMonitorTest::new(file.path(), options);
+
+    let filepath = String::from(file.path());
+    let new_filepath = format!("{}.bak", file.path());
+    file.rename(&new_filepath);
+    test.expect_no_update_callback_call();
+
+    let mut new_file = TestFile::new(&filepath);
+    test.expect_no_update_callback_call();
+    new_file.write_auth_failed_messages(options.max_failed_attempts as usize);
+    test.expect_update_callback_is_called_once();
 }
 
-fn write_messages(file: &mut TestFile, messages: &[&str], count: usize) {
-    for i in 0usize..count {
-        let message_index = i % messages.len();
-        let message = create_log_line(messages[message_index]);
-        file.write(&message);
-    }
+#[test]
+fn when_file_is_truncated_then_changes_are_still_monitored() {
+    let mut file = TestFile::with_unique_name();
+    file.write_other_messages(5);
+
+    let options = AuthMonitorOptions::default();
+    let mut test = AuthMonitorTest::new(file.path(), options);
+
+    file.truncate();
+    test.expect_no_update_callback_call();
+
+    file.write_auth_failed_messages(options.max_failed_attempts as usize);
+    test.expect_update_callback_is_called_once();
 }
diff --git a/src/test_utils/test_file.rs b/src/test_utils/test_file.rs
@@ -5,6 +5,18 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 
 use chrono::Local;
 
+const AUTH_FAILED_TEST_MESSAGES: [&str; 2] = [
+    "workstation sudo: pam_unix(sudo:auth): authentication failure; logname=john uid=1000 euid=0 tty=/dev/pts/7 ruser=john rhost=  user=john",
+    "workstation kscreenlocker_greet: pam_unix(kde:auth): authentication failure; logname= uid=1000 euid=1000 tty= ruser= rhost=  user=john",
+];
+
+const OTHER_TEST_MESSAGES: [&str; 4] = [
+    "workstation dbus-daemon[1988]: [system] Failed to activate service 'org.bluez': timed out (service_start_timeout=25000ms)",
+    "workstation CRON[9419]: pam_unix(cron:session): session opened for user root(uid=0) by (uid=0)",
+    "workstation CRON[9419]: pam_unix(cron:session): session closed for user root",
+    "workstation PackageKit: uid 1000 is trying to obtain org.freedesktop.packagekit.system-sources-refresh auth (only_trusted:0)",
+];
+
 pub struct TestFile {
     path: String,
     file: File,
@@ -53,6 +65,30 @@ impl TestFile {
         assert_eq!(bytes_written, bytes_to_add.len());
     }
 
+    pub fn write_auth_failed_messages(&mut self, count: usize) {
+        for i in 0usize..count {
+            self.write_auth_failed_message(i);
+        }
+    }
+
+    pub fn write_auth_failed_message(&mut self, index: usize) {
+        let message_index = index % AUTH_FAILED_TEST_MESSAGES.len();
+        let message = create_log_line(AUTH_FAILED_TEST_MESSAGES[message_index]);
+        self.write(&message);
+    }
+
+    pub fn write_other_messages(&mut self, count: usize) {
+        for i in 0usize..count {
+            self.write_other_message(i);
+        }
+    }
+
+    pub fn write_other_message(&mut self, index: usize) {
+        let message_index = index % OTHER_TEST_MESSAGES.len();
+        let message = create_log_line(OTHER_TEST_MESSAGES[message_index]);
+        self.write(&message);
+    }
+
     pub fn truncate(&mut self) {
         println!("Truncating test file: {}", self.path);
         self.file.set_len(0).expect("Error truncating file");
