Use turso assertion details parameter instead of interpolated strings

claude · claude · commit 85c197ed9ab9 · 2026-02-20T18:25:02.000Z
Convert panic!/assert! in turso-stress to turso_assert/turso_assert_unreachable with structured details blocks, so Antithesis gets proper metadata instead of baked-in format strings. Also remove redundant format!("{:?}", ...) wrappers in btree.rs and builder.rs details blocks since the macro already applies Debug formatting. https://claude.ai/code/session_012NRC1Tbyaoexyb8PruUQLG
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/core/storage/btree.rs b/core/storage/btree.rs
@@ -2332,7 +2332,7 @@ impl BTreeCursor {
 
                     if overflows {
                         *write_state = WriteState::Balancing;
-                        turso_assert!(matches!(self.balance_state.sub_state, BalanceSubState::Start), "no balancing operation should be in progress during insert", { "state": format!("{:?}", self.state), "sub_state": format!("{:?}", self.balance_state.sub_state) });
+                        turso_assert!(matches!(self.balance_state.sub_state, BalanceSubState::Start), "no balancing operation should be in progress during insert", { "state": self.state, "sub_state": self.balance_state.sub_state });
                         // If we balance, we must save the cursor position and seek to it later.
                         self.save_context(CursorContext::seek_eq_only(bkey));
                     } else {
@@ -2375,7 +2375,7 @@ impl BTreeCursor {
                     };
                     if overflows || underflows {
                         *write_state = WriteState::Balancing;
-                        turso_assert!(matches!(self.balance_state.sub_state, BalanceSubState::Start), "no balancing operation should be in progress during overwrite", { "state": format!("{:?}", self.state), "sub_state": format!("{:?}", self.balance_state.sub_state) });
+                        turso_assert!(matches!(self.balance_state.sub_state, BalanceSubState::Start), "no balancing operation should be in progress during overwrite", { "state": self.state, "sub_state": self.balance_state.sub_state });
                         // If we balance, we must save the cursor position and seek to it later.
                         self.save_context(CursorContext::seek_eq_only(bkey));
                     } else {
@@ -5419,7 +5419,7 @@ impl CursorTrait for BTreeCursor {
                             }
                         }
                         let balance_both = leaf_underflows && interior_overflows_or_underflows;
-                        turso_assert!(matches!(self.balance_state.sub_state, BalanceSubState::Start), "no balancing operation should be in progress during delete", { "sub_state": format!("{:?}", self.balance_state.sub_state) });
+                        turso_assert!(matches!(self.balance_state.sub_state, BalanceSubState::Start), "no balancing operation should be in progress during delete", { "sub_state": self.balance_state.sub_state });
                         let post_balancing_seek_key = post_balancing_seek_key
                             .take()
                             .expect("post_balancing_seek_key should be Some");
diff --git a/core/vdbe/builder.rs b/core/vdbe/builder.rs
@@ -925,7 +925,7 @@ impl ProgramBuilder {
     /// reordering the emitted instructions.
     #[inline]
     pub fn preassign_label_to_next_insn(&mut self, label: BranchOffset) {
-        turso_assert!(label.is_label(), "BranchOffset should be a label", { "label": format!("{:?}", label) });
+        turso_assert!(label.is_label(), "BranchOffset should be a label", { "label": label });
         self._resolve_label(label, self.offset().sub(1u32), JumpTarget::AfterThisInsn);
     }
 
diff --git a/testing/stress/Cargo.toml b/testing/stress/Cargo.toml
@@ -33,10 +33,12 @@ tokio = { workspace = true, features = ["full"] }
 tracing-appender = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "json"] }
 turso = { workspace = true }
+turso_macros = { workspace = true }
 rusqlite = { workspace = true }
 
 [target.'cfg(antithesis)'.dependencies]
 antithesis_sdk = { workspace = true, features = ["full"] }
+serde_json = { workspace = true }
 
 [target.'cfg(shuttle)'.dependencies]
 shuttle = { workspace = true }
diff --git a/testing/stress/main.rs b/testing/stress/main.rs
@@ -556,7 +556,7 @@ pub fn spawn_log_level_watcher(reload_handle: LogLevelReloadHandle) {
 fn sqlite_integrity_check(
     db_path: &std::path::Path,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    assert!(db_path.exists());
+    turso_macros::turso_assert!(db_path.exists(), "database path must exist", { "path": db_path });
     let conn = rusqlite::Connection::open(db_path)?;
     let mut stmt = conn.prepare_cached("SELECT * FROM pragma_integrity_check;")?;
     let mut rows = stmt.query(())?;
@@ -565,7 +565,10 @@ fn sqlite_integrity_check(
     while let Some(row) = rows.next()? {
         result.push(row.get(0)?);
     }
-    assert!(!result.is_empty());
+    turso_macros::turso_assert!(
+        !result.is_empty(),
+        "integrity check result must not be empty"
+    );
     if !result[0].eq_ignore_ascii_case("ok") {
         // Build a list of problems
         result.iter_mut().for_each(|row| *row = format!("- {row}"));
@@ -759,7 +762,7 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +
                     }
                     Err(e) => {
                         log_sql(&sql_log, thread, stmt, &format!("ERROR(fatal): {e}"));
-                        panic!("Error creating table: {e}");
+                        turso_macros::turso_assert_unreachable!("fatal error creating table", { "thread": thread, "stmt": stmt, "error": e });
                     }
                 }
             }
@@ -840,7 +843,7 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +
                     Err(e) => match e {
                         turso::Error::Corrupt(e) => {
                             log_sql(&sql_log, thread, &sql, &format!("ERROR(corrupt): {e}"));
-                            panic!("thread#{thread} Error[FATAL] executing query: {e}");
+                            turso_macros::turso_assert_unreachable!("corrupt error executing query", { "thread": thread, "error": e, "sql": sql });
                         }
                         turso::Error::Constraint(e) => {
                             log_sql(&sql_log, thread, &sql, &format!("ERROR(constraint): {e}"));
@@ -876,7 +879,7 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +
                         }
                         _ => {
                             log_sql(&sql_log, thread, &sql, &format!("ERROR(fatal): {e}"));
-                            panic!("thread#{thread} Error[FATAL] executing query: {e}");
+                            turso_macros::turso_assert_unreachable!("fatal error executing query", { "thread": thread, "error": e, "sql": sql });
                         }
                     },
                 }
@@ -906,13 +909,13 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +
                                     "PRAGMA integrity_check",
                                     &format!("ERROR: {value:?}"),
                                 );
