test(bpf): add chmod operation to bpf unit test

This allows us to exercise the trace_path_chmod bpf program on unit
tests.

Author: Molter73

fact/src/bpf/mod.rs

@@ -228,15 +228,14 @@ impl Bpf {
 
 #[cfg(all(test, feature = "bpf-test"))]
 mod bpf_tests {
-    use std::{env, path::PathBuf, time::Duration};
+    use std::{env, os::unix::fs::PermissionsExt, path::PathBuf, time::Duration};
 
-    use fact_ebpf::file_activity_type_t;
     use tempfile::NamedTempFile;
     use tokio::{sync::watch, time::timeout};
 
     use crate::{
         config::{reloader::Reloader, FactConfig},
-        event::process::Process,
+        event::{process::Process, EventTestData},
         host_info,
         metrics::exporter::Exporter,
     };
@@ -273,20 +272,39 @@ mod bpf_tests {
         let file = NamedTempFile::new_in(monitored_path).expect("Failed to create temporary file");
         println!("Created {file:?}");
 
+        // Trigger permission changes
+        let mut perms = file
+            .path()
+            .metadata()
+            .expect("Failed to read file permissions")
+            .permissions();
+        let old_perm = perms.mode() as u16;
+        let new_perm: u16 = 0o666;
+        perms.set_mode(new_perm as u32);
+        std::fs::set_permissions(file.path(), perms).expect("Failed to set file permissions");
+
         let current = Process::current();
         let file_path = file.path().to_path_buf();
 
         let expected_events = [
             Event::new(
-                file_activity_type_t::FILE_ACTIVITY_CREATION,
+                EventTestData::Creation,
+                host_info::get_hostname(),
+                file_path.clone(),
+                PathBuf::new(), // host path is resolved by HostScanner
+                current.clone(),
+            )
+            .unwrap(),
+            Event::new(
+                EventTestData::Chmod(new_perm, old_perm),
                 host_info::get_hostname(),
                 file_path.clone(),
                 PathBuf::new(), // host path is resolved by HostScanner
                 current.clone(),
             )
             .unwrap(),
             Event::new(
-                file_activity_type_t::FILE_ACTIVITY_UNLINK,
+                EventTestData::Unlink,
                 host_info::get_hostname(),
                 file_path,
                 PathBuf::new(), // host path is resolved by HostScanner
@@ -298,12 +316,13 @@ mod bpf_tests {
         // Close the file, removing it
         file.close().expect("Failed to close temp file");
 
-        println!("Expected: {expected_events:?}");
         let wait = timeout(Duration::from_secs(1), async move {
             for expected in expected_events {
+                println!("expected: {expected:#?}");
                 while let Some(event) = rx.recv().await {
-                    println!("{event:?}");
+                    println!("{event:#?}");
                     if event == expected {
+                        println!("Found!");
                         break;
                     }
                 }

fact/src/event/mod.rs

@@ -21,6 +21,14 @@ fn timestamp_to_proto(ts: u64) -> prost_types::Timestamp {
     prost_types::Timestamp { seconds, nanos }
 }
 
+#[cfg(test)]
+#[derive(Debug)]
+pub(crate) enum EventTestData {
+    Creation,
+    Unlink,
+    Chmod(u16, u16),
+}
+
 #[derive(Debug, Clone, Serialize)]
 pub struct Event {
     timestamp: u64,
@@ -31,8 +39,8 @@ pub struct Event {
 
 impl Event {
     #[cfg(test)]
-    pub fn new(
-        event_type: file_activity_type_t,
+    pub(crate) fn new(
+        data: EventTestData,
         hostname: &'static str,
         filename: PathBuf,
         host_file: PathBuf,
@@ -47,11 +55,17 @@ impl Event {
             host_file,
             inode: Default::default(),
         };
-        let file = match event_type {
-            file_activity_type_t::FILE_ACTIVITY_OPEN => FileData::Open(inner),
-            file_activity_type_t::FILE_ACTIVITY_CREATION => FileData::Creation(inner),
-            file_activity_type_t::FILE_ACTIVITY_UNLINK => FileData::Unlink(inner),
-            invalid => unreachable!("Invalid event type: {invalid:?}"),
+        let file = match data {
+            EventTestData::Creation => FileData::Creation(inner),
+            EventTestData::Unlink => FileData::Unlink(inner),
+            EventTestData::Chmod(new_mode, old_mode) => {
+                let data = ChmodFileData {
+                    inner,
+                    new_mode,
+                    old_mode,
+                };
+                FileData::Chmod(data)
+            }
         };
 
         Ok(Event {
@@ -193,6 +207,7 @@ impl PartialEq for FileData {
             (FileData::Open(this), FileData::Open(other)) => this == other,
             (FileData::Creation(this), FileData::Creation(other)) => this == other,
             (FileData::Unlink(this), FileData::Unlink(other)) => this == other,
+            (FileData::Chmod(this), FileData::Chmod(other)) => this == other,
             _ => false,
         }
     }
@@ -271,3 +286,12 @@ impl From<ChmodFileData> for fact_api::FilePermissionChange {
         }
     }
 }
+
+#[cfg(test)]
+impl PartialEq for ChmodFileData {
+    fn eq(&self, other: &Self) -> bool {
+        self.new_mode == other.new_mode
+            && self.old_mode == other.old_mode
+            && self.inner == other.inner
+    }
+}