From 95f0c71c1e770b3d0f98a59a743fc3b24fc62fa1 Mon Sep 17 00:00:00 2001 From: Andrei Baltariu Date: Fri, 3 Jan 2025 15:57:31 +0200 Subject: [PATCH 1/8] Updated Sovereign-Forge unit tests to use `ReturnsHandledOrError` Signed-off-by: Andrei Baltariu --- .../tests/sovereign_forge_unit_tests.rs | 40 +++++++++---------- 1 file changed, 19 insertions(+), 21 deletions(-) diff --git a/sovereign-forge/tests/sovereign_forge_unit_tests.rs b/sovereign-forge/tests/sovereign_forge_unit_tests.rs index c6af19e5..0ee5d15e 100644 --- a/sovereign-forge/tests/sovereign_forge_unit_tests.rs +++ b/sovereign-forge/tests/sovereign_forge_unit_tests.rs @@ -1,7 +1,7 @@ use multiversx_sc::types::{BigUint, ManagedBuffer, MultiValueEncoded, TestAddress, TestSCAddress}; use multiversx_sc_scenario::{ - api::StaticApi, imports::MxscPath, ExpectError, ScenarioTxRun, ScenarioTxWhitebox, - ScenarioWorld, + api::StaticApi, imports::MxscPath, ExpectError, ReturnsHandledOrError, ScenarioTxRun, + ScenarioTxWhitebox, ScenarioWorld, }; use proxies::{ chain_config_proxy::ChainConfigContractProxy, @@ -170,24 +170,25 @@ impl SovereignForgeTestState { self } + fn register_token_handler( &mut self, shard_id: u32, token_handler_address: TestSCAddress, - expected_result: Option, + error_message: Option<&str>, ) { - let transaction = self + let response = self .world .tx() .from(OWNER_ADDRESS) .to(FORGE_ADDRESS) .typed(SovereignForgeProxy) - .register_token_handler(shard_id, token_handler_address); + .register_token_handler(shard_id, token_handler_address) + .returns(ReturnsHandledOrError::new()) + .run(); - if let Some(error) = expected_result { - transaction.returns(error).run(); - } else { - transaction.run(); + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -270,21 +271,21 @@ impl SovereignForgeTestState { fn deploy_phase_two( &mut self, - expected_result: Option, + error_message: Option<&str>, bls_keys: &MultiValueEncoded>, ) { - let transaction = self + let response = self .world .tx() .from(OWNER_ADDRESS) .to(FORGE_ADDRESS) .typed(SovereignForgeProxy) - .deploy_phase_two(bls_keys); + .deploy_phase_two(bls_keys) + .returns(ReturnsHandledOrError::new()) + .run(); - if let Some(error) = expected_result { - transaction.returns(error).run(); - } else { - transaction.run(); + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -500,10 +501,7 @@ fn deploy_phase_two_without_first_phase() { let bls_keys = MultiValueEncoded::>::new(); state.deploy_phase_two( - Some(ExpectError( - 4, - "The current caller has not deployed any Sovereign Chain", - )), + Some("The current caller has not deployed any Sovereign Chain"), &bls_keys, ); } @@ -572,7 +570,7 @@ fn deploy_phase_two_header_already_deployed() { state.deploy_phase_two(None, &bls_keys); state.deploy_phase_two( - Some(ExpectError(4, "The Header-Verifier SC is already deployed")), + Some("The Header-Verifier SC is already deployed"), &bls_keys, ); } From 8a33e4405482fd7934888e6049779e646e117e75 Mon Sep 17 00:00:00 2001 From: Andrei Baltariu Date: Fri, 3 Jan 2025 16:01:18 +0200 Subject: [PATCH 2/8] Updated Header-Verifier tests to use `ReturnsHandledOrError` Signed-off-by: Andrei Baltariu --- .../tests/header_verifier_blackbox_test.rs | 38 +++++++++---------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/header-verifier/tests/header_verifier_blackbox_test.rs b/header-verifier/tests/header_verifier_blackbox_test.rs index 0a01ac5b..8429e986 100644 --- a/header-verifier/tests/header_verifier_blackbox_test.rs +++ b/header-verifier/tests/header_verifier_blackbox_test.rs @@ -4,9 +4,10 @@ use multiversx_sc::{ api::ManagedTypeApi, types::{BigUint, MultiValueEncoded, TestAddress, TestSCAddress}, }; +use multiversx_sc_scenario::ReturnsHandledOrError; use multiversx_sc_scenario::{ api::StaticApi, imports::MxscPath, multiversx_chain_vm::crypto_functions::sha256, DebugApi, - ExpectError, ScenarioTxRun, ScenarioTxWhitebox, ScenarioWorld, + ScenarioTxRun, ScenarioTxWhitebox, ScenarioWorld, }; use proxies::header_verifier_proxy::HeaderverifierProxy; @@ -98,19 +99,20 @@ impl HeaderVerifierTestState { caller: TestAddress, hash_of_hashes: &ManagedBuffer, operation_hash: &ManagedBuffer, - expected_result: Option>, + error_message: Option<&str>, ) { - let transaction = self + let response = self .world .tx() .from(caller) .to(HEADER_VERIFIER_ADDRESS) .typed(HeaderverifierProxy) - .remove_executed_hash(hash_of_hashes, operation_hash); + .remove_executed_hash(hash_of_hashes, operation_hash) + .returns(ReturnsHandledOrError::new()) + .run(); - match expected_result { - Some(error) => transaction.returns(error).run(), - None => transaction.run(), + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -119,19 +121,20 @@ impl HeaderVerifierTestState { caller: TestAddress, hash_of_hashes: &ManagedBuffer, operation_hash: &ManagedBuffer, - expected_result: Option>, + error_message: Option<&str>, ) { - let transaction = self + let response = self .world .tx() .from(caller) .to(HEADER_VERIFIER_ADDRESS) .typed(HeaderverifierProxy) - .lock_operation_hash(hash_of_hashes, operation_hash); + .lock_operation_hash(hash_of_hashes, operation_hash) + .returns(ReturnsHandledOrError::new()) + .run(); - match expected_result { - Some(error) => transaction.returns(error).run(), - None => transaction.run(), + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -271,10 +274,7 @@ fn test_remove_executed_hash_caller_not_esdt_address() { OWNER, &operation.bridge_operation_hash, &operation_1, - Some(ExpectError( - 4, - "Only ESDT Safe contract can call this endpoint", - )), + Some("Only ESDT Safe contract can call this endpoint"), ); } @@ -295,7 +295,7 @@ fn test_remove_executed_hash_no_esdt_address_registered() { ENSHRINE_ADDRESS, &operation.bridge_operation_hash, &operation_1, - Some(ExpectError(4, "There is no registered ESDT address")), + Some("There is no registered ESDT address"), ); } @@ -406,7 +406,7 @@ fn test_lock_operation_not_registered() { ENSHRINE_ADDRESS, &operation.bridge_operation_hash, &operation_1, - Some(ExpectError(4, "The current operation is not registered")), + Some("The current operation is not registered"), ); } From 8d6f59602aa0ee4d8ddab944d6e0b9ef20426623 Mon Sep 17 00:00:00 2001 From: Andrei Baltariu Date: Fri, 3 Jan 2025 16:04:41 +0200 Subject: [PATCH 3/8] Updated Fee-Market tests to use `ReturnsHandledOrError` Signed-off-by: Andrei Baltariu --- fee-market/tests/fee_market_blackbox_test.rs | 55 +++++++------------- 1 file changed, 20 insertions(+), 35 deletions(-) diff --git a/fee-market/tests/fee_market_blackbox_test.rs b/fee-market/tests/fee_market_blackbox_test.rs index d4766732..79af991e 100644 --- a/fee-market/tests/fee_market_blackbox_test.rs +++ b/fee-market/tests/fee_market_blackbox_test.rs @@ -1,12 +1,13 @@ use multiversx_sc::{ imports::OptionalValue, types::{ - BigUint, EsdtTokenPayment, ManagedVec, MultiValueEncoded, ReturnsResultUnmanaged, - TestAddress, TestSCAddress, TestTokenIdentifier, + BigUint, EsdtTokenPayment, ManagedVec, MultiValueEncoded, TestAddress, TestSCAddress, + TestTokenIdentifier, }, }; use multiversx_sc_scenario::{ - api::StaticApi, imports::MxscPath, ExpectError, ScenarioTxRun, ScenarioWorld, + api::StaticApi, imports::MxscPath, ExpectError, ReturnsHandledOrError, ScenarioTxRun, + ScenarioWorld, }; use proxies::fee_market_proxy::{FeeMarketProxy, FeeStruct, FeeType}; @@ -83,7 +84,7 @@ impl FeeMarketTestState { self } - fn substract_fee(&mut self, payment_wanted: &str, error_status: Option) { + fn substract_fee(&mut self, payment_wanted: &str, error_message: Option<&str>) { let payment: EsdtTokenPayment = match payment_wanted { "Correct" => { EsdtTokenPayment::new(TOKEN_ID.to_token_identifier(), 0u64, BigUint::from(200u64)) @@ -106,29 +107,19 @@ impl FeeMarketTestState { } }; - match error_status { - Some(error) => { - self.world - .tx() - .from(ESDT_SAFE_ADDRESS) - .to(FEE_MARKET_ADDRESS) - .typed(FeeMarketProxy) - .subtract_fee(USER_ADDRESS, 1u8, OptionalValue::Some(30u64)) - .payment(payment) - .returns(error) - .run(); - } - None => { - self.world - .tx() - .from(ESDT_SAFE_ADDRESS) - .to(FEE_MARKET_ADDRESS) - .typed(FeeMarketProxy) - .subtract_fee(USER_ADDRESS, 1u8, OptionalValue::Some(30u64)) - .payment(payment) - .returns(ReturnsResultUnmanaged) - .run(); - } + let response = self + .world + .tx() + .from(ESDT_SAFE_ADDRESS) + .to(FEE_MARKET_ADDRESS) + .typed(FeeMarketProxy) + .subtract_fee(USER_ADDRESS, 1u8, OptionalValue::Some(30u64)) + .payment(payment) + .returns(ReturnsHandledOrError::new()) + .run(); + + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -309,10 +300,7 @@ fn test_substract_fee_invalid_payment_token() { state.deploy_fee_market(); - state.substract_fee( - "InvalidToken", - Some(ExpectError(4, "Token not accepted as fee")), - ); + state.substract_fee("InvalidToken", Some("Token not accepted as fee")); state.check_balance_sc(ESDT_SAFE_ADDRESS, 1000); state.check_account(USER_ADDRESS, 1000); @@ -336,10 +324,7 @@ fn test_substract_fixed_fee_payment_not_covered() { state.deploy_fee_market(); - state.substract_fee( - "Less than fee", - Some(ExpectError(4, "Payment does not cover fee")), - ); + state.substract_fee("Less than fee", Some("Payment does not cover fee")); state.check_balance_sc(ESDT_SAFE_ADDRESS, 1000); state.check_account(USER_ADDRESS, 1000); From c19d0b1b7a94ccf87f9c71df55d692f30041d047 Mon Sep 17 00:00:00 2001 From: Andrei Baltariu Date: Fri, 3 Jan 2025 16:07:18 +0200 Subject: [PATCH 4/8] Updated Enshrine-Esdt-Safe test to use `ReturnsHandledOrError` Signed-off-by: Andrei Baltariu --- .../tests/enshrine_esdt_safe_blackbox_test.rs | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs index c8a629f0..14d98df3 100644 --- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs +++ b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs @@ -7,7 +7,7 @@ use multiversx_sc::types::{ use multiversx_sc_scenario::api::StaticApi; use multiversx_sc_scenario::multiversx_chain_vm::crypto_functions::sha256; use multiversx_sc_scenario::{imports::MxscPath, ScenarioWorld}; -use multiversx_sc_scenario::{managed_address, ExpectError, ScenarioTxRun}; +use multiversx_sc_scenario::{managed_address, ExpectError, ReturnsHandledOrError, ScenarioTxRun}; use proxies::enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy; use proxies::fee_market_proxy::{FeeMarketProxy, FeeStruct, FeeType}; use proxies::header_verifier_proxy::HeaderverifierProxy; @@ -225,7 +225,7 @@ impl EnshrineTestState { fn propose_execute_operation( &mut self, - expected_result: Option>, + error_message: Option<&str>, tokens: &Vec, ) { let (tokens, data) = self.setup_payments(tokens); @@ -235,17 +235,18 @@ impl EnshrineTestState { let hash_of_hashes: ManagedBuffer = ManagedBuffer::from(&sha256(&operation_hash.to_vec())); - let transaction = self + let response = self .world .tx() .from(USER_ADDRESS) .to(ENSHRINE_ESDT_ADDRESS) .typed(EnshrineEsdtSafeProxy) - .execute_operations(hash_of_hashes, operation); + .execute_operations(hash_of_hashes, operation) + .returns(ReturnsHandledOrError::new()) + .run(); - match expected_result { - Some(error) => transaction.returns(error).run(), - None => transaction.run(), + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -482,7 +483,7 @@ fn test_sovereign_prefix_no_prefix() { state.propose_register_operation(&token_vec); state.propose_register_esdt_in_header_verifier(); state.propose_whitelist_enshrine_esdt(); - state.propose_execute_operation(Some(ExpectError(10, "action is not allowed")), &token_vec); + state.propose_execute_operation(Some("action is not allowed"), &token_vec); } #[test] From e82b422378a64b8779d9aa72bd45c19e1d9d9755 Mon Sep 17 00:00:00 2001 From: Andrei Baltariu Date: Fri, 3 Jan 2025 16:09:37 +0200 Subject: [PATCH 5/8] Updated Chain-Factory tests to use `ReturnsHandledOrError` Signed-off-by: Andrei Baltariu --- chain-factory/tests/chain_factory_tests.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/chain-factory/tests/chain_factory_tests.rs b/chain-factory/tests/chain_factory_tests.rs index d2618810..4cd14984 100644 --- a/chain-factory/tests/chain_factory_tests.rs +++ b/chain-factory/tests/chain_factory_tests.rs @@ -4,7 +4,8 @@ use multiversx_sc::types::{ BigUint, CodeMetadata, MultiValueEncoded, TestAddress, TestSCAddress, TokenIdentifier, }; use multiversx_sc_scenario::{ - api::StaticApi, imports::MxscPath, managed_biguint, ExpectError, ScenarioTxRun, ScenarioWorld, + api::StaticApi, imports::MxscPath, managed_biguint, ReturnsHandledOrError, ScenarioTxRun, + ScenarioWorld, }; use proxies::{ chain_config_proxy::ChainConfigContractProxy, chain_factory_proxy::ChainFactoryContractProxy, @@ -88,9 +89,9 @@ impl ChainFactoryTestState { max_validators: usize, min_stake: BigUint, additional_stake_required: MultiValueEncoded>, - expected_result: Option>, + error_message: Option<&str>, ) { - let transaction = self + let response = self .world .tx() .from(CONFIG_ADDRESS) @@ -101,13 +102,12 @@ impl ChainFactoryTestState { max_validators, min_stake, additional_stake_required, - ); + ) + .returns(ReturnsHandledOrError::new()) + .run(); - match expected_result { - Some(error) => { - transaction.returns(error).run(); - } - None => transaction.run(), + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } } From d03eea5186c1934d7c02b86cb2ed5adb197e0e22 Mon Sep 17 00:00:00 2001 From: Andrei Baltariu Date: Fri, 3 Jan 2025 16:12:09 +0200 Subject: [PATCH 6/8] More updates to the Sovereign-Forge tests Signed-off-by: Andrei Baltariu --- .../tests/sovereign_forge_unit_tests.rs | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/sovereign-forge/tests/sovereign_forge_unit_tests.rs b/sovereign-forge/tests/sovereign_forge_unit_tests.rs index 0ee5d15e..e09ea10a 100644 --- a/sovereign-forge/tests/sovereign_forge_unit_tests.rs +++ b/sovereign-forge/tests/sovereign_forge_unit_tests.rs @@ -196,20 +196,20 @@ impl SovereignForgeTestState { &mut self, shard_id: u32, chain_factory_address: TestSCAddress, - expected_result: Option, + error_message: Option<&str>, ) { - let transaction = self + let response = self .world .tx() .from(OWNER_ADDRESS) .to(FORGE_ADDRESS) .typed(SovereignForgeProxy) - .register_chain_factory(shard_id, chain_factory_address); + .register_chain_factory(shard_id, chain_factory_address) + .returns(ReturnsHandledOrError::new()) + .run(); - if let Some(error) = expected_result { - transaction.returns(error).run(); - } else { - transaction.run(); + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -246,9 +246,9 @@ impl SovereignForgeTestState { max_validators: u64, min_stake: BigUint, additional_stake_required: MultiValueEncoded>, - expected_result: Option, + error_message: Option<&str>, ) { - let transaction = self + let response = self .world .tx() .from(OWNER_ADDRESS) @@ -260,12 +260,12 @@ impl SovereignForgeTestState { min_stake, additional_stake_required, ) - .egld(payment); + .egld(payment) + .returns(ReturnsHandledOrError::new()) + .run(); - if let Some(error) = expected_result { - transaction.returns(error).run(); - } else { - transaction.run(); + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -308,20 +308,20 @@ impl SovereignForgeTestState { fn deploy_phase_four( &mut self, fee: Option>, - expect_error: Option, + error_message: Option<&str>, ) { - let transaction = self + let response = self .world .tx() .from(OWNER_ADDRESS) .to(FORGE_ADDRESS) .typed(SovereignForgeProxy) - .deploy_phase_four(fee); + .deploy_phase_four(fee) + .returns(ReturnsHandledOrError::new()) + .run(); - if let Some(error) = expect_error { - transaction.returns(error).run(); - } else { - transaction.run(); + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } } From 0f5845d56b1648dd600178d551bede2ab4588998 Mon Sep 17 00:00:00 2001 From: Andrei Baltariu Date: Fri, 3 Jan 2025 16:21:24 +0200 Subject: [PATCH 7/8] Updates on Sovereign-Forge tests Signed-off-by: Andrei Baltariu --- .../tests/sovereign_forge_unit_tests.rs | 49 ++++++------------- 1 file changed, 14 insertions(+), 35 deletions(-) diff --git a/sovereign-forge/tests/sovereign_forge_unit_tests.rs b/sovereign-forge/tests/sovereign_forge_unit_tests.rs index e09ea10a..1ebea606 100644 --- a/sovereign-forge/tests/sovereign_forge_unit_tests.rs +++ b/sovereign-forge/tests/sovereign_forge_unit_tests.rs @@ -289,19 +289,19 @@ impl SovereignForgeTestState { } } - fn deploy_phase_three(&mut self, is_sovereign_chain: bool, expect_error: Option) { - let transaction = self + fn deploy_phase_three(&mut self, is_sovereign_chain: bool, error_message: Option<&str>) { + let response = self .world .tx() .from(OWNER_ADDRESS) .to(FORGE_ADDRESS) .typed(SovereignForgeProxy) - .deploy_phase_three(is_sovereign_chain); + .deploy_phase_three(is_sovereign_chain) + .returns(ReturnsHandledOrError::new()) + .run(); - if let Some(error) = expect_error { - transaction.returns(error).run(); - } else { - transaction.run(); + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -418,10 +418,7 @@ fn deploy_phase_one_deploy_cost_too_low() { 2, BigUint::from(2u32), MultiValueEncoded::new(), - Some(ExpectError( - 4, - "The given deploy cost is not equal to the standard amount", - )), + Some("The given deploy cost is not equal to the standard amount"), ); } @@ -450,10 +447,7 @@ fn deploy_phase_one_chain_config_already_deployed() { 2, BigUint::from(2u32), MultiValueEncoded::new(), - Some(ExpectError( - 4, - "The Chain-Config contract is already deployed", - )), + Some("The Chain-Config contract is already deployed"), ); } @@ -626,10 +620,7 @@ fn deploy_phase_three_without_phase_one() { state.deploy_phase_three( false, - Some(ExpectError( - 4, - "The Header-Verifier SC is not deployed, you skipped the second phase", - )), + Some("The Header-Verifier SC is not deployed, you skipped the second phase"), ); } @@ -657,10 +648,7 @@ fn deploy_phase_three_without_phase_two() { state.deploy_phase_three( false, - Some(ExpectError( - 4, - "The Header-Verifier SC is not deployed, you skipped the second phase", - )), + Some("The Header-Verifier SC is not deployed, you skipped the second phase"), ); } @@ -692,10 +680,7 @@ fn deploy_phase_three_already_deployed() { state.deploy_phase_two(None, &bls_keys); state.deploy_phase_three(false, None); - state.deploy_phase_three( - false, - Some(ExpectError(4, "The ESDT-Safe SC is already deployed")), - ); + state.deploy_phase_three(false, Some("The ESDT-Safe SC is already deployed")); } #[test] @@ -771,10 +756,7 @@ fn deploy_phase_four_without_previous_phase() { state.deploy_phase_two(None, &bls_keys); state.deploy_phase_four( None, - Some(ExpectError( - 4, - "The ESDT-Safe SC is not deployed, you skipped the third phase", - )), + Some("The ESDT-Safe SC is not deployed, you skipped the third phase"), ); } @@ -808,8 +790,5 @@ fn deploy_phase_four_fee_market_already_deployed() { state.deploy_phase_two(None, &bls_keys); state.deploy_phase_three(false, None); state.deploy_phase_four(None, None); - state.deploy_phase_four( - None, - Some(ExpectError(4, "The Fee-Market SC is already deployed")), - ); + state.deploy_phase_four(None, Some("The Fee-Market SC is already deployed")); } From c690cffa49758e32d0c8a2e32c529703ca00450e Mon Sep 17 00:00:00 2001 From: Andrei Baltariu Date: Fri, 3 Jan 2025 16:38:51 +0200 Subject: [PATCH 8/8] Updated tests Signed-off-by: Andrei Baltariu --- .../tests/enshrine_esdt_safe_blackbox_test.rs | 64 +++++++++---------- fee-market/tests/fee_market_blackbox_test.rs | 63 ++++++------------ .../tests/sovereign_forge_unit_tests.rs | 28 ++++---- 3 files changed, 66 insertions(+), 89 deletions(-) diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs index 14d98df3..73e10f51 100644 --- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs +++ b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs @@ -7,7 +7,7 @@ use multiversx_sc::types::{ use multiversx_sc_scenario::api::StaticApi; use multiversx_sc_scenario::multiversx_chain_vm::crypto_functions::sha256; use multiversx_sc_scenario::{imports::MxscPath, ScenarioWorld}; -use multiversx_sc_scenario::{managed_address, ExpectError, ReturnsHandledOrError, ScenarioTxRun}; +use multiversx_sc_scenario::{managed_address, ReturnsHandledOrError, ScenarioTxRun}; use proxies::enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy; use proxies::fee_market_proxy::{FeeMarketProxy, FeeStruct, FeeType}; use proxies::header_verifier_proxy::HeaderverifierProxy; @@ -214,10 +214,10 @@ impl EnshrineTestState { fn propose_set_fee( &mut self, fee_struct: Option<&FeeStruct>, - expected_result: Option>, + error_message: Option<&str>, ) -> &mut Self { if let Some(fee) = fee_struct { - self.propose_add_fee_token(fee, expected_result); + self.propose_add_fee_token(fee, error_message); } self @@ -303,7 +303,7 @@ impl EnshrineTestState { sender: &TestAddress, fee_payment: EsdtTokenPayment, tokens_to_register: Vec, - expected_result: Option>, + error_message: Option<&str>, ) { let mut managed_token_ids: MultiValueEncoded> = MultiValueEncoded::new(); @@ -312,18 +312,19 @@ impl EnshrineTestState { managed_token_ids.push(TokenIdentifier::from(token_id)) } - let transaction = self + let response = self .world .tx() .from(*sender) .to(ENSHRINE_ESDT_ADDRESS) .typed(EnshrineEsdtSafeProxy) .register_new_token_id(managed_token_ids) - .esdt(fee_payment); + .esdt(fee_payment) + .returns(ReturnsHandledOrError::new()) + .run(); - match expected_result { - Some(error) => transaction.returns(error).run(), - None => transaction.run(), + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -333,39 +334,41 @@ impl EnshrineTestState { to: TestAddress, payment: PaymentsVec, deposit_args: OptionalTransferData, - expected_result: Option>, + error_message: Option<&str>, ) { - let transaction = self + let response = self .world .tx() .from(from) .to(ENSHRINE_ESDT_ADDRESS) .typed(EnshrineEsdtSafeProxy) .deposit(to, deposit_args) - .payment(payment); + .payment(payment) + .returns(ReturnsHandledOrError::new()) + .run(); - match expected_result { - Some(error) => transaction.returns(error).run(), - None => transaction.run(), + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } fn propose_add_fee_token( &mut self, fee_struct: &FeeStruct, - expected_result: Option>, + error_message: Option<&str>, ) { - let transaction = self + let response = self .world .tx() .from(ENSHRINE_ESDT_OWNER_ADDRESS) .to(FEE_MARKET_ADDRESS) .typed(FeeMarketProxy) - .set_fee(fee_struct); + .set_fee(fee_struct) + .returns(ReturnsHandledOrError::new()) + .run(); - match expected_result { - Some(error) => transaction.returns(error).run(), - None => transaction.run(), + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -510,7 +513,7 @@ fn test_register_tokens_insufficient_funds() { &USER_ADDRESS, payment, token_vec, - Some(ExpectError(10, "insufficient funds")), + Some("insufficient funds"), ); } @@ -526,10 +529,7 @@ fn test_register_tokens_wrong_token_as_fee() { &ENSHRINE_ESDT_OWNER_ADDRESS, payment, token_vec, - Some(ExpectError( - 4, - "WEGLD is the only token accepted as register fee", - )), + Some("WEGLD is the only token accepted as register fee"), ); } @@ -565,7 +565,7 @@ fn test_register_tokens_insufficient_wegld() { &ENSHRINE_ESDT_OWNER_ADDRESS, payment, token_vec, - Some(ExpectError(4, "WEGLD fee amount is not met")), + Some("WEGLD fee amount is not met"), ); } @@ -613,7 +613,7 @@ fn test_deposit_token_nothing_to_transfer_fee_enabled() { USER_ADDRESS, payments, OptionalValue::None, - Some(ExpectError(4, "Nothing to transfer")), + Some("Nothing to transfer"), ); } @@ -631,7 +631,7 @@ fn test_deposit_max_transfers_exceeded() { USER_ADDRESS, payments, OptionalValue::None, - Some(ExpectError(4, "Too many tokens")), + Some("Too many tokens"), ); } @@ -714,7 +714,7 @@ fn test_deposit_with_transfer_data_gas_limit_too_high() { USER_ADDRESS, payments, transfer_data, - Some(ExpectError(4, "Gas limit too high")), + Some("Gas limit too high"), ); } @@ -744,7 +744,7 @@ fn test_deposit_with_transfer_data_banned_endpoint() { USER_ADDRESS, payments, transfer_data, - Some(ExpectError(4, "Banned endpoint name")), + Some("Banned endpoint name"), ); } @@ -848,7 +848,7 @@ fn test_deposit_with_transfer_data_not_enough_for_fee() { USER_ADDRESS, payments, transfer_data, - Some(ExpectError(4, "Payment does not cover fee")), + Some("Payment does not cover fee"), ); } diff --git a/fee-market/tests/fee_market_blackbox_test.rs b/fee-market/tests/fee_market_blackbox_test.rs index 79af991e..52cd6155 100644 --- a/fee-market/tests/fee_market_blackbox_test.rs +++ b/fee-market/tests/fee_market_blackbox_test.rs @@ -6,8 +6,7 @@ use multiversx_sc::{ }, }; use multiversx_sc_scenario::{ - api::StaticApi, imports::MxscPath, ExpectError, ReturnsHandledOrError, ScenarioTxRun, - ScenarioWorld, + api::StaticApi, imports::MxscPath, ReturnsHandledOrError, ScenarioTxRun, ScenarioWorld, }; use proxies::fee_market_proxy::{FeeMarketProxy, FeeStruct, FeeType}; @@ -137,7 +136,7 @@ impl FeeMarketTestState { &mut self, token_id: TestTokenIdentifier, fee_type: &str, - error_status: Option, + error_message: Option<&str>, ) { let fee_struct: FeeStruct = match fee_type { "None" => { @@ -185,26 +184,18 @@ impl FeeMarketTestState { } }; - match error_status { - Some(error) => { - self.world - .tx() - .from(OWNER_ADDRESS) - .to(FEE_MARKET_ADDRESS) - .typed(FeeMarketProxy) - .set_fee(fee_struct) - .returns(error) - .run(); - } - None => { - self.world - .tx() - .from(OWNER_ADDRESS) - .to(FEE_MARKET_ADDRESS) - .typed(FeeMarketProxy) - .set_fee(fee_struct) - .run(); - } + let response = self + .world + .tx() + .from(OWNER_ADDRESS) + .to(FEE_MARKET_ADDRESS) + .typed(FeeMarketProxy) + .set_fee(fee_struct) + .returns(ReturnsHandledOrError::new()) + .run(); + + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -247,25 +238,13 @@ fn test_add_fee_wrong_params() { state.deploy_fee_market(); - state.add_fee( - WRONG_TOKEN_ID, - "Fixed", - Some(ExpectError(4, "Invalid token ID")), - ); - - state.add_fee(TOKEN_ID, "None", Some(ExpectError(4, "Invalid fee type"))); - - state.add_fee( - DIFFERENT_TOKEN_ID, - "Fixed", - Some(ExpectError(4, "Invalid fee")), - ); - - state.add_fee( - TOKEN_ID, - "AnyTokenWrong", - Some(ExpectError(4, "Invalid token ID")), - ); + state.add_fee(WRONG_TOKEN_ID, "Fixed", Some("Invalid token ID")); + + state.add_fee(TOKEN_ID, "None", Some("Invalid fee type")); + + state.add_fee(DIFFERENT_TOKEN_ID, "Fixed", Some("Invalid fee")); + + state.add_fee(TOKEN_ID, "AnyTokenWrong", Some("Invalid token ID")); } #[test] diff --git a/sovereign-forge/tests/sovereign_forge_unit_tests.rs b/sovereign-forge/tests/sovereign_forge_unit_tests.rs index 1ebea606..71d871a8 100644 --- a/sovereign-forge/tests/sovereign_forge_unit_tests.rs +++ b/sovereign-forge/tests/sovereign_forge_unit_tests.rs @@ -1,7 +1,7 @@ use multiversx_sc::types::{BigUint, ManagedBuffer, MultiValueEncoded, TestAddress, TestSCAddress}; use multiversx_sc_scenario::{ - api::StaticApi, imports::MxscPath, ExpectError, ReturnsHandledOrError, ScenarioTxRun, - ScenarioTxWhitebox, ScenarioWorld, + api::StaticApi, imports::MxscPath, ReturnsHandledOrError, ScenarioTxRun, ScenarioTxWhitebox, + ScenarioWorld, }; use proxies::{ chain_config_proxy::ChainConfigContractProxy, @@ -213,19 +213,19 @@ impl SovereignForgeTestState { } } - fn complete_setup_phase(&mut self, expected_result: Option) { - let transaction = self + fn complete_setup_phase(&mut self, error_message: Option<&str>) { + let response = self .world .tx() .from(OWNER_ADDRESS) .to(FORGE_ADDRESS) .typed(SovereignForgeProxy) - .complete_setup_phase(); + .complete_setup_phase() + .returns(ReturnsHandledOrError::new()) + .run(); - if let Some(error) = expected_result { - transaction.returns(error).run(); - } else { - transaction.run(); + if let Err(error) = response { + assert_eq!(error_message, Some(error.message.as_str())) } } @@ -370,10 +370,9 @@ fn complete_setup_phase_no_chain_config_registered() { let mut state = SovereignForgeTestState::new(); state.deploy_sovereign_forge(); - state.complete_setup_phase(Some(ExpectError( - 4, + state.complete_setup_phase(Some( "There is no Chain-Factory contract assigned for shard 1", - ))); + )); } #[test] @@ -382,10 +381,9 @@ fn complete_setup_phase_no_token_handler_registered() { state.deploy_sovereign_forge(); state.register_chain_factory(1, FACTORY_ADDRESS, None); - state.complete_setup_phase(Some(ExpectError( - 4, + state.complete_setup_phase(Some( "There is no Token-Handler contract assigned for shard 1", - ))); + )); } #[test]