test macro

Author: akundaz

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     ".",            # The main rblib library
     "tools/fbutil",
+    "src/tests/framework/macros"
 ]
 resolver = "2"
 
@@ -93,6 +94,7 @@ tracing-subscriber = { workspace = true }
 
 [dev-dependencies]
 rblib = { workspace = true, features = ["test-utils"] }
+macros = { path = "src/tests/framework/macros" }
 
 dashmap = { workspace = true }
 orx-concurrent-vec = { workspace = true }

src/args.rs

@@ -109,6 +109,16 @@ impl Default for BuilderArgs {
 	}
 }
 
+impl Default for FlashblocksArgs {
+	fn default() -> Self {
+		let args = crate::args::Cli::parse_from(["dummy", "node"]);
+		let Commands::Node(node_command) = args.command else {
+			unreachable!()
+		};
+		node_command.ext.flashblocks_args
+	}
+}
+
 /// This trait is used to extend Reth's CLI with additional functionality that
 /// are specific to the OP builder, such as populating default values for CLI
 /// arguments when running in the playground mode or checking the builder mode.
@@ -187,55 +197,3 @@ fn expand_path(s: &str) -> Result<PathBuf> {
 		.parse()
 		.map_err(|e| eyre!("invalid path after expansion: {e}"))
 }
-
-#[cfg(test)]
-impl FlashblocksArgs {
-	/// Configures flashblocks for tests. Handles WS port assignment.
-	pub fn default_on_for_tests() -> Self {
-		use core::net::{Ipv4Addr, SocketAddrV4};
-
-		Self {
-			interval: Duration::from_millis(250),
-			leeway_time: Duration::from_millis(75),
-			ws_address: SocketAddrV4::new(
-				Ipv4Addr::UNSPECIFIED,
-				Self::get_available_port(),
-			)
-			.into(),
-
-			calculate_state_root: true,
-		}
-	}
-
-	pub fn default_on_custom_leeway_time_and_interval_for_tests(
-		leeway_time: Duration,
-		interval: Duration,
-	) -> Self {
-		use core::net::{Ipv4Addr, SocketAddrV4};
-
-		Self {
-			interval,
-			leeway_time,
-			ws_address: SocketAddrV4::new(
-				Ipv4Addr::UNSPECIFIED,
-				Self::get_available_port(),
-			)
-			.into(),
-
-			calculate_state_root: true,
-		}
-	}
-
-	/// Gets an available port by first binding to port 0 -- instructing the OS to
-	/// find and assign one. Then the listener is dropped when this goes out of
-	/// scope, freeing the port for the next time this function is called.
-	fn get_available_port() -> u16 {
-		use std::net::TcpListener;
-
-		TcpListener::bind("127.0.0.1:0")
-			.expect("Failed to bind to random port")
-			.local_addr()
-			.expect("Failed to get local address")
-			.port()
-	}
-}

src/main.rs

@@ -19,6 +19,7 @@ use {
 		steps::*,
 	},
 	std::sync::Arc,
+	tracing::info,
 };
 
 mod args;
