lib

commit 2eac6175e6622501d26d75ee494be4a1038d1de2
parent ea908f577b6b5a2e98169ddd535a5d68b2b0d1ad
Author: triesap <tyson@radroots.org>
Date:   Fri,  6 Mar 2026 16:33:25 +0000

replica-sync: extend emit queryfail coverage

- add a dedicated test for queryfail propagation across emit helpers
- exercise sync-all option slices with targeted failing executor needles
- assert error surfacing for profile farm plot list-set and claim emits
- keep positive-control assertions for the non-failing sqlite path

Diffstat:
M
crates/replica-sync/src/emit.rs
 | 
141
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1 file changed, 141 insertions(+), 0 deletions(-)
diff --git a/crates/replica-sync/src/emit.rs b/crates/replica-sync/src/emit.rs
@@ -1720,6 +1720,147 @@ mod tests {
     }
 
     #[test]
+    fn emit_propagates_queryfail_and_builder_errors() {
+        let exec = SqliteExecutor::open_memory().expect("db");
+        let (farm_row, _, _) = seed(&exec);
+        let selector = RadrootsReplicaFarmSelector {
+            id: Some(farm_row.id.clone()),
+            d_tag: None,
+            pubkey: None,
+        };
+
+        let profile_query_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "farm_member_claim",
+            err: SqlError::Internal,
+        };
+        assert!(radroots_replica_profile_events(&profile_query_fail, &farm_row).is_err());
+        let profile_load_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "nostr_profile",
+            err: SqlError::Internal,
+        };
+        assert!(radroots_replica_profile_events(&profile_load_fail, &farm_row).is_err());
+
+        let farm_tag_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "farm_tag",
+            err: SqlError::Internal,
+        };
+        assert!(radroots_replica_farm_event(&farm_tag_fail, &farm_row).is_err());
+
+        let plot_tag_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "plot_tag",
+            err: SqlError::Internal,
+        };
+        assert!(radroots_replica_plot_events(&plot_tag_fail, &farm_row).is_err());
+
+        let list_set_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "farm_member",
+            err: SqlError::Internal,
+        };
+        assert!(radroots_replica_list_set_events(&list_set_fail, &farm_row).is_err());
+
+        let claims_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "farm_member_claim",
+            err: SqlError::Internal,
+        };
+        assert!(radroots_replica_membership_claim_events(&claims_fail, &farm_row.pubkey).is_err());
+
+        let sync_profiles_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "nostr_profile",
+            err: SqlError::Internal,
+        };
+        assert!(
+            radroots_replica_sync_all_with_options(
+                &sync_profiles_fail,
+                &selector,
+                Some(&RadrootsReplicaSyncOptions {
+                    include_profiles: Some(true),
+                    include_list_sets: Some(false),
+                    include_membership_claims: Some(false),
+                }),
+            )
+            .is_err()
+        );
+        let sync_farm_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "farm_tag",
+            err: SqlError::Internal,
+        };
+        assert!(
+            radroots_replica_sync_all_with_options(
+                &sync_farm_fail,
+                &selector,
+                Some(&RadrootsReplicaSyncOptions {
+                    include_profiles: Some(false),
+                    include_list_sets: Some(false),
+                    include_membership_claims: Some(false),
+                }),
+            )
+            .is_err()
+        );
+        let sync_plot_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "plot_tag",
+            err: SqlError::Internal,
+        };
+        assert!(
+            radroots_replica_sync_all_with_options(
+                &sync_plot_fail,
+                &selector,
+                Some(&RadrootsReplicaSyncOptions {
+                    include_profiles: Some(false),
+                    include_list_sets: Some(false),
+                    include_membership_claims: Some(false),
+                }),
+            )
+            .is_err()
+        );
+        let sync_list_set_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "farm_member",
+            err: SqlError::Internal,
+        };
+        assert!(
+            radroots_replica_sync_all_with_options(
+                &sync_list_set_fail,
+                &selector,
+                Some(&RadrootsReplicaSyncOptions {
+                    include_profiles: Some(false),
+                    include_list_sets: Some(true),
+                    include_membership_claims: Some(false),
+                }),
+            )
+            .is_err()
+        );
+        let sync_claims_fail = QueryFailExecutor {
+            inner: &exec,
+            needle: "farm_member_claim",
+            err: SqlError::Internal,
+        };
+        assert!(
+            radroots_replica_sync_all_with_options(
+                &sync_claims_fail,
+                &selector,
+                Some(&RadrootsReplicaSyncOptions {
+                    include_profiles: Some(false),
+                    include_list_sets: Some(false),
+                    include_membership_claims: Some(true),
+                }),
+            )
+            .is_err()
+        );
+
+        assert!(radroots_replica_farm_event(&exec, &farm_row).is_ok());
+        assert!(radroots_replica_plot_events(&exec, &farm_row).is_ok());
+    }
+
+    #[test]
     fn emit_pass_through_executor_instantiation_paths_are_covered() {
         let exec = SqliteExecutor::open_memory().expect("db");
         let (farm_row, _, plot_secondary) = seed(&exec);