test: init

Author: h-a-n-a

crates/rspack_watcher/tests/helpers/macros.rs

@@ -0,0 +1,92 @@
+#[macro_export]
+macro_rules! empty {
+  () => {
+    (std::iter::empty(), std::iter::empty())
+  };
+}
+
+#[macro_export]
+macro_rules! paths {
+  ($($path:expr),*) => {
+    (vec![$(rspack_paths::ArcPath::from($path)),*].into_iter(), std::iter::empty())
+  };
+}
+
+#[macro_export]
+macro_rules! helper {
+  ($options:expr) => {
+    helper!($options, Default::default())
+  };
+  ($options:expr, $ignore:expr) => {
+    crate::helpers::TestHelper::new(|| rspack_watcher::FsWatcher::new($options, $ignore))
+  };
+}
+
+#[macro_export]
+macro_rules! counter {
+  () => {
+    std::sync::atomic::AtomicU8::new(0)
+  };
+}
+
+#[macro_export]
+macro_rules! arc_counter {
+  () => {
+    std::sync::Arc::new(std::sync::atomic::AtomicU8::new(0))
+  };
+}
+
+#[macro_export]
+macro_rules! add {
+  ($c:expr) => {
+    $c.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
+  };
+}
+
+#[macro_export]
+macro_rules! load {
+  ($c:expr) => {
+    $c.load(std::sync::atomic::Ordering::SeqCst)
+  };
+}
+
+#[macro_export]
+macro_rules! watch {
+  ($helper:expr, $($files:expr),*) => {
+    watch!(files @ $helper, $($files),*)
+  };
+  ($helper:expr, _, $($dirs:expr),*) => {
+    watch!(dirs @ $helper, $($dirs),*)
+  };
+  ($helper:expr, _, _, $($missing:expr),*) => {
+    watch!(missing @ $helper, $($missing),*)
+  };
+
+  (files @ $helper:expr, $($files:expr),*) => {
+    $helper.watch(paths!($($files),*), empty!(), empty!())
+  };
+  (dirs @ $helper:expr, $($dirs:expr),*) => {
+    $helper.watch(empty!(), paths!($($dirs),*), empty!())
+  };
+  (missing @ $helper:expr, $($missing:expr),*) => {
+    $helper.watch(empty!(), empty!(), paths!($($missing),*))
+  };
+}
+
+#[macro_export]
+macro_rules! assert_no_events {
+  ($change_events:expr, $aggregated_events:expr) => {
+    assert_eq!(
+      load!($change_events),
+      0,
+      "Expected no change events but got {}",
+      load!($change_events)
+    );
+    assert_eq!(
+      load!($aggregated_events),
+      0,
+      "Expected no aggregated events but got {}",
+      load!($aggregated_events)
+    );
+  };
+}

crates/rspack_watcher/tests/helpers/mod.rs

@@ -1,5 +1,7 @@
 #![allow(clippy::unwrap_used)]
 
