Unit Test

use crate::{mock::*, *, Error}; use frame_support::BoundedVec; use frame_support::{assert_noop, assert_ok, traits::{OnFinalize, OnInitialize, fungible::InspectHold}}; use crate::{RegionCollections, LocationRegistration, ListedToken, NextNftId, OngoingObjectListing, NextAssetId, RegisteredNftDetails, TokenOwner, TokenBuyer, TokenListings, OngoingOffers, PropertyOwnerToken, PropertyOwner, PropertyLawyer, RealEstateLawyer, RefundToken}; use pallet_assets::FrozenBalance; use sp_runtime::TokenError;

macro_rules! bvec { ($( $x:tt )) => { vec![$( $x )].try_into().unwrap() } }

fn run_to_block(n: u64) { while System::block_number() < n { if System::block_number() > 0 { NftMarketplace::on_finalize(System::block_number()); System::on_finalize(System::block_number()); } System::reset_events(); System::set_block_number(System::block_number() + 1); System::on_initialize(System::block_number()); NftMarketplace::on_initialize(System::block_number()); } }

// create_new_region function #[test] fn create_new_region_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_eq!(Balances::free_balance(&([8; 32].into())), 200_000); assert_eq!(Balances::balance_on_hold(&HoldReason::RegionDepositReserve.into(), &([8; 32].into())), 200_000); assert_eq!(RegionCollections::::get(0).unwrap(), 0); assert_eq!(RegionCollections::::get(1).unwrap(), 1); }) }

#[test] fn create_new_region_does_not_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_noop!( NftMarketplace::create_new_region(RuntimeOrigin::signed([7; 32].into()), 30), TokenError::FundsUnavailable ); }) }

// create_new_location function #[test] fn create_new_location_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![9, 10])); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 1, bvec![9, 10])); assert_eq!( LocationRegistration::::get::<u32, BoundedVec<u8, Postcode>>( 0, bvec![10, 10] ), true ); assert_eq!( LocationRegistration::::get::<u32, BoundedVec<u8, Postcode>>(0, bvec![9, 10]), true ); assert_eq!( LocationRegistration::::get::<u32, BoundedVec<u8, Postcode>>(1, bvec![9, 10]), true ); assert_eq!( LocationRegistration::::get::<u32, BoundedVec<u8, Postcode>>( 1, bvec![10, 10] ), false ); assert_eq!( LocationRegistration::::get::<u32, BoundedVec<u8, Postcode>>(1, bvec![8, 10]), false ); }) }

#[test] fn create_new_location_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_noop!( NftMarketplace::create_new_location(RuntimeOrigin::root(), 1, bvec![10, 10]), Error::::RegionUnknown ); }) }

// register_lawyer function #[test] fn register_lawyer_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_eq!(RealEstateLawyer::::get::([0; 32].into()), false); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [0; 32].into())); assert_eq!(RealEstateLawyer::::get::([0; 32].into()), true); }) }

#[test] fn register_lawyer_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [0; 32].into())); assert_noop!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [0; 32].into()), Error::::LawyerAlreadyRegistered); }) }

// list_object function #[test] fn list_object_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 100_000); assert_eq!(ListedToken::::get(0).unwrap(), 100); assert_eq!(NextNftId::::get(0), 1); assert_eq!(NextNftId::::get(1), 0); assert_eq!(NextAssetId::::get(), 1); assert_eq!(OngoingObjectListing::::get(0).is_some(), true); assert_eq!(RegisteredNftDetails::::get(0, 0).is_some(), true); assert_eq!(Nfts::owner(0, 0).unwrap(), NftMarketplace::property_account_id(0)); }) }

#[test] fn list_object_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_noop!( NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] ), Error::::RegionUnknown ); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_noop!( NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] ), Error::::LocationUnknown ); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_noop!( NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 251, bvec![22, 22] ), Error::::TooManyToken ); assert_noop!( NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 0, bvec![22, 22] ), Error::::AmountCannotBeZero ); }) }

// buy_token function #[test] fn buy_token_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [6; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [14; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([14; 32].into()), 0, bvec![10, 10], 10_000_000_000_000_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([6; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_eq!(ListedToken::::get(0).unwrap(), 70); assert_eq!(TokenOwner::::get::<AccountId, u32>([6; 32].into(), 0).token_amount, 30); assert_eq!(TokenBuyer::::get(0).len(), 1); assert_eq!(Balances::free_balance(&([6; 32].into())), 5_000); assert_eq!(ForeignAssets::balance(1984, &[6; 32].into()), 1_500_000_000_000_000_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[6; 32].into()), Some(312_000_000_000_000_000)); }) }

#[test] fn buy_token_doesnt_work() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_noop!( NftMarketplace::buy_token(RuntimeOrigin::signed([0; 32].into()), 1, 1, crate::PaymentAssets::USDT), Error::::TokenNotForSale ); }) }

#[test] fn buy_token_doesnt_work_2() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_noop!( NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 101, crate::PaymentAssets::USDT), Error::::NotEnoughTokenAvailable ); run_to_block(32); assert_noop!( NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 30, crate::PaymentAssets::USDT), Error::::ListingExpired ); }) }

