switch the block production function

Author: skaunov

src/models/peer/tests/automaton.rs

@@ -140,7 +140,11 @@ impl proptest_state_machine::StateMachineTest for TheSut {
         let g_cloned = g.clone();
 
         rt.block_on(async {
-            dbg!(&transition);
+            dbg!(format!("{:?}", transition.0)
+                .lines()
+                .next()
+                .unwrap_or_default());
+            dbg!(&transition.1.is_some());
             match transition {
                 Transition(_, Some(AssosiatedData::MakeNewBlocks(..))) => {
                     // blocks_stuff(ref_state.blocks[ref_state.blocks.len()-1 - BLOCKS_NEW_LEN..].into()).await;

src/models/peer/tests/automaton/reference/strategy_the.rs

@@ -5,7 +5,9 @@ use crate::config_models::network::Network;
 use crate::models::blockchain::block::{block_height::BlockHeight, Block};
 use crate::models::peer::peer_block_notifications::PeerBlockNotification;
 use crate::models::peer::tests::automaton::reference::AssosiatedData;
+use crate::models::peer::tests::automaton::BLOCKS_NEW_LEN;
 use crate::models::peer::{BlockProposalRequest, SyncChallenge};
+use crate::models::state::wallet::wallet_entropy::WalletEntropy;
 use proptest::prelude::*;
 use proptest::strategy::{Just, Strategy};
 use proptest_arbitrary_interop::arb;
@@ -216,16 +218,35 @@ impl proptest_state_machine::strategy::ReferenceStateMachine for Automaton {
 
     fn apply(mut state: Self::State, transition: &Self::Transition) -> Self::State {
         match transition {
-            Transition(variant, Some(AssosiatedData::MakeNewBlocks(ts, seed_the))) => {
+            Transition(variant, Some(AssosiatedData::MakeNewBlocks(_ts, seed_the))) => {
                 let tip_at_request = state.blocks.last().unwrap().clone();
-                state.blocks.append(&mut Runtime::new().unwrap().block_on(
-                    crate::tests::shared::fake_valid_sequence_of_blocks_for_tests_dyn(
-                        &tip_at_request,
-                        *ts,
-                        *seed_the,
-                        super::super::BLOCKS_NEW_LEN,
-                    ),
-                ));
+                // state.blocks.append(&mut Runtime::new().unwrap().block_on(
+                //     crate::tests::shared::fake_valid_sequence_of_blocks_for_tests_dyn(
+                //         &tip_at_request,
+                //         *ts,
+                //         *seed_the,
+                //         super::super::BLOCKS_NEW_LEN,
+                //     ),
+                // ));
+                let rt = Runtime::new().unwrap();
+                for i in 0..BLOCKS_NEW_LEN as u8 {
+                    let mut seed = *seed_the;
+                    seed[0] = seed[0].wrapping_add(i);
+                    state.blocks.push(
+                        rt.block_on(crate::tests::shared::make_mock_block(
+                            // previous_block: &Block,
+                            state.blocks.last().unwrap(),
+                            // block_timestamp: Option<Timestamp>,
+                            None,
+                            // composer_key: generation_address::GenerationSpendingKey,
+                            WalletEntropy::new_pseudorandom(seed)
+                                .nth_generation_spending_key_for_tests(0),
+                            // seed: [u8; 32], // #seedReuse
+                            seed,
+                        ))
+                        .0,
+                    );
+                }
                 if &PeerMessage::BlockNotificationRequest == variant {
                     state.sync_stage = Some(SyncStage::WaitingForChallenge(
                         // a possible problem is a testing system will be responding with another block