chore(node/actor): Adds tests for Sequencer Admin API (#3101)

Also:
- Adds admin RPC method to inspect recovery mode status
- Adds handling for new admin RPC method in SequencerActor
- Adds test utils via automock
- References existing test utils in crates/protocol/derive

Ref: #3070

---------

Co-authored-by: theo <80177219+theochap@users.noreply.github.com>

Author: op-will

crates/node/rpc/src/admin.rs

@@ -140,6 +140,18 @@ impl<S: SequencerAdminAPIClient + 'static> AdminApiServer for AdminRpc<S> {
             .map_err(|_| ErrorObject::from(ErrorCode::InternalError))
     }
 
+    async fn admin_recover_mode(&self) -> RpcResult<bool> {
+        // If the sequencer is not enabled (mode runs in validator mode), return an error.
+        let Some(ref sequencer_client) = self.sequencer_admin_client else {
+            return Err(ErrorObject::from(ErrorCode::MethodNotFound));
+        };
+
+        sequencer_client
+            .is_recovery_mode()
+            .await
+            .map_err(|_| ErrorObject::from(ErrorCode::InternalError))
+    }
+
     async fn admin_set_recover_mode(&self, mode: bool) -> RpcResult<()> {
         // If the sequencer is not enabled (mode runs in validator mode), return an error.
         let Some(ref sequencer_client) = self.sequencer_admin_client else {
@@ -208,6 +220,9 @@ pub trait SequencerAdminAPIClient: Send + Sync + Debug {
     /// Check if the conductor is enabled.
     async fn is_conductor_enabled(&self) -> Result<bool, SequencerAdminAPIError>;
 
+    /// Check if in recovery mode.
+    async fn is_recovery_mode(&self) -> Result<bool, SequencerAdminAPIError>;
+
     /// Start the sequencer.
     async fn start_sequencer(&self) -> Result<(), SequencerAdminAPIError>;
 
@@ -234,9 +249,17 @@ pub enum SequencerAdminAPIError {
 
     /// Error stopping sequencer.
     #[error("Error stopping sequencer: {0}.")]
-    StopError(String),
+    StopError(#[from] StopSequencerError),
 
     /// Error overriding leader.
     #[error("Error overriding leader: {0}.")]
     LeaderOverrideError(String),
 }
+
+/// Errors that can occur when using the sequencer admin API.
+#[derive(Debug, Error)]
+pub enum StopSequencerError {
+    /// Sequencer stopped successfully, followed by some error.
+    #[error("Sequencer stopped successfully, followed by error: {0}.")]
+    ErrorAfterSequencerWasStopped(String),
+}

crates/node/rpc/src/jsonrpsee.rs

@@ -188,6 +188,10 @@ pub trait AdminApi {
     #[method(name = "conductorEnabled")]
     async fn admin_conductor_enabled(&self) -> RpcResult<bool>;
 
+    /// Gets the recover mode.
+    #[method(name = "adminRecoverMode")]
+    async fn admin_recover_mode(&self) -> RpcResult<bool>;
+
     /// Sets the recover mode.
     #[method(name = "setRecoverMode")]
     async fn admin_set_recover_mode(&self, mode: bool) -> RpcResult<()>;

crates/node/rpc/src/lib.rs

@@ -12,7 +12,7 @@ extern crate tracing;
 mod admin;
 pub use admin::{
     AdminRpc, NetworkAdminQuery, RollupBoostAdminQuery, SequencerAdminAPIClient,
-    SequencerAdminAPIError,
+    SequencerAdminAPIError, StopSequencerError,
 };
 
 mod config;

crates/node/service/Cargo.toml

@@ -82,6 +82,7 @@ alloy-primitives = { workspace = true, features = ["k256"] }
 alloy-rpc-types-engine = { workspace = true, features = ["arbitrary"] }
 alloy-consensus = { workspace = true, features = ["arbitrary"] }
 op-alloy-consensus = { workspace = true, features = ["arbitrary", "k256"] }
+kona-derive = {workspace = true, features = ["test-utils"]}
 
 [features]
 default = []

crates/node/service/src/actors/engine/api.rs

@@ -12,6 +12,7 @@ use tokio::sync::{mpsc, watch};
 /// Trait to be referenced by those interacting with EngineActor for block building
 /// operations. The EngineActor requires the use of channels for communication, but
 /// this interface allows that to be abstracted from callers and allows easy testing.
+#[cfg_attr(test, mockall::automock)]
 #[async_trait]
 pub trait BlockBuildingClient: Debug + Send + Sync {
     /// Resets the engine's forkchoice, awaiting confirmation that it succeeded or returning the

crates/node/service/src/actors/engine/mod.rs

@@ -19,3 +19,6 @@ mod finalizer;
 pub use finalizer::L2Finalizer;
 
 mod rollup_boost;
+
+#[cfg(test)]
+pub use api::MockBlockBuildingClient;

crates/node/service/src/actors/mod.rs

@@ -41,3 +41,10 @@ pub use sequencer::{
     SequencerActor, SequencerActorBuilder, SequencerActorError, SequencerAdminQuery,
     SequencerConfig,
 };
+
+#[cfg(test)]
+pub use engine::MockBlockBuildingClient;
+#[cfg(test)]
+pub use network::MockUnsafePayloadGossipClient;
+#[cfg(test)]
+pub use sequencer::{MockConductor, MockOriginSelector};

crates/node/service/src/actors/network/gossip.rs

@@ -6,6 +6,7 @@ use thiserror::Error;
 use tokio::sync::mpsc;
 
 /// Client used to schedule unsafe [`OpExecutionPayloadEnvelope`] to be gossiped.
+#[cfg_attr(test, mockall::automock)]
 #[async_trait]
 pub trait UnsafePayloadGossipClient: Send + Sync + Debug {
     /// This is a fire-and-forget function that schedules the provided

crates/node/service/src/actors/network/mod.rs

@@ -22,3 +22,6 @@ pub use gossip::{
 };
 
 pub use config::NetworkConfig;
+
+#[cfg(test)]
+pub use gossip::MockUnsafePayloadGossipClient;

crates/node/service/src/actors/sequencer/admin_api_client.rs

@@ -26,6 +26,8 @@ pub enum SequencerAdminQuery {
     StopSequencer(oneshot::Sender<Result<B256, SequencerAdminAPIError>>),
     /// A query to check if the conductor is enabled.
     ConductorEnabled(oneshot::Sender<Result<bool, SequencerAdminAPIError>>),
+    /// A query to check if the sequencer is in recovery mode.
+    RecoveryMode(oneshot::Sender<Result<bool, SequencerAdminAPIError>>),
     /// A query to set the recovery mode.
     SetRecoveryMode(bool, oneshot::Sender<Result<(), SequencerAdminAPIError>>),
     /// A query to override the leader.
@@ -56,6 +58,17 @@ impl SequencerAdminAPIClient for QueuedSequencerAdminAPIClient {
         })?
     }
 
+    async fn is_recovery_mode(&self) -> Result<bool, SequencerAdminAPIError> {
+        let (tx, rx) = oneshot::channel();
+
+        self.request_tx.send(SequencerAdminQuery::RecoveryMode(tx)).await.map_err(|_| {
+            SequencerAdminAPIError::RequestError("request channel closed".to_string())
+        })?;
+        rx.await.map_err(|_| {
+            SequencerAdminAPIError::ResponseError("response channel closed".to_string())
+        })?
+    }
+
     async fn start_sequencer(&self) -> Result<(), SequencerAdminAPIError> {
         let (tx, rx) = oneshot::channel();