fix(json)!: Rename RunStatus to MessageKind

Author: epage

crates/libtest-json/event.schema.json

@@ -213,7 +213,7 @@
         "name"
       ]
     },
-    "RunStatus": {
+    "MessageKind": {
       "type": "string",
       "enum": [
         "ignored",
@@ -227,7 +227,7 @@
           "type": "string"
         },
         "status": {
-          "$ref": "#/$defs/RunStatus"
+          "$ref": "#/$defs/MessageKind"
         },
         "message": {
           "type": [

crates/libtest-json/src/event.rs

@@ -306,7 +306,7 @@ impl CaseStart {
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 pub struct CaseMessage {
     pub name: String,
-    pub status: RunStatus,
+    pub status: MessageKind,
     #[cfg_attr(
         feature = "serde",
         serde(default, skip_serializing_if = "Option::is_none")
@@ -476,12 +476,12 @@ impl RunMode {
 #[cfg_attr(feature = "unstable-schema", derive(schemars::JsonSchema))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
-pub enum RunStatus {
+pub enum MessageKind {
     Ignored,
     Failed,
 }
 
-impl RunStatus {
+impl MessageKind {
     pub fn as_str(&self) -> &str {
         match self {
             Self::Ignored => "ignored",

crates/libtest-json/src/lib.rs

@@ -9,8 +9,8 @@ pub mod event;
 
 pub use event::Elapsed;
 pub use event::Event;
+pub use event::MessageKind;
 pub use event::RunMode;
-pub use event::RunStatus;
 
 #[doc = include_str!("../README.md")]
 #[cfg(doctest)]

crates/libtest-json/tests/roundtrip.rs

@@ -106,7 +106,7 @@ fn case_message() {
     t(
         libtest_json::event::CaseMessage {
             name: "Hello\tworld!".to_owned(),
-            status: libtest_json::RunStatus::Failed,
+            status: libtest_json::MessageKind::Failed,
             message: None,
             elapsed_s: None,
         },
@@ -116,7 +116,7 @@ fn case_message() {
     t(
         libtest_json::event::CaseMessage {
             name: "Hello\tworld!".to_owned(),
-            status: libtest_json::RunStatus::Ignored,
+            status: libtest_json::MessageKind::Ignored,
             message: Some("This\tfailed".to_owned()),
             elapsed_s: Some(libtest_json::Elapsed(Default::default())),
         },

crates/libtest2-harness/src/case.rs

@@ -53,14 +53,14 @@ pub type RunResult = Result<(), RunError>;
 
 #[derive(Debug)]
 pub struct RunError {
-    status: notify::RunStatus,
+    status: notify::MessageKind,
     cause: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
 }
 
 impl RunError {
     pub fn with_cause(cause: impl std::error::Error + Send + Sync + 'static) -> Self {
         Self {
-            status: notify::RunStatus::Failed,
+            status: notify::MessageKind::Failed,
             cause: Some(Box::new(cause)),
         }
     }
@@ -71,19 +71,19 @@ impl RunError {
 
     pub(crate) fn ignore() -> Self {
         Self {
-            status: notify::RunStatus::Ignored,
+            status: notify::MessageKind::Ignored,
             cause: None,
         }
     }
 
     pub(crate) fn ignore_for(reason: String) -> Self {
         Self {
-            status: notify::RunStatus::Ignored,
+            status: notify::MessageKind::Ignored,
             cause: Some(Box::new(Message(reason))),
         }
     }
 
-    pub(crate) fn status(&self) -> notify::RunStatus {
+    pub(crate) fn status(&self) -> notify::MessageKind {
         self.status
     }
 

crates/libtest2-harness/src/harness.rs

@@ -317,7 +317,7 @@ fn run(
                 notifier: &mut dyn notify::Notifier,
             ) -> std::io::Result<()> {
                 if self.join_handle.join().is_err() {
-                    let status = notify::RunStatus::Failed;
+                    let status = notify::MessageKind::Failed;
                     let message = Some("panicked after reporting success".to_owned());
                     notifier.notify(
                         notify::event::CaseMessage {
@@ -485,7 +485,7 @@ fn run_case(
         .into(),
     )?;
 
-    Ok(case_status != Some(notify::RunStatus::Failed))
+    Ok(case_status != Some(notify::MessageKind::Failed))
 }
 
 /// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`.

crates/libtest2-harness/src/notify/pretty.rs

@@ -1,5 +1,5 @@
 use super::Event;
-use super::RunStatus;
+use super::MessageKind;
 use super::FAILED;
 use super::IGNORED;
 use super::OK;
@@ -55,8 +55,8 @@ impl<W: std::io::Write> super::Notifier for PrettyRunNotifier<W> {
             Event::CaseComplete(inner) => {
                 let status = self.summary.get_status(&inner.name);
                 let (s, style) = match status {
-                    Some(RunStatus::Ignored) => ("ignored", IGNORED),
-                    Some(RunStatus::Failed) => ("FAILED", FAILED),
+                    Some(MessageKind::Ignored) => ("ignored", IGNORED),
+                    Some(MessageKind::Failed) => ("FAILED", FAILED),
                     None => ("ok", OK),
                 };
 

crates/libtest2-harness/src/notify/summary.rs

@@ -1,6 +1,6 @@
 use super::event::CaseMessage;
 use super::Event;
-use super::RunStatus;
+use super::MessageKind;
 use super::FAILED;
 use super::OK;
 
@@ -16,7 +16,7 @@ pub(crate) struct Summary {
 }
 
 impl Summary {
-    pub(crate) fn get_status(&self, name: &str) -> Option<RunStatus> {
+    pub(crate) fn get_status(&self, name: &str) -> Option<MessageKind> {
         let status = self.status.get(name)?;
         find_run_status(status)
     }
@@ -38,17 +38,17 @@ impl Summary {
             let mut status = find_run_status(case_status);
             if !case_status.started {
                 // Even override `Ignored`
-                status = Some(RunStatus::Failed);
+                status = Some(MessageKind::Failed);
                 failures.insert(name, Some("test found that never started"));
             }
             if !case_status.completed {
                 // Even override `Ignored`
-                status = Some(RunStatus::Failed);
+                status = Some(MessageKind::Failed);
                 failures.insert(name, Some("test never completed"));
             }
             match status {
-                Some(RunStatus::Ignored) => num_ignored += 1,
-                Some(RunStatus::Failed) => {
+                Some(MessageKind::Ignored) => num_ignored += 1,
+                Some(MessageKind::Failed) => {
                     num_failed += 1;
                     for event in &case_status.messages {
                         if Some(event.status) == status {
@@ -142,14 +142,14 @@ impl super::Notifier for Summary {
     }
 }
 
-fn find_run_status(case_status: &CaseStatus) -> Option<RunStatus> {
+fn find_run_status(case_status: &CaseStatus) -> Option<MessageKind> {
     let mut status = None;
     for event in &case_status.messages {
         status = match (status, event.status) {
             (None, _) => Some(event.status),
-            (Some(RunStatus::Ignored), _) => status,
-            (_, RunStatus::Ignored) => Some(event.status),
-            (Some(RunStatus::Failed), _) => status,
+            (Some(MessageKind::Ignored), _) => status,
+            (_, MessageKind::Ignored) => Some(event.status),
+            (Some(MessageKind::Failed), _) => status,
         }
     }
     status

crates/libtest2-harness/src/notify/terse.rs

@@ -1,5 +1,5 @@
 use super::Event;
-use super::RunStatus;
+use super::MessageKind;
 use super::FAILED;
 use super::IGNORED;
 use super::OK;
@@ -73,8 +73,8 @@ impl<W: std::io::Write> super::Notifier for TerseRunNotifier<W> {
             Event::CaseComplete(inner) => {
                 let status = self.summary.get_status(&inner.name);
                 let (c, style) = match status {
-                    Some(RunStatus::Ignored) => ('i', IGNORED),
-                    Some(RunStatus::Failed) => ('F', FAILED),
+                    Some(MessageKind::Ignored) => ('i', IGNORED),
+                    Some(MessageKind::Failed) => ('F', FAILED),
                     None => ('.', OK),
                 };
                 write!(self.writer, "{style}{c}{style:#}")?;