merged generic_tests branch

Author: fluidvanadium

Cargo.lock

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
 
 [dependencies]
 zingolib = { path = "../zingolib", features = ["test-features", "darkside_tests"] }
@@ -38,6 +39,7 @@ zcash_client_backend = { workspace = true }
 shardtree = { workspace = true }
 serde_json = "1.0.107"
 sapling-crypto.workspace = true
+proptest = "1.4.0"
 
 [build-dependencies]
 tonic-build = { workspace = true }

darkside-tests/Cargo.toml

@@ -0,0 +1,95 @@
+use zingolib::{
+    lightclient::LightClient, test_framework::chain_generic_tests::ChainTest, wallet::WalletBase,
+};
+
+use crate::{
+    constants::{ABANDON_TO_DARKSIDE_SAP_10_000_000_ZAT, DARKSIDE_SEED},
+    utils::{scenarios::DarksideScenario, update_tree_states_for_transaction},
+};
+
+impl ChainTest for DarksideScenario {
+    async fn setup() -> Self {
+        DarksideScenario::new(None).await
+    }
+
+    async fn create_faucet(&mut self) -> LightClient {
+        self.stage_transaction(ABANDON_TO_DARKSIDE_SAP_10_000_000_ZAT)
+            .await;
+        self.client_builder
+            .build_client(DARKSIDE_SEED.to_string(), 0, true, self.regtest_network)
+            .await
+    }
+
+    async fn create_client(&mut self) -> LightClient {
+        let zingo_config = self
+            .client_builder
+            .make_unique_data_dir_and_load_config(self.regtest_network);
+        LightClient::create_from_wallet_base_async(
+            WalletBase::FreshEntropy,
+            &zingo_config,
+            0,
+            false,
+        )
+        .await
+        .unwrap()
+    }
+
+    async fn bump_chain(&mut self) {
+        let mut streamed_raw_txns = self
+            .darkside_connector
+            .get_incoming_transactions()
+            .await
+            .unwrap();
+        self.darkside_connector
+            .clear_incoming_transactions()
+            .await
+            .unwrap();
+        loop {
+            let maybe_raw_tx = streamed_raw_txns.message().await.unwrap();
+            match maybe_raw_tx {
+                None => break,
+                Some(raw_tx) => {
+                    self.darkside_connector
+                        .stage_transactions_stream(vec![(
+                            raw_tx.data.clone(),
+                            u64::from(self.staged_blockheight),
+                        )])
+                        .await
+                        .unwrap();
+                    self.tree_state = update_tree_states_for_transaction(
+                        &self.darkside_connector.0,
+                        raw_tx.clone(),
+                        u64::from(self.staged_blockheight),
+                    )
+                    .await;
+                    self.darkside_connector
+                        .add_tree_state(self.tree_state.clone())
+                        .await
+                        .unwrap();
+                }
+            }
+        }
+        self.darkside_connector
+            .stage_blocks_create(u64::from(self.staged_blockheight) as i32, 1, 0)
+            .await
+            .unwrap();
+        self.staged_blockheight = dbg!(self.staged_blockheight + 1);
+        self.apply_blocks(u64::from(self.staged_blockheight)).await;
+    }
+}
+
+#[tokio::test]
+async fn chain_generic_send() {
+    zingolib::test_framework::chain_generic_tests::simple_send::<DarksideScenario>(40_000).await;
+}
+
+use proptest::proptest;
+use tokio::runtime::Runtime;
+proptest! {
+    #[test]
+    fn chain_generic_send_proptest(value in 0..90_000u32) {
+        Runtime::new().unwrap().block_on(async {
+    zingolib::test_framework::chain_generic_tests::simple_send::<DarksideScenario>(value).await;
+        });
+     }
+}

darkside-tests/src/chain_generic_tests.rs

@@ -1,7 +1,8 @@
 pub mod constants;
-#[cfg(feature = "generic_chain_tests")]
-pub mod generic_chain_tests;
 pub mod utils;
 pub mod darkside_types {
     tonic::include_proto!("cash.z.wallet.sdk.rpc");
 }