@@ -82,6 +83,7 @@ fn build_pipeline(
 	cli_args: &BuilderArgs,
 	pool: &OrderPool<Flashblocks>,
 ) -> eyre::Result<Pipeline<Flashblocks>> {
+	info!("ARGS: {cli_args:?}");
 	let flashblock_interval = cli_args.flashblocks_args.interval;
 
 	// time by which flashblocks will be delivered earlier to account for latency

src/tests/bundle.rs

@@ -1,10 +1,12 @@
 use {
 	crate::{
 		Flashblocks,
+		args::BuilderArgs,
 		bundle::FlashblocksBundle,
-		tests::assert_has_sequencer_tx,
+		tests::{Harness, assert_has_sequencer_tx},
 	},
 	jsonrpsee::core::ClientError,
+	macros::unichain_test,
 	rand::{Rng, rng},
 	rblib::{
 		alloy::{
@@ -139,9 +141,9 @@ pub fn random_bundle_with_reverts(
 	FlashblocksBundle::with_transactions(txs)
 }
 
-#[tokio::test]
-async fn empty_bundle_rejected() -> eyre::Result<()> {
-	let (node, _) = Flashblocks::test_node().await?;
+#[unichain_test]
+async fn empty_bundle_rejected(harness: Harness) -> eyre::Result<()> {
+	let node = harness.node();
 
 	let empty_bundle = FlashblocksBundle::with_transactions(vec![]);
 	let result = BundlesApiClient::<Flashblocks>::send_bundle(
@@ -157,9 +159,9 @@ async fn empty_bundle_rejected() -> eyre::Result<()> {
 
 /// This bundle should be rejected by because we only support bundles with one
 /// transaction
-#[tokio::test]
-async fn bundle_with_two_txs_rejected() -> eyre::Result<()> {
-	let (node, _) = Flashblocks::test_node().await?;
+#[unichain_test]
+async fn bundle_with_two_txs_rejected(harness: Harness) -> eyre::Result<()> {
+	let node = harness.node();
 
 	let bundle_with_two_txs = random_valid_bundle(2);
 
@@ -174,9 +176,9 @@ async fn bundle_with_two_txs_rejected() -> eyre::Result<()> {
 	Ok(())
 }
 
-#[tokio::test]
-async fn valid_tx_included() -> eyre::Result<()> {
-	let (node, _) = Flashblocks::test_node().await?;
+#[unichain_test]
+async fn valid_tx_included(harness: Harness) -> eyre::Result<()> {
+	let node = harness.node();
 
 	let bundle_with_one_tx = random_valid_bundle(1);
 	let bundle_hash = bundle_with_one_tx.hash();
@@ -199,9 +201,9 @@ async fn valid_tx_included() -> eyre::Result<()> {
 	Ok(())
 }
 
-#[tokio::test]
-async fn reverted_tx_not_included() -> eyre::Result<()> {
-	let (node, _) = Flashblocks::test_node().await?;
+#[unichain_test]
+async fn reverted_tx_not_included(harness: Harness) -> eyre::Result<()> {
+	let node = harness.node();
 
 	let bundle_with_reverts = random_bundle_with_reverts(0, 1);
 
@@ -223,9 +225,9 @@ async fn reverted_tx_not_included() -> eyre::Result<()> {
 
 /// Bundles that will never be eligible for inclusion in any future block
 /// should be rejected by the RPC before making it to the orders pool.
-#[tokio::test]
-async fn max_block_number_in_past() -> eyre::Result<()> {
-	let (node, _) = Flashblocks::test_node().await?;
+#[unichain_test]
+async fn max_block_number_in_past(harness: Harness) -> eyre::Result<()> {
+	let node = harness.node();
 
 	let block = node.next_block().await?;
 	assert_eq!(block.number(), 1);
@@ -249,10 +251,10 @@ async fn max_block_number_in_past() -> eyre::Result<()> {
 
 /// This bundle should be rejected because its `max_timestamp` is in the past
 /// and it will never be eligible for inclusion in any future block.
-#[tokio::test]
-async fn max_block_timestamp_in_past() -> eyre::Result<()> {
+#[unichain_test]
+async fn max_block_timestamp_in_past(harness: Harness) -> eyre::Result<()> {
 	// node at genesis, block 0
-	let (node, _) = Flashblocks::test_node().await?;
+	let node = harness.node();
 	let genesis_timestamp = node.config().chain.genesis_timestamp();
 	let mut bundle = random_valid_bundle(1);
 	bundle.max_timestamp = Some(genesis_timestamp.saturating_sub(1));
@@ -268,10 +270,12 @@ async fn max_block_timestamp_in_past() -> eyre::Result<()> {
 	Ok(())
 }
 
-#[tokio::test]
-async fn min_block_greater_than_max_block() -> eyre::Result<()> {
+#[unichain_test]
+async fn min_block_greater_than_max_block(
+	harness: Harness,
+) -> eyre::Result<()> {
 	// node at genesis, block 0
-	let (node, _) = Flashblocks::test_node().await?;
+	let node = harness.node();
 	let mut bundle = random_valid_bundle(1);
 	bundle.min_block_number = Some(2);
 	bundle.max_block_number = Some(1);
@@ -289,9 +293,9 @@ async fn min_block_greater_than_max_block() -> eyre::Result<()> {
 
 /// Test that a bundle with the `min_block_number` param set to a future block
 /// isn't included until that block.
-#[tokio::test]
-async fn min_block_number_in_future() -> eyre::Result<()> {
-	let (node, _) = Flashblocks::test_node().await?;
+#[unichain_test]
+async fn min_block_number_in_future(harness: Harness) -> eyre::Result<()> {
+	let node = harness.node();
 
 	let mut bundle_with_one_tx = random_valid_bundle(1);
 	bundle_with_one_tx.min_block_number = Some(2);
@@ -321,9 +325,14 @@ async fn min_block_number_in_future() -> eyre::Result<()> {
 	Ok(())
 }
 
-#[tokio::test]
-async fn when_disabled_reverted_txs_are_included() -> eyre::Result<()> {
-	let (node, _) = Flashblocks::test_node_with_revert_protection_off().await?;
+#[unichain_test(args = BuilderArgs {
+    revert_protection: false,
+    ..Default::default()
+})]
+async fn when_disabled_reverted_txs_are_included(
+	harness: Harness,
+) -> eyre::Result<()> {
+	let node = harness.node();
 
 	// create a bundle with one valid and one reverting tx
 	let mut bundle_with_reverts = random_bundle_with_reverts(0, 1);

src/tests/flashblocks.rs

@@ -3,15 +3,20 @@
 #![allow(clippy::large_futures)]
 
 use {
-	crate::{Flashblocks, tests::*},
+	crate::{
+		Flashblocks,
+		args::{BuilderArgs, FlashblocksArgs},
+		tests::*,
+	},
+	macros::unichain_test,
 	rblib::alloy::{eips::Decodable2718, network::BlockResponse},
 	std::time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
-#[tokio::test]
-async fn empty_blocks_smoke() -> eyre::Result<()> {
-	let (node, ws_addr) = Flashblocks::test_node().await?;
-	let ws = WebSocketObserver::new(ws_addr).await?;
+#[unichain_test]
+async fn empty_blocks_smoke(harness: Harness) -> eyre::Result<()> {
+	let node = harness.node();
+	let ws = harness.ws_observer().await?;
 
 	for i in 1..=5 {
 		let block = node.next_block().await?;
@@ -40,13 +45,13 @@ async fn empty_blocks_smoke() -> eyre::Result<()> {
 	Ok(())
 }
 
-#[tokio::test]
-async fn blocks_with_txs_smoke() -> eyre::Result<()> {
+#[unichain_test]
+async fn blocks_with_txs_smoke(harness: Harness) -> eyre::Result<()> {
 	const BLOCKS: usize = 5;
 	const TXS_PER_BLOCK: usize = 60;
 
-	let (node, ws_addr) = Flashblocks::test_node().await?;
-	let ws = WebSocketObserver::new(ws_addr).await?;
+	let node = harness.node();
+	let ws = harness.ws_observer().await?;
 
 	for i in 1..=BLOCKS {
 		let mut sent_txs = Vec::new();
@@ -100,19 +105,22 @@ async fn blocks_with_txs_smoke() -> eyre::Result<()> {
 }
 
 // This test is to check that we get 8 flashblocks with 2000ms remaining time
-// and 250ms flashblock interval and 75ms leeway time
-#[tokio::test]
-async fn flashblock_timings_2000ms_block_time_0ms_leeway_time()
--> eyre::Result<()> {
+// and 250ms flashblock interval and 0ms leeway time
+#[unichain_test(args = BuilderArgs {
+    flashblocks_args: FlashblocksArgs {
+        interval: Duration::from_millis(250),
+		leeway_time: Duration::from_millis(0),
+		..Default::default()
+    },
+    ..Default::default()
+})]
+async fn flashblock_timings_2000ms_block_time_0ms_leeway_time(
+	harness: Harness,
+) -> eyre::Result<()> {
 	const TXS_PER_BLOCK: usize = 60;
 
-	let (node, ws_addr) =
-		Flashblocks::test_node_with_custom_leeway_time_and_interval(
-			Duration::from_millis(0),
-			Duration::from_millis(250),
-		)
-		.await?;
-	let ws = WebSocketObserver::new(ws_addr).await?;
+	let node = harness.node();
+	let ws = harness.ws_observer().await?;
 
 	// Create a block at the top of the timestamp second
 	// Wait until the exact top of the next second
@@ -150,16 +158,17 @@ async fn flashblock_timings_2000ms_block_time_0ms_leeway_time()
 	Ok(())
 }
 
-#[tokio::test]
 // This test is to check that we get 8 flashblocks with 2000ms - 75ms = 1925ms
 // remaining time. 2000ms blocktimes, 250ms flashblock interval, and 75ms leeway
 // time
-async fn flashblock_timings_2000ms_block_time_75ms_leeway_time()
--> eyre::Result<()> {
+#[unichain_test]
+async fn flashblock_timings_2000ms_block_time_75ms_leeway_time(
+	harness: Harness,
+) -> eyre::Result<()> {
 	const TXS_PER_BLOCK: usize = 60;
 
-	let (node, ws_addr) = Flashblocks::test_node().await?;
-	let ws = WebSocketObserver::new(ws_addr).await?;
+	let node = harness.node();
+	let ws = harness.ws_observer().await?;
 
 	// Create a block at the top of the timestamp second
 	// Wait until the exact top of the next second
@@ -197,21 +206,24 @@ async fn flashblock_timings_2000ms_block_time_75ms_leeway_time()
 	Ok(())
 }
 
-#[tokio::test]
 // This test is to check that we get 3 flashblocks with 2000ms - 500ms = 1500ms
 // remaining time. 2000ms blocktimes, 500ms flashblock interval, and 500ms
 // leeway time
-async fn flashblock_timings_2000ms_block_time_500ms_leeway_time()
--> eyre::Result<()> {
+#[unichain_test(args = BuilderArgs {
+    flashblocks_args: FlashblocksArgs {
+        interval: Duration::from_millis(500),
+		leeway_time: Duration::from_millis(500),
+		..Default::default()
+    },
+    ..Default::default()
+})]
+async fn flashblock_timings_2000ms_block_time_500ms_leeway_time(
+	harness: Harness,
+) -> eyre::Result<()> {
 	const TXS_PER_BLOCK: usize = 60;
 
-	let (node, ws_addr) =
-		Flashblocks::test_node_with_custom_leeway_time_and_interval(
-			Duration::from_millis(500),
-			Duration::from_millis(500),
-		)
-		.await?;
-	let ws = WebSocketObserver::new(ws_addr).await?;
+	let node = harness.node();
+	let ws = harness.ws_observer().await?;
 
 	// Create a block at the top of the timestamp second
 	// Wait until the exact top of the next second

src/tests/framework/macros/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "macros"
+version = "0.1.0"
+edition = "2024"
+description = "Macros supporting the tests infrastructure for unichain-builder"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "2.0"
+quote = "1.0"
+proc-macro2 = "1.0"
+paste = "1.0"