jleony/nanoreth
1
0
Fork 0
mirror of https://github.com/hl-archive-node/nanoreth.git synced 2025-12-06 19:09:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: move mdbx::test-utils to reth_db::test-utils and add DatabaseEnvRO (#3466)

Browse Source
This commit is contained in:
joshieDo
2023-06-30 00:52:26 +01:00
committed by GitHub
parent 7850cc0b8d
commit c3ea430e4a
39 changed files with 227 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
bin/reth/src/db/list.rs
View File

@ -3,12 +3,7 @@ use clap::Parser;
use super::tui::DbListTUI;
use eyre::WrapErr;
use reth_db::{
database::Database,
mdbx::{Env, NoWriteMap},
table::Table,
TableType, TableViewer, Tables,
};
use reth_db::{database::Database, table::Table, DatabaseEnvRO, TableType, TableViewer, Tables};
use tracing::error;
const DEFAULT_NUM_ITEMS: &str = "5";
@ -34,7 +29,7 @@ pub struct Command {
impl Command {
/// Execute `db list` command
pub fn execute(self, tool: &DbTool<'_, Env<NoWriteMap>>) -> eyre::Result<()> {
pub fn execute(self, tool: &DbTool<'_, DatabaseEnvRO>) -> eyre::Result<()> {
if self.table.table_type() == TableType::DupSort {
error!(target: "reth::cli", "Unsupported table.");
}
@ -46,7 +41,7 @@ impl Command {
}
struct ListTableViewer<'a> {
tool: &'a DbTool<'a, Env<NoWriteMap>>,
tool: &'a DbTool<'a, DatabaseEnvRO>,
args: &'a Command,
}

24
bin/reth/src/db/mod.rs
View File

@ -10,12 +10,12 @@ use eyre::WrapErr;
use human_bytes::human_bytes;
use reth_db::{
database::Database,
mdbx::{Env, NoWriteMap, WriteMap},
open_db, open_db_read_only,
version::{get_db_version, DatabaseVersionError, DB_VERSION},
DatabaseEnv, Tables,
Tables,
};
use reth_primitives::ChainSpec;
use std::{path::Path, sync::Arc};
use std::sync::Arc;
mod get;
mod list;
@ -84,7 +84,7 @@ impl Command {
match self.command {
// TODO: We'll need to add this on the DB trait.
Subcommands::Stats { .. } => {
let db = read_only_db(&db_path)?;
let db = open_db_read_only(&db_path)?;
let tool = DbTool::new(&db, self.chain.clone())?;
let mut stats_table = ComfyTable::new();
stats_table.load_preset(comfy_table::presets::ASCII_MARKDOWN);
@ -135,17 +135,17 @@ impl Command {
println!("{stats_table}");
}
Subcommands::List(command) => {
let db = read_only_db(&db_path)?;
let db = open_db_read_only(&db_path)?;
let tool = DbTool::new(&db, self.chain.clone())?;
command.execute(&tool)?;
}
Subcommands::Get(command) => {
let db = read_only_db(&db_path)?;
let db = open_db_read_only(&db_path)?;
let tool = DbTool::new(&db, self.chain.clone())?;
command.execute(&tool)?;
}
Subcommands::Drop => {
let db = read_write_db(&db_path)?;
let db = open_db(&db_path)?;
let mut tool = DbTool::new(&db, self.chain.clone())?;
tool.drop(db_path)?;
}
@ -173,16 +173,6 @@ impl Command {
}
}
fn read_only_db(path: &Path) -> eyre::Result<Env<NoWriteMap>> {
Env::<NoWriteMap>::open(path, reth_db::mdbx::EnvKind::RO)
.with_context(|| format!("Could not open database at path: {}", path.display()))
}
fn read_write_db(path: &Path) -> eyre::Result<DatabaseEnv> {
Env::<WriteMap>::open(path, reth_db::mdbx::EnvKind::RW)
.with_context(|| format!("Could not open database at path: {}", path.display()))
}
#[cfg(test)]
mod tests {
use super::*;

4
bin/reth/src/p2p/mod.rs
View File

@ -11,7 +11,7 @@ use crate::{
use backon::{ConstantBuilder, Retryable};
use clap::{Parser, Subcommand};
use reth_config::Config;
use reth_db::mdbx::{Env, EnvKind, WriteMap};
use reth_db::open_db;
use reth_discv4::NatResolver;
use reth_interfaces::p2p::bodies::client::BodiesClient;
use reth_primitives::{BlockHashOrNumber, ChainSpec, NodeRecord};
@ -101,7 +101,7 @@ impl Command {
/// Execute `p2p` command
pub async fn execute(&self) -> eyre::Result<()> {
let tempdir = tempfile::TempDir::new()?;
let noop_db = Arc::new(Env::<WriteMap>::open(&tempdir.into_path(), EnvKind::RW)?);
let noop_db = Arc::new(open_db(&tempdir.into_path())?);
// add network name to data dir
let data_dir = self.datadir.unwrap_or_chain_default(self.chain.chain);

10
bin/reth/src/stage/drop.rs
View File

@ -5,13 +5,7 @@ use crate::{
utils::DbTool,
};
use clap::Parser;
use reth_db::{
database::Database,
mdbx::{Env, WriteMap},
tables,
transaction::DbTxMut,
DatabaseEnv,
};
use reth_db::{database::Database, open_db, tables, transaction::DbTxMut, DatabaseEnv};
use reth_primitives::{stage::StageId, ChainSpec};
use reth_staged_sync::utils::init::{insert_genesis_header, insert_genesis_state};
use std::sync::Arc;
@ -58,7 +52,7 @@ impl Command {
let db_path = data_dir.db_path();
std::fs::create_dir_all(&db_path)?;
let db = Env::<WriteMap>::open(db_path.as_ref(), reth_db::mdbx::EnvKind::RW)?;
let db = open_db(db_path.as_ref())?;
let tool = DbTool::new(&db, self.chain.clone())?;

5
bin/reth/src/stage/dump/execution.rs
View File

@ -3,6 +3,7 @@ use crate::utils::DbTool;
use eyre::Result;
use reth_db::{
cursor::DbCursorRO, database::Database, table::TableImporter, tables, transaction::DbTx,
DatabaseEnv,
};
use reth_primitives::{stage::StageCheckpoint, ChainSpec};
use reth_provider::ProviderFactory;
@ -33,7 +34,7 @@ pub(crate) async fn dump_execution_stage<DB: Database>(
/// Imports all the tables that can be copied over a range.
fn import_tables_with_range<DB: Database>(
output_db: &reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
output_db: &DatabaseEnv,
db_tool: &mut DbTool<'_, DB>,
from: u64,
to: u64,
@ -92,7 +93,7 @@ async fn unwind_and_copy<DB: Database>(
db_tool: &mut DbTool<'_, DB>,
from: u64,
tip_block_number: u64,
output_db: &reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
output_db: &DatabaseEnv,
) -> eyre::Result<()> {
let factory = ProviderFactory::new(db_tool.db, db_tool.chain.clone());
let provider = factory.provider_rw()?;

4
bin/reth/src/stage/dump/hashing_account.rs
View File

@ -1,7 +1,7 @@
use super::setup;
use crate::utils::DbTool;
use eyre::Result;
use reth_db::{database::Database, table::TableImporter, tables};
use reth_db::{database::Database, table::TableImporter, tables, DatabaseEnv};
use reth_primitives::{stage::StageCheckpoint, BlockNumber, ChainSpec};
use reth_provider::ProviderFactory;
use reth_stages::{stages::AccountHashingStage, Stage, UnwindInput};
@ -36,7 +36,7 @@ async fn unwind_and_copy<DB: Database>(
db_tool: &mut DbTool<'_, DB>,
from: u64,
tip_block_number: u64,
output_db: &reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
output_db: &DatabaseEnv,
) -> eyre::Result<()> {
let factory = ProviderFactory::new(db_tool.db, db_tool.chain.clone());
let provider = factory.provider_rw()?;

4
bin/reth/src/stage/dump/hashing_storage.rs
View File

@ -1,7 +1,7 @@
use super::setup;
use crate::utils::DbTool;
use eyre::Result;
use reth_db::{database::Database, table::TableImporter, tables};
use reth_db::{database::Database, table::TableImporter, tables, DatabaseEnv};
use reth_primitives::{stage::StageCheckpoint, ChainSpec};
use reth_provider::ProviderFactory;
use reth_stages::{stages::StorageHashingStage, Stage, UnwindInput};
@ -31,7 +31,7 @@ async fn unwind_and_copy<DB: Database>(
db_tool: &mut DbTool<'_, DB>,
from: u64,
tip_block_number: u64,
output_db: &reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
output_db: &DatabaseEnv,
) -> eyre::Result<()> {
let factory = ProviderFactory::new(db_tool.db, db_tool.chain.clone());
let provider = factory.provider_rw()?;

4
bin/reth/src/stage/dump/merkle.rs
View File

@ -1,7 +1,7 @@
use super::setup;
use crate::utils::DbTool;
use eyre::Result;
use reth_db::{database::Database, table::TableImporter, tables};
use reth_db::{database::Database, table::TableImporter, tables, DatabaseEnv};
use reth_primitives::{stage::StageCheckpoint, BlockNumber, ChainSpec};
use reth_provider::ProviderFactory;
use reth_stages::{
@ -45,7 +45,7 @@ async fn unwind_and_copy<DB: Database>(
db_tool: &mut DbTool<'_, DB>,
range: (u64, u64),
tip_block_number: u64,
output_db: &reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
output_db: &DatabaseEnv,
) -> eyre::Result<()> {
let (from, to) = range;
let factory = ProviderFactory::new(db_tool.db, db_tool.chain.clone());

4
bin/reth/src/stage/dump/mod.rs
View File

@ -6,7 +6,7 @@ use crate::{
use clap::Parser;
use reth_db::{
cursor::DbCursorRO, database::Database, init_db, table::TableImporter, tables,
transaction::DbTx,
transaction::DbTx, DatabaseEnv,
};
use reth_primitives::ChainSpec;
use std::{path::PathBuf, sync::Arc};
@ -129,7 +129,7 @@ pub(crate) fn setup<DB: Database>(
to: u64,
output_db: &PathBuf,
db_tool: &mut DbTool<'_, DB>,
) -> eyre::Result<(reth_db::mdbx::Env<reth_db::mdbx::WriteMap>, u64)> {
) -> eyre::Result<(DatabaseEnv, u64)> {
assert!(from < to, "FROM block should be bigger than TO block.");
info!(target: "reth::cli", ?output_db, "Creating separate db");

10
bin/reth/src/stage/unwind.rs
View File

@ -5,13 +5,7 @@ use crate::{
dirs::{DataDirPath, MaybePlatformPath},
};
use clap::{Parser, Subcommand};
use reth_db::{
cursor::DbCursorRO,
database::Database,
mdbx::{Env, WriteMap},
tables,
transaction::DbTx,
};
use reth_db::{cursor::DbCursorRO, database::Database, open_db, tables, transaction::DbTx};
use reth_primitives::{BlockHashOrNumber, ChainSpec};
use reth_provider::{BlockExecutionWriter, ProviderFactory};
use std::{ops::RangeInclusive, sync::Arc};
@ -61,7 +55,7 @@ impl Command {
eyre::bail!("Database {db_path:?} does not exist.")
}
let db = Env::<WriteMap>::open(db_path.as_ref(), reth_db::mdbx::EnvKind::RW)?;
let db = open_db(db_path.as_ref())?;
let range = self.command.unwind_range(&db)?;

2
crates/blockchain-tree/src/blockchain_tree.rs
View File

@ -1085,7 +1085,7 @@ mod tests {
use crate::block_buffer::BufferedBlocks;
use assert_matches::assert_matches;
use linked_hash_set::LinkedHashSet;
use reth_db::{mdbx::test_utils::create_test_rw_db, transaction::DbTxMut, DatabaseEnv};
use reth_db::{test_utils::create_test_rw_db, transaction::DbTxMut, DatabaseEnv};
use reth_interfaces::test_utils::TestConsensus;
use reth_primitives::{
proofs::EMPTY_ROOT, stage::StageCheckpoint, ChainSpecBuilder, H256, MAINNET,

2
crates/consensus/beacon/src/engine/mod.rs
View File

@ -1381,7 +1381,7 @@ mod tests {
config::BlockchainTreeConfig, externals::TreeExternals, post_state::PostState,
BlockchainTree, ShareableBlockchainTree,
};
use reth_db::{mdbx::test_utils::create_test_rw_db, DatabaseEnv};
use reth_db::{test_utils::create_test_rw_db, DatabaseEnv};
use reth_interfaces::{
sync::NoopSyncStateUpdater,
test_utils::{NoopFullBlockClient, TestConsensus},

10
crates/net/downloaders/src/bodies/bodies.rs
View File

@ -595,7 +595,7 @@ mod tests {
};
use assert_matches::assert_matches;
use futures_util::stream::StreamExt;
use reth_db::mdbx::{test_utils::create_test_db, EnvKind, WriteMap};
use reth_db::test_utils::create_test_rw_db;
use reth_interfaces::test_utils::{generators, generators::random_block_range, TestConsensus};
use reth_primitives::{BlockBody, H256};
use std::{collections::HashMap, sync::Arc};
@ -605,7 +605,7 @@ mod tests {
#[tokio::test]
async fn streams_bodies_in_order() {
// Generate some random blocks
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let (headers, mut bodies) = generate_bodies(0..=19);
insert_headers(&db, &headers);
@ -632,7 +632,7 @@ mod tests {
#[tokio::test]
async fn requests_correct_number_of_times() {
// Generate some random blocks
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 0..=199, H256::zero(), 1..2);
@ -665,7 +665,7 @@ mod tests {
#[tokio::test]
async fn streams_bodies_in_order_after_range_reset() {
// Generate some random blocks
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let (headers, mut bodies) = generate_bodies(0..=99);
insert_headers(&db, &headers);
@ -698,7 +698,7 @@ mod tests {
#[tokio::test]
async fn can_download_new_range_after_termination() {
// Generate some random blocks
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let (headers, mut bodies) = generate_bodies(0..=199);
insert_headers(&db, &headers);

6
crates/net/downloaders/src/bodies/task.rs
View File

@ -179,7 +179,7 @@ mod tests {
test_utils::{generate_bodies, TestBodiesClient},
};
use assert_matches::assert_matches;
use reth_db::mdbx::{test_utils::create_test_db, EnvKind, WriteMap};
use reth_db::test_utils::create_test_rw_db;
use reth_interfaces::{p2p::error::DownloadError, test_utils::TestConsensus};
use std::sync::Arc;
@ -187,7 +187,7 @@ mod tests {
async fn download_one_by_one_on_task() {
reth_tracing::init_test_tracing();
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let (headers, mut bodies) = generate_bodies(0..=19);
insert_headers(&db, &headers);
@ -216,7 +216,7 @@ mod tests {
async fn set_download_range_error_returned() {
reth_tracing::init_test_tracing();
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let downloader = BodiesDownloaderBuilder::default().build(
Arc::new(TestBodiesClient::default()),
Arc::new(TestConsensus::default()),

8
crates/net/downloaders/src/bodies/test_utils.rs
View File

@ -1,12 +1,6 @@
#![allow(unused)]
//! Test helper impls for generating bodies
use reth_db::{
database::Database,
mdbx::{Env, WriteMap},
tables,
transaction::DbTxMut,
DatabaseEnv,
};
use reth_db::{database::Database, tables, transaction::DbTxMut, DatabaseEnv};
use reth_interfaces::{db, p2p::bodies::response::BlockResponse};
use reth_primitives::{Block, BlockBody, SealedBlock, SealedHeader, H256};
use std::collections::HashMap;

8
crates/net/downloaders/src/test_utils/file_client.rs
View File

@ -258,7 +258,7 @@ mod tests {
use assert_matches::assert_matches;
use futures::SinkExt;
use futures_util::stream::StreamExt;
use reth_db::mdbx::{test_utils::create_test_db, EnvKind, WriteMap};
use reth_db::test_utils::create_test_rw_db;
use reth_interfaces::{
p2p::{
bodies::downloader::BodyDownloader,
@ -278,7 +278,7 @@ mod tests {
#[tokio::test]
async fn streams_bodies_from_buffer() {
// Generate some random blocks
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let (headers, mut bodies) = generate_bodies(0..=19);
insert_headers(&db, &headers);
@ -336,7 +336,7 @@ mod tests {
#[tokio::test]
async fn test_download_headers_from_file() {
// Generate some random blocks
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let (file, headers, mut bodies) = generate_bodies_file(0..=19).await;
// now try to read them back
@ -361,7 +361,7 @@ mod tests {
#[tokio::test]
async fn test_download_bodies_from_file() {
// Generate some random blocks
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let (file, headers, mut bodies) = generate_bodies_file(0..=19).await;
// now try to read them back

2
crates/staged-sync/src/utils/init.rs
View File

@ -178,9 +178,9 @@ mod tests {
use super::*;
use reth_db::{
mdbx::test_utils::create_test_rw_db,
models::{storage_sharded_key::StorageShardedKey, ShardedKey},
table::Table,
test_utils::create_test_rw_db,
DatabaseEnv,
};
use reth_primitives::{

2
crates/stages/src/lib.rs
View File

@ -26,7 +26,7 @@
//!
//! ```
//! # use std::sync::Arc;
//! # use reth_db::mdbx::test_utils::create_test_rw_db;
//! # use reth_db::test_utils::create_test_rw_db;
//! # use reth_downloaders::bodies::bodies::BodiesDownloaderBuilder;
//! # use reth_downloaders::headers::reverse_headers::ReverseHeadersDownloaderBuilder;
//! # use reth_interfaces::consensus::Consensus;

14
crates/stages/src/pipeline/mod.rs
View File

@ -480,7 +480,7 @@ mod tests {
use super::*;
use crate::{test_utils::TestStage, UnwindOutput};
use assert_matches::assert_matches;
use reth_db::mdbx::{self, test_utils, EnvKind};
use reth_db::test_utils::create_test_rw_db;
use reth_interfaces::{
consensus,
provider::ProviderError,
@ -519,7 +519,7 @@ mod tests {
/// Runs a simple pipeline.
#[tokio::test]
async fn run_pipeline() {
let db = test_utils::create_test_db::<mdbx::WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let mut pipeline = Pipeline::builder()
.add_stage(
@ -574,7 +574,7 @@ mod tests {
/// Unwinds a simple pipeline.
#[tokio::test]
async fn unwind_pipeline() {
let db = test_utils::create_test_db::<mdbx::WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let mut pipeline = Pipeline::builder()
.add_stage(
@ -690,7 +690,7 @@ mod tests {
/// Unwinds a pipeline with intermediate progress.
#[tokio::test]
async fn unwind_pipeline_with_intermediate_progress() {
let db = test_utils::create_test_db::<mdbx::WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let mut pipeline = Pipeline::builder()
.add_stage(
@ -777,7 +777,7 @@ mod tests {
/// - The pipeline finishes
#[tokio::test]
async fn run_pipeline_with_unwind() {
let db = test_utils::create_test_db::<mdbx::WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let mut pipeline = Pipeline::builder()
.add_stage(
@ -871,7 +871,7 @@ mod tests {
#[tokio::test]
async fn pipeline_error_handling() {
// Non-fatal
let db = test_utils::create_test_db::<mdbx::WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let mut pipeline = Pipeline::builder()
.add_stage(
TestStage::new(StageId::Other("NonFatal"))
@ -884,7 +884,7 @@ mod tests {
assert_matches!(result, Ok(()));
// Fatal
let db = test_utils::create_test_db::<mdbx::WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let mut pipeline = Pipeline::builder()
.add_stage(TestStage::new(StageId::Other("Fatal")).add_exec(Err(
StageError::DatabaseIntegrity(ProviderError::BlockBodyIndicesNotFound(5)),

2
crates/stages/src/sets.rs
View File

@ -14,7 +14,7 @@
//! # use reth_stages::sets::{OfflineStages};
//! # use reth_revm::Factory;
//! # use reth_primitives::MAINNET;
//! use reth_db::mdbx::test_utils::create_test_rw_db;
//! use reth_db::test_utils::create_test_rw_db;
//!
//! # let factory = Factory::new(MAINNET.clone());
//! # let db = create_test_rw_db();

17
crates/stages/src/stages/execution.rs
View File

@ -417,10 +417,7 @@ mod tests {
use super::*;
use crate::test_utils::TestTransaction;
use assert_matches::assert_matches;
use reth_db::{
mdbx::{test_utils::create_test_db, EnvKind, WriteMap},
models::AccountBeforeTx,
};
use reth_db::{models::AccountBeforeTx, test_utils::create_test_rw_db};
use reth_primitives::{
hex_literal::hex, keccak256, stage::StageUnitCheckpoint, Account, Bytecode,
ChainSpecBuilder, SealedBlock, StorageEntry, H160, H256, MAINNET, U256,
@ -441,7 +438,7 @@ mod tests {
#[test]
fn execution_checkpoint_matches() {
let state_db = create_test_db::<WriteMap>(EnvKind::RW);
let state_db = create_test_rw_db();
let factory = ProviderFactory::new(state_db.as_ref(), MAINNET.clone());
let tx = factory.provider_rw().unwrap();
@ -466,7 +463,7 @@ mod tests {
#[test]
fn execution_checkpoint_precedes() {
let state_db = create_test_db::<WriteMap>(EnvKind::RW);
let state_db = create_test_rw_db();
let factory = ProviderFactory::new(state_db.as_ref(), MAINNET.clone());
let provider = factory.provider_rw().unwrap();
@ -502,7 +499,7 @@ mod tests {
#[test]
fn execution_checkpoint_recalculate_full_previous_some() {
let state_db = create_test_db::<WriteMap>(EnvKind::RW);
let state_db = create_test_rw_db();
let factory = ProviderFactory::new(state_db.as_ref(), MAINNET.clone());
let provider = factory.provider_rw().unwrap();
@ -538,7 +535,7 @@ mod tests {
#[test]
fn execution_checkpoint_recalculate_full_previous_none() {
let state_db = create_test_db::<WriteMap>(EnvKind::RW);
let state_db = create_test_rw_db();
let factory = ProviderFactory::new(state_db.as_ref(), MAINNET.clone());
let provider = factory.provider_rw().unwrap();
@ -568,7 +565,7 @@ mod tests {
async fn sanity_execution_of_block() {
// TODO cleanup the setup after https://github.com/paradigmxyz/reth/issues/332
// is merged as it has similar framework
let state_db = create_test_db::<WriteMap>(EnvKind::RW);
let state_db = create_test_rw_db();
let factory = ProviderFactory::new(state_db.as_ref(), MAINNET.clone());
let provider = factory.provider_rw().unwrap();
let input = ExecInput {
@ -678,7 +675,7 @@ mod tests {
// TODO cleanup the setup after https://github.com/paradigmxyz/reth/issues/332
// is merged as it has similar framework
let state_db = create_test_db::<WriteMap>(EnvKind::RW);
let state_db = create_test_rw_db();
let factory = ProviderFactory::new(state_db.as_ref(), MAINNET.clone());
let provider = factory.provider_rw().unwrap();
let input = ExecInput {

5
crates/stages/src/stages/hashing_storage.rs
View File

@ -233,7 +233,6 @@ mod tests {
use rand::Rng;
use reth_db::{
cursor::{DbCursorRO, DbCursorRW},
mdbx::{tx::Tx, WriteMap, RW},
models::{BlockNumberAddress, StoredBlockBodyIndices},
};
use reth_interfaces::test_utils::{
@ -621,9 +620,9 @@ mod tests {
.map_err(|e| e.into())
}
fn insert_storage_entry(
fn insert_storage_entry<'a, TX: DbTxMut<'a>>(
&self,
tx: &Tx<'_, RW, WriteMap>,
tx: &'a TX,
tid_address: BlockNumberAddress,
entry: StorageEntry,
hash: bool,

5
crates/stages/src/test_utils/runner.rs
View File

@ -1,9 +1,6 @@
use super::TestTransaction;
use crate::{ExecInput, ExecOutput, Stage, StageError, UnwindInput, UnwindOutput};
use reth_db::{
mdbx::{Env, WriteMap},
DatabaseEnv,
};
use reth_db::DatabaseEnv;
use reth_primitives::MAINNET;
use reth_provider::ProviderFactory;
use std::{borrow::Borrow, sync::Arc};

24
crates/stages/src/test_utils/test_db.rs
View File

@ -1,15 +1,12 @@
use reth_db::{
common::KeyValue,
cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO},
mdbx::{
test_utils::{create_test_db, create_test_db_with_path},
tx::Tx,
Env, EnvKind, WriteMap, RO, RW,
},
database::DatabaseGAT,
models::{AccountBeforeTx, StoredBlockBodyIndices},
table::Table,
tables,
transaction::{DbTx, DbTxMut},
test_utils::create_test_rw_db,
transaction::{DbTx, DbTxGAT, DbTxMut, DbTxMutGAT},
DatabaseEnv, DatabaseError as DbError,
};
use reth_primitives::{
@ -34,7 +31,7 @@ use std::{
/// ```
#[derive(Debug)]
pub struct TestTransaction {
/// WriteMap DB
/// DB
pub tx: Arc<DatabaseEnv>,
pub path: Option<PathBuf>,
pub factory: ProviderFactory<Arc<DatabaseEnv>>,
@ -43,14 +40,14 @@ pub struct TestTransaction {
impl Default for TestTransaction {
/// Create a new instance of [TestTransaction]
fn default() -> Self {
let tx = create_test_db::<WriteMap>(EnvKind::RW);
let tx = create_test_rw_db();
Self { tx: tx.clone(), path: None, factory: ProviderFactory::new(tx, MAINNET.clone()) }
}
}
impl TestTransaction {
pub fn new(path: &Path) -> Self {
let tx = create_test_db::<WriteMap>(EnvKind::RW);
let tx = create_test_rw_db();
Self {
tx: tx.clone(),
path: Some(path.to_path_buf()),
@ -76,7 +73,7 @@ impl TestTransaction {
/// Invoke a callback with transaction committing it afterwards
pub fn commit<F>(&self, f: F) -> Result<(), DbError>
where
F: FnOnce(&Tx<'_, RW, WriteMap>) -> Result<(), DbError>,
F: FnOnce(&<DatabaseEnv as DatabaseGAT<'_>>::TXMut) -> Result<(), DbError>,
{
let mut tx = self.inner_rw();
f(tx.tx_ref())?;
@ -87,7 +84,7 @@ impl TestTransaction {
/// Invoke a callback with a read transaction
pub fn query<F, R>(&self, f: F) -> Result<R, DbError>
where
F: FnOnce(&Tx<'_, RO, WriteMap>) -> Result<R, DbError>,
F: FnOnce(&<DatabaseEnv as DatabaseGAT<'_>>::TX) -> Result<R, DbError>,
{
f(self.inner().tx_ref())
}
@ -200,7 +197,10 @@ impl TestTransaction {
}
/// Inserts a single [SealedHeader] into the corresponding tables of the headers stage.
fn insert_header(tx: &Tx<'_, RW, WriteMap>, header: &SealedHeader) -> Result<(), DbError> {
fn insert_header<'a, TX: DbTxMut<'a> + DbTx<'a>>(
tx: &'a TX,
header: &SealedHeader,
) -> Result<(), DbError> {
tx.put::<tables::CanonicalHeaders>(header.number, header.hash())?;
tx.put::<tables::HeaderNumbers>(header.hash(), header.number)?;
tx.put::<tables::Headers>(header.number, header.clone().unseal())

14
crates/storage/db/benches/criterion.rs
View File

@ -131,7 +131,10 @@ where
|| {
// Reset DB
let _ = std::fs::remove_dir_all(bench_db_path);
(input.clone(), create_test_db_with_path::<WriteMap>(EnvKind::RW, bench_db_path))
(
input.clone(),
Arc::try_unwrap(create_test_rw_db_with_path(bench_db_path)).unwrap(),
)
},
|(input, db)| {
// Create TX
@ -154,7 +157,7 @@ where
|| {
// Reset DB
let _ = std::fs::remove_dir_all(bench_db_path);
(input, create_test_db_with_path::<WriteMap>(EnvKind::RW, bench_db_path))
(input, Arc::try_unwrap(create_test_rw_db_with_path(bench_db_path)).unwrap())
},
|(input, db)| {
// Create TX
@ -225,7 +228,10 @@ where
|| {
// Reset DB
let _ = std::fs::remove_dir_all(bench_db_path);
(input.clone(), create_test_db_with_path::<WriteMap>(EnvKind::RW, bench_db_path))
(
input.clone(),
Arc::try_unwrap(create_test_rw_db_with_path(bench_db_path)).unwrap(),
)
},
|(input, db)| {
// Create TX
@ -249,7 +255,7 @@ where
// Reset DB
let _ = std::fs::remove_dir_all(bench_db_path);
(input, create_test_db_with_path::<WriteMap>(EnvKind::RW, bench_db_path))
(input, Arc::try_unwrap(create_test_rw_db_with_path(bench_db_path)).unwrap())
},
|(input, db)| {
// Create TX

3
crates/storage/db/benches/hash_keys.rs
View File

@ -12,7 +12,6 @@ use proptest::{
};
use reth_db::{
cursor::{DbCursorRW, DbDupCursorRO, DbDupCursorRW},
mdbx::Env,
TxHashNumber,
};
use std::{collections::HashSet, time::Instant};
@ -86,7 +85,7 @@ where
let setup = || {
// Reset DB
let _ = std::fs::remove_dir_all(bench_db_path);
let db = create_test_db_with_path::<WriteMap>(EnvKind::RW, bench_db_path);
let db = Arc::try_unwrap(create_test_rw_db_with_path(bench_db_path)).unwrap();
let mut unsorted_input = unsorted_input.clone();
if scenario_str == "append_all" {

8
crates/storage/db/benches/utils.rs
View File

@ -1,12 +1,12 @@
use reth_db::DatabaseEnv;
#[allow(unused_imports)]
use reth_db::{
database::Database,
mdbx::{test_utils::create_test_db_with_path, EnvKind, WriteMap},
table::*,
test_utils::create_test_rw_db_with_path,
transaction::{DbTx, DbTxMut},
DatabaseEnv,
};
use std::path::Path;
use std::{path::Path, sync::Arc};
/// Path where the DB is initialized for benchmarks.
#[allow(unused)]
@ -60,7 +60,7 @@ where
{
// Reset DB
let _ = std::fs::remove_dir_all(bench_db_path);
let db = create_test_db_with_path::<WriteMap>(EnvKind::RW, bench_db_path);
let db = Arc::try_unwrap(create_test_rw_db_with_path(bench_db_path)).unwrap();
{
// Prepare data to be read

100
crates/storage/db/src/implementation/mdbx/mod.rs
View File

@ -124,26 +124,25 @@ impl<E: EnvironmentKind> Deref for Env<E> {
}
}
/// Collection of database test utilities
#[cfg(any(test, feature = "test-utils"))]
pub mod test_utils {
#[cfg(test)]
mod tests {
use super::*;
use reth_libmdbx::WriteMap;
use std::sync::Arc;
use crate::{
cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO, DbDupCursorRW, ReverseWalker, Walker},
database::Database,
models::{AccountBeforeTx, ShardedKey},
tables::{AccountHistory, CanonicalHeaders, Headers, PlainAccountState, PlainStorageState},
test_utils::*,
transaction::{DbTx, DbTxMut},
AccountChangeSet, DatabaseError,
};
use reth_libmdbx::{NoWriteMap, WriteMap};
use reth_primitives::{Account, Address, Header, IntegerList, StorageEntry, H160, H256, U256};
use std::{path::Path, str::FromStr, sync::Arc};
use tempfile::TempDir;
/// Error during database creation
pub const ERROR_DB_CREATION: &str = "Not able to create the mdbx file.";
/// Error during table creation
pub const ERROR_TABLE_CREATION: &str = "Not able to create tables in the database.";
/// Error during tempdir creation
pub const ERROR_TEMPDIR: &str = "Not able to create a temporary directory.";
/// Create rw database for testing
pub fn create_test_rw_db() -> Arc<Env<WriteMap>> {
create_test_db(EnvKind::RW)
}
/// Create database for testing
pub fn create_test_db<E: EnvironmentKind>(kind: EnvKind) -> Arc<Env<E>> {
fn create_test_db<E: EnvironmentKind>(kind: EnvKind) -> Arc<Env<E>> {
Arc::new(create_test_db_with_path(
kind,
&tempfile::TempDir::new().expect(ERROR_TEMPDIR).into_path(),
@ -151,28 +150,11 @@ pub mod test_utils {
}
/// Create database for testing with specified path
pub fn create_test_db_with_path<E: EnvironmentKind>(kind: EnvKind, path: &Path) -> Env<E> {
fn create_test_db_with_path<E: EnvironmentKind>(kind: EnvKind, path: &Path) -> Env<E> {
let env = Env::<E>::open(path, kind).expect(ERROR_DB_CREATION);
env.create_tables().expect(ERROR_TABLE_CREATION);
env
}
}
#[cfg(test)]
mod tests {
use super::{test_utils, Env, EnvKind};
use crate::{
cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO, DbDupCursorRW, ReverseWalker, Walker},
database::Database,
models::{AccountBeforeTx, ShardedKey},
tables::{AccountHistory, CanonicalHeaders, Headers, PlainAccountState, PlainStorageState},
transaction::{DbTx, DbTxMut},
AccountChangeSet, DatabaseError,
};
use reth_libmdbx::{NoWriteMap, WriteMap};
use reth_primitives::{Account, Address, Header, IntegerList, StorageEntry, H160, H256, U256};
use std::{str::FromStr, sync::Arc};
use tempfile::TempDir;
const ERROR_DB_CREATION: &str = "Not able to create the mdbx file.";
const ERROR_PUT: &str = "Not able to insert value into table.";
@ -186,12 +168,12 @@ mod tests {
#[test]
fn db_creation() {
test_utils::create_test_db::<NoWriteMap>(EnvKind::RW);
create_test_db::<NoWriteMap>(EnvKind::RW);
}
#[test]
fn db_manual_put_get() {
let env = test_utils::create_test_db::<NoWriteMap>(EnvKind::RW);
let env = create_test_db::<NoWriteMap>(EnvKind::RW);
let value = Header::default();
let key = 1u64;
@ -210,7 +192,7 @@ mod tests {
#[test]
fn db_cursor_walk() {
let env = test_utils::create_test_db::<NoWriteMap>(EnvKind::RW);
let env = create_test_db::<NoWriteMap>(EnvKind::RW);
let value = Header::default();
let key = 1u64;
@ -235,7 +217,7 @@ mod tests {
#[test]
fn db_cursor_walk_range() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
// PUT (0, 0), (1, 0), (2, 0), (3, 0)
let tx = db.tx_mut().expect(ERROR_INIT_TX);
@ -299,7 +281,7 @@ mod tests {
#[test]
fn db_cursor_walk_range_on_dup_table() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
let address0 = Address::zero();
let address1 = Address::from_low_u64_be(1);
@ -341,7 +323,7 @@ mod tests {
#[allow(clippy::reversed_empty_ranges)]
#[test]
fn db_cursor_walk_range_invalid() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
// PUT (0, 0), (1, 0), (2, 0), (3, 0)
let tx = db.tx_mut().expect(ERROR_INIT_TX);
@ -369,7 +351,7 @@ mod tests {
#[test]
fn db_walker() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
// PUT (0, 0), (1, 0), (3, 0)
let tx = db.tx_mut().expect(ERROR_INIT_TX);
@ -399,7 +381,7 @@ mod tests {
#[test]
fn db_reverse_walker() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
// PUT (0, 0), (1, 0), (3, 0)
let tx = db.tx_mut().expect(ERROR_INIT_TX);
@ -429,7 +411,7 @@ mod tests {
#[test]
fn db_walk_back() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
// PUT (0, 0), (1, 0), (3, 0)
let tx = db.tx_mut().expect(ERROR_INIT_TX);
@ -468,7 +450,7 @@ mod tests {
#[test]
fn db_cursor_seek_exact_or_previous_key() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
// PUT
let tx = db.tx_mut().expect(ERROR_INIT_TX);
@ -494,7 +476,7 @@ mod tests {
#[test]
fn db_cursor_insert() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
// PUT
let tx = db.tx_mut().expect(ERROR_INIT_TX);
@ -528,7 +510,7 @@ mod tests {
#[test]
fn db_cursor_insert_dup() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
let tx = db.tx_mut().expect(ERROR_INIT_TX);
let mut dup_cursor = tx.cursor_dup_write::<PlainStorageState>().unwrap();
@ -546,7 +528,7 @@ mod tests {
#[test]
fn db_cursor_delete_current_non_existent() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
let tx = db.tx_mut().expect(ERROR_INIT_TX);
let key1 = Address::from_low_u64_be(1);
@ -574,7 +556,7 @@ mod tests {
#[test]
fn db_cursor_insert_wherever_cursor_is() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
let tx = db.tx_mut().expect(ERROR_INIT_TX);
// PUT
@ -607,7 +589,7 @@ mod tests {
#[test]
fn db_cursor_append() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
// PUT
let tx = db.tx_mut().expect(ERROR_INIT_TX);
@ -634,7 +616,7 @@ mod tests {
#[test]
fn db_cursor_append_failure() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
// PUT
let tx = db.tx_mut().expect(ERROR_INIT_TX);
@ -662,7 +644,7 @@ mod tests {
#[test]
fn db_cursor_upsert() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
let tx = db.tx_mut().expect(ERROR_INIT_TX);
let mut cursor = tx.cursor_write::<PlainAccountState>().unwrap();
@ -697,7 +679,7 @@ mod tests {
#[test]
fn db_cursor_dupsort_append() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
let transition_id = 2;
@ -743,7 +725,7 @@ mod tests {
#[test]
fn db_closure_put_get() {
let path = TempDir::new().expect(test_utils::ERROR_TEMPDIR).into_path();
let path = TempDir::new().expect(ERROR_TEMPDIR).into_path();
let value = Account {
nonce: 18446744073709551615,
@ -754,7 +736,7 @@ mod tests {
.expect(ERROR_ETH_ADDRESS);
{
let env = test_utils::create_test_db_with_path::<WriteMap>(EnvKind::RW, &path);
let env = create_test_db_with_path::<WriteMap>(EnvKind::RW, &path);
// PUT
let result = env.update(|tx| {
@ -775,7 +757,7 @@ mod tests {
#[test]
fn db_dup_sort() {
let env = test_utils::create_test_db::<NoWriteMap>(EnvKind::RW);
let env = create_test_db::<NoWriteMap>(EnvKind::RW);
let key = Address::from_str("0xa2c122be93b0074270ebee7f6b7292c7deb45047")
.expect(ERROR_ETH_ADDRESS);
@ -819,7 +801,7 @@ mod tests {
#[test]
fn db_iterate_over_all_dup_values() {
let env = test_utils::create_test_db::<NoWriteMap>(EnvKind::RW);
let env = create_test_db::<NoWriteMap>(EnvKind::RW);
let key1 = Address::from_str("0x1111111111111111111111111111111111111111")
.expect(ERROR_ETH_ADDRESS);
let key2 = Address::from_str("0x2222222222222222222222222222222222222222")
@ -865,7 +847,7 @@ mod tests {
#[test]
fn dup_value_with_same_subkey() {
let env = test_utils::create_test_db::<NoWriteMap>(EnvKind::RW);
let env = create_test_db::<NoWriteMap>(EnvKind::RW);
let key1 = H160([0x11; 20]);
let key2 = H160([0x22; 20]);
@ -908,7 +890,7 @@ mod tests {
#[test]
fn db_sharded_key() {
let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<Env<WriteMap>> = create_test_db(EnvKind::RW);
let real_key = Address::from_str("0xa2c122be93b0074270ebee7f6b7292c7deb45047").unwrap();
for i in 1..5 {

82
crates/storage/db/src/lib.rs
View File

@ -89,16 +89,23 @@ pub use tables::*;
pub use utils::is_database_empty;
#[cfg(feature = "mdbx")]
use mdbx::{Env, EnvKind, WriteMap};
use mdbx::{Env, EnvKind, NoWriteMap, WriteMap};
#[cfg(feature = "mdbx")]
/// Alias type for the database engine in use.
/// Alias type for the database environment in use. Read/Write mode.
pub type DatabaseEnv = Env<WriteMap>;
/// Opens up an existing database or creates a new one at the specified path.
pub fn init_db<P: AsRef<std::path::Path>>(path: P) -> eyre::Result<DatabaseEnv> {
#[cfg(feature = "mdbx")]
/// Alias type for the database engine in use. Read only mode.
pub type DatabaseEnvRO = Env<NoWriteMap>;
use eyre::WrapErr;
use std::path::Path;
/// Opens up an existing database or creates a new one at the specified path. Creates tables if
/// necessary. Read/Write mode.
pub fn init_db<P: AsRef<Path>>(path: P) -> eyre::Result<DatabaseEnv> {
use crate::version::{check_db_version_file, create_db_version_file, DatabaseVersionError};
use eyre::WrapErr;
let rpath = path.as_ref();
if is_database_empty(rpath) {
@ -124,6 +131,71 @@ pub fn init_db<P: AsRef<std::path::Path>>(path: P) -> eyre::Result<DatabaseEnv>
}
}
/// Opens up an existing database. Read only mode. It doesn't create it or create tables if missing.
pub fn open_db_read_only(path: &Path) -> eyre::Result<DatabaseEnvRO> {
#[cfg(feature = "mdbx")]
{
Env::<NoWriteMap>::open(path, mdbx::EnvKind::RO)
.with_context(|| format!("Could not open database at path: {}", path.display()))
}
#[cfg(not(feature = "mdbx"))]
{
unimplemented!();
}
}
/// Opens up an existing database. Read/Write mode. It doesn't create it or create tables if
/// missing.
pub fn open_db(path: &Path) -> eyre::Result<DatabaseEnv> {
#[cfg(feature = "mdbx")]
{
Env::<WriteMap>::open(path, mdbx::EnvKind::RW)
.with_context(|| format!("Could not open database at path: {}", path.display()))
}
#[cfg(not(feature = "mdbx"))]
{
unimplemented!();
}
}
/// Collection of database test utilities
#[cfg(any(test, feature = "test-utils"))]
pub mod test_utils {
use super::*;
use std::sync::Arc;
/// Error during database open
pub const ERROR_DB_OPEN: &str = "Not able to open the database file.";
/// Error during database creation
pub const ERROR_DB_CREATION: &str = "Not able to create the database file.";
/// Error during table creation
pub const ERROR_TABLE_CREATION: &str = "Not able to create tables in the database.";
/// Error during tempdir creation
pub const ERROR_TEMPDIR: &str = "Not able to create a temporary directory.";
/// Create read/write database for testing
pub fn create_test_rw_db() -> Arc<DatabaseEnv> {
Arc::new(
init_db(tempfile::TempDir::new().expect(ERROR_TEMPDIR).into_path())
.expect(ERROR_DB_CREATION),
)
}
/// Create read/write database for testing
pub fn create_test_rw_db_with_path<P: AsRef<Path>>(path: P) -> Arc<DatabaseEnv> {
Arc::new(init_db(path.as_ref()).expect(ERROR_DB_CREATION))
}
/// Create read only database for testing
pub fn create_test_ro_db() -> Arc<DatabaseEnvRO> {
let path = tempfile::TempDir::new().expect(ERROR_TEMPDIR).into_path();
{
init_db(path.as_path()).expect(ERROR_DB_CREATION);
}
Arc::new(open_db_read_only(path.as_path()).expect(ERROR_DB_OPEN))
}
}
#[cfg(test)]
mod tests {
use crate::{

19
crates/storage/provider/src/post_state/mod.rs
View File

@ -223,10 +223,10 @@ impl PostState {
/// ```
/// use reth_primitives::{Address, Account};
/// use reth_provider::PostState;
/// use reth_db::{mdbx::{EnvKind, WriteMap, test_utils::create_test_db}, database::Database};
/// use reth_db::{test_utils::create_test_rw_db, database::Database};
///
/// // Initialize the database
/// let db = create_test_db::<WriteMap>(EnvKind::RW);
/// let db = create_test_rw_db();
///
/// // Initialize the post state
/// let mut post_state = PostState::new();
@ -642,10 +642,7 @@ mod tests {
use super::*;
use crate::{AccountReader, ProviderFactory};
use reth_db::{
database::Database,
mdbx::{test_utils, EnvKind},
transaction::DbTx,
DatabaseEnv,
database::Database, test_utils::create_test_rw_db, transaction::DbTx, DatabaseEnv,
};
use reth_primitives::{proofs::EMPTY_ROOT, MAINNET};
use reth_trie::test_utils::state_root;
@ -1067,7 +1064,7 @@ mod tests {
#[test]
fn write_to_db_account_info() {
let db: Arc<DatabaseEnv> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<DatabaseEnv> = create_test_rw_db();
let factory = ProviderFactory::new(db, MAINNET.clone());
let provider = factory.provider_rw().unwrap();
@ -1136,7 +1133,7 @@ mod tests {
#[test]
fn write_to_db_storage() {
let db: Arc<DatabaseEnv> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<DatabaseEnv> = create_test_rw_db();
let tx = db.tx_mut().expect("Could not get database tx");
let mut post_state = PostState::new();
@ -1272,7 +1269,7 @@ mod tests {
#[test]
fn write_to_db_multiple_selfdestructs() {
let db: Arc<DatabaseEnv> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<DatabaseEnv> = create_test_rw_db();
let tx = db.tx_mut().expect("Could not get database tx");
let address1 = Address::random();
@ -1821,7 +1818,7 @@ mod tests {
#[test]
fn empty_post_state_state_root() {
let db: Arc<DatabaseEnv> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<DatabaseEnv> = create_test_rw_db();
let tx = db.tx().unwrap();
let post_state = PostState::new();
@ -1840,7 +1837,7 @@ mod tests {
})
.collect();
let db: Arc<DatabaseEnv> = test_utils::create_test_db(EnvKind::RW);
let db: Arc<DatabaseEnv> = create_test_rw_db();
// insert initial state to the database
db.update(|tx| {

11
crates/storage/provider/src/providers/database/mod.rs
View File

@ -348,10 +348,7 @@ mod tests {
use super::ProviderFactory;
use crate::{BlockHashReader, BlockNumReader};
use reth_db::{
mdbx::{
test_utils::{create_test_db, ERROR_TEMPDIR},
EnvKind, WriteMap,
},
test_utils::{create_test_rw_db, ERROR_TEMPDIR},
DatabaseEnv,
};
use reth_primitives::{ChainSpecBuilder, H256};
@ -360,7 +357,7 @@ mod tests {
#[test]
fn common_history_provider() {
let chain_spec = ChainSpecBuilder::mainnet().build();
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let provider = ProviderFactory::new(db, Arc::new(chain_spec));
let _ = provider.latest();
}
@ -368,7 +365,7 @@ mod tests {
#[test]
fn default_chain_info() {
let chain_spec = ChainSpecBuilder::mainnet().build();
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let factory = ProviderFactory::new(db, Arc::new(chain_spec));
let provider = factory.provider().unwrap();
@ -380,7 +377,7 @@ mod tests {
#[test]
fn provider_flow() {
let chain_spec = ChainSpecBuilder::mainnet().build();
let db = create_test_db::<WriteMap>(EnvKind::RW);
let db = create_test_rw_db();
let factory = ProviderFactory::new(db, Arc::new(chain_spec));
let provider = factory.provider().unwrap();
provider.block_hash(0).unwrap();

2
crates/storage/provider/src/providers/state/historical.rs
View File

@ -223,9 +223,9 @@ mod tests {
};
use reth_db::{
database::Database,
mdbx::test_utils::create_test_rw_db,
models::{storage_sharded_key::StorageShardedKey, AccountBeforeTx, ShardedKey},
tables,
test_utils::create_test_rw_db,
transaction::{DbTx, DbTxMut},
BlockNumberList,
};

2
crates/storage/provider/src/transaction.rs
View File

@ -7,9 +7,9 @@ use std::fmt::Debug;
mod test {
use crate::{test_utils::blocks::*, ProviderFactory, TransactionsProvider};
use reth_db::{
mdbx::test_utils::create_test_rw_db,
models::{storage_sharded_key::StorageShardedKey, ShardedKey},
tables,
test_utils::create_test_rw_db,
};
use reth_primitives::{ChainSpecBuilder, IntegerList, H160, MAINNET, U256};
use std::sync::Arc;

2
crates/trie/src/hashed_cursor/post_state.rs
View File

@ -372,7 +372,7 @@ where
mod tests {
use super::*;
use proptest::prelude::*;
use reth_db::{database::Database, mdbx::test_utils::create_test_rw_db, transaction::DbTxMut};
use reth_db::{database::Database, test_utils::create_test_rw_db, transaction::DbTxMut};
fn assert_account_cursor_order<'a, 'b>(
factory: &'a impl HashedCursorFactory<'b>,

2
crates/trie/src/trie.rs
View File

@ -514,8 +514,8 @@ mod tests {
use proptest::{prelude::ProptestConfig, proptest};
use reth_db::{
cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO},
mdbx::test_utils::create_test_rw_db,
tables,
test_utils::create_test_rw_db,
transaction::DbTxMut,
DatabaseEnv,
};

2
crates/trie/src/trie_cursor/account_cursor.rs
View File

@ -42,8 +42,8 @@ mod tests {
use super::*;
use reth_db::{
cursor::{DbCursorRO, DbCursorRW},
mdbx::test_utils::create_test_rw_db,
tables,
test_utils::create_test_rw_db,
transaction::DbTxMut,
};
use reth_primitives::{hex_literal::hex, MAINNET};

2
crates/trie/src/trie_cursor/storage_cursor.rs
View File

@ -58,7 +58,7 @@ mod tests {
use super::*;
use reth_db::{
cursor::DbCursorRW, mdbx::test_utils::create_test_rw_db, tables, transaction::DbTxMut,
cursor::DbCursorRW, tables, test_utils::create_test_rw_db, transaction::DbTxMut,
};
use reth_primitives::{
trie::{BranchNodeCompact, StorageTrieEntry},

2
crates/trie/src/walker.rs
View File

@ -260,7 +260,7 @@ mod tests {
use super::*;
use crate::trie_cursor::{AccountTrieCursor, StorageTrieCursor};
use reth_db::{
cursor::DbCursorRW, mdbx::test_utils::create_test_rw_db, tables, transaction::DbTxMut,
cursor::DbCursorRW, tables, test_utils::create_test_rw_db, transaction::DbTxMut,
};
use reth_primitives::{trie::StorageTrieEntry, MAINNET};
use reth_provider::ProviderFactory;

2
testing/ef-tests/src/cases/blockchain_test.rs
View File

@ -4,7 +4,7 @@ use crate::{
models::{BlockchainTest, ForkSpec, RootOrState},
Case, Error, Suite,
};
use reth_db::mdbx::test_utils::create_test_rw_db;
use reth_db::test_utils::create_test_rw_db;
use reth_primitives::{BlockBody, SealedBlock};
use reth_provider::{BlockWriter, ProviderFactory};
use reth_rlp::Decodable;