Revert "fix test case for forking main"

This reverts commit fe965ed.

Author: sanlee42

chain/mock/src/mock_chain.rs

@@ -4,7 +4,7 @@
 use anyhow::Result;
 use starcoin_account_api::AccountInfo;
 use starcoin_chain::{BlockChain, ChainReader, ChainWriter};
-use starcoin_config::{ChainNetwork, NodeConfig};
+use starcoin_config::ChainNetwork;
 use starcoin_consensus::Consensus;
 use starcoin_crypto::HashValue;
 use starcoin_dag::blockdag::BlockDAG;
@@ -24,9 +24,8 @@ pub struct MockChain {
 
 impl MockChain {
     pub fn new(net: ChainNetwork) -> Result<Self> {
-        let node_config = Arc::new(NodeConfig::random_for_test());
         let (storage, chain_info, _, dag) =
-            Genesis::init_storage_for_test(node_config).expect("init storage by genesis fail.");
+            Genesis::init_storage_for_test(&net).expect("init storage by genesis fail.");
 
         let chain = BlockChain::new(
             net.time_service(),

chain/src/chain.rs

@@ -272,17 +272,7 @@ impl BlockChain {
         } else if tips.is_some() {
             tips
         } else {
-            let current_tips = self.current_tips_hash()?;
-            match &current_tips {
-                Some(cur_tips) => {
-                    debug!("jacktest: create block template with tips:{:?}", &cur_tips);
-                    if cur_tips.is_empty() {
-                        panic!("jacktest: current tips is empty");
-                    }
-                }
-                None => panic!("jacktest: current tips is none"),
-            }
-            current_tips
+            self.current_tips_hash()?
         };
         let strategy = epoch.strategy();
         let difficulty = strategy.calculate_next_difficulty(self)?;
@@ -1308,11 +1298,7 @@ impl BlockChain {
         if self.epoch.end_block_number() == block.header().number() {
             self.epoch = get_epoch_from_statedb(&self.statedb)?;
         }
-        let result = self.storage.save_dag_state(DagState { tips: tips.clone() });
-        match result {
-            std::result::Result::Ok(_) => debug!("jacktest: save dag state success, tips: {:?}", tips),
-            Err(_) => panic!("jacktest: save dag state failed, tips: {:?}", tips),
-        }
+        self.storage.save_dag_state(DagState { tips })?;
         Ok(executed_block)
     }
 

chain/tests/block_test_utils.rs

@@ -259,7 +259,7 @@ proptest! {
             // recursion depth
             10)) {
         let config = Arc::new(NodeConfig::random_for_test());
-        let mut block_chain = test_helper::gen_blockchain_for_test(config.clone()).unwrap();
+        let mut block_chain = test_helper::gen_blockchain_for_test(config.net()).unwrap();
         // blocks in ;
         for block in blocks {
             if !block.header().is_genesis() {

chain/tests/test_block_chain.rs

@@ -359,7 +359,7 @@ fn test_uncle_in_diff_epoch() {
 ///
 fn test_block_chain_txn_info_fork_mapping() -> Result<()> {
     let config = Arc::new(NodeConfig::random_for_test());
-    let mut block_chain = test_helper::gen_blockchain_for_test(config.clone())?;
+    let mut block_chain = test_helper::gen_blockchain_for_test(config.net())?;
     let header = block_chain.current_header();
     let miner_account = AccountInfo::random();
     let (template_b1, _) = block_chain.create_block_template(

chain/tests/test_epoch_switch.rs

@@ -381,7 +381,8 @@ pub fn modify_on_chain_config_by_dao_block(
 #[stest::test(timeout = 120)]
 fn test_modify_on_chain_config_consensus_by_dao() -> Result<()> {
     let config = Arc::new(NodeConfig::random_for_test());
-    let _chain = test_helper::gen_blockchain_for_test(config.clone())?;
+    let net = config.net();
+    let _chain = test_helper::gen_blockchain_for_test(net)?;
 
     let _alice = Account::new();
     let _bob = Account::new();

chain/tests/test_opened_block.rs

@@ -15,7 +15,7 @@ use std::{convert::TryInto, sync::Arc};
 #[stest::test]
 pub fn test_open_block() -> Result<()> {
     let config = Arc::new(NodeConfig::random_for_test());
-    let chain = test_helper::gen_blockchain_for_test(config.clone())?;
+    let chain = test_helper::gen_blockchain_for_test(config.net())?;
     let header = chain.current_header();
     let block_gas_limit = 10000000;
 

chain/tests/test_txn_info_and_proof.rs

@@ -46,7 +46,7 @@ fn test_transaction_info_and_proof_1() -> Result<()> {
     starcoin_types::block::set_test_flexidag_fork_height(2);
     // generate 5 block
     let config = Arc::new(NodeConfig::random_for_test());
-    let mut block_chain = test_helper::gen_blockchain_for_test(config.clone())?;
+    let mut block_chain = test_helper::gen_blockchain_for_test(config.net())?;
     let _current_header = block_chain.current_header();
     let miner_account = AccountInfo::random();
     let mut seq_num = 0;
@@ -112,7 +112,7 @@ fn test_transaction_info_and_proof_1() -> Result<()> {
 #[stest::test(timeout = 480)]
 fn test_transaction_info_and_proof() -> Result<()> {
     let config = Arc::new(NodeConfig::random_for_test());
-    let mut block_chain = test_helper::gen_blockchain_for_test(config.clone())?;
+    let mut block_chain = test_helper::gen_blockchain_for_test(config.net())?;
     let mut current_header = block_chain.current_header();
     let miner_account = AccountInfo::random();
 

config/src/lib.rs

@@ -472,14 +472,6 @@ impl NodeConfig {
         Self::load_with_opt(&opt).expect("Auto generate test config should success.")
     }
 
-    pub fn config_for_net(net: ChainNetworkID) -> Self {
-        let opt = StarcoinOpt {
-            net: Some(net),
-            ..StarcoinOpt::default()
-        };
-        Self::load_with_opt(&opt).expect("Auto generate test config should success.")
-    }
-
     pub fn customize_for_test() -> Self {
         let opt = StarcoinOpt {
             net: Some(BuiltinNetworkID::Test.into()),

flexidag/dag/Cargo.toml

@@ -27,7 +27,6 @@ parking_lot = { workspace = true }
 itertools = { workspace = true }
 starcoin-config = { workspace = true }
 bcs-ext = { workspace = true }
-tempfile = { workspace = true }
 
 [dev-dependencies]
 proptest = { workspace = true }

flexidag/dag/src/blockdag.rs

@@ -12,14 +12,13 @@ use crate::consensusdb::{
 use crate::ghostdag::protocol::GhostdagManager;
 use anyhow::{bail, Ok};
 use parking_lot::RwLock;
-use starcoin_config::RocksdbConfig;
+use starcoin_config::{temp_dir, RocksdbConfig};
 use starcoin_crypto::{HashValue as Hash, HashValue};
 use starcoin_types::block::BlockHeader;
 use starcoin_types::{
     blockhash::{BlockHashes, KType},
     consensus_header::ConsensusHeader,
 };
-use tempfile::tempdir;
 use std::path::Path;
 use std::sync::Arc;
 
@@ -59,7 +58,7 @@ impl BlockDAG {
     }
     pub fn create_for_testing() -> anyhow::Result<Self> {
         let dag_storage =
-            FlexiDagStorage::create_from_path(tempdir()?.path(), FlexiDagStorageConfig::default())?;
+            FlexiDagStorage::create_from_path(temp_dir(), FlexiDagStorageConfig::default())?;
         Ok(BlockDAG::new(8, dag_storage))
     }
 

genesis/src/lib.rs

@@ -12,17 +12,13 @@ use starcoin_accumulator::accumulator_info::AccumulatorInfo;
 use starcoin_accumulator::node::AccumulatorStoreType;
 use starcoin_accumulator::{Accumulator, MerkleAccumulator};
 use starcoin_chain::{BlockChain, ChainReader};
-use starcoin_config::DEFAULT_CACHE_SIZE;
-use starcoin_config::NodeConfig;
 use starcoin_config::{
     genesis_key_pair, BuiltinNetworkID, ChainNetwork, ChainNetworkID, GenesisBlockParameter,
 };
 use starcoin_dag::blockdag::BlockDAG;
 use starcoin_logger::prelude::*;
 use starcoin_state_api::ChainStateWriter;
 use starcoin_statedb::ChainStateDB;
-use starcoin_storage::cache_storage::CacheStorage;
-use starcoin_storage::db_storage::DBStorage;
 use starcoin_storage::storage::StorageInstance;
 use starcoin_storage::table_info::TableInfoStore;
 use starcoin_storage::{BlockStore, Storage, Store};
@@ -40,9 +36,7 @@ use starcoin_vm_types::transaction::{
     RawUserTransaction, SignedUserTransaction, TransactionPayload,
 };
 use starcoin_vm_types::vm_status::KeptVMStatus;
-use tempfile::tempdir;
 use std::collections::BTreeMap;
-use std::env::temp_dir;
 use std::fmt::Display;
 use std::fs::{create_dir_all, File};
 use std::io::{Read, Write};
@@ -385,15 +379,13 @@ impl Genesis {
     }
 
     pub fn init_storage_for_test(
-        node_config: Arc<NodeConfig>,
+        net: &ChainNetwork,
     ) -> Result<(Arc<Storage>, ChainInfo, Genesis, BlockDAG)> {
         debug!("init storage by genesis for test.");
-        let storage = Arc::new(Storage::new(
-            StorageInstance::new_cache_and_db_instance(CacheStorage::new_with_capacity(DEFAULT_CACHE_SIZE, None), 
-            DBStorage::new(tempdir()?.path(), node_config.storage.rocksdb_config(), None)?))?);
-        let genesis = Genesis::load_or_build(node_config.net())?;
+        let storage = Arc::new(Storage::new(StorageInstance::new_cache_instance())?);
+        let genesis = Genesis::load_or_build(net)?;
         let dag = BlockDAG::create_for_testing()?;
-        let chain_info = genesis.execute_genesis_block(node_config.net(), storage.clone(), dag.clone())?;
+        let chain_info = genesis.execute_genesis_block(net, storage.clone(), dag.clone())?;
         Ok((storage, chain_info, genesis, dag))
     }
 }

miner/src/create_block_template/test_create_block_template.rs

@@ -37,7 +37,7 @@ fn test_create_block_template_by_net(net: ChainNetworkID) {
 
     let node_config = Arc::new(NodeConfig::load_with_opt(&opt).unwrap());
     let (storage, chain_info, genesis, dag) =
-        StarcoinGenesis::init_storage_for_test(node_config.clone())
+        StarcoinGenesis::init_storage_for_test(node_config.net())
             .expect("init storage by genesis fail.");
     let genesis_id = genesis.block().id();
     let miner_account = AccountInfo::random();
@@ -63,7 +63,7 @@ fn test_create_block_template_by_net(net: ChainNetworkID) {
 #[stest::test(timeout = 120)]
 fn test_switch_main() {
     let node_config = Arc::new(NodeConfig::random_for_test());
-    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.clone())
+    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.net())
         .expect("init storage by genesis fail.");
     let genesis_id = genesis.block().id();
     let times = 10;
@@ -195,7 +195,7 @@ fn test_switch_main() {
 #[stest::test]
 fn test_do_uncles() {
     let node_config = Arc::new(NodeConfig::random_for_test());
-    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.clone())
+    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.net())
         .expect("init storage by genesis fail.");
     let genesis_id = genesis.block().id();
     let times = 2;
@@ -323,7 +323,7 @@ fn test_do_uncles() {
 #[stest::test(timeout = 120)]
 fn test_new_head() {
     let node_config = Arc::new(NodeConfig::random_for_test());
-    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.clone())
+    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.net())
         .expect("init storage by genesis fail.");
     let genesis_id = genesis.block().id();
     let times = 10;
@@ -367,7 +367,7 @@ fn test_new_head() {
 #[stest::test(timeout = 120)]
 fn test_new_branch() {
     let node_config = Arc::new(NodeConfig::random_for_test());
-    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.clone())
+    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.net())
         .expect("init storage by genesis fail.");
     let genesis_id = genesis.block().id();
     let times = 5;
@@ -449,7 +449,7 @@ async fn test_create_block_template_actor() {
     let registry = RegistryService::launch();
     registry.put_shared(node_config.clone()).await.unwrap();
 
-    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.clone())
+    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.net())
         .expect("init storage by genesis fail.");
     let genesis_id = genesis.block().id();
     let chain_header = storage
@@ -480,7 +480,7 @@ async fn test_create_block_template_actor() {
 fn test_create_block_template_by_adjust_time() -> Result<()> {
     let node_config = Arc::new(NodeConfig::random_for_test());
 
-    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.clone())?;
+    let (storage, _, genesis, dag) = StarcoinGenesis::init_storage_for_test(node_config.net())?;
     let mut inner = Inner::new(
         node_config.net(),
         storage,

miner/src/lib.rs

@@ -278,7 +278,6 @@ impl EventHandler<Self, GenerateBlockEvent> for MinerService {
         }
         if self.config.miner.disable_miner_client() && self.client_subscribers_num == 0 {
             debug!("No miner client connected, ignore GenerateBlockEvent.");
-            panic!("jacktest: to checkout where is this panic.");
             // Once Miner client connect, we should dispatch task.
             ctx.run_later(Duration::from_secs(2), |ctx| {
                 ctx.notify(GenerateBlockEvent::default());

miner/tests/miner_test.rs

@@ -24,7 +24,7 @@ async fn test_miner_service() {
     let node_config = Arc::new(config.clone());
     registry.put_shared(node_config.clone()).await.unwrap();
     let (storage, _chain_info, genesis, dag) =
-        Genesis::init_storage_for_test(config.clone()).unwrap();
+        Genesis::init_storage_for_test(config.net()).unwrap();
     registry.put_shared(storage.clone()).await.unwrap();
     registry.put_shared(dag).await.unwrap();
 

storage/src/chain_info/mod.rs

@@ -5,7 +5,6 @@ use crate::storage::{ColumnFamily, InnerStorage, KVStore};
 use crate::{StorageVersion, CHAIN_INFO_PREFIX_NAME};
 use anyhow::Result;
 use starcoin_crypto::HashValue;
-use starcoin_logger::prelude::debug;
 use starcoin_types::startup_info::{BarnardHardFork, DagState, SnapshotRange, StartupInfo};
 use std::convert::{TryFrom, TryInto};
 
@@ -32,7 +31,6 @@ impl ChainInfoStorage {
     const DAG_STATE_KEY: &'static str = "dag_state";
 
     pub fn save_dag_state(&self, dag_state: DagState) -> Result<()> {
-        debug!("jacktest: save dag state: {:?}", dag_state);
         self.put_sync(
             Self::DAG_STATE_KEY.as_bytes().to_vec(),
             dag_state.try_into()?,

sync/src/block_connector/test_illegal_block.rs

@@ -313,15 +313,15 @@ async fn test_verify_consensus(succ: bool) -> Result<()> {
     Ok(())
 }
 
-// #[stest::test(timeout = 120)]
-// async fn test_verify_consensus_failed() {
-//     assert!(test_verify_consensus(true).await.is_ok());
-//     let apply_failed = test_verify_consensus(false).await;
-//     assert!(apply_failed.is_err());
-//     if let Err(apply_err) = apply_failed {
-//         error!("apply failed : {:?}", apply_err);
-//     }
-// }
+#[stest::test(timeout = 120)]
+async fn test_verify_consensus_failed() {
+    assert!(test_verify_consensus(true).await.is_ok());
+    let apply_failed = test_verify_consensus(false).await;
+    assert!(apply_failed.is_err());
+    if let Err(apply_err) = apply_failed {
+        error!("apply failed : {:?}", apply_err);
+    }
+}
 
 #[stest::test(timeout = 120)]
 async fn test_verify_new_epoch_block_uncle_should_none_failed() {
@@ -503,15 +503,15 @@ async fn test_verify_illegal_uncle_consensus(succ: bool) -> Result<()> {
     Ok(())
 }
 
-// #[stest::test(timeout = 120)]
-// async fn test_verify_illegal_uncle_consensus_failed() {
-//     assert!(test_verify_illegal_uncle_consensus(true).await.is_ok());
-//     let apply_failed = test_verify_illegal_uncle_consensus(false).await;
-//     assert!(apply_failed.is_err());
-//     if let Err(apply_err) = apply_failed {
-//         error!("apply failed : {:?}", apply_err);
-//     }
-// }
+#[stest::test(timeout = 120)]
+async fn test_verify_illegal_uncle_consensus_failed() {
+    assert!(test_verify_illegal_uncle_consensus(true).await.is_ok());
+    let apply_failed = test_verify_illegal_uncle_consensus(false).await;
+    assert!(apply_failed.is_err());
+    if let Err(apply_err) = apply_failed {
+        error!("apply failed : {:?}", apply_err);
+    }
+}
 
 async fn test_verify_state_root(succ: bool) -> Result<()> {
     let (mut new_block, mut main) = new_block_and_main().await;

sync/src/block_connector/test_write_block_chain.rs

@@ -26,7 +26,7 @@ pub async fn create_writeable_block_chain() -> (
     let node_config = NodeConfig::random_for_test();
     let node_config = Arc::new(node_config);
 
-    let (storage, chain_info, _, dag) = StarcoinGenesis::init_storage_for_test(node_config.clone())
+    let (storage, chain_info, _, dag) = StarcoinGenesis::init_storage_for_test(node_config.net())
         .expect("init storage by genesis fail.");
     let registry = RegistryService::launch();
     let bus = registry.service_ref::<BusService>().await.unwrap();

sync/src/block_connector/test_write_dag_block_chain.rs

@@ -104,7 +104,7 @@ fn gen_fork_dag_block_chain(
     writeable_block_chain_service: &mut WriteBlockChainService<MockTxPoolService>,
 ) -> Option<HashValue> {
     let miner_account = AccountInfo::random();
-    // let dag = BlockDAG::create_for_testing().unwrap();
+    let dag = BlockDAG::create_for_testing().unwrap();
     if let Some(block_header) = writeable_block_chain_service
         .get_main()
         .get_header_by_number(fork_number)
@@ -118,7 +118,7 @@ fn gen_fork_dag_block_chain(
                 parent_id,
                 writeable_block_chain_service.get_main().get_storage(),
                 None,
-                writeable_block_chain_service.get_dag(),
+                dag.clone(),
             )
             .unwrap();
             let (block_template, _) = block_chain

sync/src/block_connector/write_block_chain.rs

@@ -181,10 +181,6 @@ where
         &self.main
     }
 
-    pub fn get_dag(&self) -> BlockDAG {
-        self.dag.clone()
-    }
-
     #[cfg(test)]
     pub fn create_block(
         &self,