#[test] fn buy_token_fails_insufficient_balance() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [14; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [4; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([14; 32].into()), 0, bvec![10, 10], 10_000_000_000_000_000, 100, bvec![22, 22] )); assert_noop!( NftMarketplace::buy_token(RuntimeOrigin::signed([4; 32].into()), 0, 30, crate::PaymentAssets::USDT), Error::::NotEnoughFunds ); assert_eq!(ForeignAssets::balance(1984, &[4; 32].into()), 50); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[6; 32].into()), None); }) }

#[test] fn listing_and_selling_multiple_objects() { new_test_ext().execute_with(|| { assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [15; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([15; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([2; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 1, 80, crate::PaymentAssets::USDT)); assert_eq!(PropertyLawyer::::get(1).is_some(), false); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 1, 20, crate::PaymentAssets::USDT)); assert_eq!(PropertyLawyer::::get(1).is_some(), true); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 1, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 1, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 1, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 1, true, )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 2, 10, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 2, 10, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 2, 30, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([15; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 0, 33, crate::PaymentAssets::USDT)); assert_eq!(ListedToken::::get(0).unwrap(), 67); assert_eq!(ListedToken::::get(2).unwrap(), 50); assert_eq!(ListedToken::::get(3).unwrap(), 100); assert_eq!(TokenOwner::::get::<AccountId, u32>([2; 32].into(), 2).token_amount, 30); assert_eq!(TokenBuyer::::get(2).len(), 2); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 1).token_amount, 0); assert_eq!(TokenBuyer::::get(1).len(), 0); assert_eq!(PropertyOwnerToken::::get::<u32, AccountId>(1, [1; 32].into()), 100); }); }

// lawyer_claim_property function #[test] fn claim_property_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([10; 32].into())); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, Some([11; 32].into())); }) }

#[test] fn claim_property_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 99, crate::PaymentAssets::USDT)); assert_noop!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, ), Error::::InvalidIndex); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 1, crate::PaymentAssets::USDT)); assert_noop!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([9; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, ), Error::::NoPermission); assert_noop!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 11_000, ), Error::::CostsTooHigh); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([10; 32].into())); assert_noop!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, ), Error::::LawyerJobTaken); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, None); }) }

// remove_from_case function #[test] fn remove_from_case_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [12; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([10; 32].into())); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, Some([11; 32].into())); assert_ok!(NftMarketplace::remove_from_case( RuntimeOrigin::signed([10; 32].into()), 0, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, None); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, Some([11; 32].into())); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([12; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([12; 32].into())); }) }

#[test] fn remove_from_case_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_noop!(NftMarketplace::remove_from_case( RuntimeOrigin::signed([10; 32].into()), 0, ), Error::::NoPermission); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_noop!(NftMarketplace::remove_from_case( RuntimeOrigin::signed([10; 32].into()), 1, ), Error::::InvalidIndex); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_noop!(NftMarketplace::remove_from_case( RuntimeOrigin::signed([10; 32].into()), 0, ), Error::::AlreadyConfirmed); }) }

// lawyer_confirm_documents function #[test] fn distributes_nfts_and_funds() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 100_000); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 60, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 40, crate::PaymentAssets::USDC)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([10; 32].into())); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, Some([11; 32].into())); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_status, crate::DocumentStatus::Approved); assert_eq!(LocalAssets::balance(0, &NftMarketplace::property_account_id(0)), 0); assert_eq!(OngoingObjectListing::::get(0).unwrap().asset_id, 0); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 100); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 0); assert_eq!(PropertyLawyer::::get(1).is_some(), false); assert_eq!(ForeignAssets::balance(1984, &[0; 32].into()), 20_594_000); assert_eq!(ForeignAssets::balance(1337, &[0; 32].into()), 20_396_000); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::treasury_account_id()), 4_000); assert_eq!(ForeignAssets::balance(1337, &NftMarketplace::treasury_account_id()), 8_000); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 876_000); assert_eq!(ForeignAssets::balance(1984, &[10; 32].into()), 22_000); assert_eq!(ForeignAssets::balance(1984, &[11; 32].into()), 4_000); assert_eq!(ForeignAssets::balance(1337, &[1; 32].into()), 1_084_000); assert_eq!(ForeignAssets::balance(1337, &[10; 32].into()), 12_000); assert_eq!(ForeignAssets::balance(1337, &[11; 32].into()), 0); assert_eq!(RegisteredNftDetails::::get(0, 0).unwrap().spv_created, true); assert_eq!(ListedToken::::get(0), None); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 0); assert_eq!(TokenBuyer::::get(0).len(), 0); assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 100); }) }

#[test] fn distributes_nfts_and_funds_2() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); //assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 00, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDC)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([10; 32].into())); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, Some([11; 32].into())); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_status, crate::DocumentStatus::Approved); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_eq!(PropertyLawyer::::get(1).is_some(), false); assert_eq!(ForeignAssets::balance(1984, &[0; 32].into()), 20_000_000); assert_eq!(ForeignAssets::balance(1337, &[0; 32].into()), 20_990_000); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::treasury_account_id()), 0); assert_eq!(ForeignAssets::balance(1337, &NftMarketplace::treasury_account_id()), 12000); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_500_000); assert_eq!(ForeignAssets::balance(1984, &[10; 32].into()), 0); assert_eq!(ForeignAssets::balance(1984, &[11; 32].into()), 0); assert_eq!(ForeignAssets::balance(1337, &[1; 32].into()), 460_000); assert_eq!(ForeignAssets::balance(1337, &[10; 32].into()), 34_000); assert_eq!(ForeignAssets::balance(1337, &[11; 32].into()), 4_000); assert_eq!(RegisteredNftDetails::::get(0, 0).unwrap().spv_created, true); assert_eq!(ListedToken::::get(0), None); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 0); assert_eq!(TokenBuyer::::get(0).len(), 0); assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 100); }) }

