harden tests for drop/create table transactionality

Author: Centril

crates/core/src/db/datastore/locking_tx_datastore/datastore.rs

@@ -1038,6 +1038,7 @@ fn metadata_from_row(row: RowRef<'_>) -> Result<Metadata> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::db::datastore::locking_tx_datastore::tx_state::PendingSchemaChange;
     use crate::db::datastore::system_tables::{
         system_tables, StColumnRow, StConstraintData, StConstraintFields, StConstraintRow, StIndexAlgorithm,
         StIndexFields, StIndexRow, StRowLevelSecurityFields, StScheduledFields, StSequenceFields, StSequenceRow,
@@ -2902,11 +2903,25 @@ mod tests {
 
         // Create a transaction and drop the table and roll back.
         let mut tx = begin_mut_tx(&datastore);
+        assert_eq!(&*tx.tx_state.pending_schema_changes, []);
         assert!(datastore.drop_table_mut_tx(&mut tx, table_id).is_ok());
+        assert_matches!(
+            &*tx.tx_state.pending_schema_changes,
+            [
+                PendingSchemaChange::IndexRemoved(..),
+                PendingSchemaChange::IndexRemoved(..),
+                PendingSchemaChange::SequenceRemoved(..),
+                PendingSchemaChange::ConstraintRemoved(..),
+                PendingSchemaChange::ConstraintRemoved(..),
+                PendingSchemaChange::TableRemoved(removed_table_id, _)
+            ]
+                if *removed_table_id == table_id
+        );
         datastore.rollback_mut_tx(tx);
 
         // Ensure the table still exists in the next transaction.
         let tx = begin_mut_tx(&datastore);
+        assert_eq!(&*tx.tx_state.pending_schema_changes, []);
         assert!(
             datastore.table_id_exists_mut_tx(&tx, &table_id),
             "Table should still exist",
@@ -2919,10 +2934,23 @@ mod tests {
     fn test_create_table_is_transactional() -> ResultTest<()> {
         // Create a table in a failed transaction.
         let (datastore, tx, table_id) = setup_table()?;
+        assert_matches!(
+            &*tx.tx_state.pending_schema_changes,
+            [
+                PendingSchemaChange::TableAdded(added_table_id),
+                PendingSchemaChange::IndexAdded(..),
+                PendingSchemaChange::IndexAdded(..),
+                PendingSchemaChange::ConstraintAdded(..),
+                PendingSchemaChange::ConstraintAdded(..),
+                PendingSchemaChange::SequenceAdded(..),
+            ]
+                if *added_table_id == table_id
+        );
         datastore.rollback_mut_tx(tx);
 
         // Nothing should have happened.
         let tx = begin_mut_tx(&datastore);
+        assert_eq!(&*tx.tx_state.pending_schema_changes, []);
         assert!(
             !datastore.table_id_exists_mut_tx(&tx, &table_id),
             "Table should not exist"

crates/core/src/db/datastore/locking_tx_datastore/sequence.rs

@@ -3,6 +3,7 @@ use spacetimedb_primitives::SequenceId;
 use spacetimedb_schema::schema::SequenceSchema;
 use spacetimedb_table::MemoryUsage;
 
+#[derive(Debug, PartialEq)]
 pub(super) struct Sequence {
     schema: SequenceSchema,
     pub(super) value: i128,

crates/core/src/db/datastore/locking_tx_datastore/tx_state.rs

@@ -86,6 +86,7 @@ pub(super) struct TxState {
 /// The places that do need to care about changes are those that make them, and merge/rollback.
 /// Architecting this way should benefit performance both during transactions and merge.
 /// On rollback, it should be fairly cheap to e.g., just re-add an index or drop it on the floor.
+#[derive(Debug, PartialEq)]
 pub(super) enum PendingSchemaChange {
     /// The [`TableIndex`] / [`IndexSchema`] with `IndexId`
     /// was removed from the table with [`TableId`].