gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-05-30 04:37:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove TestRandom (#9006)

Browse Source 
We  have a legacy `TestRandom` trait which generates random types for testing and fuzzing.
This function overlaps with `arbitrary` which is used very commonly in the ecosystem.


  Remove `TestRandom` and generate random type instances using `Arbitrary`.


Co-Authored-By: Mac L <mjladson@pm.me>

Co-Authored-By: Michael Sproul <michael@sigmaprime.io>
This commit is contained in:
Mac L
2026-05-05 10:35:57 +04:00
committed by GitHub
parent 4b314d8e79
commit 3351db1ba8
121 changed files with 418 additions and 1141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
common/eth2/Cargo.toml
View File

@@ -38,6 +38,6 @@ types = { workspace = true }
zeroize = { workspace = true, optional = true }
[dev-dependencies]
rand = { workspace = true }
test_random_derive = { path = "../../common/test_random_derive" }
arbitrary = { workspace = true }
tokio = { workspace = true }
types = { workspace = true, features = ["arbitrary"] }

105
common/eth2/src/types.rs
View File

@@ -26,11 +26,6 @@ use std::sync::Arc;
use std::time::Duration;
use superstruct::superstruct;
#[cfg(test)]
use test_random_derive::TestRandom;
#[cfg(test)]
use types::test_utils::TestRandom;
// TODO(mac): Temporary module and re-export hack to expose old `consensus/types` via `eth2/types`.
pub use crate::beacon_response::*;
pub mod beacon_response {
@@ -2364,7 +2359,7 @@ pub enum ContentType {
Ssz,
}
#[cfg_attr(test, derive(TestRandom))]
#[cfg_attr(test, derive(arbitrary::Arbitrary))]
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Encode, Decode)]
#[serde(bound = "E: EthSpec")]
pub struct BlobsBundle<E: EthSpec> {
@@ -2470,7 +2465,7 @@ pub struct BlobWrapper<E: EthSpec> {
mod test {
use std::fmt::Debug;
use types::test_utils::{SeedableRng, TestRandom, XorShiftRng};
use arbitrary::Arbitrary;
use super::*;
@@ -2498,13 +2493,16 @@ mod test {
assert_eq!(request, deserialized_request);
};
let rng = &mut XorShiftRng::from_seed([42; 16]);
let mut u = types::test_utils::test_unstructured();
for fork_name in ForkName::list_all() {
let signed_beacon_block =
map_fork_name!(fork_name, SignedBeaconBlock, <_>::random_for_test(rng));
let signed_beacon_block = map_fork_name!(
fork_name,
SignedBeaconBlock,
<_>::arbitrary(&mut u).unwrap()
);
let request = if fork_name.deneb_enabled() && !fork_name.gloas_enabled() {
let kzg_proofs = KzgProofs::<MainnetEthSpec>::random_for_test(rng);
let blobs = BlobsList::<MainnetEthSpec>::random_for_test(rng);
let kzg_proofs = KzgProofs::<MainnetEthSpec>::arbitrary(&mut u).unwrap();
let blobs = BlobsList::<MainnetEthSpec>::arbitrary(&mut u).unwrap();
let block_contents = SignedBlockContents {
signed_block: Arc::new(signed_beacon_block),
kzg_proofs,
@@ -2532,12 +2530,15 @@ mod test {
};
let mut fork_name = ForkName::Deneb;
let rng = &mut XorShiftRng::from_seed([42; 16]);
let mut u = types::test_utils::test_unstructured();
loop {
let signed_beacon_block =
map_fork_name!(fork_name, SignedBeaconBlock, <_>::random_for_test(rng));
let kzg_proofs = KzgProofs::<MainnetEthSpec>::random_for_test(rng);
let blobs = BlobsList::<MainnetEthSpec>::random_for_test(rng);
let signed_beacon_block = map_fork_name!(
fork_name,
SignedBeaconBlock,
<_>::arbitrary(&mut u).unwrap()
);
let kzg_proofs = KzgProofs::<MainnetEthSpec>::arbitrary(&mut u).unwrap();
let blobs = BlobsList::<MainnetEthSpec>::arbitrary(&mut u).unwrap();
let block_contents = SignedBlockContents {
signed_block: Arc::new(signed_beacon_block),
kzg_proofs,
@@ -2555,25 +2556,27 @@ mod test {
#[test]
fn test_execution_payload_execution_payload_deserialize_by_fork() {
let rng = &mut XorShiftRng::from_seed([42; 16]);
let mut u = types::test_utils::test_unstructured();
let payloads = [
ExecutionPayload::Bellatrix(
ExecutionPayloadBellatrix::<MainnetEthSpec>::random_for_test(rng),
ExecutionPayloadBellatrix::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
),
ExecutionPayload::Capella(
ExecutionPayloadCapella::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
),
ExecutionPayload::Deneb(
ExecutionPayloadDeneb::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
),
ExecutionPayload::Electra(
ExecutionPayloadElectra::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
),
ExecutionPayload::Fulu(
ExecutionPayloadFulu::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
),
ExecutionPayload::Gloas(
ExecutionPayloadGloas::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
),
ExecutionPayload::Capella(ExecutionPayloadCapella::<MainnetEthSpec>::random_for_test(
rng,
)),
ExecutionPayload::Deneb(ExecutionPayloadDeneb::<MainnetEthSpec>::random_for_test(
rng,
)),
ExecutionPayload::Electra(ExecutionPayloadElectra::<MainnetEthSpec>::random_for_test(
rng,
)),
ExecutionPayload::Fulu(ExecutionPayloadFulu::<MainnetEthSpec>::random_for_test(rng)),
ExecutionPayload::Gloas(ExecutionPayloadGloas::<MainnetEthSpec>::random_for_test(
rng,
)),
];
let merged_forks = &ForkName::list_all()[2..];
assert_eq!(
@@ -2592,48 +2595,44 @@ mod test {
#[test]
fn test_execution_payload_and_blobs_deserialize_by_fork() {
let rng = &mut XorShiftRng::from_seed([42; 16]);
let mut u = types::test_utils::test_unstructured();
let payloads = [
{
let execution_payload =
ExecutionPayload::Deneb(
ExecutionPayloadDeneb::<MainnetEthSpec>::random_for_test(rng),
);
let blobs_bundle = BlobsBundle::random_for_test(rng);
let execution_payload = ExecutionPayload::Deneb(
ExecutionPayloadDeneb::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
);
let blobs_bundle = BlobsBundle::<MainnetEthSpec>::arbitrary(&mut u).unwrap();
ExecutionPayloadAndBlobs {
execution_payload,
blobs_bundle,
}
},
{
let execution_payload =
ExecutionPayload::Electra(
ExecutionPayloadElectra::<MainnetEthSpec>::random_for_test(rng),
);
let blobs_bundle = BlobsBundle::random_for_test(rng);
let execution_payload = ExecutionPayload::Electra(
ExecutionPayloadElectra::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
);
let blobs_bundle = BlobsBundle::<MainnetEthSpec>::arbitrary(&mut u).unwrap();
ExecutionPayloadAndBlobs {
execution_payload,
blobs_bundle,
}
},
{
let execution_payload =
ExecutionPayload::Fulu(
ExecutionPayloadFulu::<MainnetEthSpec>::random_for_test(rng),
);
let blobs_bundle = BlobsBundle::random_for_test(rng);
let execution_payload = ExecutionPayload::Fulu(
ExecutionPayloadFulu::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
);
let blobs_bundle = BlobsBundle::<MainnetEthSpec>::arbitrary(&mut u).unwrap();
ExecutionPayloadAndBlobs {
execution_payload,
blobs_bundle,
}
},
{
let execution_payload =
ExecutionPayload::Gloas(
ExecutionPayloadGloas::<MainnetEthSpec>::random_for_test(rng),
);
let blobs_bundle = BlobsBundle::random_for_test(rng);
let execution_payload = ExecutionPayload::Gloas(
ExecutionPayloadGloas::<MainnetEthSpec>::arbitrary(&mut u).unwrap(),
);
let blobs_bundle = BlobsBundle::<MainnetEthSpec>::arbitrary(&mut u).unwrap();
ExecutionPayloadAndBlobs {
execution_payload,
blobs_bundle,

13
common/test_random_derive/Cargo.toml
View File

@@ -1,13 +0,0 @@
[package]
name = "test_random_derive"
version = "0.2.0"
authors = ["thojest <thojest@gmail.com>"]
edition = { workspace = true }
description = "Procedural derive macros for implementation of TestRandom trait"
[lib]
proc-macro = true
[dependencies]
quote = { workspace = true }
syn = { workspace = true }

59
common/test_random_derive/src/lib.rs
View File

@@ -1,59 +0,0 @@
use proc_macro::TokenStream;
use quote::quote;
use syn::{DeriveInput, parse_macro_input};
/// Returns true if some field has an attribute declaring it should be generated from default (not
/// randomized).
///
/// The field attribute is: `#[test_random(default)]`
fn should_use_default(field: &syn::Field) -> bool {
field.attrs.iter().any(|attr| {
attr.path().is_ident("test_random")
&& matches!(&attr.meta, syn::Meta::List(list) if list.tokens.to_string().replace(' ', "") == "default")
})
}
#[proc_macro_derive(TestRandom, attributes(test_random))]
pub fn test_random_derive(input: TokenStream) -> TokenStream {
let derived_input = parse_macro_input!(input as DeriveInput);
let name = &derived_input.ident;
let (impl_generics, ty_generics, where_clause) = &derived_input.generics.split_for_impl();
let syn::Data::Struct(struct_data) = &derived_input.data else {
panic!("test_random_derive only supports structs.");
};
// Build quotes for fields that should be generated and those that should be built from
// `Default`.
let mut quotes = vec![];
for field in &struct_data.fields {
match &field.ident {
Some(ident) => {
if should_use_default(field) {
quotes.push(quote! {
#ident: <_>::default(),
});
} else {
quotes.push(quote! {
#ident: <_>::random_for_test(rng),
});
}
}
_ => panic!("test_random_derive only supports named struct fields."),
};
}
let output = quote! {
impl #impl_generics TestRandom for #name #ty_generics #where_clause {
fn random_for_test(rng: &mut impl rand::RngCore) -> Self {
Self {
#(
#quotes
)*
}
}
}
};
output.into()
}