#[test] fn reject_contract_and_refund() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 60, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 40, crate::PaymentAssets::USDC)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([10; 32].into())); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, Some([11; 32].into())); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, false, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_status, crate::DocumentStatus::Rejected); assert_eq!(pallet_nfts::Item::::get(0, 0).is_none(), false);

	assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[1; 32].into()), None);
	assert_eq!(ForeignAssetsFreezer::frozen_balance(1337, &[1; 32].into()), None);
	assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 876_000);
	assert_eq!(ForeignAssets::balance(1337, &[1; 32].into()), 1_084_000);
	assert_eq!(
		TokenOwner::<Test>::get::<AccountId, u32>([1; 32].into(), 0)
			.paid_funds
			.get(&crate::PaymentAssets::USDT)
			.unwrap(),
		&600000_u128
	);
	assert_eq!(
		TokenOwner::<Test>::get::<AccountId, u32>([1; 32].into(), 0)
			.paid_tax
			.get(&crate::PaymentAssets::USDT)
			.unwrap(),
		&18000_u128
	); 
	assert_ok!(NftMarketplace::lawyer_confirm_documents(
		RuntimeOrigin::signed([11; 32].into()),
		0,
		false,
	));
	assert_eq!(RefundToken::<Test>::get(0).unwrap().refund_amount, 100);
	assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 100);
	assert_eq!(TokenOwner::<Test>::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 100);
	assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 100_000);
	assert_ok!(NftMarketplace::withdraw_funds(RuntimeOrigin::signed([1; 32].into()), 0));
	assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 0);
	assert_eq!(RefundToken::<Test>::get(0).is_none(), true);
	assert_eq!(PropertyLawyer::<Test>::get(1).is_some(), false);
	assert_eq!(ForeignAssets::balance(1984, &[0; 32].into()), 20_000_000);
	assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::treasury_account_id()), 2000);
	assert_eq!(ForeignAssets::balance(1337, &NftMarketplace::treasury_account_id()), 4000); 
	assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::property_account_id(0)), 0);
	assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_494_000);
	assert_eq!(ForeignAssets::balance(1337, &[1; 32].into()), 1_496_000);
	assert_eq!(ForeignAssets::balance(1984, &[11; 32].into()), 4000);
	assert_eq!(ForeignAssets::balance(1337, &[11; 32].into()), 0);
	assert_eq!(RegisteredNftDetails::<Test>::get(0, 0).is_none(), true);
	assert_eq!(ListedToken::<Test>::get(0), None);
	assert_eq!(TokenOwner::<Test>::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 0);
	assert_eq!(TokenBuyer::<Test>::get(0).len(), 0);
	assert_eq!(pallet_nfts::Item::<Test>::get(0, 0).is_none(), true);
	assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::property_account_id(0)), 0);
	assert_eq!(Balances::free_balance(&(NftMarketplace::property_account_id(0))), 0);
	assert_eq!(Balances::balance(&(NftMarketplace::property_account_id(0))), 0);
})

}

#[test] fn reject_contract_and_refund_2() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [7; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([7; 32].into()), 0, 40, crate::PaymentAssets::USDC)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([10; 32].into())); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, Some([11; 32].into())); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, false, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_status, crate::DocumentStatus::Rejected); assert_eq!(pallet_nfts::Item::::get(0, 0).is_none(), false); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_188_000); assert_eq!(ForeignAssets::balance(1984, &[2; 32].into()), 838_000); assert_eq!(ForeignAssets::balance(1337, &[7; 32].into()), 84_000); assert_eq!(ForeignAssets::balance(1337, &[1; 32].into()), 1_500_000); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, false, )); assert_eq!(RefundToken::::get(0).unwrap().refund_amount, 100); assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 30); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 30); assert_ok!(NftMarketplace::withdraw_funds(RuntimeOrigin::signed([1; 32].into()), 0)); assert_eq!(RefundToken::::get(0).unwrap().refund_amount, 70); assert_eq!(ForeignAssets::balance(1984, &[0; 32].into()), 20_000_000); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::treasury_account_id()), 0); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_497_000); assert_eq!(ForeignAssets::balance(1984, &[11; 32].into()), 0); assert_eq!(ForeignAssets::balance(1337, &[11; 32].into()), 0); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 0); assert_eq!(TokenBuyer::::get(0).len(), 3); assert_eq!(pallet_nfts::Item::::get(0, 0).is_none(), false); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::property_account_id(0)), 315000); assert_ok!(NftMarketplace::withdraw_funds(RuntimeOrigin::signed([2; 32].into()), 0)); assert_ok!(NftMarketplace::withdraw_funds(RuntimeOrigin::signed([7; 32].into()), 0)); assert_eq!(pallet_nfts::Item::::get(0, 0).is_none(), true); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::property_account_id(0)), 0); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::treasury_account_id()), 2000); assert_eq!(ForeignAssets::balance(1337, &NftMarketplace::treasury_account_id()), 4000); assert_eq!(ForeignAssets::balance(1984, &[11; 32].into()), 4000); assert_eq!(RefundToken::::get(0).is_none(), true); assert_eq!(TokenBuyer::::get(0).len(), 0); }) }

