add tests in procedure-client

Author: Centril

crates/bindings/src/lib.rs

@@ -1186,6 +1186,8 @@ impl ProcedureContext {
 
         let run = || {
             // Start the transaction.
+
+            use core::mem;
             let timestamp = sys::procedure::procedure_start_mut_tx().expect(
                 "holding `&mut ProcedureContext`, so should not be in a tx already; called manually elsewhere?",
             );
@@ -1207,7 +1209,7 @@ impl ProcedureContext {
             let abort_guard = DoOnDrop(abort);
             let res = body(&tx);
             // Defuse the bomb.
-            let DoOnDrop(_) = abort_guard;
+            mem::forget(abort_guard);
             res
         };
 

modules/sdk-test-procedure/src/lib.rs

@@ -1,4 +1,4 @@
-use spacetimedb::{procedure, ProcedureContext, SpacetimeType};
+use spacetimedb::{procedure, table, ProcedureContext, SpacetimeType, Table, TxContext};
 
 #[derive(SpacetimeType)]
 struct ReturnStruct {
@@ -45,8 +45,42 @@ fn will_panic(_ctx: &mut ProcedureContext) {
 // and returns some value derived from the error.
 // Then write a test which invokes it in the Rust client SDK test suite.
 
-// TODO(procedure-tx): Add a procedure here which acquires a transaction, inserts a row, commits, then returns.
-// Then write a test which invokes it and asserts observing the row in the Rust client SDK test suite.
+#[table(public, name = my_table)]
+struct MyTable {
+    field: ReturnStruct,
+}
+
+fn insert_my_table(ctx: &TxContext) {
+    ctx.db.my_table().insert(MyTable {
+        field: ReturnStruct {
+            a: 42,
+            b: "magic".into(),
+        },
+    });
+}
+
+fn assert_row_count(ctx: &mut ProcedureContext, count: u64) {
+    ctx.with_tx(|ctx| {
+        assert_eq!(count, ctx.db.my_table().count());
+    });
+}
+
+#[procedure]
+fn insert_with_tx_commit(ctx: &mut ProcedureContext) {
+    // Insert a row and commit.
+    ctx.with_tx(insert_my_table);
+
+    // Assert that there's a row.
+    assert_row_count(ctx, 1);
+}
 
-// TODO(procedure-tx): Add a procedure here which acquires a transaction, inserts a row, rolls back, then returns.
-// Then write a test which invokes it and asserts not observing the row in the Rust client SDK test suite.
+#[procedure]
+fn insert_with_tx_rollback(ctx: &mut ProcedureContext) {
+    let _: Result<(), u32> = ctx.try_with_tx(|ctx| {
+        insert_my_table(ctx);
+        Err(24)
+    });
+
+    // Assert that there's not a row.
+    assert_row_count(ctx, 0);
+}

sdks/rust/tests/procedure-client/README.md

@@ -1,23 +1,15 @@
-This test client is used with two modules:
+This test client is used with the module:
 
-- [`sdk-test-connect-disconnect`](/modules/sdk-test-connect-disconnect)
-- [`sdk-test-connect-disconnect-cs`](/modules/sdk-test-connect-disconnect-cs)
+- [`sdk-test-procedure`](/modules/sdk-test-procedure)
 
-Currently, the bindings are generated using only one of those two modules,
-chosen arbitrarily on each test run.
-The two tests which use this client,
-`connect_disconnect_callbacks` and `connect_disconnect_callbacks_csharp`,
-are not intended to test code generation.
-
-The goal of the two tests is to verify that module-side `connect` and `disconnect` events
-fire when an SDK connects or disconnects via WebSocket,
-and that the client can observe mutations performed by those events.
+The goal of the test is to exercise various procedure related
+aspects of the (Rust) module ABI and the rust SDK.
 
 To (re-)generate the `module_bindings`, from this directory, run:
 
 ```sh
 mkdir -p src/module_bindings
 spacetime generate --lang rust                                     \
     --out-dir src/module_bindings                                  \
-    --project-path ../../../../modules/sdk-test-connect-disconnect
+    --project-path ../../../../modules/sdk-test-procedure
 ```

sdks/rust/tests/procedure-client/src/main.rs

@@ -1,9 +1,8 @@
 mod module_bindings;
 
-use module_bindings::*;
-
 use anyhow::Context;
-use spacetimedb_sdk::DbConnectionBuilder;
+use module_bindings::*;
+use spacetimedb_sdk::{DbConnectionBuilder, DbContext, Table};
 use test_counter::TestCounter;
 
 const LOCALHOST: &str = "http://localhost:3000";
@@ -39,10 +38,33 @@ fn main() {
     match &*test {
         "procedure-return-values" => exec_procedure_return_values(),
         "procedure-observe-panic" => exec_procedure_panic(),
+        "insert-with-tx-commit" => exec_insert_with_tx_commit(),
+        "insert-with-tx-rollback" => exec_insert_with_tx_rollback(),
         _ => panic!("Unknown test: {test}"),
     }
 }
 
+fn assert_table_empty<T: Table>(tbl: T) -> anyhow::Result<()> {
+    let count = tbl.count();
+    if count != 0 {
+        anyhow::bail!(
+            "Expected table {} to be empty, but found {} rows resident",
+            std::any::type_name::<T::Row>(),
+            count,
+        )
+    }
+    Ok(())
+}
+
+/// Each subscribing test runs against a fresh DB,
+/// so all tables should be empty until we call an insert reducer.
+///
+/// We'll call this function within our initial `on_subscription_applied` callback to verify that.
+fn assert_all_tables_empty(ctx: &impl RemoteDbContext) -> anyhow::Result<()> {
+    assert_table_empty(ctx.db().my_table())?;
+    Ok(())
+}
+
 fn connect_with_then(
     test_counter: &std::sync::Arc<TestCounter>,
     on_connect_suffix: &str,
@@ -71,6 +93,24 @@ fn connect_then(
     connect_with_then(test_counter, "", |x| x, callback)
 }
 
+/// A query that subscribes to all rows from all tables.
+const SUBSCRIBE_ALL: &[&str] = &["SELECT * FROM my_table;"];
+
+fn subscribe_all_then(ctx: &impl RemoteDbContext, callback: impl FnOnce(&SubscriptionEventContext) + Send + 'static) {
+    subscribe_these_then(ctx, SUBSCRIBE_ALL, callback)
+}
+
+fn subscribe_these_then(
+    ctx: &impl RemoteDbContext,
+    queries: &[&str],
+    callback: impl FnOnce(&SubscriptionEventContext) + Send + 'static,
+) {
+    ctx.subscription_builder()
+        .on_applied(callback)
+        .on_error(|_ctx, error| panic!("Subscription errored: {error:?}"))
+        .subscribe(queries);
+}
+
 fn exec_procedure_return_values() {
     let test_counter = TestCounter::new();
 
@@ -142,3 +182,65 @@ fn exec_procedure_panic() {
 
     test_counter.wait_for_all();
 }
+
+fn exec_insert_with_tx_commit() {
+    fn expected() -> ReturnStruct {
+        ReturnStruct {
+            a: 42,
+            b: "magic".into(),
+        }
+    }
+
+    let test_counter = TestCounter::new();
+    let sub_applied_nothing_result = test_counter.add_test("on_subscription_applied_nothing");
+    let inspect_result = test_counter.add_test("insert_with_tx_commit_values");
+    let mut callback_result = Some(test_counter.add_test("insert_with_tx_commit_callback"));
+
+    connect_then(&test_counter, {
+        move |ctx| {
+            ctx.db().my_table().on_insert(move |_, row| {
+                assert_eq!(row.field, expected());
+                (callback_result.take().unwrap())(Ok(()));
+            });
+
+            subscribe_all_then(ctx, move |ctx| {
+                sub_applied_nothing_result(assert_all_tables_empty(ctx));
+
+                ctx.procedures.insert_with_tx_commit_then(move |ctx, res| {
+                    assert!(res.is_ok());
+                    let row = ctx.db().my_table().iter().next().unwrap();
+                    assert_eq!(row.field, expected());
+                    inspect_result(Ok(()));
+                });
+            });
+        }
+    });
+
+    test_counter.wait_for_all();
+}
+
+fn exec_insert_with_tx_rollback() {
+    let test_counter = TestCounter::new();
+    let sub_applied_nothing_result = test_counter.add_test("on_subscription_applied_nothing");
+    let inspect_result = test_counter.add_test("insert_with_tx_rollback_values");
+
+    connect_then(&test_counter, {
+        move |ctx| {
+            ctx.db()
+                .my_table()
+                .on_insert(|_, _| unreachable!("should not have inserted a row"));
+
+            subscribe_all_then(ctx, move |ctx| {
+                sub_applied_nothing_result(assert_all_tables_empty(ctx));
+
+                ctx.procedures.insert_with_tx_rollback_then(move |ctx, res| {
+                    assert!(res.is_ok());
+                    assert_eq!(ctx.db().my_table().iter().next(), None);
+                    inspect_result(Ok(()));
+                });
+            });
+        }
+    });
+
+    test_counter.wait_for_all();
+}