make lib and async

Author: Shubham8287

Cargo.lock

@@ -1,5 +1,5 @@
 [package]
-name = "spacetimedb-dst"
+name = "spacetimedb-dst-lib"
 version.workspace = true
 edition.workspace = true
 rust-version.workspace = true

crates/dst/Cargo.toml

@@ -274,10 +274,14 @@ impl EngineTarget {
 impl TargetDriver<Interaction> for EngineTarget {
     type Observation = Observation;
 
-    fn execute(&mut self, interaction: &Interaction) -> Result<Self::Observation, anyhow::Error> {
-        EngineTarget::execute(self, interaction)
+    fn execute<'a>(
+        &'a mut self,
+        interaction: &'a Interaction,
+    ) -> impl std::future::Future<Output = Result<Self::Observation, anyhow::Error>> + 'a {
+        async move { EngineTarget::execute(self, interaction) }
     }
 }
+
 pub struct EngineTest;
 
 impl TestSuite for EngineTest {
@@ -289,15 +293,21 @@ impl TestSuite for EngineTest {
 
     type Properties = EngineProperties;
 
-    fn build(&self, rng: Rng) -> Result<(Self::Interactions, Self::Target, Self::Properties), anyhow::Error> {
-        let schema = default_schema(rng.clone());
-        let runtime_seed = rng.next_u64();
-        let target = EngineTarget::init(schema.clone(), runtime_seed)?;
-        let properties = EngineProperties::new(schema.clone());
-
-        let model = Model::new(schema);
-        let interactions = WorkloadGen::new(rng, model);
-
-        Ok((interactions, target, properties))
+    fn build(
+        &self,
+        rng: Rng,
+    ) -> impl std::future::Future<Output = Result<(Self::Interactions, Self::Target, Self::Properties), anyhow::Error>> + '_
+    {
+        async move {
+            let schema = default_schema(rng.clone());
+            let runtime_seed = rng.next_u64();
+            let target = EngineTarget::init(schema.clone(), runtime_seed)?;
+            let properties = EngineProperties::new(schema.clone());
+
+            let model = Model::new(schema);
+            let interactions = WorkloadGen::new(rng, model);
+
+            Ok((interactions, target, properties))
+        }
     }
 }

crates/dst/README.md

@@ -0,0 +1,6 @@
+pub mod engine;
+pub mod schema;
+pub mod sim;
+pub mod traits;
+
+pub use traits::{Properties, TargetDriver, TestSuite, TestSuiteParts};

crates/dst/src/engine.rs

@@ -22,6 +22,12 @@ pub struct InMemoryCommitlog {
     options: Options,
 }
 
+impl Default for InMemoryCommitlog {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl InMemoryCommitlog {
     pub fn new() -> Self {
         Self {

crates/dst/src/lib.rs

@@ -5,7 +5,10 @@ use spacetimedb_runtime::sim::Rng;
 pub trait TargetDriver<I> {
     type Observation;
 
-    fn execute(&mut self, interaction: &I) -> Result<Self::Observation, Error>;
+    fn execute<'a>(
+        &'a mut self,
+        interaction: &'a I,
+    ) -> impl std::future::Future<Output = Result<Self::Observation, Error>> + 'a;
 }
 
 /// Ensures if Output of `TargetDrive` is expected for the input
@@ -20,32 +23,35 @@ pub type TestSuiteParts<S> = (
 );
 
 pub trait TestSuite {
-    type Interaction;
+    type Interaction: std::fmt::Debug;
     type Interactions: Iterator<Item = Self::Interaction> + std::fmt::Debug;
     type Target: TargetDriver<Self::Interaction>;
     type Properties: Properties<Self::Interaction, <Self::Target as TargetDriver<Self::Interaction>>::Observation>;
 
-    fn build(&self, rng: Rng) -> Result<TestSuiteParts<Self>, Error>
+    fn build(&self, rng: Rng) -> impl std::future::Future<Output = Result<TestSuiteParts<Self>, Error>> + '_
     where
         Self: Sized;
 
-    fn run(&self, rng: Rng, max_interactions: Option<usize>) -> Result<(), Error>
+    fn run(&self, rng: Rng, max_interactions: usize) -> impl std::future::Future<Output = Result<(), Error>> + '_
     where
         Self: Sized,
     {
-        let (mut interactions, mut target, mut properties) = self.build(rng)?;
+        async move {
+            let (mut interactions, mut target, mut properties) = self.build(rng).await?;
 
-        let result = (|| {
-            for interaction in interactions.by_ref().take(max_interactions.unwrap_or(usize::MAX)) {
-                let observation = target.execute(&interaction)?;
-                properties.observe(&interaction, &observation)?;
-            }
+            let result = async {
+                for interaction in interactions.by_ref().take(max_interactions) {
+                    let observation = target.execute(&interaction).await?;
+                    properties.observe(&interaction, &observation)?;
+                }
 
-            Ok(())
-        })();
+                Ok(())
+            }
+            .await;
 
-        tracing::info!(interaction_counts = ?interactions, "final interaction counts");
+            tracing::info!(interaction_counts = ?interactions, "final interaction counts");
 
-        result
+            result
+        }
     }
 }