#[test] fn second_attempt_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([10; 32].into())); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, Some([11; 32].into())); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_status, crate::DocumentStatus::Approved); assert_eq!(pallet_nfts::Item::::get(0, 0).is_none(), false); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, false, )); assert_eq!(PropertyLawyer::::get(0).unwrap().second_attempt, true); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, false, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_status, crate::DocumentStatus::Rejected); assert_eq!(pallet_nfts::Item::::get(0, 0).is_none(), false); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::withdraw_funds(RuntimeOrigin::signed([1; 32].into()), 0)); assert_eq!(ForeignAssets::balance(1984, &[0; 32].into()), 20_000_000); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::treasury_account_id()), 6000); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_490_000); assert_eq!(ForeignAssets::balance(1984, &[11; 32].into()), 4_000); assert_eq!(RegisteredNftDetails::::get(0, 0).is_none(), true); assert_eq!(ListedToken::::get(0), None); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 0); assert_eq!(TokenBuyer::::get(0).len(), 0); assert_eq!(pallet_nfts::Item::::get(0, 0).is_none(), true); }) }

#[test] fn lawyer_confirm_documents_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [12; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().real_estate_developer_lawyer, Some([10; 32].into())); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_eq!(PropertyLawyer::::get(0).unwrap().spv_lawyer, Some([11; 32].into())); assert_noop!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 1, false, ), Error::::InvalidIndex); assert_noop!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([12; 32].into()), 0, false, ), Error::::NoPermission); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, false, )); assert_noop!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, ), Error::::AlreadyConfirmed); }) }

// list_token function #[test] fn relist_a_nft() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_eq!(RegisteredNftDetails::::get(0, 0).unwrap().spv_created, true); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 1000, 1 )); assert_eq!(TokenListings::::get(1).is_some(), true); assert_eq!(TokenListings::::get(1).unwrap().item_id, 0); assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 100); assert_eq!(LocalAssetsFreezer::frozen_balance(0, &[1; 32].into()), Some(1)); }) }

#[test] fn relist_nfts_not_created_with_marketplace_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(Nfts::create( RuntimeOrigin::signed([0; 32].into()), sp_runtime::MultiAddress::Id([0; 32].into()), Default::default() )); assert_ok!(Nfts::mint( RuntimeOrigin::signed([0; 32].into()), 0, 0, sp_runtime::MultiAddress::Id([0; 32].into()), None )); assert_noop!( NftMarketplace::relist_token(RuntimeOrigin::signed([0; 32].into()), 0, 0, 1000, 1), Error::::RegionUnknown ); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_noop!( NftMarketplace::relist_token(RuntimeOrigin::signed([0; 32].into()), 0, 0, 1000, 1), Error::::NftNotFound ); }) }

#[test] fn relist_a_nft_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_eq!(RegisteredNftDetails::::get(0, 0).unwrap().spv_created, true); assert_noop!( NftMarketplace::relist_token(RuntimeOrigin::signed([0; 32].into()), 0, 0, 1000, 1), Error::::NotEnoughFunds ); }) }

// buy_relisted_token function #[test] fn buy_relisted_token_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [3; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_eq!(ForeignAssets::balance(1984, &([0; 32].into())), 20990000); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::treasury_account_id()), 12000); assert_eq!(ForeignAssets::balance(1984, &([1; 32].into())), 460_000); assert_eq!(RegisteredNftDetails::::get(0, 0).unwrap().spv_created, true); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 1000, 3 )); assert_ok!(NftMarketplace::buy_relisted_token(RuntimeOrigin::signed([3; 32].into()), 1, 2, crate::PaymentAssets::USDT)); assert_eq!(ForeignAssets::balance(1984, &([3; 32].into())), 3_000); assert_eq!(LocalAssets::balance(0, &[3; 32].into()), 2); assert_eq!(TokenListings::::get(1).is_some(), true); assert_ok!(NftMarketplace::buy_relisted_token(RuntimeOrigin::signed([3; 32].into()), 1, 1, crate::PaymentAssets::USDT)); assert_eq!(ForeignAssets::balance(1984, &([3; 32].into())), 2_000); assert_eq!(TokenListings::::get(1).is_some(), false); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 500, 1 )); assert_ok!(NftMarketplace::buy_relisted_token(RuntimeOrigin::signed([3; 32].into()), 2, 1, crate::PaymentAssets::USDT)); assert_eq!(TokenListings::::get(0).is_some(), false); assert_eq!(PropertyOwner::::get(0).len(), 2); assert_eq!(PropertyOwnerToken::::get::<u32, AccountId>(0, [1; 32].into()), 96); assert_eq!(PropertyOwnerToken::::get::<u32, AccountId>(0, [3; 32].into()), 4); assert_eq!(ForeignAssets::balance(1984, &([1; 32].into())), 463_465); assert_eq!(ForeignAssets::balance(1984, &([3; 32].into())), 1_500); assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 96); assert_eq!(LocalAssets::balance(0, &[3; 32].into()), 4); }) }

