Skip to main content

cmtraceopen_parser/collector/
profile.rs

1use std::collections::HashSet;
2
3use crate::collector::types::CollectionProfile;
4
5const EMBEDDED_PROFILE_JSON: &str = include_str!("profile_data.json");
6
7impl CollectionProfile {
8    /// Load the embedded collection profile compiled into the binary.
9    pub fn embedded() -> CollectionProfile {
10        let profile: CollectionProfile = serde_json::from_str(EMBEDDED_PROFILE_JSON)
11            .expect("embedded collection profile JSON must be valid");
12        assert!(
13            profile.has_unique_artifact_ids(),
14            "embedded collection profile artifact IDs must be unique"
15        );
16        profile
17    }
18
19    /// Total number of individual collection items across all categories.
20    pub fn total_items(&self) -> usize {
21        self.logs.len()
22            + self.registry.len()
23            + self.event_logs.len()
24            + self.exports.len()
25            + self.commands.len()
26    }
27
28    /// Filter all collection items to only those whose `family` is in the provided list.
29    pub fn filter_by_families(&mut self, families: &[String]) {
30        self.logs.retain(|item| families.contains(&item.family));
31        self.registry.retain(|item| families.contains(&item.family));
32        self.event_logs
33            .retain(|item| families.contains(&item.family));
34        self.exports.retain(|item| families.contains(&item.family));
35        self.commands.retain(|item| families.contains(&item.family));
36    }
37
38    /// IDs are a bundle-wide contract, so uniqueness spans every category.
39    pub fn artifact_ids(&self) -> impl Iterator<Item = &str> {
40        self.logs
41            .iter()
42            .map(|item| item.id.as_str())
43            .chain(self.registry.iter().map(|item| item.id.as_str()))
44            .chain(self.event_logs.iter().map(|item| item.id.as_str()))
45            .chain(self.exports.iter().map(|item| item.id.as_str()))
46            .chain(self.commands.iter().map(|item| item.id.as_str()))
47    }
48
49    pub fn has_unique_artifact_ids(&self) -> bool {
50        let mut seen = HashSet::new();
51        self.artifact_ids().all(|id| seen.insert(id))
52    }
53}
54
55#[cfg(test)]
56mod tests {
57    use super::*;
58
59    #[test]
60    fn embedded_profile_deserializes() {
61        let profile = CollectionProfile::embedded();
62        assert_eq!(profile.profile_name, "cmtrace-full-diagnostics-v1");
63        assert!(!profile.logs.is_empty());
64        assert!(!profile.registry.is_empty());
65        assert!(!profile.event_logs.is_empty());
66        assert!(!profile.exports.is_empty());
67        assert!(!profile.commands.is_empty());
68    }
69
70    #[test]
71    fn total_items_sums_all_categories() {
72        let profile = CollectionProfile::embedded();
73        let expected = profile.logs.len()
74            + profile.registry.len()
75            + profile.event_logs.len()
76            + profile.exports.len()
77            + profile.commands.len();
78        assert_eq!(profile.total_items(), expected);
79        assert!(expected > 100, "full profile should have 100+ items");
80    }
81
82    #[test]
83    fn filter_by_families_retains_only_matching() {
84        let mut profile = CollectionProfile::embedded();
85        let original_total = profile.total_items();
86
87        profile.filter_by_families(&["general".to_string(), "networking".to_string()]);
88
89        assert!(
90            profile.total_items() > 0,
91            "should have some items for general+networking"
92        );
93        assert!(
94            profile.total_items() < original_total,
95            "should be fewer items than full profile"
96        );
97
98        // Verify every remaining item belongs to an allowed family.
99        for item in &profile.logs {
100            assert!(
101                item.family == "general" || item.family == "networking",
102                "unexpected log family: {}",
103                item.family
104            );
105        }
106        for item in &profile.registry {
107            assert!(
108                item.family == "general" || item.family == "networking",
109                "unexpected registry family: {}",
110                item.family
111            );
112        }
113        for item in &profile.commands {
114            assert!(
115                item.family == "general" || item.family == "networking",
116                "unexpected command family: {}",
117                item.family
118            );
119        }
120    }
121
122    #[test]
123    fn filter_by_families_empty_list_yields_empty_profile() {
124        let mut profile = CollectionProfile::embedded();
125        profile.filter_by_families(&[]);
126        assert_eq!(profile.total_items(), 0);
127    }
128
129    #[test]
130    fn embedded_profile_includes_new_teams_msix_logs() {
131        // Regression guard for issue #205: the new Teams (MSIX) client writes
132        // logs under %LOCALAPPDATA%\Packages\MSTeams_8wekyb3d8bbwe\..., which the
133        // classic-Teams manifest rows do not cover.
134        let profile = CollectionProfile::embedded();
135        let item = profile
136            .logs
137            .iter()
138            .find(|i| i.id == "teams-msix-logs")
139            .expect("profile must contain the new Teams MSIX log source");
140        assert_eq!(item.family, "teams");
141        assert!(
142            item.source_pattern.contains("MSTeams_8wekyb3d8bbwe"),
143            "unexpected source pattern: {}",
144            item.source_pattern
145        );
146    }
147}