Fix web3signer tests

Author: michaelsproul

testing/web3signer_tests/src/lib.rs

@@ -539,6 +539,59 @@ mod tests {
             }
             self
         }
+
+        /// Assert that a slashable attestation fails to be signed locally (empty result) and is
+        /// either signed or not by the web3signer rig depending on the value of
+        /// `web3signer_should_sign`.
+        ///
+        /// The batch attestation signing API returns an empty result instead of an error for
+        /// slashable attestations.
+        pub async fn assert_slashable_attestation_should_sign<F, R>(
+            self,
+            case_name: &str,
+            generate_sig: F,
+            web3signer_should_sign: bool,
+        ) -> Self
+        where
+            F: Fn(
+                PublicKeyBytes,
+                Arc<LighthouseValidatorStore<TestingSlotClock, E>>,
+            ) -> R,
+            R: Future<Output = Result<Vec<Attestation<E>>, lighthouse_validator_store::Error>>,
+        {
+            for validator_rig in &self.validator_rigs {
+                let result =
+                    generate_sig(self.validator_pubkey, validator_rig.validator_store.clone())
+                        .await;
+
+                if !validator_rig.using_web3signer || !web3signer_should_sign {
+                    // For local validators, slashable attestations should return an empty result
+                    // or an error.
+                    match result {
+                        Ok(attestations) => {
+                            assert!(
+                                attestations.is_empty(),
+                                "should not sign slashable {case_name}: expected empty result"
+                            );
+                        }
+                        Err(ValidatorStoreError::Slashable(_)) => {
+                            // Also acceptable - error indicates slashable
+                        }
+                        Err(e) => {
+                            panic!("unexpected error for slashable {case_name}: {e:?}");
+                        }
+                    }
+                } else {
+                    // Web3signer should sign (has its own slashing protection)
+                    let attestations = result.expect("should sign slashable {case_name}");
+                    assert!(
+                        !attestations.is_empty(),
+                        "web3signer should sign slashable {case_name}"
+                    );
+                }
+            }
+            self
+        }
     }
 
     /// Get a generic, arbitrary attestation for signing.
@@ -838,38 +891,35 @@ mod tests {
                 .unwrap()
         })
         .await
-        .assert_slashable_message_should_sign(
+        .assert_slashable_attestation_should_sign(
             "double_vote_attestation",
             move |pubkey, validator_store| async move {
                 let attestation = double_vote_attestation();
                 validator_store
                     .sign_attestations(vec![(pubkey, 0, attestation)])
                     .await
-                    .map(|_| ())
             },
             slashable_message_should_sign,
         )
         .await
-        .assert_slashable_message_should_sign(
+        .assert_slashable_attestation_should_sign(
             "surrounding_attestation",
             move |pubkey, validator_store| async move {
                 let attestation = surrounding_attestation();
                 validator_store
                     .sign_attestations(vec![(pubkey, 0, attestation)])
                     .await
-                    .map(|_| ())
             },
             slashable_message_should_sign,
         )
         .await
-        .assert_slashable_message_should_sign(
+        .assert_slashable_attestation_should_sign(
             "surrounded_attestation",
             move |pubkey, validator_store| async move {
                 let attestation = surrounded_attestation();
                 validator_store
                     .sign_attestations(vec![(pubkey, 0, attestation)])
                     .await
-                    .map(|_| ())
             },
             slashable_message_should_sign,
         )