#[test] fn buy_relisted_token_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [3; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_eq!(ForeignAssets::balance(1984, &([0; 32].into())), 20990000); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::treasury_account_id()), 12_000); assert_eq!(ForeignAssets::balance(1984, &([1; 32].into())), 460_000); assert_eq!(RegisteredNftDetails::::get(0, 0).unwrap().spv_created, true); assert_noop!( NftMarketplace::buy_relisted_token(RuntimeOrigin::signed([3; 32].into()), 1, 1, crate::PaymentAssets::USDT), Error::::TokenNotForSale ); }) }

// make_offer function #[test] fn make_offer_works() { new_test_ext().execute_with(|| { assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 500, 1 )); assert_ok!(NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 2000, 1, crate::PaymentAssets::USDT)); assert_eq!(TokenListings::::get(1).is_some(), true); assert_eq!(OngoingOffers::::get::<u32, AccountId>(1, [2; 32].into()).is_some(), true); assert_eq!(ForeignAssets::balance(1984, &([2; 32].into())), 1_150_000); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::property_account_id(0)), 0); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[2; 32].into()), Some(2000)); }) }

#[test] fn make_offer_fails() { new_test_ext().execute_with(|| { assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [3; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_noop!( NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 200, 1, crate::PaymentAssets::USDT), Error::::TokenNotForSale ); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 500, 1 )); assert_noop!( NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 200, 2, crate::PaymentAssets::USDT), Error::::NotEnoughTokenAvailable ); assert_ok!(NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 200, 1, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::make_offer(RuntimeOrigin::signed([3; 32].into()), 1, 300, 1, crate::PaymentAssets::USDT)); assert_noop!( NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 400, 1, crate::PaymentAssets::USDT), Error::::OnlyOneOfferPerUser ); assert_eq!(OngoingOffers::::get::<u32, AccountId>(1, [2; 32].into()).unwrap().token_price, 200); assert_eq!(OngoingOffers::::get::<u32, AccountId>(1, [3; 32].into()).unwrap().token_price, 300); }) }

// handle_offer function #[test] fn handle_offer_works() { new_test_ext().execute_with(|| { assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [3; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 5000, 20 )); assert_ok!(NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 200, 1, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::make_offer(RuntimeOrigin::signed([3; 32].into()), 1, 150, 1, crate::PaymentAssets::USDC)); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[2; 32].into()), Some(200)); assert_eq!(ForeignAssetsFreezer::frozen_balance(1337, &[3; 32].into()), Some(150)); assert_ok!(NftMarketplace::handle_offer( RuntimeOrigin::signed([1; 32].into()), 1, [2; 32].into(), crate::Offer::Reject )); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[2; 32].into()), None); assert_ok!(NftMarketplace::cancel_offer(RuntimeOrigin::signed([3; 32].into()), 1)); assert_eq!(ForeignAssets::balance(1984, &([2; 32].into())), 1_150_000); assert_eq!(TokenListings::::get(1).is_some(), true); assert_eq!(OngoingOffers::::get::<u32, AccountId>(1, [2; 32].into()).is_none(), true); assert_ok!(NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 2000, 10, crate::PaymentAssets::USDT)); assert_eq!(ForeignAssets::balance(1984, &([2; 32].into())), 1_150_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[2; 32].into()), Some(20000)); assert_ok!(NftMarketplace::handle_offer( RuntimeOrigin::signed([1; 32].into()), 1, [2; 32].into(), crate::Offer::Accept )); assert_eq!(TokenListings::::get(1).unwrap().amount, 10); assert_eq!(OngoingOffers::::get::<u32, AccountId>(1, [2; 32].into()).is_none(), true); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::property_account_id(1)), 0); assert_eq!(LocalAssets::balance(0, &([1; 32].into())), 90); assert_eq!(LocalAssets::balance(0, &([2; 32].into())), 10); assert_eq!(LocalAssetsFreezer::frozen_balance(0, &[1; 32].into()), Some(10)); assert_eq!(ForeignAssets::balance(1984, &([1; 32].into())), 479_800); assert_eq!(ForeignAssets::balance(1984, &([2; 32].into())), 1_130_000); }) }

#[test] fn handle_offer_fails() { new_test_ext().execute_with(|| { assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_noop!( NftMarketplace::handle_offer( RuntimeOrigin::signed([1; 32].into()), 1, [2; 32].into(), crate::Offer::Reject ), Error::::TokenNotForSale ); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 5000, 2 )); assert_noop!( NftMarketplace::handle_offer( RuntimeOrigin::signed([1; 32].into()), 1, [2; 32].into(), crate::Offer::Reject ), Error::::InvalidIndex ); assert_ok!(NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 200, 1, crate::PaymentAssets::USDT)); assert_noop!( NftMarketplace::handle_offer( RuntimeOrigin::signed([2; 32].into()), 1, [2; 32].into(), crate::Offer::Accept ), Error::::NoPermission ); }) }

