more assertions, macro fix

Author: THardy98

crates/sdk-core/src/abstractions.rs

@@ -427,14 +427,14 @@ macro_rules! dbg_panic {
     ($($arg:tt)*) => {{
         let message = format!($($arg)*);
         error!("{}", message);
-        crate::antithesis::assert_always_failure(
+        crate::antithesis::assert_always_failure!(
             "dbg_panic invariant triggered",
             ::serde_json::json!({
                 "message": message.clone(),
                 "file": file!(),
                 "line": line!(),
                 "module": module_path!(),
-            }),
+            })
         );
         debug_assert!(false, "{}", message);
     }};

crates/sdk-core/src/antithesis.rs

@@ -1,9 +1,6 @@
 #[cfg(feature = "antithesis_assertions")]
 use std::sync::OnceLock;
 
-#[cfg(feature = "antithesis_assertions")]
-use serde_json::Value;
-
 /// Ensure Antithesis is initialized exactly once.
 #[cfg(feature = "antithesis_assertions")]
 pub(crate) fn ensure_init() {
@@ -17,9 +14,44 @@ pub(crate) fn ensure_init() {
 #[inline]
 pub(crate) fn ensure_init() {}
 
-/// Record an always-true assertion failure to Antithesis when an invariant is
-/// violated.
 #[cfg(feature = "antithesis_assertions")]
-pub(crate) fn assert_always_failure(name: &str, metadata: Value) {
-    ::antithesis_sdk::assert_always!(false, name, &metadata);
+macro_rules! assert_always {
+    ($message:literal, $condition:expr, $details:expr) => {{
+        $crate::antithesis::ensure_init();
+        let details: ::serde_json::Value = $details;
+        ::antithesis_sdk::assert_always!($condition, $message, &details);
+    }};
+    ($message:literal, $condition:expr) => {{
+        $crate::antithesis::ensure_init();
+        ::antithesis_sdk::assert_always!($condition, $message);
+    }};
+}
+
+#[cfg(not(feature = "antithesis_assertions"))]
+macro_rules! assert_always {
+    ($message:literal, $condition:expr, $details:expr) => {{
+        let _ = ($message, $condition);
+        let _ = $details;
+    }};
+    ($message:literal, $condition:expr) => {{
+        let _ = ($message, $condition);
+    }};
+}
+
+#[cfg(feature = "antithesis_assertions")]
+macro_rules! assert_always_failure {
+    ($message:literal, $details:expr) => {{
+        $crate::antithesis::assert_always!($message, false, $details);
+    }};
+}
+
+#[cfg(not(feature = "antithesis_assertions"))]
+macro_rules! assert_always_failure {
+    ($message:literal, $details:expr) => {{
+        let _ = $message;
+        let _ = $details;
+    }};
 }
+
+pub(crate) use assert_always;
+pub(crate) use assert_always_failure;

crates/sdk-core/src/lib.rs

@@ -95,14 +95,13 @@ where
     crate::antithesis::ensure_init();
     let namespace = worker_config.namespace.clone();
     if namespace.is_empty() {
-        #[cfg(feature = "antithesis_assertions")]
-        crate::antithesis::assert_always_failure(
+        crate::antithesis::assert_always_failure!(
             "worker namespace must not be empty",
             ::serde_json::json!({
                 "namespace": namespace.clone(),
                 "task_queue": worker_config.task_queue.clone(),
                 "has_identity_override": worker_config.client_identity_override.is_some(),
-            }),
+            })
         );
         bail!("Worker namespace cannot be empty");
     }
@@ -119,13 +118,12 @@ where
     let sticky_q = sticky_q_name_for_worker(&client_ident, worker_config.max_cached_workflows);
 
     if client_ident.is_empty() {
-        #[cfg(feature = "antithesis_assertions")]
-        crate::antithesis::assert_always_failure(
+        crate::antithesis::assert_always_failure!(
             "client identity must not be empty",
             ::serde_json::json!({
                 "namespace": namespace.clone(),
                 "task_queue": worker_config.task_queue.clone(),
-            }),
+            })
         );
         bail!("Client identity cannot be empty. Either lang or user should be setting this value");
     }

crates/sdk-core/src/worker/workflow/machines/activity_state_machine.rs

@@ -193,7 +193,18 @@ impl ActivityMachine {
                 ActivityMachineCommand::Cancel(details) => {
                     vec![self.create_cancelation_resolve(details).into()]
                 }
-                x => panic!("Invalid cancel event response {x:?}"),
+                x => {
+                    crate::antithesis::assert_always!(
+                        "activity cancel yields supported command",
+                        false,
+                        ::serde_json::json!({
+                            "activity_seq": self.shared_state.attrs.seq,
+                            "unexpected_command": format!("{x:?}"),
+                            "state": self.state().to_string(),
+                        })
+                    );
+                    panic!("Invalid cancel event response {x:?}");
+                }
             })
             .collect();
         Ok(res)

crates/sdk-core/src/worker/workflow/machines/child_workflow_state_machine.rs

@@ -496,7 +496,19 @@ impl ChildWorkflowMachine {
                 | c @ ChildWorkflowCommand::IssueCancelAfterStarted { .. } => {
                     self.adapt_response(c, None)
                 }
-                x => panic!("Invalid cancel event response {x:?}"),
+                x => {
+                    crate::antithesis::assert_always!(
+                        "child workflow cancel yields supported command",
+                        false,
+                        ::serde_json::json!({
+                            "workflow_id": self.shared_state.workflow_id.clone(),
+                            "run_id": self.shared_state.run_id.clone(),
+                            "unexpected_command": format!("{x:?}"),
+                            "state": self.state().to_string(),
+                        })
+                    );
+                    panic!("Invalid cancel event response {x:?}");
+                }
             })
             .flatten_ok()
             .try_collect()?;

crates/sdk-core/src/worker/workflow/machines/complete_workflow_state_machine.rs

@@ -41,7 +41,16 @@ pub(super) fn complete_workflow(attribs: CompleteWorkflowExecution) -> NewMachin
             .pop()
         {
             Some(CompleteWFCommand::AddCommand(c)) => c,
-            _ => panic!("complete wf machine on_schedule must produce command"),
+            unexpected => {
+                crate::antithesis::assert_always!(
+                    "complete workflow scheduling yields command",
+                    false,
+                    ::serde_json::json!({
+                        "unexpected": format!("{unexpected:?}"),
+                    })
+                );
+                panic!("complete wf machine on_schedule must produce command");
+            }
         };
     NewMachineWithCommand {
         command: add_cmd,