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

Add tests

Browse Source
This commit is contained in:
Pawan Dhananjay
2026-06-22 15:45:04 -07:00
parent 20c909c027
commit 8f23b587df
1 changed files with 61 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
beacon_node/beacon_chain/tests/block_verification.rs
View File

@@ -2415,10 +2415,10 @@ async fn import_gloas_block_without_envelope(
(block, envelope, block_root) (block, envelope, block_root)
} }
/// A relevant envelope (payload not yet received) lets an already-imported block back through /// Retrying a range-sync batch can provide the envelope for a block that was previously imported
/// `filter_chain_segment` so it can be re-processed with its envelope. /// without one. The duplicate block should be allowed through far enough to import the envelope.
#[tokio::test] #[tokio::test]
async fn filter_chain_segment_keeps_imported_block_with_relevant_envelope() { async fn process_chain_segment_imports_missing_envelope_for_duplicate_gloas_block() {
let spec = test_spec::<E>(); let spec = test_spec::<E>();
if !spec.fork_name_at_slot::<E>(Slot::new(1)).gloas_enabled() { if !spec.fork_name_at_slot::<E>(Slot::new(1)).gloas_enabled() {
return; return;
@@ -2432,26 +2432,66 @@ async fn filter_chain_segment_keeps_imported_block_with_relevant_envelope() {
.mock_execution_layer() .mock_execution_layer()
.build(); .build();
let (block, envelope, _) = import_gloas_block_without_envelope(&harness).await; let (block, envelope, block_root) = import_gloas_block_without_envelope(&harness).await;
let block_slot = block.slot();
assert!(
!harness
.chain
.canonical_head
.fork_choice_read_lock()
.is_payload_received(&block_root),
"payload should start missing"
);
assert!(
harness
.chain
.store
.get_payload_envelope(&block_root)
.expect("should read envelope from store")
.is_none(),
"envelope should start missing from the store"
);
let available_envelope = AvailableEnvelope::new(Arc::new(envelope), vec![]); let available_envelope = AvailableEnvelope::new(Arc::new(envelope), vec![]);
let segment = vec![RangeSyncBlock::new_gloas(block, Some(available_envelope)).unwrap()]; let segment = vec![RangeSyncBlock::new_gloas(block, Some(available_envelope)).unwrap()];
let Ok(filtered) = harness.chain.filter_chain_segment(segment) else { let result = harness
panic!("filter should succeed"); .chain
.process_chain_segment(segment, NotifyExecutionLayer::Yes)
.await;
let ChainSegmentResult::Successful { imported_blocks } = result else {
panic!("range sync should succeed");
}; };
assert_eq!( assert_eq!(
filtered.len(), imported_blocks,
1, vec![(block_root, block_slot)],
"block with a relevant envelope should not be filtered as a duplicate" "the duplicate block should be reported as processed"
);
assert!(
harness
.chain
.canonical_head
.fork_choice_read_lock()
.is_payload_received(&block_root),
"range sync should mark the payload as received"
);
assert!(
harness
.chain
.store
.get_payload_envelope(&block_root)
.expect("should read envelope from store")
.is_some(),
"range sync should persist the envelope"
); );
} }
/// Once the payload has been received the envelope is no longer relevant, so an already-imported /// Once the payload has been received, retrying the same block and envelope is a no-op.
/// block is filtered out of the segment as a duplicate.
#[tokio::test] #[tokio::test]
async fn filter_chain_segment_drops_imported_block_when_payload_received() { async fn process_chain_segment_ignores_duplicate_gloas_block_when_payload_received() {
let spec = test_spec::<E>(); let spec = test_spec::<E>();
if !spec.fork_name_at_slot::<E>(Slot::new(1)).gloas_enabled() { if !spec.fork_name_at_slot::<E>(Slot::new(1)).gloas_enabled() {
return; return;
@@ -2477,13 +2517,18 @@ async fn filter_chain_segment_drops_imported_block_when_payload_received() {
let available_envelope = AvailableEnvelope::new(Arc::new(envelope), vec![]); let available_envelope = AvailableEnvelope::new(Arc::new(envelope), vec![]);
let segment = vec![RangeSyncBlock::new_gloas(block, Some(available_envelope)).unwrap()]; let segment = vec![RangeSyncBlock::new_gloas(block, Some(available_envelope)).unwrap()];
let Ok(filtered) = harness.chain.filter_chain_segment(segment) else { let result = harness
panic!("filter should succeed"); .chain
.process_chain_segment(segment, NotifyExecutionLayer::Yes)
.await;
let ChainSegmentResult::Successful { imported_blocks } = result else {
panic!("range sync should succeed");
}; };
assert!( assert!(
filtered.is_empty(), imported_blocks.is_empty(),
"block whose payload was already received should be filtered as a duplicate" "block whose payload was already received should be ignored as a duplicate"
); );
} }