// cancel_offer function #[test] fn cancel_offer_works() { new_test_ext().execute_with(|| { assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 500, 1 )); assert_ok!(NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 2000, 1, crate::PaymentAssets::USDT)); assert_eq!(TokenListings::::get(1).is_some(), true); assert_eq!(OngoingOffers::::get::<u32, AccountId>(1, [2; 32].into()).is_some(), true); assert_eq!(ForeignAssets::balance(1984, &([2; 32].into())), 1_150_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[2; 32].into()), Some(2000)); assert_ok!(NftMarketplace::cancel_offer(RuntimeOrigin::signed([2; 32].into()), 1)); assert_eq!(TokenListings::::get(1).is_some(), true); assert_eq!(OngoingOffers::::get::<u32, AccountId>(1, [2; 32].into()).is_some(), false); assert_eq!(ForeignAssets::balance(1984, &([2; 32].into())), 1_150_000); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::property_account_id(1)), 0); }) }

#[test] fn cancel_offer_fails() { new_test_ext().execute_with(|| { assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 500, 1 )); assert_noop!( NftMarketplace::cancel_offer(RuntimeOrigin::signed([2; 32].into()), 1), Error::::InvalidIndex ); assert_ok!(NftMarketplace::make_offer(RuntimeOrigin::signed([2; 32].into()), 1, 2000, 1, crate::PaymentAssets::USDT)); assert_eq!(TokenListings::::get(1).is_some(), true); assert_eq!(OngoingOffers::::get::<u32, AccountId>(1, [2; 32].into()).is_some(), true); assert_eq!(ForeignAssets::balance(1984, &([2; 32].into())), 1_150_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[2; 32].into()), Some(2000)); assert_noop!( NftMarketplace::cancel_offer(RuntimeOrigin::signed([1; 32].into()), 1), Error::::InvalidIndex ); }) }

// upgrade_listing function #[test] fn upgrade_price_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 1000, 1 )); assert_ok!(NftMarketplace::upgrade_listing(RuntimeOrigin::signed([1; 32].into()), 1, 300)); assert_eq!(TokenListings::::get(1).unwrap().token_price, 300); }) }

#[test] fn upgrade_price_fails_if_not_owner() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [4; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 1000, 1 )); assert_noop!( NftMarketplace::upgrade_listing(RuntimeOrigin::signed([4; 32].into()), 1, 300), Error::::NoPermission ); }) }

// upgrade_object function #[test] fn upgrade_object_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::upgrade_object(RuntimeOrigin::signed([0; 32].into()), 0, 30000)); assert_eq!(OngoingObjectListing::::get(0).unwrap().token_price, 30000); }) }

#[test] fn upgrade_object_and_distribute_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 50, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::upgrade_object( RuntimeOrigin::signed([0; 32].into()), 0, 20_000 )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 0, 50, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_eq!(ForeignAssets::balance(1984, &([0; 32].into())), 21485000); assert_eq!(ForeignAssets::balance(1984, &NftMarketplace::treasury_account_id()), 22000); assert_eq!(ForeignAssets::balance(1984, &([1; 32].into())), 980_000); assert_eq!(ForeignAssets::balance(1984, &([2; 32].into())), 110_000);

	assert_eq!(RegisteredNftDetails::<Test>::get(0, 0).unwrap().spv_created, true);
	assert_eq!(ListedToken::<Test>::get(0), None);
})

}

#[test] fn upgrade_single_nft_from_listed_object_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_noop!( NftMarketplace::upgrade_listing(RuntimeOrigin::signed([0; 32].into()), 0, 300), Error::::TokenNotForSale ); }) }

#[test] fn upgrade_object_for_relisted_nft_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([0; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([0; 32].into()), 0, 0, 1000, 1 )); assert_noop!( NftMarketplace::upgrade_object(RuntimeOrigin::signed([0; 32].into()), 1, 300), Error::::TokenNotForSale ); }) }

#[test] fn upgrade_unknown_collection_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_noop!( NftMarketplace::upgrade_object(RuntimeOrigin::signed([0; 32].into()), 0, 300), Error::::TokenNotForSale ); }) }

// delist_token function #[test] fn delist_single_token_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 1000, 1 )); assert_ok!(NftMarketplace::delist_token(RuntimeOrigin::signed([1; 32].into()), 1)); assert_eq!(TokenListings::::get(0), None); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 1000, 3 )); assert_ok!(NftMarketplace::buy_relisted_token(RuntimeOrigin::signed([2; 32].into()), 2, 2, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::delist_token(RuntimeOrigin::signed([1; 32].into()), 2)); assert_eq!(LocalAssets::balance(0, &[2; 32].into()), 2); assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 98); }) }

#[test] fn delist_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [4; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 0, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 0, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 0, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 0, true, )); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 0, 0, 1000, 1 )); assert_noop!( NftMarketplace::delist_token(RuntimeOrigin::signed([4; 32].into()), 1), Error::::NoPermission ); assert_noop!( NftMarketplace::delist_token(RuntimeOrigin::signed([1; 32].into()), 2), Error::::TokenNotForSale ); }) }

