Add failing test

Author: paulhauner

beacon_node/beacon_chain/src/test_utils.rs

@@ -209,6 +209,20 @@ impl<E: EthSpec> Builder<EphemeralHarnessType<E>> {
         self.store = Some(store);
         self.store_mutator(Box::new(mutator))
     }
+
+    /// Disk store, resume.
+    pub fn resumed_ephemeral_store(
+        mut self,
+        store: Arc<HotColdDB<E, MemoryStore<E>, MemoryStore<E>>>,
+    ) -> Self {
+        let mutator = move |builder: BeaconChainBuilder<_>| {
+            builder
+                .resume_from_db()
+                .expect("should resume from database")
+        };
+        self.store = Some(store);
+        self.store_mutator(Box::new(mutator))
+    }
 }
 
 impl<E: EthSpec> Builder<DiskHarnessType<E>> {

beacon_node/beacon_chain/tests/payload_invalidation.rs

@@ -1199,48 +1199,72 @@ async fn attesting_to_optimistic_head() {
     get_aggregated_by_slot_and_root().unwrap();
 }
 
-#[tokio::test]
-async fn recover_from_invalid_head() {
-    let mut rig = InvalidPayloadRig::new().enable_attestations();
-    rig.move_to_terminal_block();
-    rig.import_block(Payload::Valid).await; // Import a valid transition block.
+/// Helper for running tests where we generate a chain with an invalid head and then some
+/// `fork_blocks` to recover it.
+struct InvalidHeadSetup {
+    rig: InvalidPayloadRig,
+    fork_blocks: Vec<Arc<SignedBeaconBlock<E>>>,
+    invalid_head: CachedHead<E>,
+}
 
-    // Import blocks until the first time the chain finalizes.
-    while rig.cached_head().finalized_checkpoint().epoch == 0 {
-        rig.import_block(Payload::Syncing).await;
-    }
+impl InvalidHeadSetup {
+    async fn new() -> InvalidHeadSetup {
+        let mut rig = InvalidPayloadRig::new().enable_attestations();
+        rig.move_to_terminal_block();
+        rig.import_block(Payload::Valid).await; // Import a valid transition block.
 
-    let invalid_head = rig.cached_head();
+        // Import blocks until the first time the chain finalizes.
+        while rig.cached_head().finalized_checkpoint().epoch == 0 {
+            rig.import_block(Payload::Syncing).await;
+        }
 
-    // Invalidate the head block.
-    rig.invalidate_manually(invalid_head.head_block_root())
-        .await;
-    assert!(rig
-        .canonical_head()
-        .head_execution_status()
-        .unwrap()
-        .is_invalid());
+        let invalid_head = rig.cached_head();
 
-    // Finding a new head should fail since the only possible head is not valid.
-    rig.assert_get_head_error_contains("InvalidBestNode");
+        // Invalidate the head block.
+        rig.invalidate_manually(invalid_head.head_block_root())
+            .await;
+        assert!(rig
+            .canonical_head()
+            .head_execution_status()
+            .unwrap()
+            .is_invalid());
 
-    // Build three "fork" blocks that conflict with the current canonical head. Don't apply them to
-    // the chain yet.
-    let mut fork_blocks = vec![];
-    let mut parent_state = rig
-        .harness
-        .chain
-        .state_at_slot(
-            invalid_head.head_slot() - 3,
-            StateSkipConfig::WithStateRoots,
-        )
-        .unwrap();
-    for _ in 0..3 {
-        let slot = parent_state.slot() + 1;
-        let (fork_block, post_state) = rig.harness.make_block(parent_state, slot).await;
-        parent_state = post_state;
-        fork_blocks.push(Arc::new(fork_block))
+        // Finding a new head should fail since the only possible head is not valid.
+        rig.assert_get_head_error_contains("InvalidBestNode");
+
+        // Build three "fork" blocks that conflict with the current canonical head. Don't apply them to
+        // the chain yet.
+        let mut fork_blocks = vec![];
+        let mut parent_state = rig
+            .harness
+            .chain
+            .state_at_slot(
+                invalid_head.head_slot() - 3,
+                StateSkipConfig::WithStateRoots,
+            )
+            .unwrap();
+        for _ in 0..3 {
+            let slot = parent_state.slot() + 1;
+            let (fork_block, post_state) = rig.harness.make_block(parent_state, slot).await;
+            parent_state = post_state;
+            fork_blocks.push(Arc::new(fork_block))
+        }
+
+        Self {
+            rig,
+            fork_blocks,
+            invalid_head,
+        }
     }
+}
+
+#[tokio::test]
+async fn recover_from_invalid_head_by_importing_blocks() {
+    let InvalidHeadSetup {
+        rig,
+        fork_blocks,
+        invalid_head,
+    } = InvalidHeadSetup::new().await;
 
     // Import the first two blocks, they should not become the head.
     for i in 0..2 {
@@ -1300,3 +1324,29 @@ async fn recover_from_invalid_head() {
         .unwrap();
     assert_eq!(manual_get_head, new_head.head_block_root(),);
 }
+
+#[tokio::test]
+async fn recover_from_invalid_head_after_reboot() {
+    let InvalidHeadSetup {
+        rig,
+        fork_blocks,
+        invalid_head,
+    } = InvalidHeadSetup::new().await;
+
+    // Forcefully persist the head and fork choice.
+    rig.harness.chain.persist_head_and_fork_choice().unwrap();
+
+    let resumed = BeaconChainHarness::builder(MainnetEthSpec)
+        .default_spec()
+        .deterministic_keypairs(VALIDATOR_COUNT)
+        .resumed_ephemeral_store(rig.harness.chain.store.clone())
+        .mock_execution_layer()
+        .build();
+
+    let resumed_head = resumed.chain.canonical_head.cached_head();
+    assert_eq!(
+        resumed_head.head_block_root(),
+        invalid_head.finalized_checkpoint().root,
+        "the resumed harness should have a head at the finalized checkpoint"
+    );
+}