chore(test): Replay WAL before start round

code/crates/core-consensus/src/handle.rs

@@ -16,7 +16,7 @@ mod vote_set;
 use proposal::on_proposal;
 use propose::on_propose;
 use proposed_value::on_proposed_value;
-use start_height::reset_and_start_height;
+use start_height::{on_prepare_height, on_start_height};
 use sync::on_commit_certificate;
 use timeout::on_timeout_elapsed;
 use vote::on_vote;
@@ -48,9 +48,10 @@ where
     Ctx: Context,
 {
     match input {
-        Input::StartHeight(height, validator_set) => {
-            reset_and_start_height(co, state, metrics, height, validator_set).await
+        Input::PrepareHeight(height, validator_set) => {
+            on_prepare_height(co, state, metrics, height, validator_set).await
         }
+        Input::StartHeight(height) => on_start_height(co, state, metrics, height).await,
         Input::Vote(vote) => on_vote(co, state, metrics, vote).await,
         Input::Proposal(proposal) => on_proposal(co, state, metrics, proposal).await,
         Input::Propose(value) => on_propose(co, state, metrics, value).await,

code/crates/core-consensus/src/handle/start_height.rs

@@ -3,10 +3,10 @@ use crate::prelude::*;
 use crate::handle::driver::apply_driver_input;
 use crate::handle::handle_input;
 
-pub async fn reset_and_start_height<Ctx>(
+pub async fn on_prepare_height<Ctx>(
     co: &Co<Ctx>,
     state: &mut State<Ctx>,
-    metrics: &Metrics,
+    #[allow(unused_variables)] metrics: &Metrics,
     height: Ctx::Height,
     validator_set: Ctx::ValidatorSet,
 ) -> Result<(), Error<Ctx>>
@@ -24,18 +24,21 @@ where
     debug_assert_eq!(state.driver.height(), height);
     debug_assert_eq!(state.driver.round(), Round::Nil);
 
-    start_height(co, state, metrics, height).await
+    Ok(())
 }
 
-pub async fn start_height<Ctx>(
+pub async fn on_start_height<Ctx>(
     co: &Co<Ctx>,
     state: &mut State<Ctx>,
-    metrics: &Metrics,
+    #[allow(unused_variables)] metrics: &Metrics,
     height: Ctx::Height,
 ) -> Result<(), Error<Ctx>>
 where
     Ctx: Context,
 {
+    debug_assert_eq!(state.driver.height(), height);
+    debug_assert_eq!(state.driver.round(), Round::Nil);
+
     let round = Round::new(0);
     info!(%height, "Starting new height");
 

code/crates/core-consensus/src/input.rs

@@ -15,8 +15,11 @@ pub enum Input<Ctx>
 where
     Ctx: Context,
 {
-    /// Start a new height with the given validator set
-    StartHeight(Ctx::Height, Ctx::ValidatorSet),
+    /// Prepare state for starting a new height with the given validator set
+    PrepareHeight(Ctx::Height, Ctx::ValidatorSet),
+
+    /// Start consensus for the given height
+    StartHeight(Ctx::Height),
 
     /// Process a vote
     Vote(SignedVote<Ctx>),

code/crates/engine/src/consensus.rs

@@ -286,14 +286,30 @@ where
     ) -> Result<(), ActorProcessingErr> {
         match msg {
             Msg::StartHeight(height, validator_set) => {
+                // Prepare the driver state for the new height,
+                // but do not start consensus yet.
                 let result = self
                     .process_input(
                         &myself,
                         state,
-                        ConsensusInput::StartHeight(height, validator_set),
+                        ConsensusInput::PrepareHeight(height, validator_set),
                     )
                     .await;
 
+                if let Err(e) = result {
+                    error!(%height, "Error when preparing for height: {e}");
+                }
+
+                // Replay the WAL if necessary
+                if let Err(e) = self.check_and_replay_wal(&myself, state, height).await {
+                    error!(%height, "Error when checking and replaying WAL: {e}");
+                }
+
+                // Start consensus
+                let result = self
+                    .process_input(&myself, state, ConsensusInput::StartHeight(height))
+                    .await;
+
                 if let Err(e) = result {
                     error!(%height, "Error when starting height: {e}");
                 }
@@ -307,10 +323,6 @@ where
 
                 self.tx_event.send(|| Event::StartedHeight(height));
 
-                if let Err(e) = self.check_and_replay_wal(&myself, state, height).await {
-                    error!(%height, "Error when checking and replaying WAL: {e}");
-                }
-
                 self.process_buffered_msgs(&myself, state).await;
 
                 state.phase = Phase::Running;

code/crates/test/tests/it/wal.rs

@@ -91,6 +91,7 @@ async fn proposer_crashes_after_proposing(params: TestParams) {
                 )
             }
         })
+        .wait_until(CRASH_HEIGHT + 2)
         .success();
 
     test.build()