#[test] fn listing_objects_in_different_regions() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 1, bvec![10, 10])); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 2, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [10; 32].into())); assert_ok!(NftMarketplace::register_lawyer(RuntimeOrigin::root(), [11; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 1, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 2, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 1, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 1, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 1, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 1, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 1, true, )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 2, 100, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([10; 32].into()), 2, crate::LegalProperty::RealEstateDeveloperSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_claim_property( RuntimeOrigin::signed([11; 32].into()), 2, crate::LegalProperty::SpvSide, 4_000, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([10; 32].into()), 2, true, )); assert_ok!(NftMarketplace::lawyer_confirm_documents( RuntimeOrigin::signed([11; 32].into()), 2, true, )); assert_eq!(RegisteredNftDetails::::get(1, 0).unwrap().spv_created, true); assert_eq!(RegisteredNftDetails::::get(2, 0).unwrap().spv_created, true); assert_ok!(NftMarketplace::relist_token( RuntimeOrigin::signed([1; 32].into()), 1, 0, 1000, 100 )); assert_ok!(NftMarketplace::buy_relisted_token( RuntimeOrigin::signed([2; 32].into()), 3, 100, crate::PaymentAssets::USDT )); assert_eq!(LocalAssets::balance(1, &[2; 32].into()), 100); assert_eq!(LocalAssets::balance(2, &[2; 32].into()), 100); }) }

#[test] fn cancel_buy_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_eq!(ListedToken::::get(0).unwrap(), 40); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 30); assert_eq!(TokenOwner::::get::<AccountId, u32>([2; 32].into(), 0).token_amount, 30); assert_eq!(TokenBuyer::::get(0).len(), 2); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_500_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[1; 32].into()), Some(312_000)); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[2; 32].into()), Some(312_000)); assert_ok!(NftMarketplace::cancel_buy(RuntimeOrigin::signed([1; 32].into()), 0)); assert_eq!(ListedToken::::get(0).unwrap(), 70); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[1; 32].into()), None); assert_eq!(TokenBuyer::::get(0).len(), 1); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_500_000); }) }

#[test] fn cancel_buy_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_noop!( NftMarketplace::cancel_buy(RuntimeOrigin::signed([1; 32].into()), 0), Error::::InvalidIndex ); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_noop!( NftMarketplace::cancel_buy(RuntimeOrigin::signed([3; 32].into()), 0), Error::::NoTokenBought ); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 0, 40, crate::PaymentAssets::USDT)); assert_noop!( NftMarketplace::cancel_buy(RuntimeOrigin::signed([1; 32].into()), 0), Error::::PropertyAlreadySold ); }) }

#[test] fn cancel_buy_fails_2() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 0, 40, crate::PaymentAssets::USDT)); run_to_block(40); assert_noop!( NftMarketplace::cancel_buy(RuntimeOrigin::signed([1; 32].into()), 0), Error::::ListingExpired ); }) }

#[test] fn refund_expired_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_eq!(ListedToken::::get(0).unwrap(), 70); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 30); assert_eq!(TokenBuyer::::get(0).len(), 1); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_500_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[1; 32].into()), Some(312_000)); run_to_block(40); assert_ok!(NftMarketplace::refund_expired(RuntimeOrigin::signed([1; 32].into()), 0)); assert_eq!(ListedToken::::get(0), None); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 0); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_500_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[1; 32].into()), None); }) }

#[test] fn refund_expired_works_2() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [3; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 1_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 30, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([2; 32].into()), 0, 20, crate::PaymentAssets::USDT)); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([3; 32].into()), 0, 4, crate::PaymentAssets::USDT)); assert_eq!(ListedToken::::get(0).unwrap(), 46); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 30); assert_eq!(TokenBuyer::::get(0).len(), 3); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_500_000); assert_eq!(ForeignAssets::balance(1984, &[2; 32].into()), 1_150_000); assert_eq!(ForeignAssets::balance(1984, &[3; 32].into()), 5_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[1; 32].into()), Some(31_200)); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[2; 32].into()), Some(20_800)); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[3; 32].into()), Some(4_160)); run_to_block(40); assert_ok!(NftMarketplace::refund_expired(RuntimeOrigin::signed([1; 32].into()), 0)); assert_eq!(ListedToken::::get(0), Some(76)); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 0); assert_eq!(TokenOwner::::get::<AccountId, u32>([3; 32].into(), 0).token_amount, 4); assert_eq!(TokenBuyer::::get(0).len(), 2); assert_eq!(ForeignAssets::balance(1984, &[1; 32].into()), 1_500_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[1; 32].into()), None); assert_ok!(NftMarketplace::refund_expired(RuntimeOrigin::signed([2; 32].into()), 0)); assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 10_000); assert_eq!(Balances::free_balance(&(NftMarketplace::property_account_id(0))), 99); assert_eq!(Balances::balance(&(NftMarketplace::property_account_id(0))), 99); assert_ok!(NftMarketplace::refund_expired(RuntimeOrigin::signed([3; 32].into()), 0)); assert_eq!(Balances::free_balance(&(NftMarketplace::property_account_id(0))), 0); assert_eq!(Balances::balance(&(NftMarketplace::property_account_id(0))), 0); assert_eq!(TokenOwner::::get::<AccountId, u32>([1; 32].into(), 0).token_amount, 0); assert_eq!(TokenBuyer::::get(0).len(), 0); assert_eq!(ForeignAssets::balance(1984, &[3; 32].into()), 5_000); assert_eq!(ForeignAssetsFreezer::frozen_balance(1984, &[3; 32].into()), None); assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 0); }) }

