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

get tests compiling

Browse Source
This commit is contained in:
realbigsean
2023-05-23 12:10:54 -04:00
parent 8ea98c596c
commit 98d7a1014f
3 changed files with 62 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
View File

@@ -1138,11 +1138,13 @@ mod test {
.as_ref() .as_ref()
.cloned() .cloned()
.expect("kzg should exist"); .expect("kzg should exist");
let mut kzg_verified_blobs = Vec::new();
for (blob_index, gossip_blob) in blobs.into_iter().enumerate() { for (blob_index, gossip_blob) in blobs.into_iter().enumerate() {
let kzg_verified_blob = let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref())
verify_kzg_for_blob(gossip_blob, kzg.as_ref()).expect("kzg should verify"); .expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
let availability = cache let availability = cache
.put_kzg_verified_blob(kzg_verified_blob) .put_kzg_verified_blobs(root, kzg_verified_blobs.as_slice())
.expect("should put blob"); .expect("should put blob");
if blob_index == blobs_expected - 1 { if blob_index == blobs_expected - 1 {
assert!(matches!(availability, Availability::Available(_))); assert!(matches!(availability, Availability::Available(_)));
@@ -1164,11 +1166,13 @@ mod test {
"should have expected number of blobs" "should have expected number of blobs"
); );
let root = pending_block.import_data.block_root; let root = pending_block.import_data.block_root;
let mut kzg_verified_blobs = vec![];
for gossip_blob in blobs { for gossip_blob in blobs {
let kzg_verified_blob = let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref())
verify_kzg_for_blob(gossip_blob, kzg.as_ref()).expect("kzg should verify"); .expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
let availability = cache let availability = cache
.put_kzg_verified_blob(kzg_verified_blob) .put_kzg_verified_blobs(root, kzg_verified_blobs.as_slice())
.expect("should put blob"); .expect("should put blob");
assert_eq!( assert_eq!(
availability, availability,
@@ -1308,11 +1312,13 @@ mod test {
let blobs_0 = pending_blobs.pop_front().expect("should have blobs"); let blobs_0 = pending_blobs.pop_front().expect("should have blobs");
let expected_blobs = blobs_0.len(); let expected_blobs = blobs_0.len();
let mut kzg_verified_blobs = vec![];
for (blob_index, gossip_blob) in blobs_0.into_iter().enumerate() { for (blob_index, gossip_blob) in blobs_0.into_iter().enumerate() {
let kzg_verified_blob = let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref())
verify_kzg_for_blob(gossip_blob, kzg.as_ref()).expect("kzg should verify"); .expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
let availability = cache let availability = cache
.put_kzg_verified_blob(kzg_verified_blob) .put_kzg_verified_blobs(roots[0], kzg_verified_blobs.as_slice())
.expect("should put blob"); .expect("should put blob");
if blob_index == expected_blobs - 1 { if blob_index == expected_blobs - 1 {
assert!(matches!(availability, Availability::Available(_))); assert!(matches!(availability, Availability::Available(_)));
@@ -1396,15 +1402,18 @@ mod test {
.cloned() .cloned()
.expect("kzg should exist"); .expect("kzg should exist");
let mut kzg_verified_blobs = vec![];
for _ in 0..(n_epochs * capacity) { for _ in 0..(n_epochs * capacity) {
let pending_block = pending_blocks.pop_front().expect("should have block"); let pending_block = pending_blocks.pop_front().expect("should have block");
let block_root = pending_block.block.as_block().canonical_root();
let expected_blobs = pending_block.num_blobs_expected(); let expected_blobs = pending_block.num_blobs_expected();
if expected_blobs > 1 { if expected_blobs > 1 {
// might as well add a blob too // might as well add a blob too
let mut pending_blobs = pending_blobs.pop_front().expect("should have blobs"); let mut pending_blobs = pending_blobs.pop_front().expect("should have blobs");
let one_blob = pending_blobs.pop().expect("should have at least one blob"); let one_blob = pending_blobs.pop().expect("should have at least one blob");
let kzg_verified_blob = let kzg_verified_blob = verify_kzg_for_blob(one_blob.to_blob(), kzg.as_ref())
verify_kzg_for_blob(one_blob, kzg.as_ref()).expect("kzg should verify"); .expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
// generate random boolean // generate random boolean
let block_first = (rand::random::<usize>() % 2) == 0; let block_first = (rand::random::<usize>() % 2) == 0;
if block_first { if block_first {
@@ -1416,7 +1425,7 @@ mod test {
"should have pending blobs" "should have pending blobs"
); );
let availability = cache let availability = cache
.put_kzg_verified_blob(kzg_verified_blob) .put_kzg_verified_blobs(block_root, kzg_verified_blobs.as_slice())
.expect("should put blob"); .expect("should put blob");
assert!( assert!(
matches!(availability, Availability::MissingComponents(_)), matches!(availability, Availability::MissingComponents(_)),
@@ -1425,7 +1434,7 @@ mod test {
); );
} else { } else {
let availability = cache let availability = cache
.put_kzg_verified_blob(kzg_verified_blob) .put_kzg_verified_blobs(block_root, kzg_verified_blobs.as_slice())
.expect("should put blob"); .expect("should put blob");
let root = pending_block.block.as_block().canonical_root(); let root = pending_block.block.as_block().canonical_root();
assert_eq!( assert_eq!(
@@ -1547,6 +1556,7 @@ mod test {
.expect("kzg should exist"); .expect("kzg should exist");
let mut remaining_blobs = HashMap::new(); let mut remaining_blobs = HashMap::new();
let mut kzg_verified_blobs = vec![];
for _ in 0..(n_epochs * capacity) { for _ in 0..(n_epochs * capacity) {
let pending_block = pending_blocks.pop_front().expect("should have block"); let pending_block = pending_blocks.pop_front().expect("should have block");
let block_root = pending_block.block.as_block().canonical_root(); let block_root = pending_block.block.as_block().canonical_root();
@@ -1555,8 +1565,9 @@ mod test {
// might as well add a blob too // might as well add a blob too
let mut pending_blobs = pending_blobs.pop_front().expect("should have blobs"); let mut pending_blobs = pending_blobs.pop_front().expect("should have blobs");
let one_blob = pending_blobs.pop().expect("should have at least one blob"); let one_blob = pending_blobs.pop().expect("should have at least one blob");
let kzg_verified_blob = let kzg_verified_blob = verify_kzg_for_blob(one_blob.to_blob(), kzg.as_ref())
verify_kzg_for_blob(one_blob, kzg.as_ref()).expect("kzg should verify"); .expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
// generate random boolean // generate random boolean
let block_first = (rand::random::<usize>() % 2) == 0; let block_first = (rand::random::<usize>() % 2) == 0;
remaining_blobs.insert(block_root, pending_blobs); remaining_blobs.insert(block_root, pending_blobs);
@@ -1569,7 +1580,7 @@ mod test {
"should have pending blobs" "should have pending blobs"
); );
let availability = cache let availability = cache
.put_kzg_verified_blob(kzg_verified_blob) .put_kzg_verified_blobs(block_root, kzg_verified_blobs.as_slice())
.expect("should put blob"); .expect("should put blob");
assert!( assert!(
matches!(availability, Availability::MissingComponents(_)), matches!(availability, Availability::MissingComponents(_)),
@@ -1578,7 +1589,7 @@ mod test {
); );
} else { } else {
let availability = cache let availability = cache
.put_kzg_verified_blob(kzg_verified_blob) .put_kzg_verified_blobs(block_root, kzg_verified_blobs.as_slice())
.expect("should put blob"); .expect("should put blob");
let root = pending_block.block.as_block().canonical_root(); let root = pending_block.block.as_block().canonical_root();
assert_eq!( assert_eq!(
@@ -1664,13 +1675,15 @@ mod test {
); );
// now lets insert the remaining blobs until the cache is empty // now lets insert the remaining blobs until the cache is empty
for (_, blobs) in remaining_blobs { for (root, blobs) in remaining_blobs {
let additional_blobs = blobs.len(); let additional_blobs = blobs.len();
let mut kzg_verified_blobs = vec![];
for (i, gossip_blob) in blobs.into_iter().enumerate() { for (i, gossip_blob) in blobs.into_iter().enumerate() {
let kzg_verified_blob = let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref())
verify_kzg_for_blob(gossip_blob, kzg.as_ref()).expect("kzg should verify"); .expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
let availability = recovered_cache let availability = recovered_cache
.put_kzg_verified_blob(kzg_verified_blob) .put_kzg_verified_blobs(root, kzg_verified_blobs.as_slice())
.expect("should put blob"); .expect("should put blob");
if i == additional_blobs - 1 { if i == additional_blobs - 1 {
assert!(matches!(availability, Availability::Available(_))) assert!(matches!(availability, Availability::Available(_)))

15
beacon_node/beacon_chain/tests/attestation_production.rs
View File

@@ -133,12 +133,13 @@ async fn produces_attestations() {
assert_eq!(data.target.root, target_root, "bad target root"); assert_eq!(data.target.root, target_root, "bad target root");
let block_wrapper: BlockWrapper<MainnetEthSpec> = Arc::new(block.clone()).into(); let block_wrapper: BlockWrapper<MainnetEthSpec> = Arc::new(block.clone()).into();
let available_block = chain let beacon_chain::blob_verification::MaybeAvailableBlock::Available(available_block) = chain
.data_availability_checker .data_availability_checker
.check_availability(block_wrapper) .check_availability(block_wrapper)
.unwrap() .unwrap()
.try_into() else {
.unwrap(); panic!("block should be available")
};
let early_attestation = { let early_attestation = {
let proto_block = chain let proto_block = chain
@@ -202,13 +203,13 @@ async fn early_attester_cache_old_request() {
.unwrap(); .unwrap();
let block_wrapper: BlockWrapper<MainnetEthSpec> = head.beacon_block.clone().into(); let block_wrapper: BlockWrapper<MainnetEthSpec> = head.beacon_block.clone().into();
let available_block = harness let beacon_chain::blob_verification::MaybeAvailableBlock::Available(available_block) = harness.chain
.chain
.data_availability_checker .data_availability_checker
.check_availability(block_wrapper) .check_availability(block_wrapper)
.unwrap() .unwrap()
.try_into() else {
.unwrap(); panic!("block should be available")
};
harness harness
.chain .chain

31
beacon_node/network/src/sync/block_lookups/tests.rs
View File

@@ -724,7 +724,14 @@ fn test_parent_lookup_too_many_attempts() {
} }
} }
if i < parent_lookup::PARENT_FAIL_TOLERANCE { if i < parent_lookup::PARENT_FAIL_TOLERANCE {
assert_eq!(bl.parent_lookups[0].failed_block_attempts(), dbg!(i)); assert_eq!(
bl.parent_lookups[0]
.current_parent_request
.block_request_state
.state
.failed_attempts(),
dbg!(i)
);
} }
} }
@@ -776,7 +783,14 @@ fn test_parent_lookup_too_many_download_attempts_no_blacklist() {
rig.expect_penalty(); rig.expect_penalty();
} }
if i < parent_lookup::PARENT_FAIL_TOLERANCE { if i < parent_lookup::PARENT_FAIL_TOLERANCE {
assert_eq!(bl.parent_lookups[0].failed_block_attempts(), dbg!(i)); assert_eq!(
bl.parent_lookups[0]
.current_parent_request
.block_request_state
.state
.failed_attempts(),
dbg!(i)
);
} }
} }
@@ -1132,12 +1146,7 @@ fn test_same_chain_race_condition() {
mod deneb_only { mod deneb_only {
use super::*; use super::*;
use beacon_chain::blob_verification::{BlobError, MaybeAvailableBlock}; use beacon_chain::blob_verification::BlobError;
use beacon_chain::data_availability_checker::AvailabilityPendingBlock;
use beacon_chain::ExecutedBlock::AvailabilityPending;
use beacon_chain::IntoExecutionPendingBlock;
use beacon_chain::PayloadVerificationOutcome;
use beacon_chain::{AvailabilityPendingExecutedBlock, NotifyExecutionLayer};
use std::ops::IndexMut; use std::ops::IndexMut;
use std::str::FromStr; use std::str::FromStr;
@@ -1219,7 +1228,7 @@ mod deneb_only {
child_root, child_root,
Some(child_block), Some(child_block),
None, None,
peer_id, &[PeerShouldHave::Neither(peer_id)],
&mut cx, &mut cx,
); );
@@ -1258,7 +1267,7 @@ mod deneb_only {
child_root, child_root,
None, None,
Some(blobs), Some(blobs),
peer_id, &[PeerShouldHave::Neither(peer_id)],
&mut cx, &mut cx,
); );
@@ -1339,7 +1348,7 @@ mod deneb_only {
self self
} }
fn block_response_triggering_process(mut self) -> Self { fn block_response_triggering_process(self) -> Self {
let mut me = self.block_response(); let mut me = self.block_response();
me.rig.expect_block_process(ResponseType::Block); me.rig.expect_block_process(ResponseType::Block);