WIP: proptest_async

Author: kasbah

Cargo.lock

@@ -54,3 +54,6 @@ uuid = { version = "1.10.0", features = ["v7", "serde"] }
 proptest = { version = "1.9.0", optional = true }
 proptest-derive = { version = "0.7.0", optional = true }
 proptest-arbitrary-interop = { version = "0.1", optional = true }
+
+[dev-dependencies]
+test-strategy = "0.4"

packages/backend/Cargo.toml

@@ -2,36 +2,30 @@
 mod tests {
     use backend::app::AppError;
     use backend::auth::PermissionLevel;
-    use backend::user_state::UserState;
-    use proptest::prelude::*;
+    use backend::user_state::arbitrary::arbitrary_user_state_with_id;
+    use backend::user_state::{UserState, read_user_state_from_db};
     use sqlx::PgPool;
-
-    struct UserStateTestFixture {
-        pool: PgPool,
+    use test_strategy::proptest;
+
+    async fn get_pool() -> PgPool {
+        let database_url =
+            std::env::var("DATABASE_URL").expect("DATABASE_URL must be set for tests");
+        PgPool::connect(&database_url)
+            .await
+            .expect("Failed to connect to database")
     }
 
-    impl UserStateTestFixture {
-        async fn setup() -> Self {
-            let database_url =
-                std::env::var("DATABASE_URL").expect("DATABASE_URL must be set for tests");
-
-            let pool = PgPool::connect(&database_url).await.expect("Failed to connect to database");
-
-            Self { pool }
-        }
-
-        async fn cleanup(&self, user_ids: &[&str]) {
-            // TODO: find saner way to setup and cleanup a test db
-            let _ = sqlx::query("DELETE FROM permissions WHERE subject = ANY($1)")
-                .bind(user_ids)
-                .execute(&self.pool)
-                .await;
-
-            let _ = sqlx::query("DELETE FROM users WHERE id = ANY($1)")
-                .bind(user_ids)
-                .execute(&self.pool)
-                .await;
-        }
+    async fn cleanup(pool: &PgPool, user_ids: &[&str]) {
+        // TODO: find saner way to setup and cleanup a test db
+        let _ = sqlx::query("DELETE FROM permissions WHERE subject = ANY($1)")
+            .bind(user_ids)
+            .execute(pool)
+            .await;
+
+        let _ = sqlx::query("DELETE FROM users WHERE id = ANY($1)")
+            .bind(user_ids)
+            .execute(pool)
+            .await;
     }
 
     /// Writes user state to the database. This is only for testing purposes.
@@ -44,7 +38,7 @@ mod tests {
     /// Note: The owner of a document is determined by who has the 'own' permission.
     /// If the doc has an owner specified, that user gets 'own' permission.
     /// The requesting user gets their specified permission level.
-    pub async fn write_user_state_to_db(
+    async fn write_user_state_to_db(
         user_id: String,
         db: &PgPool,
         state: &UserState,
@@ -68,7 +62,7 @@ mod tests {
                     user_id.clone()
                 } else {
                     // No owner specified and user doesn't own - skip this invalid case
-                    return user_id.clone();
+                    user_id.clone()
                 }
             });
 
@@ -147,61 +141,40 @@ mod tests {
         Ok(())
     }
 
-    proptest! {
-        #[test]
-        fn generates_user_states_always_true(_state in any::<UserState>()) {
-            prop_assert!(true);
-        }
-    }
-
-    #[tokio::test]
-    async fn user_state_roundtrip() {
-        use backend::user_state::arbitrary::arbitrary_user_state_with_id;
-        use backend::user_state::read_user_state_from_db;
-        use proptest::strategy::ValueTree;
-        use proptest::test_runner::TestRunner;
-
-        // Skip test if DATABASE_URL is not set
-        if std::env::var("DATABASE_URL").is_err() {
-            eprintln!("Skipping user_state_roundtrip: DATABASE_URL not set");
-            return;
-        }
-
-        let fixture = UserStateTestFixture::setup().await;
-
-        // Generate test cases synchronously
-        let mut runner = TestRunner::default();
-        let strategy = arbitrary_user_state_with_id();
-
-        for _ in 0..256 {
-            let (user_id, state) =
-                strategy.new_tree(&mut runner).expect("Failed to generate test case").current();
-
-            // Write state to db
-            write_user_state_to_db(user_id.clone(), &fixture.pool, &state)
-                .await
-                .expect("Failed to write user state");
-
-            // Read state back from db
-            let read_state = read_user_state_from_db(user_id.clone(), &fixture.pool)
-                .await
-                .expect("Failed to read user state");
-
-            // Cleanup test data
-            let user_ids: Vec<&str> = std::iter::once(user_id.as_str())
-                .chain(
-                    state.documents.iter().filter_map(|d| d.owner.as_ref().map(|o| o.id.as_str())),
-                )
-                .collect();
-            fixture.cleanup(&user_ids).await;
+    #[proptest(async = "tokio")]
+    async fn user_state_roundtrip(
+        #[strategy(arbitrary_user_state_with_id())] user_id_and_state: (String, UserState),
+    ) {
+        let (user_id, state) = user_id_and_state;
+        let pool = get_pool().await;
+
+        // Write state to db
+        write_user_state_to_db(user_id.clone(), &pool, &state)
+            .await
+            .expect("Failed to write user state");
+
+        // Read state back from db
+        let read_state = read_user_state_from_db(user_id.clone(), &pool)
+            .await
+            .expect("Failed to read user state");
+
+        // Cleanup test data
+        let user_ids: Vec<&str> = std::iter::once(user_id.as_str())
+            .chain(
+                state
+                    .documents
+                    .iter()
+                    .filter_map(|d| d.owner.as_ref().map(|o| o.id.as_str())),
+            )
+            .collect();
+        cleanup(&pool, &user_ids).await;
 
-            // Sort both document lists by ref_id for comparison (read returns sorted by created_at DESC)
-            let mut expected_docs = state.documents.clone();
-            let mut actual_docs = read_state.documents.clone();
-            expected_docs.sort_by(|a, b| a.ref_id.cmp(&b.ref_id));
-            actual_docs.sort_by(|a, b| a.ref_id.cmp(&b.ref_id));
+        // Sort both document lists by ref_id for comparison (read returns sorted by created_at DESC)
+        let mut expected_docs = state.documents.clone();
+        let mut actual_docs = read_state.documents.clone();
+        expected_docs.sort_by(|a, b| a.ref_id.cmp(&b.ref_id));
+        actual_docs.sort_by(|a, b| a.ref_id.cmp(&b.ref_id));
 
-            assert_eq!(expected_docs, actual_docs, "UserState roundtrip failed");
-        }
+        proptest::prop_assert_eq!(expected_docs, actual_docs);
     }
 }