#[test] fn refund_expired_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_noop!( NftMarketplace::refund_expired(RuntimeOrigin::signed([1; 32].into()), 0), Error::::InvalidIndex ); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_noop!( NftMarketplace::refund_expired(RuntimeOrigin::signed([1; 32].into()), 0), Error::::ListingNotExpired ); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); run_to_block(40); assert_noop!( NftMarketplace::refund_expired(RuntimeOrigin::signed([1; 32].into()), 0), Error::::PropertyAlreadySold ); }) }

#[test] fn refund_expired_fails_2() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 99, crate::PaymentAssets::USDT)); run_to_block(40); assert_noop!( NftMarketplace::refund_expired(RuntimeOrigin::signed([2; 32].into()), 0), Error::::NoTokenBought ); }) }

#[test] fn send_property_token_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [3; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_eq!(PropertyOwnerToken::::get::<u32, AccountId>(0, [1; 32].into()), 100); assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 100); assert_eq!(PropertyOwner::::get(0).len(), 1); assert_ok!(NftMarketplace::send_property_token( RuntimeOrigin::signed([1; 32].into()), 0, [2; 32].into(), 20 )); assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 80); assert_eq!(PropertyOwner::::get(0).len(), 2); assert_eq!(PropertyOwnerToken::::get::<u32, AccountId>(0, [1; 32].into()), 80); assert_eq!(LocalAssets::balance(0, &[2; 32].into()), 20); assert_eq!(PropertyOwnerToken::::get::<u32, AccountId>(0, [2; 32].into()), 20); assert_ok!(NftMarketplace::send_property_token( RuntimeOrigin::signed([1; 32].into()), 0, [3; 32].into(), 80 )); assert_ok!(NftMarketplace::send_property_token( RuntimeOrigin::signed([2; 32].into()), 0, [3; 32].into(), 20 )); assert_eq!(LocalAssets::balance(0, &[1; 32].into()), 0); assert_eq!(PropertyOwner::::get(0).len(), 1); assert_eq!(LocalAssets::balance(0, &[2; 32].into()), 0); assert_eq!(PropertyOwnerToken::::get::<u32, AccountId>(0, [2; 32].into()), 0); assert_eq!(LocalAssets::balance(0, &[3; 32].into()), 100); assert_eq!(PropertyOwnerToken::::get::<u32, AccountId>(0, [3; 32].into()), 100); }) }

#[test] fn send_property_token_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_noop!(NftMarketplace::send_property_token( RuntimeOrigin::signed([1; 32].into()), 0, [2; 32].into(), 20 ), Error::::UserNotWhitelisted); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); assert_noop!(NftMarketplace::send_property_token( RuntimeOrigin::signed([1; 32].into()), 0, [2; 32].into(), 20 ), Error::::UserNotWhitelisted); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [2; 32].into())); assert_noop!(NftMarketplace::send_property_token( RuntimeOrigin::signed([2; 32].into()), 1, [1; 32].into(), 20 ), Error::::NotEnoughToken); }) }

#[test] fn reclaim_unsold_works() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 100_000); run_to_block(40); assert_ok!(NftMarketplace::reclaim_unsold(RuntimeOrigin::signed([0; 32].into()), 0)); assert_eq!(ListedToken::::get(0), None); assert_eq!(pallet_nfts::Item::::get(0, 0).is_none(), true); assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 0); }) }

#[test] fn reclaim_unsold_fails() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 100_000); run_to_block(20); assert_noop!(NftMarketplace::reclaim_unsold(RuntimeOrigin::signed([0; 32].into()), 0), Error::::ListingNotExpired); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 10, crate::PaymentAssets::USDT)); assert_noop!(NftMarketplace::reclaim_unsold(RuntimeOrigin::signed([0; 32].into()), 1), Error::::InvalidIndex); run_to_block(40); assert_noop!(NftMarketplace::reclaim_unsold(RuntimeOrigin::signed([0; 32].into()), 0), Error::::TokenNotReturned); }) }

#[test] fn reclaim_unsold_fails_2() { new_test_ext().execute_with(|| { System::set_block_number(1); assert_ok!(NftMarketplace::create_new_region(RuntimeOrigin::signed([8; 32].into()), 30)); assert_ok!(NftMarketplace::create_new_location(RuntimeOrigin::root(), 0, bvec![10, 10])); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [0; 32].into())); assert_ok!(XcavateWhitelist::add_to_whitelist(RuntimeOrigin::root(), [1; 32].into())); assert_ok!(NftMarketplace::list_object( RuntimeOrigin::signed([0; 32].into()), 0, bvec![10, 10], 10_000, 100, bvec![22, 22] )); assert_eq!(Balances::balance_on_hold(&HoldReason::ListingDepositReserve.into(), &([0; 32].into())), 100_000); run_to_block(20); assert_ok!(NftMarketplace::buy_token(RuntimeOrigin::signed([1; 32].into()), 0, 100, crate::PaymentAssets::USDT)); run_to_block(40); assert_noop!(NftMarketplace::reclaim_unsold(RuntimeOrigin::signed([0; 32].into()), 0), Error::::PropertyAlreadySold); }) }