+
+#[cfg(test)]
+pub mod chain_generic_tests;

darkside-tests/src/generic_chain_tests.rs

@@ -512,13 +512,13 @@ pub mod scenarios {
 
     pub struct DarksideScenario {
         darkside_handler: DarksideHandler,
-        darkside_connector: DarksideConnector,
-        client_builder: ClientBuilder,
-        regtest_network: RegtestNetwork,
+        pub(crate) darkside_connector: DarksideConnector,
+        pub(crate) client_builder: ClientBuilder,
+        pub(crate) regtest_network: RegtestNetwork,
         faucet: Option<LightClient>,
         lightclients: Vec<LightClient>,
-        staged_blockheight: BlockHeight,
-        tree_state: TreeState,
+        pub(crate) staged_blockheight: BlockHeight,
+        pub(crate) tree_state: TreeState,
         transaction_set_index: u64,
     }
     impl DarksideScenario {

darkside-tests/src/lib.rs

@@ -0,0 +1,77 @@
+use zcash_client_backend::PoolType;
+use zcash_client_backend::ShieldedProtocol::Sapling;
+
+use zingo_testutils::scenarios::setup::ScenarioBuilder;
+use zingoconfig::RegtestNetwork;
+use zingolib::lightclient::LightClient;
+use zingolib::test_framework::chain_generic_tests::ChainTest;
+use zingolib::wallet::WalletBase;
+
+struct LibtonodeChain {
+    regtest_network: RegtestNetwork,
+    scenario_builder: ScenarioBuilder,
+}
+
+impl ChainTest for LibtonodeChain {
+    async fn setup() -> Self {
+        let regtest_network = RegtestNetwork::all_upgrades_active();
+        let scenario_builder = ScenarioBuilder::build_configure_launch(
+            Some(PoolType::Shielded(Sapling).into()),
+            None,
+            None,
+            &regtest_network,
+        )
+        .await;
+        LibtonodeChain {
+            regtest_network,
+            scenario_builder,
+        }
+    }
+
+    async fn create_faucet(&mut self) -> LightClient {
+        self.scenario_builder
+            .client_builder
+            .build_faucet(false, self.regtest_network)
+            .await
+    }
+
+    async fn create_client(&mut self) -> LightClient {
+        let zingo_config = self
+            .scenario_builder
+            .client_builder
+            .make_unique_data_dir_and_load_config(self.regtest_network);
+        LightClient::create_from_wallet_base_async(
+            WalletBase::FreshEntropy,
+            &zingo_config,
+            0,
+            false,
+        )
+        .await
+        .unwrap()
+    }
+
+    async fn bump_chain(&mut self) {
+        let start_height = self
+            .scenario_builder
+            .regtest_manager
+            .get_current_height()
+            .unwrap();
+        let target = start_height + 1;
+        self.scenario_builder
+            .regtest_manager
+            .generate_n_blocks(1)
+            .expect("Called for side effect, failed!");
+        assert_eq!(
+            self.scenario_builder
+                .regtest_manager
+                .get_current_height()
+                .unwrap(),
+            target
+        );
+    }
+}
+
+#[tokio::test]
+async fn chain_generic_send() {
+    zingolib::test_framework::chain_generic_tests::simple_send::<LibtonodeChain>(40_000).await;
+}

darkside-tests/src/utils.rs

@@ -3978,3 +3978,5 @@ mod basic_transactions {
 async fn proxy_server_worky() {
     zingo_testutils::check_proxy_server_works().await
 }
+
+pub mod chain_generic_tests;

integration-tests/tests/chain_generic_tests.rs

@@ -11,7 +11,6 @@ deprecations = ["lightclient-deprecated"]
 test-features = ["lightclient-deprecated", "zingo-testvectors"]
 lightclient-deprecated = []
 darkside_tests = []
-generic_chain_tests = []
 
 [dependencies]
 zingoconfig = { path = "../zingoconfig" }