add test schedule_procedure

Author: Centril

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

@@ -1,4 +1,7 @@
-use spacetimedb::{procedure, table, ProcedureContext, SpacetimeType, Table, TxContext};
+use spacetimedb::{
+    duration, procedure, reducer, table, DbContext, ProcedureContext, ReducerContext, ScheduleAt, SpacetimeType, Table,
+    Timestamp, TxContext,
+};
 
 #[derive(SpacetimeType)]
 struct ReturnStruct {
@@ -98,3 +101,52 @@ fn insert_with_tx_rollback(ctx: &mut ProcedureContext) {
     // Assert that there's not a row.
     assert_row_count(ctx, 0);
 }
+
+/// A reducer that schedules [`scheduled_proc`] via `ScheduledProcTable`.
+#[reducer]
+fn schedule_proc(ctx: &ReducerContext) {
+    // Schedule the procedure to run in 1s.
+    ctx.db().scheduled_proc_table().insert(ScheduledProcTable {
+        scheduled_id: 0,
+        scheduled_at: duration!("1000ms").into(),
+        // Store the timestamp at which this reducer was called.
+        // In tests, we'll compare this with the timestamp the procedure was called.
+        reducer_ts: ctx.timestamp,
+        x: 42,
+        y: 24,
+    });
+}
+
+#[table(name = scheduled_proc_table, scheduled(scheduled_proc))]
+struct ScheduledProcTable {
+    #[primary_key]
+    #[auto_inc]
+    scheduled_id: u64,
+    scheduled_at: ScheduleAt,
+    reducer_ts: Timestamp,
+    x: u8,
+    y: u8,
+}
+
+/// A procedure that should be called 1s after `schedule_proc`.
+#[procedure]
+fn scheduled_proc(ctx: &mut ProcedureContext, data: ScheduledProcTable) {
+    let ScheduledProcTable { reducer_ts, x, y, .. } = data;
+    let procedure_ts = ctx.timestamp;
+    ctx.with_tx(|ctx| {
+        ctx.db().proc_inserts_into().insert(ProcInsertsInto {
+            reducer_ts,
+            procedure_ts,
+            x,
+            y,
+        })
+    });
+}
+
+#[table(name = proc_inserts_into, public)]
+struct ProcInsertsInto {
+    reducer_ts: Timestamp,
+    procedure_ts: Timestamp,
+    x: u8,
+    y: u8,
+}

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

@@ -43,6 +43,7 @@ fn main() {
         "procedure-http-err" => exec_procedure_http_err(),
         "insert-with-tx-commit" => exec_insert_with_tx_commit(),
         "insert-with-tx-rollback" => exec_insert_with_tx_rollback(),
+        "schedule-procedure" => exec_schedule_procedure(),
         _ => panic!("Unknown test: {test}"),
     }
 }
@@ -97,7 +98,7 @@ fn connect_then(
 }
 
 /// A query that subscribes to all rows from all tables.
-const SUBSCRIBE_ALL: &[&str] = &["SELECT * FROM my_table;"];
+const SUBSCRIBE_ALL: &[&str] = &["SELECT * FROM my_table;", "SELECT * FROM proc_inserts_into;"];
 
 fn subscribe_all_then(ctx: &impl RemoteDbContext, callback: impl FnOnce(&SubscriptionEventContext) + Send + 'static) {
     subscribe_these_then(ctx, SUBSCRIBE_ALL, callback)
@@ -310,5 +311,30 @@ fn exec_procedure_http_err() {
             })
         }
     });
+
+    test_counter.wait_for_all();
+}
+
+fn exec_schedule_procedure() {
+    let test_counter = TestCounter::new();
+    let sub_applied_nothing_result = test_counter.add_test("on_subscription_applied_nothing");
+
+    let mut callback_result = Some(test_counter.add_test("insert_with_tx_commit_callback"));
+
+    connect_then(&test_counter, {
+        move |ctx| {
+            ctx.db().proc_inserts_into().on_insert(move |_, row| {
+                assert_eq!(row.x, 24);
+                assert_eq!(row.y, 42);
+                (callback_result.take().unwrap())(Ok(()));
+            });
+
+            subscribe_all_then(ctx, move |ctx| {
+                sub_applied_nothing_result(assert_all_tables_empty(ctx));
+                ctx.reducers.schedule_proc().unwrap();
+            });
+        }
+    });
+
     test_counter.wait_for_all();
 }