-                                panic!("thread#{thread} integrity check failed: {value:?}");
+                                turso_macros::turso_assert_unreachable!("integrity check failed", { "thread": thread, "value": value });
                             }
                             log_sql(&sql_log, thread, "PRAGMA integrity_check", "OK");
                         }
                         Ok(None) => {
                             log_sql(&sql_log, thread, "PRAGMA integrity_check", "ERROR: no rows");
-                            panic!("thread#{thread} integrity check failed: no rows");
+                            turso_macros::turso_assert_unreachable!("integrity check returned no rows", { "thread": thread });
                         }
                         Err(e) => {
                             log_sql(
@@ -926,7 +929,7 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +
                     }
                     match res.next().await {
                         Ok(Some(_)) => {
-                            panic!("thread#{thread} integrity check failed: more than 1 row")
+                            turso_macros::turso_assert_unreachable!("integrity check returned more than 1 row", { "thread": thread });
                         }
                         Err(e) => println!("thread#{thread} Error performing integrity check: {e}"),
                         _ => {}

Original file line number	Diff line number	Diff line change
`@@ -925,7 +925,7 @@ impl ProgramBuilder {`
`925`	`925`	`/// reordering the emitted instructions.`
`926`	`926`	`#[inline]`
`927`	`927`	`pub fn preassign_label_to_next_insn(&mut self, label: BranchOffset) {`
`928`		`- turso_assert!(label.is_label(), "BranchOffset should be a label", { "label": format!("{:?}", label) });`
	`928`	`+ turso_assert!(label.is_label(), "BranchOffset should be a label", { "label": label });`
`929`	`929`	`self._resolve_label(label, self.offset().sub(1u32), JumpTarget::AfterThisInsn);`
`930`	`930`	`}`
`931`	`931`
Original file line number	Diff line number	Diff line change
`@@ -556,7 +556,7 @@ pub fn spawn_log_level_watcher(reload_handle: LogLevelReloadHandle) {`
`556`	`556`	`fn sqlite_integrity_check(`
`557`	`557`	`db_path: &std::path::Path,`
`558`	`558`	`) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {`
`559`		`- assert!(db_path.exists());`
	`559`	`+ turso_macros::turso_assert!(db_path.exists(), "database path must exist", { "path": db_path });`
`560`	`560`	`let conn = rusqlite::Connection::open(db_path)?;`
`561`	`561`	`let mut stmt = conn.prepare_cached("SELECT * FROM pragma_integrity_check;")?;`
`562`	`562`	`let mut rows = stmt.query(())?;`
`@@ -565,7 +565,10 @@ fn sqlite_integrity_check(`
`565`	`565`	`while let Some(row) = rows.next()? {`
`566`	`566`	`result.push(row.get(0)?);`
`567`	`567`	`}`
`568`		`- assert!(!result.is_empty());`
	`568`	`+ turso_macros::turso_assert!(`
	`569`	`+ !result.is_empty(),`
	`570`	`+ "integrity check result must not be empty"`
	`571`	`+ );`
`569`	`572`	`if !result[0].eq_ignore_ascii_case("ok") {`
`570`	`573`	`// Build a list of problems`
`571`	`574`	`result.iter_mut().for_each(\|row\| *row = format!("- {row}"));`
`@@ -759,7 +762,7 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +`
`759`	`762`	`}`
`760`	`763`	`Err(e) => {`
`761`	`764`	`log_sql(&sql_log, thread, stmt, &format!("ERROR(fatal): {e}"));`
`762`		`- panic!("Error creating table: {e}");`
	`765`	`+ turso_macros::turso_assert_unreachable!("fatal error creating table", { "thread": thread, "stmt": stmt, "error": e });`
`763`	`766`	`}`
`764`	`767`	`}`
`765`	`768`	`}`
`@@ -840,7 +843,7 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +`
`840`	`843`	`Err(e) => match e {`
`841`	`844`	`turso::Error::Corrupt(e) => {`
`842`	`845`	`log_sql(&sql_log, thread, &sql, &format!("ERROR(corrupt): {e}"));`
`843`		`- panic!("thread#{thread} Error[FATAL] executing query: {e}");`
	`846`	`+ turso_macros::turso_assert_unreachable!("corrupt error executing query", { "thread": thread, "error": e, "sql": sql });`
`844`	`847`	`}`
`845`	`848`	`turso::Error::Constraint(e) => {`
`846`	`849`	`log_sql(&sql_log, thread, &sql, &format!("ERROR(constraint): {e}"));`
`@@ -876,7 +879,7 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +`
`876`	`879`	`}`
`877`	`880`	`_ => {`
`878`	`881`	`log_sql(&sql_log, thread, &sql, &format!("ERROR(fatal): {e}"));`
`879`		`- panic!("thread#{thread} Error[FATAL] executing query: {e}");`
	`882`	`+ turso_macros::turso_assert_unreachable!("fatal error executing query", { "thread": thread, "error": e, "sql": sql });`
`880`	`883`	`}`
`881`	`884`	`},`
`882`	`885`	`}`
`@@ -906,13 +909,13 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +`
`906`	`909`	`"PRAGMA integrity_check",`
`907`	`910`	`&format!("ERROR: {value:?}"),`
`908`	`911`	`);`
`909`		`- panic!("thread#{thread} integrity check failed: {value:?}");`
	`912`	`+ turso_macros::turso_assert_unreachable!("integrity check failed", { "thread": thread, "value": value });`
`910`	`913`	`}`
`911`	`914`	`log_sql(&sql_log, thread, "PRAGMA integrity_check", "OK");`
`912`	`915`	`}`
`913`	`916`	`Ok(None) => {`
`914`	`917`	`log_sql(&sql_log, thread, "PRAGMA integrity_check", "ERROR: no rows");`
`915`		`- panic!("thread#{thread} integrity check failed: no rows");`
	`918`	`+ turso_macros::turso_assert_unreachable!("integrity check returned no rows", { "thread": thread });`
`916`	`919`	`}`
`917`	`920`	`Err(e) => {`
`918`	`921`	`log_sql(`
`@@ -926,7 +929,7 @@ async fn async_main(opts: Opts) -> Result<(), Box<dyn std::error::Error + Send +`
`926`	`929`	`}`
`927`	`930`	`match res.next().await {`
`928`	`931`	`Ok(Some(_)) => {`
`929`		`- panic!("thread#{thread} integrity check failed: more than 1 row")`
	`932`	`+ turso_macros::turso_assert_unreachable!("integrity check returned more than 1 row", { "thread": thread });`
`930`	`933`	`}`
`931`	`934`	`Err(e) => println!("thread#{thread} Error performing integrity check: {e}"),`
`932`	`935`	`_ => {}`