1use std::{
4 fmt,
5 hash::{Hash, Hasher},
6 path::PathBuf,
7};
8
9use bitflags::bitflags;
10
11#[cfg(feature = "serde")]
12use serde::{Deserialize, Serialize};
13
14#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
16#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
17#[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
18pub enum AccessMode {
19 Any,
21
22 Execute,
24
25 Read,
27
28 Write,
30
31 Other,
33}
34
35#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
37#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
38#[cfg_attr(feature = "serde", serde(tag = "kind", content = "mode"))]
39#[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
40pub enum AccessKind {
41 Any,
43
44 Read,
46
47 Open(AccessMode),
49
50 Close(AccessMode),
52
53 Other,
55}
56
57#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
59#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
60#[cfg_attr(feature = "serde", serde(tag = "kind"))]
61#[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
62pub enum CreateKind {
63 Any,
65
66 File,
68
69 Folder,
71
72 Other,
74}
75
76#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
78#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
79#[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
80pub enum DataChange {
81 Any,
83
84 Size,
86
87 Content,
89
90 Other,
92}
93
94#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
96#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
97#[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
98pub enum MetadataKind {
99 Any,
101
102 AccessTime,
104
105 WriteTime,
107
108 Permissions,
110
111 Ownership,
113
114 Extended,
119
120 Other,
122}
123
124#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
126#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
127#[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
128pub enum RenameMode {
129 Any,
131
132 To,
134
135 From,
137
138 Both,
143
144 Other,
146}
147
148#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
150#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
151#[cfg_attr(feature = "serde", serde(tag = "kind", content = "mode"))]
152#[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
153pub enum ModifyKind {
154 Any,
156
157 Data(DataChange),
159
160 Metadata(MetadataKind),
162
163 #[cfg_attr(feature = "serde", serde(rename = "rename"))]
165 Name(RenameMode),
166
167 Other,
169}
170
171#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
173#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
174#[cfg_attr(feature = "serde", serde(tag = "kind"))]
175#[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
176pub enum RemoveKind {
177 Any,
179
180 File,
182
183 Folder,
185
186 Other,
188}
189
190#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
196#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
197#[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
198#[cfg_attr(
199 all(feature = "serde", not(feature = "serialization-compat-6")),
200 serde(tag = "type")
201)]
202pub enum EventKind {
203 #[default]
211 Any,
212
213 Access(AccessKind),
221
222 Create(CreateKind),
227
228 Modify(ModifyKind),
233
234 Remove(RemoveKind),
243
244 Other,
248}
249
250impl EventKind {
251 #[must_use]
253 pub fn is_access(&self) -> bool {
254 matches!(self, EventKind::Access(_))
255 }
256
257 #[must_use]
259 pub fn is_create(&self) -> bool {
260 matches!(self, EventKind::Create(_))
261 }
262
263 #[must_use]
265 pub fn is_modify(&self) -> bool {
266 matches!(self, EventKind::Modify(_))
267 }
268
269 #[must_use]
271 pub fn is_remove(&self) -> bool {
272 matches!(self, EventKind::Remove(_))
273 }
274
275 #[must_use]
277 pub fn is_other(&self) -> bool {
278 matches!(self, EventKind::Other)
279 }
280}
281
282bitflags! {
283 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
306 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
307 pub struct EventKindMask: u32 {
308 const CREATE = 0b0000_0001;
310
311 const REMOVE = 0b0000_0010;
313
314 const MODIFY_DATA = 0b0000_0100;
316
317 const MODIFY_META = 0b0000_1000;
319
320 const MODIFY_NAME = 0b0001_0000;
322
323 const ACCESS_OPEN = 0b0010_0000;
325
326 const ACCESS_CLOSE = 0b0100_0000;
329
330 const ACCESS_CLOSE_NOWRITE = 0b1000_0000;
334
335 const ALL_MODIFY = Self::MODIFY_DATA.bits() | Self::MODIFY_META.bits() | Self::MODIFY_NAME.bits();
337
338 const ALL_ACCESS = Self::ACCESS_OPEN.bits() | Self::ACCESS_CLOSE.bits() | Self::ACCESS_CLOSE_NOWRITE.bits();
340
341 const CORE = Self::CREATE.bits() | Self::REMOVE.bits() | Self::ALL_MODIFY.bits();
343
344 const ALL = Self::CORE.bits() | Self::ALL_ACCESS.bits();
347 }
348}
349
350impl Default for EventKindMask {
351 fn default() -> Self {
352 EventKindMask::ALL
353 }
354}
355
356impl EventKindMask {
357 #[must_use]
377 pub fn matches(&self, kind: &EventKind) -> bool {
378 match kind {
379 EventKind::Any | EventKind::Other => true,
381
382 EventKind::Create(_) => self.intersects(EventKindMask::CREATE),
384
385 EventKind::Remove(_) => self.intersects(EventKindMask::REMOVE),
387
388 EventKind::Modify(modify_kind) => match modify_kind {
390 ModifyKind::Data(_) => self.intersects(EventKindMask::MODIFY_DATA),
391 ModifyKind::Metadata(_) => self.intersects(EventKindMask::MODIFY_META),
392 ModifyKind::Name(_) => self.intersects(EventKindMask::MODIFY_NAME),
393 ModifyKind::Any | ModifyKind::Other => self.intersects(EventKindMask::ALL_MODIFY),
395 },
396
397 EventKind::Access(access_kind) => match access_kind {
399 AccessKind::Open(_) => self.intersects(EventKindMask::ACCESS_OPEN),
400 AccessKind::Close(AccessMode::Write) => {
402 self.intersects(EventKindMask::ACCESS_CLOSE)
403 }
404 AccessKind::Close(AccessMode::Read) => {
406 self.intersects(EventKindMask::ACCESS_CLOSE_NOWRITE)
407 }
408 AccessKind::Close(_) => self
410 .intersects(EventKindMask::ACCESS_CLOSE | EventKindMask::ACCESS_CLOSE_NOWRITE),
411 AccessKind::Read | AccessKind::Any | AccessKind::Other => {
413 self.intersects(EventKindMask::ALL_ACCESS)
414 }
415 },
416 }
417 }
418}
419
420#[derive(Clone)]
425#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
426pub struct Event {
427 #[cfg_attr(
449 all(feature = "serde", not(feature = "serialization-compat-6")),
450 serde(flatten)
451 )]
452 #[cfg_attr(
453 all(feature = "serde", feature = "serialization-compat-6"),
454 serde(rename = "type")
455 )]
456 pub kind: EventKind,
457
458 pub paths: Vec<PathBuf>,
471
472 #[cfg_attr(feature = "serde", serde(default))]
499 pub attrs: EventAttributes,
500}
501
502#[derive(Clone, Default, Debug)]
507#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
508pub struct EventAttributes {
509 #[cfg_attr(feature = "serde", serde(flatten))]
510 inner: Option<Box<EventAttributesInner>>,
511}
512
513#[derive(Clone, Default, Debug)]
514#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
515struct EventAttributesInner {
516 #[cfg_attr(
518 feature = "serde",
519 serde(default, skip_serializing_if = "Option::is_none")
520 )]
521 tracker: Option<usize>,
522
523 #[cfg_attr(
525 feature = "serde",
526 serde(default, skip_serializing_if = "Option::is_none")
527 )]
528 flag: Option<Flag>,
529
530 #[cfg_attr(
532 feature = "serde",
533 serde(default, skip_serializing_if = "Option::is_none")
534 )]
535 info: Option<String>,
536
537 #[cfg_attr(
539 feature = "serde",
540 serde(default, skip_serializing_if = "Option::is_none")
541 )]
542 source: Option<String>,
543
544 #[cfg_attr(
549 feature = "serde",
550 serde(default, skip_serializing, skip_deserializing)
551 )]
552 process_id: Option<u32>,
553}
554
555impl EventAttributes {
556 #[must_use]
558 pub fn new() -> Self {
559 Self { inner: None }
560 }
561
562 #[must_use]
575 pub fn tracker(&self) -> Option<usize> {
576 self.inner.as_ref().and_then(|inner| inner.tracker)
577 }
578
579 #[must_use]
581 pub fn flag(&self) -> Option<Flag> {
582 self.inner.as_ref().and_then(|inner| inner.flag)
583 }
584
585 #[must_use]
617 pub fn info(&self) -> Option<&str> {
618 self.inner.as_ref().and_then(|inner| inner.info.as_deref())
619 }
620
621 #[must_use]
629 pub fn source(&self) -> Option<&str> {
630 self.inner
631 .as_ref()
632 .and_then(|inner| inner.source.as_deref())
633 }
634
635 #[must_use]
640 pub fn process_id(&self) -> Option<u32> {
641 self.inner.as_ref().and_then(|inner| inner.process_id)
642 }
643
644 pub fn set_tracker(&mut self, tracker: usize) {
646 self.inner_mut().tracker = Some(tracker);
647 }
648
649 pub fn set_flag(&mut self, flag: Flag) {
651 self.inner_mut().flag = Some(flag);
652 }
653
654 pub fn set_info(&mut self, info: &str) {
658 self.inner_mut().info = Some(info.to_string());
659 }
660
661 pub fn set_process_id(&mut self, process_id: u32) {
663 self.inner_mut().process_id = Some(process_id)
664 }
665
666 fn inner_mut(&mut self) -> &mut EventAttributesInner {
667 self.inner.get_or_insert_with(Box::default)
668 }
669}
670
671#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
676#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
677#[cfg_attr(
678 all(feature = "serde", not(feature = "serialization-compat-6")),
679 serde(rename_all = "camelCase")
680)]
681pub enum Flag {
682 Rescan,
690}
691
692impl Event {
693 #[must_use]
698 pub fn need_rescan(&self) -> bool {
699 matches!(self.flag(), Some(Flag::Rescan))
700 }
701 #[must_use]
703 pub fn tracker(&self) -> Option<usize> {
704 self.attrs.tracker()
705 }
706
707 #[must_use]
709 pub fn flag(&self) -> Option<Flag> {
710 self.attrs.flag()
711 }
712
713 #[must_use]
715 pub fn info(&self) -> Option<&str> {
716 self.attrs.info()
717 }
718
719 #[must_use]
721 pub fn source(&self) -> Option<&str> {
722 self.attrs.source()
723 }
724
725 #[must_use]
727 pub fn new(kind: EventKind) -> Self {
728 Self {
729 kind,
730 paths: Vec::new(),
731 attrs: EventAttributes::new(),
732 }
733 }
734
735 #[must_use]
737 pub fn set_kind(mut self, kind: EventKind) -> Self {
738 self.kind = kind;
739 self
740 }
741
742 #[must_use]
744 pub fn add_path(mut self, path: PathBuf) -> Self {
745 self.paths.push(path);
746 self
747 }
748
749 #[must_use]
751 pub fn add_some_path(self, path: Option<PathBuf>) -> Self {
752 if let Some(path) = path {
753 self.add_path(path)
754 } else {
755 self
756 }
757 }
758
759 #[must_use]
761 pub fn set_tracker(mut self, tracker: usize) -> Self {
762 self.attrs.set_tracker(tracker);
763 self
764 }
765
766 #[must_use]
768 pub fn set_info(mut self, info: &str) -> Self {
769 self.attrs.set_info(info);
770 self
771 }
772
773 #[must_use]
775 pub fn set_flag(mut self, flag: Flag) -> Self {
776 self.attrs.set_flag(flag);
777 self
778 }
779
780 #[must_use]
782 pub fn set_process_id(mut self, process_id: u32) -> Self {
783 self.attrs.set_process_id(process_id);
784 self
785 }
786}
787
788impl fmt::Debug for Event {
789 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
790 f.debug_struct("Event")
791 .field("kind", &self.kind)
792 .field("paths", &self.paths)
793 .field("attr:tracker", &self.tracker())
794 .field("attr:flag", &self.flag())
795 .field("attr:info", &self.info())
796 .field("attr:source", &self.source())
797 .finish()
798 }
799}
800impl Default for Event {
801 fn default() -> Self {
802 Self {
803 kind: EventKind::default(),
804 paths: Vec::new(),
805 attrs: EventAttributes::new(),
806 }
807 }
808}
809
810impl Eq for Event {}
811impl PartialEq for Event {
812 fn eq(&self, other: &Self) -> bool {
813 self.kind.eq(&other.kind)
814 && self.paths.eq(&other.paths)
815 && self.tracker().eq(&other.tracker())
816 && self.flag().eq(&other.flag())
817 && self.info().eq(&other.info())
818 && self.source().eq(&other.source())
819 }
820}
821
822impl Hash for Event {
823 fn hash<H: Hasher>(&self, state: &mut H) {
824 self.kind.hash(state);
825 self.paths.hash(state);
826 self.tracker().hash(state);
827 self.flag().hash(state);
828 self.info().hash(state);
829 self.source().hash(state);
830 }
831}
832
833#[cfg(test)]
834mod event_kind_mask_tests {
835 use super::*;
836
837 #[test]
838 fn default_is_all() {
839 assert_eq!(EventKindMask::default(), EventKindMask::ALL);
840 }
841
842 #[test]
843 fn matches_create_events() {
844 let mask = EventKindMask::CREATE;
845 assert!(mask.matches(&EventKind::Create(CreateKind::File)));
846 assert!(mask.matches(&EventKind::Create(CreateKind::Folder)));
847 assert!(mask.matches(&EventKind::Create(CreateKind::Any)));
848 assert!(mask.matches(&EventKind::Create(CreateKind::Other)));
849 assert!(!mask.matches(&EventKind::Remove(RemoveKind::File)));
850 }
851
852 #[test]
853 fn matches_remove_events() {
854 let mask = EventKindMask::REMOVE;
855 assert!(mask.matches(&EventKind::Remove(RemoveKind::File)));
856 assert!(mask.matches(&EventKind::Remove(RemoveKind::Folder)));
857 assert!(mask.matches(&EventKind::Remove(RemoveKind::Any)));
858 assert!(!mask.matches(&EventKind::Create(CreateKind::File)));
859 }
860
861 #[test]
862 fn matches_access_open_events() {
863 let mask = EventKindMask::ACCESS_OPEN;
864 assert!(mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
865 assert!(mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Read))));
866 assert!(mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Write))));
867 assert!(!mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
868 assert!(!mask.matches(&EventKind::Create(CreateKind::File)));
869 }
870
871 #[test]
872 fn matches_access_close_events() {
873 let mask = EventKindMask::ACCESS_CLOSE;
875 assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
876 assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Any)))); assert!(!mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Read)))); assert!(!mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
879 }
880
881 #[test]
882 fn matches_access_close_nowrite_events() {
883 let mask = EventKindMask::ACCESS_CLOSE_NOWRITE;
885 assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Read))));
886 assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Any)))); assert!(!mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write)))); assert!(!mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
889 }
890
891 #[test]
892 fn combined_close_masks_match_both() {
893 let mask = EventKindMask::ACCESS_CLOSE | EventKindMask::ACCESS_CLOSE_NOWRITE;
895 assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
896 assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Read))));
897 assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Any))));
898 }
899
900 #[test]
901 fn all_access_matches_open_close_read_any_other() {
902 let mask = EventKindMask::ALL_ACCESS;
903 assert!(mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Read))));
904 assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
905 assert!(mask.matches(&EventKind::Access(AccessKind::Read)));
906 assert!(mask.matches(&EventKind::Access(AccessKind::Any)));
907 assert!(mask.matches(&EventKind::Access(AccessKind::Other)));
908 }
909
910 #[test]
911 fn matches_modify_data_events() {
912 let mask = EventKindMask::MODIFY_DATA;
913 assert!(mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
914 assert!(mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Size))));
915 assert!(mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Content))));
916 assert!(!mask.matches(&EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any))));
917 assert!(!mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::From))));
918 }
919
920 #[test]
921 fn matches_modify_metadata_events() {
922 let mask = EventKindMask::MODIFY_META;
923 assert!(mask.matches(&EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any))));
924 assert!(mask.matches(&EventKind::Modify(ModifyKind::Metadata(
925 MetadataKind::Permissions
926 ))));
927 assert!(!mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
928 }
929
930 #[test]
931 fn matches_modify_name_events() {
932 let mask = EventKindMask::MODIFY_NAME;
933 assert!(mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::From))));
934 assert!(mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::To))));
935 assert!(mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::Both))));
936 assert!(!mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
937 }
938
939 #[test]
940 fn all_modify_matches_data_meta_name() {
941 let mask = EventKindMask::ALL_MODIFY;
942 assert!(mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
943 assert!(mask.matches(&EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any))));
944 assert!(mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::From))));
945 assert!(mask.matches(&EventKind::Modify(ModifyKind::Any)));
946 assert!(mask.matches(&EventKind::Modify(ModifyKind::Other)));
947 }
948
949 #[test]
950 fn any_and_other_always_pass() {
951 let empty = EventKindMask::empty();
952 assert!(empty.matches(&EventKind::Any));
953 assert!(empty.matches(&EventKind::Other));
954 }
955
956 #[test]
957 fn core_excludes_access() {
958 let core = EventKindMask::CORE;
959 assert!(core.matches(&EventKind::Create(CreateKind::File)));
960 assert!(core.matches(&EventKind::Remove(RemoveKind::File)));
961 assert!(core.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
962 assert!(core.matches(&EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any))));
963 assert!(core.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::From))));
964 assert!(!core.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
965 assert!(!core.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
966 }
967
968 #[test]
969 fn empty_mask_only_passes_any_other() {
970 let empty = EventKindMask::empty();
971 assert!(empty.matches(&EventKind::Any));
972 assert!(empty.matches(&EventKind::Other));
973 assert!(!empty.matches(&EventKind::Create(CreateKind::File)));
974 assert!(!empty.matches(&EventKind::Remove(RemoveKind::File)));
975 assert!(!empty.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
976 assert!(!empty.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
977 }
978
979 #[test]
980 fn bitwise_or_combines_masks() {
981 let mask = EventKindMask::CREATE | EventKindMask::REMOVE;
982 assert!(mask.matches(&EventKind::Create(CreateKind::File)));
983 assert!(mask.matches(&EventKind::Remove(RemoveKind::Folder)));
984 assert!(!mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
985 assert!(!mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
986 }
987
988 #[test]
989 fn all_matches_everything() {
990 let all = EventKindMask::ALL;
991 assert!(all.matches(&EventKind::Any));
992 assert!(all.matches(&EventKind::Other));
993 assert!(all.matches(&EventKind::Create(CreateKind::File)));
994 assert!(all.matches(&EventKind::Remove(RemoveKind::File)));
995 assert!(all.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
996 assert!(all.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
997 assert!(all.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
998 }
999
1000 #[test]
1001 fn access_read_and_any_match_with_all_access() {
1002 let mask = EventKindMask::ALL_ACCESS;
1004 assert!(mask.matches(&EventKind::Access(AccessKind::Read)));
1005 assert!(mask.matches(&EventKind::Access(AccessKind::Any)));
1006 assert!(mask.matches(&EventKind::Access(AccessKind::Other)));
1007 }
1008}
1009
1010#[cfg(all(test, feature = "serde", not(feature = "serialization-compat-6")))]
1011mod tests {
1012 use super::*;
1013
1014 use insta::assert_snapshot;
1015 use rstest::rstest;
1016
1017 #[rustfmt::skip]
1018 #[rstest]
1019 #[case("any", EventKind::Any)]
1020 #[case("access-any", EventKind::Access(AccessKind::Any))]
1021 #[case("access-read", EventKind::Access(AccessKind::Read))]
1022 #[case("access-open-any", EventKind::Access(AccessKind::Open(AccessMode::Any)))]
1023 #[case("access-open-execute", EventKind::Access(AccessKind::Open(AccessMode::Execute)))]
1024 #[case("access-open-read", EventKind::Access(AccessKind::Open(AccessMode::Read)))]
1025 #[case("access-open-write", EventKind::Access(AccessKind::Open(AccessMode::Write)))]
1026 #[case("access-open-other", EventKind::Access(AccessKind::Open(AccessMode::Other)))]
1027 #[case("access-close-any", EventKind::Access(AccessKind::Close(AccessMode::Any)))]
1028 #[case("access-close-execute", EventKind::Access(AccessKind::Close(AccessMode::Execute)))]
1029 #[case("access-close-read", EventKind::Access(AccessKind::Close(AccessMode::Read)))]
1030 #[case("access-close-write", EventKind::Access(AccessKind::Close(AccessMode::Write)))]
1031 #[case("access-close-other", EventKind::Access(AccessKind::Close(AccessMode::Other)))]
1032 #[case("access-other", EventKind::Access(AccessKind::Other))]
1033 #[case("create-any", EventKind::Create(CreateKind::Any))]
1034 #[case("create-file", EventKind::Create(CreateKind::File))]
1035 #[case("create-folder", EventKind::Create(CreateKind::Folder))]
1036 #[case("create-other", EventKind::Create(CreateKind::Other))]
1037 #[case("modify-any", EventKind::Modify(ModifyKind::Any))]
1038 #[case("modify-data-any", EventKind::Modify(ModifyKind::Data(DataChange::Any)))]
1039 #[case("modify-data-size", EventKind::Modify(ModifyKind::Data(DataChange::Size)))]
1040 #[case("modify-data-content", EventKind::Modify(ModifyKind::Data(DataChange::Content)))]
1041 #[case("modify-data-other", EventKind::Modify(ModifyKind::Data(DataChange::Other)))]
1042 #[case("modify-metadata-any", EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any)))]
1043 #[case("modify-metadata-accesstime", EventKind::Modify(ModifyKind::Metadata(MetadataKind::AccessTime)))]
1044 #[case("modify-metadata-writetime", EventKind::Modify(ModifyKind::Metadata(MetadataKind::WriteTime)))]
1045 #[case("modify-metadata-permissions", EventKind::Modify(ModifyKind::Metadata(MetadataKind::Permissions)))]
1046 #[case("modify-metadata-ownership", EventKind::Modify(ModifyKind::Metadata(MetadataKind::Ownership)))]
1047 #[case("modify-metadata-extended", EventKind::Modify(ModifyKind::Metadata(MetadataKind::Extended)))]
1048 #[case("modify-metadata-other", EventKind::Modify(ModifyKind::Metadata(MetadataKind::Other)))]
1049 #[case("modify-name-any", EventKind::Modify(ModifyKind::Name(RenameMode::Any)))]
1050 #[case("modify-name-to", EventKind::Modify(ModifyKind::Name(RenameMode::To)))]
1051 #[case("modify-name-from", EventKind::Modify(ModifyKind::Name(RenameMode::From)))]
1052 #[case("modify-name-both", EventKind::Modify(ModifyKind::Name(RenameMode::Both)))]
1053 #[case("modify-name-other", EventKind::Modify(ModifyKind::Name(RenameMode::Other)))]
1054 #[case("modify-other", EventKind::Modify(ModifyKind::Other))]
1055 #[case("remove-any", EventKind::Remove(RemoveKind::Any))]
1056 #[case("remove-file", EventKind::Remove(RemoveKind::File))]
1057 #[case("remove-folder", EventKind::Remove(RemoveKind::Folder))]
1058 #[case("remove-other", EventKind::Remove(RemoveKind::Other))]
1059 #[case("other", EventKind::Other)]
1060 fn serialize_event_kind(
1061 #[case] name: &str,
1062 #[case] event_kind: EventKind,
1063 ) {
1064 let event = Event::new(event_kind);
1065 let json = serde_json::to_string(&event).unwrap();
1066 assert_snapshot!(name, json);
1067 }
1068
1069 #[test]
1070 fn serialize_event_with_attrs() {
1071 let event = Event::new(EventKind::Any)
1072 .set_tracker(123)
1073 .set_flag(Flag::Rescan)
1074 .set_info("test event")
1075 .set_process_id(0);
1076 let json = serde_json::to_string(&event).unwrap();
1077 assert_snapshot!(json);
1078 }
1079}