gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-04-17 04:48:21 +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()
.cloned()
.expect("kzg should exist");
let mut kzg_verified_blobs = Vec::new();
for (blob_index, gossip_blob) in blobs.into_iter().enumerate() {
let kzg_verified_blob =
verify_kzg_for_blob(gossip_blob, kzg.as_ref()).expect("kzg should verify");
let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref())
.expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
let availability = cache
.put_kzg_verified_blob(kzg_verified_blob)
.put_kzg_verified_blobs(root, kzg_verified_blobs.as_slice())
.expect("should put blob");
if blob_index == blobs_expected - 1 {
assert!(matches!(availability, Availability::Available(_)));
@@ -1164,11 +1166,13 @@ mod test {
"should have expected number of blobs"
);
let root = pending_block.import_data.block_root;
let mut kzg_verified_blobs = vec![];
for gossip_blob in blobs {
let kzg_verified_blob =
verify_kzg_for_blob(gossip_blob, kzg.as_ref()).expect("kzg should verify");
let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref())
.expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
let availability = cache
.put_kzg_verified_blob(kzg_verified_blob)
.put_kzg_verified_blobs(root, kzg_verified_blobs.as_slice())
.expect("should put blob");
assert_eq!(
availability,
@@ -1308,11 +1312,13 @@ mod test {
let blobs_0 = pending_blobs.pop_front().expect("should have blobs");
let expected_blobs = blobs_0.len();
let mut kzg_verified_blobs = vec![];
for (blob_index, gossip_blob) in blobs_0.into_iter().enumerate() {
let kzg_verified_blob =
verify_kzg_for_blob(gossip_blob, kzg.as_ref()).expect("kzg should verify");
let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref())
.expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
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");
if blob_index == expected_blobs - 1 {
assert!(matches!(availability, Availability::Available(_)));
@@ -1396,15 +1402,18 @@ mod test {
.cloned()
.expect("kzg should exist");
let mut kzg_verified_blobs = vec![];
for _ in 0..(n_epochs * capacity) {
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();
if expected_blobs > 1 {
// might as well add a blob too
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 kzg_verified_blob =
verify_kzg_for_blob(one_blob, kzg.as_ref()).expect("kzg should verify");
let kzg_verified_blob = verify_kzg_for_blob(one_blob.to_blob(), kzg.as_ref())
.expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
// generate random boolean
let block_first = (rand::random::<usize>() % 2) == 0;
if block_first {
@@ -1416,7 +1425,7 @@ mod test {
"should have pending blobs"
);
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");
assert!(
matches!(availability, Availability::MissingComponents(_)),
@@ -1425,7 +1434,7 @@ mod test {
);
} else {
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");
let root = pending_block.block.as_block().canonical_root();
assert_eq!(
@@ -1547,6 +1556,7 @@ mod test {
.expect("kzg should exist");
let mut remaining_blobs = HashMap::new();
let mut kzg_verified_blobs = vec![];
for _ in 0..(n_epochs * capacity) {
let pending_block = pending_blocks.pop_front().expect("should have block");
let block_root = pending_block.block.as_block().canonical_root();
@@ -1555,8 +1565,9 @@ mod test {
// might as well add a blob too
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 kzg_verified_blob =
verify_kzg_for_blob(one_blob, kzg.as_ref()).expect("kzg should verify");
let kzg_verified_blob = verify_kzg_for_blob(one_blob.to_blob(), kzg.as_ref())
.expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
// generate random boolean
let block_first = (rand::random::<usize>() % 2) == 0;
remaining_blobs.insert(block_root, pending_blobs);
@@ -1569,7 +1580,7 @@ mod test {
"should have pending blobs"
);
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");
assert!(
matches!(availability, Availability::MissingComponents(_)),
@@ -1578,7 +1589,7 @@ mod test {
);
} else {
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");
let root = pending_block.block.as_block().canonical_root();
assert_eq!(
@@ -1664,13 +1675,15 @@ mod test {
);
// 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 mut kzg_verified_blobs = vec![];
for (i, gossip_blob) in blobs.into_iter().enumerate() {
let kzg_verified_blob =
verify_kzg_for_blob(gossip_blob, kzg.as_ref()).expect("kzg should verify");
let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref())
.expect("kzg should verify");
kzg_verified_blobs.push(kzg_verified_blob);
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");
if i == additional_blobs - 1 {
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");
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
.check_availability(block_wrapper)
.unwrap()
.try_into()
.unwrap();
else {
panic!("block should be available")
};
let early_attestation = {
let proto_block = chain
@@ -202,13 +203,13 @@ async fn early_attester_cache_old_request() {
.unwrap();
let block_wrapper: BlockWrapper<MainnetEthSpec> = head.beacon_block.clone().into();
let available_block = harness
.chain
let beacon_chain::blob_verification::MaybeAvailableBlock::Available(available_block) = harness.chain
.data_availability_checker
.check_availability(block_wrapper)
.unwrap()
.try_into()
.unwrap();
else {
panic!("block should be available")
};
harness
.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 {
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();
}
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 {
use super::*;
use beacon_chain::blob_verification::{BlobError, MaybeAvailableBlock};
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 beacon_chain::blob_verification::BlobError;
use std::ops::IndexMut;
use std::str::FromStr;
@@ -1219,7 +1228,7 @@ mod deneb_only {
child_root,
Some(child_block),
None,
peer_id,
&[PeerShouldHave::Neither(peer_id)],
&mut cx,
);
@@ -1258,7 +1267,7 @@ mod deneb_only {
child_root,
None,
Some(blobs),
peer_id,
&[PeerShouldHave::Neither(peer_id)],
&mut cx,
);
@@ -1339,7 +1348,7 @@ mod deneb_only {
self
}
fn block_response_triggering_process(mut self) -> Self {
fn block_response_triggering_process(self) -> Self {
let mut me = self.block_response();
me.rig.expect_block_process(ResponseType::Block);