+pub mod macros;
+
 use std::{
   mem::ManuallyDrop,
   path::PathBuf,
@@ -16,6 +18,8 @@ use rspack_watcher::{EventAggregateHandler, EventHandler, FsWatcher};
 use tempfile::TempDir;
 use tokio::sync::RwLock;
 
+const TEST_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
+
 pub struct TestHelper {
   /// Temporary directory for testing
   temp_dir: ManuallyDrop<TempDir>,
@@ -163,13 +167,19 @@ impl TestHelper {
     .unwrap();
   }
 
-  pub fn collect_events(
+  /// Collects events from the receiver in a blocking manner.
+  ///
+  /// The `on_changed` and `on_aggregated` callbacks are invoked for each respective event.
+  /// If either callback sets the `abort` flag to `true`, the collection stops.
+  ///
+  /// The function will timeout after a predefined duration (10s) if no events are received.
+  pub fn collect_events_blocking(
     &self,
     rx: Receiver<Event>,
     mut on_changed: impl FnMut(&ChangedEvent, &mut bool),
     mut on_aggregated: impl FnMut(&AggregatedEvent, &mut bool),
   ) {
-    while let Ok(event) = rx.recv_timeout(std::time::Duration::from_secs(10)) {
+    while let Ok(event) = rx.recv_timeout(TEST_TIMEOUT) {
       match event {
         Event::Aggregated(agg_event) => {
           let mut abort = false;
@@ -189,11 +199,50 @@ impl TestHelper {
     }
   }
 
+  /// Collects events from the receiver in a separate thread.
+  ///
+  /// The `on_changed` and `on_aggregated` callbacks are invoked for each respective event.
+  /// If either callback sets the `abort` flag to `true`, the collection stops.
+  ////
+  /// The function will timeout after a predefined duration (10s) if no events are received.
+  pub fn collect_events(
+    &self,
+    rx: Receiver<Event>,
+    on_changed: impl Fn(&ChangedEvent, &mut bool) + Send + 'static,
+    on_aggregated: impl Fn(&AggregatedEvent, &mut bool) + Send + 'static,
+  ) {
+    std::thread::spawn(move || {
+      while let Ok(event) = rx.recv_timeout(TEST_TIMEOUT) {
+        match event {
+          Event::Aggregated(agg_event) => {
+            let mut abort = false;
+            on_aggregated(&agg_event, &mut abort);
+            if abort {
+              break;
+            }
+          }
+          Event::Changed(chg_event) => {
+            let mut abort = false;
+            on_changed(&chg_event, &mut abort);
+            if abort {
+              break;
+            }
+          }
+        }
+      }
+    });
+  }
+
   pub fn tick(&self, f: impl FnOnce()) {
     std::thread::sleep(std::time::Duration::from_millis(200));
     f();
   }
 
+  pub fn tick_ms(&self, duration: u64, f: impl FnOnce()) {
+    std::thread::sleep(std::time::Duration::from_millis(duration));
+    f();
+  }
+
   /// Watches the specified files, directories, and missing paths.
   ///
   /// All paths are relative to the temporary directory.

crates/rspack_watcher/tests/watcher.rs

@@ -1,97 +1,120 @@
 #![allow(dead_code)]
 
-use std::sync::atomic::AtomicU8;
+use std::sync::{Arc, atomic::AtomicU8};
 
 use rspack_paths::ArcPath;
-use rspack_watcher::{FsWatcher, FsWatcherOptions};
+use rspack_regex::RspackRegex;
+use rspack_watcher::{FsWatcher, FsWatcherIgnored, FsWatcherOptions};
 
 mod helpers;
 
-macro_rules! e {
-  () => {
-    (std::iter::empty(), std::iter::empty())
-  };
-}
-
-macro_rules! f {
-  ($($file:expr),*) => {
-    (vec![$(ArcPath::from($file)),*].into_iter(), std::iter::empty())
-  };
-}
-
-macro_rules! h {
-  ($options:expr) => {
-    h!($options, Default::default())
-  };
-  ($options:expr, $ignore:expr) => {
-    helpers::TestHelper::new(|| FsWatcher::new($options, $ignore))
-  };
-}
-
-macro_rules! c {
-  () => {
-    AtomicU8::new(0)
-  };
-}
-
-macro_rules! add {
-  ($c:expr) => {
-    $c.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
-  };
-}
-
-macro_rules! load {
-  ($c:expr) => {
-    $c.load(std::sync::atomic::Ordering::SeqCst)
-  };
-}
-
-macro_rules! watch {
-  ($helper:expr, $($files:expr),*) => {
-    watch!(files @ $helper, $($files),*)
-  };
-  ($helper:expr, _, $($dirs:expr),*) => {
-    watch!(dirs @ $helper, $($dirs),*)
-  };
-  ($helper:expr, _, _, $($missing:expr),*) => {
-    watch!(missing @ $helper, $($missing),*)
-  };
-
-  (files @ $helper:expr, $($files:expr),*) => {
-    $helper.watch(f!($($files),*), e!(), e!())
-  };
-  (dirs @ $helper:expr, $($dirs:expr),*) => {
-    $helper.watch(e!(), f!($($dirs),*), e!())
-  };
-  (missing @ $helper:expr, $($missing:expr),*) => {
-    $helper.watch(e!(), e!(), f!($($missing),*))
-  };
-}
-
 #[test]
 fn should_watch_a_single_file() {
-  let mut helper = h!(FsWatcherOptions {
+  let mut h = helper!(FsWatcherOptions {
     aggregate_timeout: Some(1000),
     ..Default::default()
   });
 
-  let rx = watch!(helper, "a");
+  let rx = watch!(h, "a");
 
-  helper.tick(|| {
-    helper.file("a");
+  h.tick(|| {
+    h.file("a");
   });
 
-  let change_events = c!();
-  helper.collect_events(
+  let change_events = counter!();
+
+  h.collect_events_blocking(
     rx,
     |file, _| {
-      file.assert_path(helper.join("a"));
+      file.assert_path(h.join("a"));
       add!(change_events);
     },
     |changes, abort| {
-      changes.assert_changed(helper.join("a"));
+      changes.assert_changed(h.join("a"));
       assert!(load!(change_events) > 0);
       *abort = true;
     },
   );
 }
+
+#[test]
+fn should_not_watch_a_single_ignored_file_glob() {
+  let mut h = helper!(
+    FsWatcherOptions {
+      aggregate_timeout: Some(300),
+      ..Default::default()
+    },
+    FsWatcherIgnored::Path("**/a".to_string())
+  );
+
+  let rx = watch!(h, "a");
+
+  let change_events = arc_counter!();
+  let aggregated_events = arc_counter!();
+
+  h.tick(|| {
+    h.file("a");
+    h.tick_ms(1000, || {
+      {
+        let change_events = change_events.clone();
+        let aggregated_events = aggregated_events.clone();
+
+        h.collect_events(
+          rx,
+          move |_file, _abort| {
+            add!(change_events);
+          },
+          move |_changes, _abort| {
+            add!(aggregated_events);
+          },
+        );
+      }
+
+      assert_no_events!(change_events, aggregated_events);
+    });
+  });
+}
+
+#[test]
+fn should_not_watch_a_single_ignored_file_regexp() {
+  let mut h = helper!(
+    FsWatcherOptions {
+      aggregate_timeout: Some(300),
+      ..Default::default()
+    },
+    FsWatcherIgnored::Regex(RspackRegex::new(r"/a$").unwrap())
+  );
+
+  let rx = watch!(h, "a");
+
+  let change_events = arc_counter!();
+  let aggregated_events = arc_counter!();
+
+  h.tick(|| {
+    h.file("a");
+    h.tick_ms(1000, || {
+      {
+        let change_events = change_events.clone();
+        let aggregated_events = aggregated_events.clone();
+
+        h.collect_events(
+          rx,
+          move |_file, _abort| {
+            add!(change_events);
+          },
+          move |_changes, _abort| {
+            add!(aggregated_events);
+          },
+        );
+      }
+
+      assert_no_events!(change_events, aggregated_events);
+    });
+  });
+}
+
+#[test]
+#[ignore]
+fn should_not_watch_a_single_ignored_file_function() {
+  todo!("FsWatcherIgnored::Function")
+}