[tests] bc: #172 revert blocks with tx that consume UTXOs

lib/modules/blockchain/blockchain/tests/apply_blocks_cautious.rs

@@ -18,15 +18,10 @@ mod common;
 use crate::common::*;
 use dubp_block_doc::BlockDocument;
 use dubp_currency_params::genesis_block_params::v10::BlockV10Parameters;
-use durs_bc::BlockchainModule;
 use durs_message::events::{BlockchainEvent, DursEvent};
-use durs_message::requests::DursReqContent;
 use durs_message::DursMsg;
-use durs_module::{
-    ModuleEvent, ModuleReqFullId, ModuleReqId, ModuleRole, ModuleStaticName, RouterThreadMessage,
-};
+use durs_module::{ModuleEvent, ModuleStaticName, RouterThreadMessage};
 use durs_network::events::NetworkEvent;
-use durs_network::requests::OldNetworkRequest;
 use pretty_assertions::assert_eq;
 use std::sync::mpsc::{channel, Receiver, Sender};
 
@@ -56,29 +51,7 @@ fn test_apply_blocks_cautious() {
     });
 
     // Receive 11 requests GetBlocks
-    for i in 0..11 {
-        let msg = router_receiver
-            .recv()
-            .expect("blockchain module disconnected.");
-        if let RouterThreadMessage::ModuleMessage(durs_msg) = msg {
-            assert_eq!(
-                DursMsg::Request {
-                    req_from: BlockchainModule::name(),
-                    req_to: ModuleRole::InterNodesNetwork,
-                    req_id: ModuleReqId(i),
-                    req_content: DursReqContent::OldNetworkRequest(OldNetworkRequest::GetBlocks(
-                        ModuleReqFullId(BlockchainModule::name(), ModuleReqId(i)),
-                        50,
-                        i * 50
-                    )),
-                },
-                durs_msg
-            );
-            log::info!("Router receive: {:?}", durs_msg);
-        } else {
-            panic!("Expect ModuleMesage, found: {:?}", msg)
-        }
-    }
+    recv_n_queries_get_blocks(11, &router_receiver);
 
     // Receive first g1-test chunk
     let gt_chunk_0 = dubp_blocks_tests_tools::gt::get_gt_chunk(0);

lib/modules/blockchain/blockchain/tests/common.rs

@@ -17,10 +17,12 @@ use dubp_currency_params::genesis_block_params::v10::BlockV10Parameters;
 use dubp_currency_params::{CurrencyName, CurrencyParameters};
 use durs_bc::BlockchainModule;
 use durs_bc_db_writer::WotsV10DBs;
+use durs_message::requests::DursReqContent;
 use durs_message::DursMsg;
-use durs_module::RouterThreadMessage;
+use durs_module::{ModuleReqFullId, ModuleReqId, ModuleRole, RouterThreadMessage};
+use durs_network::requests::OldNetworkRequest;
 use std::path::{Path, PathBuf};
-use std::sync::mpsc::Sender;
+use std::sync::mpsc::{Receiver, Sender};
 use std::thread::JoinHandle;
 use tempfile::TempDir;
 
@@ -77,3 +79,32 @@ pub fn init_bc_module(
     )
     .expect("Fail to init BlockchainModule with empty blockchain.")
 }
+
+pub fn recv_n_queries_get_blocks(
+    n: usize,
+    router_receiver: &Receiver<RouterThreadMessage<DursMsg>>,
+) {
+    for i in 0..n {
+        let msg = router_receiver
+            .recv()
+            .expect("blockchain module disconnected.");
+        if let RouterThreadMessage::ModuleMessage(durs_msg) = msg {
+            assert_eq!(
+                DursMsg::Request {
+                    req_from: BlockchainModule::name(),
+                    req_to: ModuleRole::InterNodesNetwork,
+                    req_id: ModuleReqId(i as u32),
+                    req_content: DursReqContent::OldNetworkRequest(OldNetworkRequest::GetBlocks(
+                        ModuleReqFullId(BlockchainModule::name(), ModuleReqId(i as u32)),
+                        50,
+                        (i * 50) as u32
+                    )),
+                },
+                durs_msg
+            );
+            log::info!("Router receive: {:?}", durs_msg);
+        } else {
+            panic!("Expect ModuleMesage, found: {:?}", msg)
+        }
+    }
+}

lib/modules/blockchain/blockchain/tests/revert_blocks.rs

@@ -17,24 +17,20 @@ mod common;
 
 use crate::common::*;
 use dubp_block_doc::{block::BlockDocumentTrait, BlockDocument};
+use dubp_common_doc::traits::Document;
 use dubp_common_doc::BlockNumber;
 use dubp_currency_params::genesis_block_params::v10::BlockV10Parameters;
 use dup_crypto::keys::{KeyPair, Signator, SignatorEnum};
-use durs_bc::BlockchainModule;
 use durs_message::events::{BlockchainEvent, DursEvent};
-use durs_message::requests::DursReqContent;
 use durs_message::DursMsg;
-use durs_module::{
-    ModuleEvent, ModuleReqFullId, ModuleReqId, ModuleRole, ModuleStaticName, RouterThreadMessage,
-};
+use durs_module::{ModuleEvent, ModuleStaticName, RouterThreadMessage};
 use durs_network::events::NetworkEvent;
-use durs_network::requests::OldNetworkRequest;
 use pretty_assertions::assert_eq;
 use std::sync::mpsc::{channel, Receiver, Sender};
 
 #[cfg(unix)]
 #[test]
