fix: use tempdir when testing static files (paradigmxyz#6962)

altugbakan · Mar 16, 2024 · 3b4726a · 3b4726a
1 parent 5e9e21d
commit 3b4726a
Show file tree

Hide file tree

Showing 10 changed files with 88 additions and 96 deletions.
diff --git a/crates/consensus/beacon/src/engine/mod.rs b/crates/consensus/beacon/src/engine/mod.rs
@@ -2150,13 +2150,11 @@ mod tests {
 
             let genesis = random_block(&mut rng, 0, None, None, Some(0));
             let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
+            let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), static_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&genesis, &block1].into_iter(),
             );
             env.db
@@ -2208,13 +2206,12 @@ mod tests {
 
             let genesis = random_block(&mut rng, 0, None, None, Some(0));
             let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
+
+            let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), static_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&genesis, &block1].into_iter(),
             );
 
@@ -2230,15 +2227,12 @@ mod tests {
             // if we `await` in the assert, the forkchoice will poll after we've inserted the block,
             // and it will return VALID instead of SYNCING
             let invalid_rx = env.send_forkchoice_updated(next_forkchoice_state).await;
+            let (_static_dir, static_dir_path) = create_test_static_files_dir();
 
             // Insert next head immediately after sending forkchoice update
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), static_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&next_head].into_iter(),
             );
 
@@ -2274,13 +2268,12 @@ mod tests {
 
             let genesis = random_block(&mut rng, 0, None, None, Some(0));
             let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
+
+            let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), static_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&genesis, &block1].into_iter(),
             );
 
@@ -2329,13 +2322,10 @@ mod tests {
             let mut block3 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
             block3.header.set_difficulty(U256::from(1));
 
+            let (_static_dir, static_dir_path) = create_test_static_files_dir();
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), static_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&genesis, &block1, &block2, &block3].into_iter(),
             );
 
@@ -2377,13 +2367,11 @@ mod tests {
             let genesis = random_block(&mut rng, 0, None, None, Some(0));
             let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
 
+            let (_temp_dir, temp_dir_path) = create_test_static_files_dir();
+
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), temp_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&genesis, &block1].into_iter(),
             );
 
@@ -2481,13 +2469,11 @@ mod tests {
             let genesis = random_block(&mut rng, 0, None, None, Some(0));
             let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
             let block2 = random_block(&mut rng, 2, Some(block1.hash()), None, Some(0));
+
+            let (_static_dir, static_dir_path) = create_test_static_files_dir();
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), static_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&genesis, &block1, &block2].into_iter(),
             );
 
@@ -2552,13 +2538,11 @@ mod tests {
             // TODO: add transactions that transfer from the alloc accounts, generating the new
             // block tx and state root
 
+            let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), static_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&genesis, &block1].into_iter(),
             );
 
@@ -2598,13 +2582,11 @@ mod tests {
 
             let genesis = random_block(&mut rng, 0, None, None, Some(0));
 
+            let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), static_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&genesis].into_iter(),
             );
 
