1use serde::{Deserialize, Serialize};
22
23pub const USAGE_SCHEMA_VERSION: u32 = 1;
26
27pub const COUNT_MAX: u32 = 10_000;
29
30#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
32#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
33#[serde(tag = "kind", rename_all = "camelCase")]
34#[cfg_attr(feature = "codegen", schemars(title = "Modelith usage report"))]
35pub enum UsageReport {
36 #[cfg_attr(
38 feature = "codegen",
39 schemars(extend(
40 "x-modelith-when" = "startup",
41 "x-modelith-level" = "all",
42 "x-modelith-max-bytes" = 1024
43 ))
44 )]
45 Startup(StartupReport),
46 #[cfg_attr(
48 feature = "codegen",
49 schemars(extend(
50 "x-modelith-when" = "daily",
51 "x-modelith-level" = "all",
52 "x-modelith-max-bytes" = 8192
53 ))
54 )]
55 Daily(Box<DailyReport>),
56 #[cfg_attr(
58 feature = "codegen",
59 schemars(extend(
60 "x-modelith-when" = "error",
61 "x-modelith-level" = "error",
62 "x-modelith-max-bytes" = 4096
63 ))
64 )]
65 Error(ErrorReport),
66 #[cfg_attr(
68 feature = "codegen",
69 schemars(extend(
70 "x-modelith-when" = "daily",
71 "x-modelith-level" = "all",
72 "x-modelith-max-bytes" = 2048
73 ))
74 )]
75 ServerDaily(ServerDailyReport),
76}
77
78#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
80#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
81#[serde(rename_all = "camelCase")]
82pub struct StartupReport {
83 pub schema_version: u32,
84 #[serde(flatten)]
85 pub sender: Sender,
86 #[serde(default, skip_serializing_if = "Option::is_none")]
88 #[cfg_attr(feature = "codegen", ts(optional))]
89 pub browser: Option<Browser>,
90 #[serde(default, skip_serializing_if = "Option::is_none")]
91 #[cfg_attr(feature = "codegen", ts(optional))]
92 pub os: Option<Os>,
93 #[serde(default, skip_serializing_if = "Option::is_none")]
95 #[cfg_attr(feature = "codegen", ts(optional))]
96 pub screen: Option<ScreenClass>,
97 #[serde(default, skip_serializing_if = "Option::is_none")]
99 #[cfg_attr(feature = "codegen", ts(optional))]
100 pub language: Option<Language>,
101 #[serde(default, skip_serializing_if = "Option::is_none")]
103 #[cfg_attr(feature = "codegen", ts(optional))]
104 pub folder_access: Option<bool>,
105 pub startup_time: DurationClass,
107}
108
109#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
111#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
112#[serde(rename_all = "camelCase")]
113pub struct DailyReport {
114 pub schema_version: u32,
115 #[serde(flatten)]
116 pub sender: Sender,
117 #[serde(default, skip_serializing_if = "Option::is_none")]
120 #[cfg_attr(feature = "codegen", ts(optional))]
121 pub browser: Option<Browser>,
122 #[serde(default, skip_serializing_if = "Option::is_none")]
123 #[cfg_attr(feature = "codegen", ts(optional))]
124 pub os: Option<Os>,
125 #[serde(default, skip_serializing_if = "Option::is_none")]
126 #[cfg_attr(feature = "codegen", ts(optional))]
127 pub screen: Option<ScreenClass>,
128 #[serde(default, skip_serializing_if = "Option::is_none")]
129 #[cfg_attr(feature = "codegen", ts(optional))]
130 pub language: Option<Language>,
131 #[serde(default, skip_serializing_if = "Option::is_none")]
132 #[cfg_attr(feature = "codegen", ts(optional))]
133 pub folder_access: Option<bool>,
134 #[serde(default)]
136 #[cfg_attr(
137 feature = "codegen",
138 schemars(length(max = 7), extend("uniqueItems" = true))
139 )]
140 pub onboarding: Vec<OnboardingStep>,
141 #[serde(default)]
143 pub auto_views: AutoViews,
144 #[serde(default)]
146 pub created_views: CreatedViews,
147 #[serde(default)]
149 pub edits: Edits,
150 #[serde(default)]
152 pub layout: Layout,
153 #[serde(default)]
155 pub saves: Saves,
156 #[serde(default)]
158 pub exports: Exports,
159 #[serde(default)]
161 pub checks: Checks,
162 #[serde(default)]
165 pub plugin_uses: Count,
166 #[serde(default)]
168 pub ai_rewrites: Count,
169 #[serde(default)]
171 #[cfg_attr(feature = "codegen", schemars(length(max = 20)))]
172 pub parse_times: Vec<ParseTime>,
173 #[serde(default)]
175 pub wasm_load_failures: Count,
176 #[serde(default)]
178 pub worker_restarts: Count,
179 #[serde(default, skip_serializing_if = "Option::is_none")]
181 #[cfg_attr(feature = "codegen", ts(optional))]
182 pub weeks_used: Option<WeeksClass>,
183 #[serde(default, skip_serializing_if = "Option::is_none")]
185 #[cfg_attr(feature = "codegen", schemars(regex(pattern = r"^\d{4}-Q[1-4]$")))]
186 #[cfg_attr(feature = "codegen", ts(optional))]
187 pub first_quarter: Option<String>,
188}
189
190#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
192#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
193#[serde(rename_all = "camelCase")]
194pub struct ErrorReport {
195 pub schema_version: u32,
196 #[serde(flatten)]
197 pub sender: Sender,
198 pub level: SendLevel,
200 pub error_kind: ErrorKind,
201 pub error_name: ErrorName,
203 #[cfg_attr(feature = "codegen", schemars(length(max = 30)))]
206 pub frames: Vec<StackFrame>,
207}
208
209#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
211#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
212#[serde(rename_all = "camelCase")]
213pub struct StackFrame {
214 #[cfg_attr(
216 feature = "codegen",
217 schemars(regex(pattern = r"^[A-Za-z0-9_][A-Za-z0-9_./-]{0,119}$"))
218 )]
219 pub module: String,
220 #[serde(default, skip_serializing_if = "Option::is_none")]
222 #[cfg_attr(
223 feature = "codegen",
224 schemars(regex(pattern = r"^[A-Za-z0-9_:<>$.]{1,200}$"))
225 )]
226 #[cfg_attr(feature = "codegen", ts(optional))]
227 pub function: Option<String>,
228 #[serde(default, skip_serializing_if = "Option::is_none")]
230 #[cfg_attr(feature = "codegen", schemars(range(max = 10_000_000)))]
231 #[cfg_attr(feature = "codegen", ts(optional))]
232 pub line: Option<u32>,
233 #[serde(default, skip_serializing_if = "Option::is_none")]
235 #[cfg_attr(feature = "codegen", schemars(range(max = 10_000_000)))]
236 #[cfg_attr(feature = "codegen", ts(optional))]
237 pub column: Option<u32>,
238}
239
240#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
242#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
243#[serde(rename_all = "camelCase")]
244pub struct ServerDailyReport {
245 pub schema_version: u32,
246 #[serde(flatten)]
247 pub sender: Sender,
248 #[cfg_attr(
250 feature = "codegen",
251 schemars(regex(
252 pattern = r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
253 ))
254 )]
255 pub instance_id: String,
256 pub os: Os,
257 pub deployment: Deployment,
258 pub login: LoginMethods,
260 pub users: AmountClass,
262 pub active_users_7d: AmountClass,
264 pub projects: AmountClass,
266 pub storage: StorageClass,
268 pub plugins: AmountClass,
270}
271
272#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
274#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
275#[serde(rename_all = "camelCase")]
276pub struct Sender {
277 #[cfg_attr(feature = "codegen", schemars(extend("x-modelith-dimension" = true)))]
278 pub client: Client,
279 #[cfg_attr(
281 feature = "codegen",
282 schemars(
283 regex(pattern = r"^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$"),
284 length(max = 32),
285 extend("x-modelith-dimension" = true)
286 )
287 )]
288 pub app_version: String,
289 #[cfg_attr(feature = "codegen", schemars(extend("x-modelith-dimension" = true)))]
290 pub channel: Channel,
291}
292
293#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
295#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
296#[serde(rename_all = "camelCase")]
297pub enum Client {
298 Web,
300 Server,
302}
303
304#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
306#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
307#[serde(rename_all = "camelCase")]
308pub enum Channel {
309 Stable,
310 Rc,
311 Preview,
312}
313
314#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
316#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
317#[serde(rename_all = "camelCase", default)]
318pub struct AutoViews {
319 pub trace: Count,
321 pub structure: Count,
323 pub control: Count,
325 pub ibd: Count,
327 pub behavior: Count,
329 pub seq: Count,
331 pub afv: Count,
333 pub stm: Count,
335 pub all: Count,
337}
338
339#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
341#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
342#[serde(rename_all = "camelCase", default)]
343pub struct CreatedViews {
344 pub general: Count,
346 pub interconnection: Count,
348 pub action_flow: Count,
350 pub state_transition: Count,
352 pub sequence: Count,
354 pub other: Count,
356}
357
358#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
360#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
361#[serde(rename_all = "camelCase", default)]
362pub struct Edits {
363 pub add_node: Count,
364 pub add_usage: Count,
365 pub rename: Count,
366 pub delete: Count,
367 pub delete_edge: Count,
368 pub connect: Count,
369 pub add_message: Count,
370 pub update_message: Count,
371 pub move_message: Count,
372 pub set_phase: Count,
373 pub init_phases: Count,
374 pub make_port: Count,
375 pub set_port_dir: Count,
376 pub delete_port: Count,
377 pub save_view: Count,
378 pub add_to_view: Count,
379 pub remove_from_view: Count,
380 pub rename_view: Count,
381 pub delete_view: Count,
382 pub set_attribute: Count,
383 pub remove_attribute: Count,
384 pub set_doc: Count,
385 pub undo: Count,
386 pub redo: Count,
387}
388
389#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
391#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
392#[serde(rename_all = "camelCase", default)]
393pub struct Layout {
394 pub r#move: Count,
396 pub adjust_edge: Count,
398 pub align: Count,
400}
401
402#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
404#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
405#[serde(rename_all = "camelCase", default)]
406pub struct Saves {
407 pub draft: Count,
409 pub download: Count,
411 pub folder: Count,
413}
414
415#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
417#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
418#[serde(rename_all = "camelCase", default)]
419pub struct Exports {
420 pub svg: Count,
421 pub png: Count,
422 pub jpeg: Count,
423 pub drawio: Count,
424 pub clipboard: Count,
426}
427
428#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
430#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
431#[serde(rename_all = "camelCase", default)]
432pub struct Checks {
433 pub runs: Count,
434 pub no_problems: Count,
436 pub problems_1_to_9: Count,
438 pub problems_10_to_99: Count,
440 pub problems_100_or_more: Count,
442}
443
444#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
446#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
447#[serde(rename_all = "camelCase")]
448pub struct ParseTime {
449 pub file_size: SizeClass,
450 pub duration: ParseDurationClass,
451 pub count: Count,
452}
453
454#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default, Serialize)]
456#[cfg_attr(feature = "codegen", derive(ts_rs::TS))]
457pub struct Count(u32);
458
459impl Count {
460 pub fn capped(n: u64) -> Self {
462 Self(u32::try_from(n.min(u64::from(COUNT_MAX))).unwrap_or(COUNT_MAX))
463 }
464
465 pub fn get(self) -> u32 {
466 self.0
467 }
468}
469
470impl TryFrom<u32> for Count {
471 type Error = String;
472 fn try_from(n: u32) -> Result<Self, Self::Error> {
473 if n <= COUNT_MAX {
474 Ok(Self(n))
475 } else {
476 Err(format!("count {n} exceeds the maximum {COUNT_MAX}"))
477 }
478 }
479}
480
481impl<'de> Deserialize<'de> for Count {
482 fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
483 Self::try_from(u32::deserialize(d)?).map_err(serde::de::Error::custom)
484 }
485}
486
487#[cfg(feature = "codegen")]
488impl schemars::JsonSchema for Count {
489 fn schema_name() -> std::borrow::Cow<'static, str> {
490 "Count".into()
491 }
492
493 fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
494 schemars::json_schema!({
495 "type": "integer",
496 "minimum": 0,
497 "maximum": COUNT_MAX,
498 "description": "A count from 0 up to the maximum. Senders cap larger counts at the maximum."
499 })
500 }
501}
502
503#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
505#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
506#[serde(rename_all = "camelCase")]
507pub enum SendLevel {
508 All,
510 ErrorsOnly,
512}
513
514#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
515#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
516#[serde(rename_all = "camelCase")]
517pub enum Browser {
518 Chrome,
519 Edge,
520 Firefox,
521 Safari,
522 Other,
523}
524
525#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
526#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
527#[serde(rename_all = "camelCase")]
528pub enum Os {
529 Windows,
530 Macos,
531 Linux,
532 Android,
533 Ios,
534 Other,
535}
536
537#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
539#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
540#[serde(rename_all = "camelCase")]
541pub enum ScreenClass {
542 Phone,
544 Tablet,
546 Desktop,
548}
549
550#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
552#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
553#[serde(rename_all = "camelCase")]
554pub enum Language {
555 Ja,
556 En,
557 Other,
558}
559
560#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
562#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
563#[serde(rename_all = "camelCase")]
564pub enum OnboardingStep {
565 SampleOpened,
567 TextWritten,
569 DiagramOpened,
571 Edited,
573 ViewCreated,
575 Saved,
577 FolderOpened,
579}
580
581#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
583#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
584pub enum DurationClass {
585 #[serde(rename = "lt1s")]
587 Under1s,
588 #[serde(rename = "1to3s")]
590 From1To3s,
591 #[serde(rename = "3to10s")]
593 From3To10s,
594 #[serde(rename = "ge10s")]
596 Over10s,
597}
598
599#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
601#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
602pub enum ParseDurationClass {
603 #[serde(rename = "lt100ms")]
605 Under100Ms,
606 #[serde(rename = "100to300ms")]
608 From100To300Ms,
609 #[serde(rename = "300msTo1s")]
611 From300MsTo1s,
612 #[serde(rename = "1to3s")]
614 From1To3s,
615 #[serde(rename = "ge3s")]
617 Over3s,
618}
619
620#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
622#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
623pub enum SizeClass {
624 #[serde(rename = "lt10kb")]
626 Under10Kb,
627 #[serde(rename = "10to100kb")]
629 From10To100Kb,
630 #[serde(rename = "100kbTo1mb")]
632 From100KbTo1Mb,
633 #[serde(rename = "ge1mb")]
635 Over1Mb,
636}
637
638#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
640#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
641pub enum WeeksClass {
642 #[serde(rename = "1")]
644 One,
645 #[serde(rename = "2to4")]
647 From2To4,
648 #[serde(rename = "5to12")]
650 From5To12,
651 #[serde(rename = "ge13")]
653 Over13,
654}
655
656#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
658#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
659pub enum AmountClass {
660 #[serde(rename = "0")]
661 Zero,
662 #[serde(rename = "1")]
663 One,
664 #[serde(rename = "2to10")]
666 From2To10,
667 #[serde(rename = "11to100")]
669 From11To100,
670 #[serde(rename = "101to1000")]
672 From101To1000,
673 #[serde(rename = "ge1001")]
675 Over1000,
676}
677
678#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
680#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
681pub enum StorageClass {
682 #[serde(rename = "lt100mb")]
684 Under100Mb,
685 #[serde(rename = "100mbTo1gb")]
687 From100MbTo1Gb,
688 #[serde(rename = "1to10gb")]
690 From1To10Gb,
691 #[serde(rename = "ge10gb")]
693 Over10Gb,
694}
695
696#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
698#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
699#[serde(rename_all = "camelCase")]
700pub enum Deployment {
701 Docker,
702 Binary,
703}
704
705#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
707#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
708#[serde(rename_all = "camelCase")]
709pub struct LoginMethods {
710 pub accounts: bool,
712 pub oidc: bool,
713}
714
715#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
717#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
718#[serde(rename_all = "camelCase")]
719pub enum ErrorKind {
720 UncaughtError,
722 UnhandledRejection,
724 WasmPanic,
726}
727
728#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
730#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
731#[serde(rename_all = "camelCase")]
732pub enum ErrorName {
733 Error,
734 TypeError,
735 RangeError,
736 ReferenceError,
737 SyntaxError,
738 NotAllowedError,
740 QuotaExceededError,
742 AbortError,
744 SecurityError,
746 NotFoundError,
748 OtherDomException,
750 Panic,
752 Other,
753}
754
755#[cfg(test)]
756mod tests {
757 use serde_json::json;
758
759 use super::*;
760
761 fn startup() -> serde_json::Value {
762 json!({
763 "kind": "startup", "schemaVersion": 1, "client": "web", "appVersion": "0.2.0-rc.1",
764 "channel": "rc", "browser": "chrome", "os": "macos", "screen": "desktop", "language": "ja",
765 "folderAccess": true, "startupTime": "1to3s"
766 })
767 }
768
769 fn with(mut base: serde_json::Value, key: &str, value: serde_json::Value) -> serde_json::Value {
770 base[key] = value;
771 base
772 }
773
774 #[test]
777 fn startup_report_uses_kind_tag_and_flat_sender() {
778 let json = startup();
780 let report: UsageReport = serde_json::from_value(json).unwrap();
782 let UsageReport::Startup(s) = report else {
784 panic!("not startup")
785 };
786 assert_eq!(
787 (s.sender.client, s.sender.channel, s.startup_time),
788 (Client::Web, Channel::Rc, DurationClass::From1To3s)
789 );
790 }
791
792 #[test]
793 fn startup_report_needs_no_environment() {
794 let mut json = startup();
796 for key in ["browser", "os", "screen", "language", "folderAccess"] {
797 json.as_object_mut().unwrap().remove(key);
798 }
799 let report: UsageReport = serde_json::from_value(json).unwrap();
801 let UsageReport::Startup(s) = report else {
803 panic!("not startup")
804 };
805 assert_eq!(
806 (s.browser, s.startup_time),
807 (None, DurationClass::From1To3s)
808 );
809 }
810
811 #[test]
812 fn daily_report_counts_default_to_zero() {
813 let json = json!({
815 "kind": "daily", "schemaVersion": 1, "client": "web", "appVersion": "0.2.0",
816 "channel": "stable"
817 });
818 let report: UsageReport = serde_json::from_value(json).unwrap();
820 let UsageReport::Daily(daily) = report else {
822 panic!("not daily")
823 };
824 assert_eq!(
825 (daily.edits, daily.exports.clipboard, daily.plugin_uses),
826 (Edits::default(), Count::default(), Count::default())
827 );
828 }
829
830 #[test]
831 fn ignores_unknown_fields() {
832 let json = with(startup(), "newField", json!(1));
834 let result = serde_json::from_value::<UsageReport>(json);
836 assert!(result.is_ok(), "{result:?}");
838 }
839
840 #[test]
841 fn accepts_count_at_the_maximum() {
842 let n = COUNT_MAX;
844 let count = serde_json::from_value::<Count>(json!(n));
846 assert_eq!(count.unwrap().get(), COUNT_MAX);
848 }
849
850 #[test]
851 fn capped_stops_at_the_maximum() {
852 let inputs = [u64::from(COUNT_MAX), u64::from(COUNT_MAX) + 1, u64::MAX, 3];
854 let counts = inputs.map(|n| Count::capped(n).get());
856 assert_eq!(counts, [COUNT_MAX, COUNT_MAX, COUNT_MAX, 3]);
858 }
859
860 #[test]
861 fn class_names_are_the_documented_words() {
862 let values = (
864 DurationClass::Under1s,
865 SizeClass::From100KbTo1Mb,
866 WeeksClass::Over13,
867 AmountClass::Zero,
868 SendLevel::ErrorsOnly,
869 );
870 let json = serde_json::to_value(values).unwrap();
872 assert_eq!(
874 json,
875 json!(["lt1s", "100kbTo1mb", "ge13", "0", "errorsOnly"])
876 );
877 }
878
879 #[test]
880 fn frame_function_is_omitted_when_absent() {
881 let frame = StackFrame {
883 module: "assets/index.js".into(),
884 function: None,
885 line: Some(1),
886 column: Some(2),
887 };
888 let json = serde_json::to_value(frame).unwrap();
890 assert_eq!(
892 json,
893 json!({ "module": "assets/index.js", "line": 1, "column": 2 })
894 );
895 }
896
897 #[test]
900 fn rejects_count_over_the_maximum() {
901 let n = COUNT_MAX + 1;
903 let result = serde_json::from_value::<Count>(json!(n));
905 assert!(result.is_err());
907 }
908
909 #[test]
910 fn rejects_negative_count() {
911 let n = -1;
913 let result = serde_json::from_value::<Count>(json!(n));
915 assert!(result.is_err());
917 }
918
919 #[test]
920 fn rejects_free_text_in_a_class() {
921 let json = with(startup(), "startupTime", json!("2.3 seconds"));
923 let result = serde_json::from_value::<UsageReport>(json);
925 assert!(result.is_err());
927 }
928
929 #[test]
930 fn rejects_a_missing_sender_field() {
931 let mut json = startup();
933 json.as_object_mut().unwrap().remove("client");
934 let result = serde_json::from_value::<UsageReport>(json);
936 assert!(result.is_err());
938 }
939
940 #[test]
941 fn rejects_unknown_kind() {
942 let json = with(startup(), "kind", json!("pageView"));
944 let result = serde_json::from_value::<UsageReport>(json);
946 assert!(result.is_err());
948 }
949}