-fn test_revert_blocks() {
+fn test_revert_blocks_g1() {
     // Init test
     let tmp_profile_path = common::init();
 
@@ -53,35 +49,79 @@ fn test_revert_blocks() {
     // Create blockchain module channel
     let (bc_sender, bc_receiver): (Sender<DursMsg>, Receiver<DursMsg>) = channel();
 
+    // Start blockchain module
     let handle = std::thread::spawn(move || {
         bc.start_blockchain(&bc_receiver, None);
     });
 
     // Receive 11 requests GetBlocks
-    for i in 0..11 {
-        let msg = router_receiver
-            .recv()
-            .expect("blockchain module disconnected.");
-        if let RouterThreadMessage::ModuleMessage(durs_msg) = msg {
-            assert_eq!(
-                DursMsg::Request {
-                    req_from: BlockchainModule::name(),
-                    req_to: ModuleRole::InterNodesNetwork,
-                    req_id: ModuleReqId(i),
-                    req_content: DursReqContent::OldNetworkRequest(OldNetworkRequest::GetBlocks(
-                        ModuleReqFullId(BlockchainModule::name(), ModuleReqId(i)),
-                        50,
-                        i * 50
-                    )),
-                },
-                durs_msg
+    recv_n_queries_get_blocks(11, &router_receiver);
+
+    // Receive first g1 chunk
+    let mut g1_chunk_0 = dubp_blocks_tests_tools::g1::get_g1_chunk(0);
+    g1_chunk_0.truncate(65);
+    let block_61 = g1_chunk_0.get(61).cloned().expect("g1_chunk_0 is empty !");
+    receive_valid_blocks(&bc_sender, &router_receiver, g1_chunk_0);
+
+    // Generate 6 forks blocks from 62 to 67 included
+    let signator = SignatorEnum::Ed25519(
+        dup_crypto::keys::ed25519::Ed25519KeyPair::generate_random()
+            .generate_signator()
+            .expect("fail to generatye signator"),
     );
-            log::info!("Router receive: {:?}", durs_msg);
-        } else {
-            panic!("Expect ModuleMesage, found: {:?}", msg)
+    let mut fork_blocks = Vec::new();
+    let mut previous_hash = block_61.hash().expect("block_61 have None hash").0;
+    let mut bc_time = block_61.common_time();
+    for n in 62..=67 {
+        bc_time += 301;
+        let block = dubp_blocks_tests_tools::mocks::gen_empty_timed_issued_hashed_block_v10(
+            BlockNumber(n),
+            bc_time,
+            signator.public_key(),
+            previous_hash,
+            &signator,
+        );
+        let block_hash = block.hash().clone().expect("block must have hash");
+        fork_blocks.push(BlockDocument::V10(block));
+        previous_hash = block_hash.0;
     }
+
+    // Cause the revert of 3 blocks (send forks blocks from 62)
+    receive_valid_blocks(&bc_sender, &router_receiver, fork_blocks);
+
+    // Stop and clean
+    common::stop_and_clean(bc_sender, handle, tmp_profile_path);
 }
 
+#[cfg(unix)]
+#[test]
+fn test_revert_blocks_gt() {
+    // Init test
+    let tmp_profile_path = common::init();
+
+    // Router channel
+    let (router_sender, router_receiver) = channel(); // RouterThreadMessage<DursMsg>
+
+    let genesis_params = BlockV10Parameters::default();
+
+    let mut bc = init_bc_module(
+        router_sender,
+        genesis_params,
+        tmp_profile_path.as_path(),
+        false,
+    );
+
+    // Create blockchain module channel
+    let (bc_sender, bc_receiver): (Sender<DursMsg>, Receiver<DursMsg>) = channel();
+
+    // Start blockchain module
+    let handle = std::thread::spawn(move || {
+        bc.start_blockchain(&bc_receiver, None);
+    });
+
+    // Receive 11 requests GetBlocks
+    recv_n_queries_get_blocks(11, &router_receiver);
+
     // Receive first g1-test chunk
     let gt_chunk_0 = dubp_blocks_tests_tools::gt::get_gt_chunk(0);
     receive_valid_blocks(&bc_sender, &router_receiver, gt_chunk_0);
@@ -96,7 +136,7 @@ fn test_revert_blocks() {
     let block_546 = gt_chunk_2.get(46).cloned().expect("gt_chunk_2 is empty !");
     receive_valid_blocks(&bc_sender, &router_receiver, gt_chunk_2);
 
-    // Generate 6 forks blocks from 547 to 553
+    // Generate 7 forks blocks from 547 to 553 included
     let signator = SignatorEnum::Ed25519(
         dup_crypto::keys::ed25519::Ed25519KeyPair::generate_random()
             .generate_signator()
@@ -149,6 +189,7 @@ fn receive_valid_blocks(
         let msg = router_receiver
             .recv()
             .expect("blockchain module disconnected.");
+        let _blockstamp = block.blockstamp();
         if let RouterThreadMessage::ModuleMessage(durs_msg) = msg {
             assert_eq!(
                 DursMsg::Event {
@@ -160,7 +201,7 @@ fn receive_valid_blocks(
                 },
                 durs_msg
             );
-        //log::debug!("Router receive: {:?}", msg);
+        //log::debug!("StackUpValidBlock(#{})", blockstamp);
         } else {
             panic!("Expect ModuleMesage, found: {:?}", msg)
         }