@@ -2664,13 +2646,11 @@ mod tests {
                 .with_executor_results(Vec::from([exec_result2]))
                 .build();
 
+            let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
             insert_blocks(
-                ProviderFactory::new(
-                    env.db.as_ref(),
-                    chain_spec.clone(),
-                    create_test_static_files_dir(),
-                )
-                .expect("create provider factory with static_files"),
+                ProviderFactory::new(env.db.as_ref(), chain_spec.clone(), static_dir_path)
+                    .expect("create provider factory with static_files"),
                 [&data.genesis, &block1].into_iter(),
             );
 

diff --git a/crates/net/downloaders/src/bodies/bodies.rs b/crates/net/downloaders/src/bodies/bodies.rs
@@ -615,10 +615,12 @@ mod tests {
         let client = Arc::new(
             TestBodiesClient::default().with_bodies(bodies.clone()).with_should_delay(true),
         );
+        let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
         let mut downloader = BodiesDownloaderBuilder::default().build(
             client.clone(),
             Arc::new(TestConsensus::default()),
-            ProviderFactory::new(db, MAINNET.clone(), create_test_static_files_dir()).unwrap(),
+            ProviderFactory::new(db, MAINNET.clone(), static_dir_path).unwrap(),
         );
         downloader.set_download_range(0..=19).expect("failed to set download range");
 
@@ -653,11 +655,13 @@ mod tests {
 
         let request_limit = 10;
         let client = Arc::new(TestBodiesClient::default().with_bodies(bodies.clone()));
+        let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
         let mut downloader =
             BodiesDownloaderBuilder::default().with_request_limit(request_limit).build(
                 client.clone(),
                 Arc::new(TestConsensus::default()),
-                ProviderFactory::new(db, MAINNET.clone(), create_test_static_files_dir()).unwrap(),
+                ProviderFactory::new(db, MAINNET.clone(), static_dir_path).unwrap(),
             );
         downloader.set_download_range(0..=199).expect("failed to set download range");
 
@@ -680,13 +684,14 @@ mod tests {
         let client = Arc::new(
             TestBodiesClient::default().with_bodies(bodies.clone()).with_should_delay(true),
         );
+        let (_static_dir, static_dir_path) = create_test_static_files_dir();
         let mut downloader = BodiesDownloaderBuilder::default()
             .with_stream_batch_size(stream_batch_size)
             .with_request_limit(request_limit)
             .build(
                 client.clone(),
                 Arc::new(TestConsensus::default()),
-                ProviderFactory::new(db, MAINNET.clone(), create_test_static_files_dir()).unwrap(),
+                ProviderFactory::new(db, MAINNET.clone(), static_dir_path).unwrap(),
             );
 
         let mut range_start = 0;
@@ -713,10 +718,12 @@ mod tests {
         insert_headers(db.db(), &headers);
 
         let client = Arc::new(TestBodiesClient::default().with_bodies(bodies.clone()));
+        let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
         let mut downloader = BodiesDownloaderBuilder::default().with_stream_batch_size(100).build(
             client.clone(),
             Arc::new(TestConsensus::default()),
-            ProviderFactory::new(db, MAINNET.clone(), create_test_static_files_dir()).unwrap(),
+            ProviderFactory::new(db, MAINNET.clone(), static_dir_path).unwrap(),
         );
 
         // Set and download the first range
@@ -747,6 +754,8 @@ mod tests {
         insert_headers(db.db(), &headers);
 
         let client = Arc::new(TestBodiesClient::default().with_bodies(bodies.clone()));
+
+        let (_static_dir, static_dir_path) = create_test_static_files_dir();
         // Set the max buffered block size to 1 byte, to make sure that every response exceeds the
         // limit
         let mut downloader = BodiesDownloaderBuilder::default()
@@ -756,7 +765,7 @@ mod tests {
             .build(
                 client.clone(),
                 Arc::new(TestConsensus::default()),
-                ProviderFactory::new(db, MAINNET.clone(), create_test_static_files_dir()).unwrap(),
+                ProviderFactory::new(db, MAINNET.clone(), static_dir_path).unwrap(),
             );
 
         // Set and download the entire range
@@ -781,13 +790,15 @@ mod tests {
         let client = Arc::new(
             TestBodiesClient::default().with_bodies(bodies.clone()).with_empty_responses(2),
         );
+        let (_static_dir, static_dir_path) = create_test_static_files_dir();
+
         let mut downloader = BodiesDownloaderBuilder::default()
             .with_request_limit(3)
             .with_stream_batch_size(100)
             .build(
                 client.clone(),
                 Arc::new(TestConsensus::default()),
-                ProviderFactory::new(db, MAINNET.clone(), create_test_static_files_dir()).unwrap(),
+                ProviderFactory::new(db, MAINNET.clone(), static_dir_path).unwrap(),
             );
 
         // Download the requested range

diff --git a/crates/net/downloaders/src/bodies/task.rs b/crates/net/downloaders/src/bodies/task.rs
@@ -205,11 +205,12 @@ mod tests {
     #[allow(clippy::reversed_empty_ranges)]
     async fn set_download_range_error_returned() {
         reth_tracing::init_test_tracing();
+        let factory = create_test_provider_factory();
 
         let downloader = BodiesDownloaderBuilder::default().build(
             Arc::new(TestBodiesClient::default()),
             Arc::new(TestConsensus::default()),
-            create_test_provider_factory(),
+            factory,
         );
         let mut downloader = TaskDownloader::spawn(downloader);
 

diff --git a/crates/prune/src/pruner.rs b/crates/prune/src/pruner.rs
@@ -273,9 +273,9 @@ mod tests {
     #[test]
     fn is_pruning_needed() {
         let db = create_test_rw_db();
-        let provider_factory =
-            ProviderFactory::new(db, MAINNET.clone(), create_test_static_files_dir())
-                .expect("create provide factory with static_files");
+        let (_static_dir, static_dir_path) = create_test_static_files_dir();
+        let provider_factory = ProviderFactory::new(db, MAINNET.clone(), static_dir_path)
+            .expect("create provide factory with static_files");
         let mut pruner = Pruner::new(provider_factory, vec![], 5, 0, 5);
 
         // No last pruned block number was set before

diff --git a/crates/stages/src/test_utils/test_db.rs b/crates/stages/src/test_utils/test_db.rs
@@ -21,34 +21,37 @@ use reth_provider::{
     HistoryWriter, ProviderError, ProviderFactory,
 };
 use std::{collections::BTreeMap, path::Path, sync::Arc};
+use tempfile::TempDir;
 
 /// Test database that is used for testing stage implementations.
 #[derive(Debug)]
 pub struct TestStageDB {
     pub factory: ProviderFactory<Arc<TempDatabase<DatabaseEnv>>>,
+    pub temp_static_files_dir: TempDir,
 }
 
 impl Default for TestStageDB {
     /// Create a new instance of [TestStageDB]
     fn default() -> Self {
+        let (static_dir, static_dir_path) = create_test_static_files_dir();
         Self {
-            factory: ProviderFactory::new(
-                create_test_rw_db(),
-                MAINNET.clone(),
-                create_test_static_files_dir(),
-            )
-            .unwrap(),
+            temp_static_files_dir: static_dir,
+            factory: ProviderFactory::new(create_test_rw_db(), MAINNET.clone(), static_dir_path)
+                .unwrap(),
         }
     }
 }
 
 impl TestStageDB {
     pub fn new(path: &Path) -> Self {
+        let (static_dir, static_dir_path) = create_test_static_files_dir();
+
         Self {
+            temp_static_files_dir: static_dir,
             factory: ProviderFactory::new(
                 create_test_rw_db_with_path(path),
                 MAINNET.clone(),
-                create_test_static_files_dir(),
+                static_dir_path,
             )
             .unwrap(),
         }

diff --git a/crates/static-file/src/static_file_producer.rs b/crates/static-file/src/static_file_producer.rs
@@ -257,8 +257,9 @@ mod tests {
         sync::{mpsc::channel, Arc},
         time::Duration,
     };
+    use tempfile::TempDir;
 
-    fn setup() -> (ProviderFactory<Arc<TempDatabase<DatabaseEnv>>>, StaticFileProvider) {
+    fn setup() -> (ProviderFactory<Arc<TempDatabase<DatabaseEnv>>>, StaticFileProvider, TempDir) {
         let mut rng = generators::rng();
         let db = TestStageDB::default();
 
@@ -290,12 +291,12 @@ mod tests {
 
         let provider_factory = db.factory;
         let static_file_provider = provider_factory.static_file_provider();
-        (provider_factory, static_file_provider)
+        (provider_factory, static_file_provider, db.temp_static_files_dir)
     }
 
     #[test]
     fn run() {
-        let (provider_factory, static_file_provider) = setup();
+        let (provider_factory, static_file_provider, _temp_static_files_dir) = setup();
 
         let mut static_file_producer = StaticFileProducerInner::new(
             provider_factory,
@@ -373,7 +374,7 @@ mod tests {
     /// Tests that a cloneable [`StaticFileProducer`] type is not susceptible to any race condition.
     #[test]
     fn only_one() {
-        let (provider_factory, static_file_provider) = setup();
+        let (provider_factory, static_file_provider, _temp_static_files_dir) = setup();
 
         let static_file_producer = StaticFileProducer::new(
             provider_factory,