From 6c1cc7ee4bff850100cb8e34f233aed36e68c22f Mon Sep 17 00:00:00 2001 From: kozyrevdev <73348153+kozyrevdev@users.noreply.github.com> Date: Thu, 25 Nov 2021 18:48:30 +0000 Subject: [PATCH] Merge pull request #242 from UniqueNetwork/feature/fix_unit_tests Fix unit tests --- --- a/Cargo.lock +++ b/Cargo.lock @@ -4939,216 +4939,6 @@ ] [[package]] -name = "nft" -version = "0.9.12" -dependencies = [ - "cumulus-client-cli", - "cumulus-client-collator", - "cumulus-client-consensus-aura", - "cumulus-client-consensus-common", - "cumulus-client-network", - "cumulus-client-service", - "cumulus-primitives-core", - "cumulus-primitives-parachain-inherent", - "fc-consensus", - "fc-db", - "fc-mapping-sync", - "fc-rpc", - "fc-rpc-core", - "flexi_logger", - "fp-rpc", - "frame-benchmarking", - "frame-benchmarking-cli", - "futures 0.3.17", - "jsonrpc-core", - "jsonrpc-pubsub", - "log", - "nft-data-structs", - "nft-rpc", - "nft-runtime", - "pallet-ethereum", - "pallet-transaction-payment-rpc", - "parity-scale-codec", - "parking_lot 0.11.2", - "polkadot-cli", - "polkadot-parachain", - "polkadot-primitives", - "polkadot-service", - "polkadot-test-service", - "sc-basic-authorship", - "sc-chain-spec", - "sc-cli", - "sc-client-api", - "sc-consensus", - "sc-consensus-aura", - "sc-executor", - "sc-finality-grandpa", - "sc-keystore", - "sc-network", - "sc-rpc", - "sc-rpc-api", - "sc-service", - "sc-telemetry", - "sc-tracing", - "sc-transaction-pool", - "serde", - "serde_json", - "sp-api", - "sp-block-builder", - "sp-blockchain", - "sp-consensus", - "sp-consensus-aura", - "sp-core", - "sp-finality-grandpa", - "sp-inherents", - "sp-keystore", - "sp-offchain", - "sp-runtime", - "sp-session", - "sp-timestamp", - "sp-transaction-pool", - "sp-trie", - "structopt", - "substrate-build-script-utils", - "substrate-frame-rpc-system", - "substrate-prometheus-endpoint", -] - -[[package]] -name = "nft-data-structs" -version = "0.9.0" -dependencies = [ - "derivative", - "frame-support", - "frame-system", - "parity-scale-codec", - "scale-info", - "serde", - "sp-core", - "sp-runtime", - "sp-std", -] - -[[package]] -name = "nft-rpc" -version = "3.3.1" -dependencies = [ - "fc-db", - "fc-mapping-sync", - "fc-rpc", - "fc-rpc-core", - "fp-rpc", - "futures 0.3.17", - "jsonrpc-core", - "jsonrpc-pubsub", - "nft-runtime", - "pallet-ethereum", - "pallet-nft", - "pallet-transaction-payment-rpc", - "pallet-transaction-payment-rpc-runtime-api", - "sc-client-api", - "sc-consensus-aura", - "sc-consensus-epochs", - "sc-finality-grandpa", - "sc-finality-grandpa-rpc", - "sc-keystore", - "sc-network", - "sc-rpc", - "sc-rpc-api", - "sc-service", - "sc-transaction-pool", - "sp-api", - "sp-block-builder", - "sp-blockchain", - "sp-consensus", - "sp-consensus-aura", - "sp-core", - "sp-offchain", - "sp-runtime", - "sp-session", - "sp-storage", - "sp-transaction-pool", - "substrate-frame-rpc-system", - "tokio 0.2.25", - "uc-rpc", - "up-rpc", -] - -[[package]] -name = "nft-runtime" -version = "0.9.12" -dependencies = [ - "cumulus-pallet-aura-ext", - "cumulus-pallet-dmp-queue", - "cumulus-pallet-parachain-system", - "cumulus-pallet-xcm", - "cumulus-pallet-xcmp-queue", - "cumulus-primitives-core", - "cumulus-primitives-timestamp", - "cumulus-primitives-utility", - "derivative", - "fp-rpc", - "fp-self-contained", - "frame-benchmarking", - "frame-executive", - "frame-support", - "frame-system", - "frame-system-benchmarking", - "frame-system-rpc-runtime-api", - "hex-literal", - "nft-data-structs", - "orml-vesting", - "pallet-aura", - "pallet-balances", - "pallet-common", - "pallet-ethereum", - "pallet-evm", - "pallet-evm-coder-substrate", - "pallet-evm-contract-helpers", - "pallet-evm-migration", - "pallet-evm-transaction-payment", - "pallet-fungible", - "pallet-inflation", - "pallet-nft", - "pallet-nonfungible", - "pallet-randomness-collective-flip", - "pallet-refungible", - "pallet-sudo", - "pallet-template-transaction-payment", - "pallet-timestamp", - "pallet-transaction-payment", - "pallet-transaction-payment-rpc-runtime-api", - "pallet-treasury", - "pallet-unq-scheduler", - "pallet-xcm", - "parachain-info", - "parity-scale-codec", - "polkadot-parachain", - "scale-info", - "serde", - "smallvec", - "sp-api", - "sp-arithmetic", - "sp-block-builder", - "sp-consensus-aura", - "sp-core", - "sp-inherents", - "sp-io", - "sp-offchain", - "sp-runtime", - "sp-session", - "sp-std", - "sp-transaction-pool", - "sp-version", - "substrate-wasm-builder", - "up-evm-mapping", - "up-rpc", - "xcm", - "xcm-builder", - "xcm-executor", -] - -[[package]] name = "nodrop" version = "0.1.14" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -5581,7 +5371,6 @@ "evm-coder", "frame-support", "frame-system", - "nft-data-structs", "pallet-evm", "pallet-evm-coder-substrate", "parity-scale-codec", @@ -5590,6 +5379,7 @@ "sp-core", "sp-runtime", "sp-std", + "up-data-structs", "up-evm-mapping", ] @@ -5853,7 +5643,6 @@ "frame-benchmarking", "frame-support", "frame-system", - "nft-data-structs", "pallet-common", "pallet-evm-coder-substrate", "parity-scale-codec", @@ -5861,6 +5650,7 @@ "sp-core", "sp-runtime", "sp-std", + "up-data-structs", ] [[package]] @@ -5956,7 +5746,7 @@ [[package]] name = "pallet-inflation" -version = "3.0.0" +version = "0.1.0" dependencies = [ "frame-benchmarking", "frame-support", @@ -6057,43 +5847,6 @@ ] [[package]] -name = "pallet-nft" -version = "3.0.0" -dependencies = [ - "ethereum 0.9.0 (git+https://github.com/purestake/ethereum?branch=joshy-scale-info)", - "evm-coder", - "fp-evm", - "frame-benchmarking", - "frame-support", - "frame-system", - "hex-literal", - "nft-data-structs", - "pallet-balances", - "pallet-common", - "pallet-ethereum", - "pallet-evm", - "pallet-evm-coder-substrate", - "pallet-fungible", - "pallet-nonfungible", - "pallet-randomness-collective-flip", - "pallet-refungible", - "pallet-timestamp", - "pallet-transaction-payment", - "parity-scale-codec", - "primitive-types 0.10.1", - "rlp", - "scale-info", - "serde", - "sp-api", - "sp-core", - "sp-io", - "sp-runtime", - "sp-std", - "up-evm-mapping", - "up-sponsorship", -] - -[[package]] name = "pallet-nicks" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.12#d76f39995315ec36980908e4b99709bd14927044" @@ -6116,7 +5869,6 @@ "frame-benchmarking", "frame-support", "frame-system", - "nft-data-structs", "pallet-common", "pallet-evm-coder-substrate", "parity-scale-codec", @@ -6124,6 +5876,7 @@ "sp-core", "sp-runtime", "sp-std", + "up-data-structs", ] [[package]] @@ -6216,13 +5969,13 @@ "frame-benchmarking", "frame-support", "frame-system", - "nft-data-structs", "pallet-common", "parity-scale-codec", "scale-info", "sp-core", "sp-runtime", "sp-std", + "up-data-structs", ] [[package]] @@ -6469,8 +6222,45 @@ ] [[package]] +name = "pallet-unique" +version = "0.1.0" +dependencies = [ + "ethereum 0.9.0 (git+https://github.com/purestake/ethereum?branch=joshy-scale-info)", + "evm-coder", + "fp-evm", + "frame-benchmarking", + "frame-support", + "frame-system", + "hex-literal", + "pallet-balances", + "pallet-common", + "pallet-ethereum", + "pallet-evm", + "pallet-evm-coder-substrate", + "pallet-fungible", + "pallet-nonfungible", + "pallet-randomness-collective-flip", + "pallet-refungible", + "pallet-timestamp", + "pallet-transaction-payment", + "parity-scale-codec", + "primitive-types 0.10.1", + "rlp", + "scale-info", + "serde", + "sp-api", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", + "up-data-structs", + "up-evm-mapping", + "up-sponsorship", +] + +[[package]] name = "pallet-unq-scheduler" -version = "3.0.0" +version = "0.1.0" dependencies = [ "frame-benchmarking", "frame-support", @@ -11714,7 +11504,6 @@ "jsonrpc-core", "jsonrpc-core-client", "jsonrpc-derive", - "nft-data-structs", "pallet-common", "parity-scale-codec", "sp-api", @@ -11722,6 +11511,7 @@ "sp-core", "sp-rpc", "sp-runtime", + "up-data-structs", "up-rpc", ] @@ -11786,6 +11576,201 @@ checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" [[package]] +name = "unique-node" +version = "0.9.12" +dependencies = [ + "cumulus-client-cli", + "cumulus-client-collator", + "cumulus-client-consensus-aura", + "cumulus-client-consensus-common", + "cumulus-client-network", + "cumulus-client-service", + "cumulus-primitives-core", + "cumulus-primitives-parachain-inherent", + "fc-consensus", + "fc-db", + "fc-mapping-sync", + "fc-rpc", + "fc-rpc-core", + "flexi_logger", + "fp-rpc", + "frame-benchmarking", + "frame-benchmarking-cli", + "futures 0.3.17", + "jsonrpc-core", + "jsonrpc-pubsub", + "log", + "pallet-ethereum", + "pallet-transaction-payment-rpc", + "parity-scale-codec", + "parking_lot 0.11.2", + "polkadot-cli", + "polkadot-parachain", + "polkadot-primitives", + "polkadot-service", + "polkadot-test-service", + "sc-basic-authorship", + "sc-chain-spec", + "sc-cli", + "sc-client-api", + "sc-consensus", + "sc-consensus-aura", + "sc-executor", + "sc-finality-grandpa", + "sc-keystore", + "sc-network", + "sc-rpc", + "sc-rpc-api", + "sc-service", + "sc-telemetry", + "sc-tracing", + "sc-transaction-pool", + "serde", + "serde_json", + "sp-api", + "sp-block-builder", + "sp-blockchain", + "sp-consensus", + "sp-consensus-aura", + "sp-core", + "sp-finality-grandpa", + "sp-inherents", + "sp-keystore", + "sp-offchain", + "sp-runtime", + "sp-session", + "sp-timestamp", + "sp-transaction-pool", + "sp-trie", + "structopt", + "substrate-build-script-utils", + "substrate-frame-rpc-system", + "substrate-prometheus-endpoint", + "unique-rpc", + "unique-runtime", + "up-data-structs", +] + +[[package]] +name = "unique-rpc" +version = "0.1.0" +dependencies = [ + "fc-db", + "fc-mapping-sync", + "fc-rpc", + "fc-rpc-core", + "fp-rpc", + "futures 0.3.17", + "jsonrpc-core", + "jsonrpc-pubsub", + "pallet-ethereum", + "pallet-transaction-payment-rpc", + "pallet-transaction-payment-rpc-runtime-api", + "pallet-unique", + "sc-client-api", + "sc-consensus-aura", + "sc-consensus-epochs", + "sc-finality-grandpa", + "sc-finality-grandpa-rpc", + "sc-keystore", + "sc-network", + "sc-rpc", + "sc-rpc-api", + "sc-service", + "sc-transaction-pool", + "sp-api", + "sp-block-builder", + "sp-blockchain", + "sp-consensus", + "sp-consensus-aura", + "sp-core", + "sp-offchain", + "sp-runtime", + "sp-session", + "sp-storage", + "sp-transaction-pool", + "substrate-frame-rpc-system", + "tokio 0.2.25", + "uc-rpc", + "unique-runtime", + "up-rpc", +] + +[[package]] +name = "unique-runtime" +version = "0.9.12" +dependencies = [ + "cumulus-pallet-aura-ext", + "cumulus-pallet-dmp-queue", + "cumulus-pallet-parachain-system", + "cumulus-pallet-xcm", + "cumulus-pallet-xcmp-queue", + "cumulus-primitives-core", + "cumulus-primitives-timestamp", + "cumulus-primitives-utility", + "derivative", + "fp-rpc", + "fp-self-contained", + "frame-benchmarking", + "frame-executive", + "frame-support", + "frame-system", + "frame-system-benchmarking", + "frame-system-rpc-runtime-api", + "hex-literal", + "orml-vesting", + "pallet-aura", + "pallet-balances", + "pallet-common", + "pallet-ethereum", + "pallet-evm", + "pallet-evm-coder-substrate", + "pallet-evm-contract-helpers", + "pallet-evm-migration", + "pallet-evm-transaction-payment", + "pallet-fungible", + "pallet-inflation", + "pallet-nonfungible", + "pallet-randomness-collective-flip", + "pallet-refungible", + "pallet-sudo", + "pallet-template-transaction-payment", + "pallet-timestamp", + "pallet-transaction-payment", + "pallet-transaction-payment-rpc-runtime-api", + "pallet-treasury", + "pallet-unique", + "pallet-unq-scheduler", + "pallet-xcm", + "parachain-info", + "parity-scale-codec", + "polkadot-parachain", + "scale-info", + "serde", + "smallvec", + "sp-api", + "sp-arithmetic", + "sp-block-builder", + "sp-consensus-aura", + "sp-core", + "sp-inherents", + "sp-io", + "sp-offchain", + "sp-runtime", + "sp-session", + "sp-std", + "sp-transaction-pool", + "sp-version", + "substrate-wasm-builder", + "up-data-structs", + "up-evm-mapping", + "up-rpc", + "xcm", + "xcm-builder", + "xcm-executor", +] + +[[package]] name = "universal-hash" version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -11832,6 +11817,21 @@ checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a" [[package]] +name = "up-data-structs" +version = "0.1.0" +dependencies = [ + "derivative", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "serde", + "sp-core", + "sp-runtime", + "sp-std", +] + +[[package]] name = "up-evm-mapping" version = "0.1.0" dependencies = [ @@ -11843,13 +11843,13 @@ name = "up-rpc" version = "0.1.0" dependencies = [ - "nft-data-structs", "pallet-common", "parity-scale-codec", "sp-api", "sp-core", "sp-runtime", "sp-std", + "up-data-structs", ] [[package]] --- a/pallets/common/src/account.rs +++ b/pallets/common/src/account.rs @@ -7,7 +7,7 @@ use pallet_evm::AddressMapping; use sp_std::vec::Vec; use sp_std::clone::Clone; -use up_evm_mapping::EvmBackwardsAddressMapping; +pub use up_evm_mapping::EvmBackwardsAddressMapping; pub trait CrossAccountId: Encode + EncodeLike + Decode + TypeInfo + Clone + PartialEq + Ord + core::fmt::Debug + Default --- a/pallets/common/src/lib.rs +++ b/pallets/common/src/lib.rs @@ -273,8 +273,8 @@ TotalCollectionsLimitExceeded, /// variable_data exceeded data limit. TokenVariableDataLimitExceeded, - /// Exceeded max admin amount - CollectionAdminAmountExceeded, + /// Exceeded max admin count + CollectionAdminCountExceeded, /// Collection settings not allowing items transferring TransferNotAllowed, @@ -506,10 +506,10 @@ if admin { let amount = amount .checked_add(1) - .ok_or(>::CollectionAdminAmountExceeded)?; + .ok_or(>::CollectionAdminCountExceeded)?; ensure!( amount <= Self::collection_admins_limit(), - >::CollectionAdminAmountExceeded, + >::CollectionAdminCountExceeded, ); // ========= --- a/pallets/fungible/src/common.rs +++ b/pallets/fungible/src/common.rs @@ -182,7 +182,7 @@ _token: TokenId, _data: Vec, ) -> DispatchResultWithPostInfo { - fail!(>::FungibleItemsHaveData) + fail!(>::FungibleItemsDontHaveData) } fn account_tokens(&self, account: T::CrossAccountId) -> Vec { --- a/pallets/fungible/src/lib.rs +++ b/pallets/fungible/src/lib.rs @@ -35,7 +35,7 @@ /// Not default id passed as TokenId argument FungibleItemsHaveNoId, /// Tried to set data for fungible item - FungibleItemsHaveData, + FungibleItemsDontHaveData, } #[pallet::config] @@ -48,7 +48,7 @@ pub struct Pallet(_); #[pallet::storage] - pub(super) type TotalSupply = + pub type TotalSupply = StorageMap; #[pallet::storage] @@ -62,7 +62,7 @@ >; #[pallet::storage] - pub(super) type Allowance = StorageNMap< + pub type Allowance = StorageNMap< Key = ( Key, Key, --- a/pallets/inflation/src/lib.rs +++ b/pallets/inflation/src/lib.rs @@ -46,7 +46,8 @@ pub type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; -pub const YEAR: u32 = 5_259_600; +// pub const YEAR: u32 = 5_259_600; // 6-second block +pub const YEAR: u32 = 2_629_800; // 12-second block pub const TOTAL_YEARS_UNTIL_FLAT: u32 = 9; pub const START_INFLATION_PERCENT: u32 = 10; pub const END_INFLATION_PERCENT: u32 = 4; --- a/pallets/inflation/src/tests.rs +++ b/pallets/inflation/src/tests.rs @@ -18,7 +18,7 @@ type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; type Block = frame_system::mocking::MockBlock; -const YEAR: u64 = 5_259_600; +const YEAR: u64 = 2_629_800; parameter_types! { pub const ExistentialDeposit: u64 = 1; @@ -112,8 +112,8 @@ // first inflation deposit should be equal to BlockInflation Inflation::on_initialize(1); - // SBP M2 review: Verify expected block inflation for year 1 - assert_eq!(Inflation::block_inflation(), 1901); + // Expected 100-block inflation for year 1 is 100 * 100_000_000 / YEAR = 3803 + assert_eq!(Inflation::block_inflation(), 3803); assert_eq!( Balances::free_balance(1234) - initial_issuance, Inflation::block_inflation() @@ -158,26 +158,21 @@ let _ = >::deposit_creating(&1234, initial_issuance); assert_eq!(Balances::free_balance(1234), initial_issuance); Inflation::on_initialize(1); - let block_inflation_year_0 = Inflation::block_inflation(); - // SBP M2 review: go through all the block inflations for year 1, + // Go through all the block inflations for year 1, // total issuance will be updated accordingly for block in (100..YEAR).step_by(100) { Inflation::on_initialize(block); } assert_eq!( - initial_issuance + (1901 * (YEAR / 100)), + initial_issuance + (3803 * (YEAR / 100)), >::total_issuance() ); Inflation::on_initialize(YEAR); let block_inflation_year_1 = Inflation::block_inflation(); - // SBP M2 review: Verify expected block inflation for year 2 - assert_eq!(block_inflation_year_1, 1952); - - // SBP M2 review: this is actually not true - // Assert that year 1 inflation is less than year 0 - // assert!(block_inflation_year_0 > block_inflation_year_1); + // Expected 100-block inflation for year 2: 100 * 9.33% * initial issuance * 110% / YEAR = 3904 + assert_eq!(block_inflation_year_1, 3904); }); } --- a/pallets/nonfungible/src/lib.rs +++ b/pallets/nonfungible/src/lib.rs @@ -58,7 +58,7 @@ } #[pallet::pallet] - #[pallet::generate_store(pub trait Store)] + #[pallet::generate_store(pub(super) trait Store)] pub struct Pallet(_); #[pallet::storage] --- a/pallets/refungible/src/lib.rs +++ b/pallets/refungible/src/lib.rs @@ -54,7 +54,7 @@ } #[pallet::pallet] - #[pallet::generate_store(pub trait Store)] + #[pallet::generate_store(pub(super) trait Store)] pub struct Pallet(_); #[pallet::storage] --- a/pallets/scheduler/src/lib.rs +++ b/pallets/scheduler/src/lib.rs @@ -738,9 +738,7 @@ use super::*; use frame_support::{ - Hashable, assert_err, assert_noop, assert_ok, ord_parameter_types, parameter_types, - traits::{Contains, OnFinalize, OnInitialize}, - weights::constants::RocksDbWeight, + ord_parameter_types, parameter_types, traits::Contains, weights::constants::RocksDbWeight, }; use sp_core::H256; use sp_runtime::{ @@ -749,7 +747,6 @@ traits::{BlakeTwo256, IdentityLookup}, }; use frame_system::{EnsureOneOf, EnsureRoot, EnsureSignedBy}; - use substrate_test_utils::assert_eq_uvec; use crate as scheduler; mod logger { @@ -758,9 +755,6 @@ thread_local! { static LOG: RefCell> = RefCell::new(Vec::new()); - } - pub fn log() -> Vec<(OriginCaller, u32)> { - LOG.with(|log| log.borrow().clone()) } pub trait Config: system::Config { type Event: From + Into<::Event>; @@ -871,24 +865,5 @@ type MaxScheduledPerBlock = MaxScheduledPerBlock; type WeightInfo = (); type SponsorshipHandler = (); - } - - pub fn new_test_ext() -> sp_io::TestExternalities { - let t = system::GenesisConfig::default() - .build_storage::() - .unwrap(); - t.into() - } - - fn run_to_block(n: u64) { - while System::block_number() < n { - Scheduler::on_finalize(System::block_number()); - System::set_block_number(System::block_number() + 1); - Scheduler::on_initialize(System::block_number()); - } - } - - fn root() -> OriginCaller { - system::RawOrigin::Root.into() } } --- a/pallets/unique/src/mock.rs +++ b/pallets/unique/src/mock.rs @@ -10,7 +10,7 @@ use pallet_transaction_payment::{CurrencyAdapter}; use frame_system as system; use pallet_evm::AddressMapping; -use crate::{EvmBackwardsAddressMapping, CrossAccountId}; +use pallet_common::account::{EvmBackwardsAddressMapping, CrossAccountId}; use codec::{Encode, Decode}; use scale_info::TypeInfo; @@ -27,6 +27,10 @@ System: frame_system::{Pallet, Call, Config, Storage, Event}, TemplateModule: pallet_template::{Pallet, Call, Storage}, Balances: pallet_balances::{Pallet, Call, Storage}, + Common: pallet_common::{Pallet, Storage, Event}, + Fungible: pallet_fungible::{Pallet, Storage}, + Refungible: pallet_refungible::{Pallet, Storage}, + Nonfungible: pallet_nonfungible::{Pallet, Storage}, } ); @@ -124,13 +128,16 @@ #[derive(Encode, Decode, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, TypeInfo)] pub struct TestCrossAccountId(u64, sp_core::H160); impl CrossAccountId for TestCrossAccountId { + fn as_sub(&self) -> &u64 { + &self.0 + } + fn as_eth(&self) -> &sp_core::H160 { + &self.1 + } fn from_sub(sub: u64) -> Self { let mut eth = [0; 20]; eth[12..20].copy_from_slice(&sub.to_be_bytes()); Self(sub, sp_core::H160(eth)) - } - fn as_sub(&self) -> &u64 { - &self.0 } fn from_eth(eth: sp_core::H160) -> Self { let mut sub_raw = [0; 8]; @@ -138,11 +145,17 @@ let sub = u64::from_be_bytes(sub_raw); Self(sub, eth) } - fn as_eth(&self) -> &sp_core::H160 { - &self.1 + fn conv_eq(&self, other: &Self) -> bool { + self.as_sub() == other.as_sub() } } +impl Default for TestCrossAccountId { + fn default() -> Self { + Self::from_sub(0) + } +} + pub struct TestEtheremTransactionSender; impl pallet_ethereum::EthereumTransactionSender for TestEtheremTransactionSender { fn submit_logs_transaction( @@ -157,15 +170,29 @@ type EthereumTransactionSender = TestEtheremTransactionSender; } -impl pallet_template::Config for Test { +impl pallet_common::Config for Test { type Event = (); - type WeightInfo = (); - type CollectionCreationPrice = CollectionCreationPrice; - type Currency = pallet_balances::Pallet; - type TreasuryAccountId = TreasuryAccountId; - type EvmAddressMapping = TestEvmAddressMapping; type EvmBackwardsAddressMapping = TestEvmBackwardsAddressMapping; + type EvmAddressMapping = TestEvmAddressMapping; type CrossAccountId = TestCrossAccountId; + + type Currency = Balances; + type CollectionCreationPrice = CollectionCreationPrice; + type TreasuryAccountId = TreasuryAccountId; +} + +impl pallet_fungible::Config for Test { + type WeightInfo = (); +} +impl pallet_refungible::Config for Test { + type WeightInfo = (); +} +impl pallet_nonfungible::Config for Test { + type WeightInfo = (); +} + +impl pallet_template::Config for Test { + type WeightInfo = (); } // Build genesis storage according to the mock runtime. --- a/pallets/unique/src/tests.rs +++ b/pallets/unique/src/tests.rs @@ -1,10 +1,11 @@ // Tests to be written here use super::*; use crate::mock::*; -use crate::{AccessMode, CollectionMode, Ownership, CreateItemData}; +use crate::{AccessMode, CollectionMode}; use up_data_structs::{ - CreateNftData, CreateFungibleData, CreateReFungibleData, CollectionId, TokenId, - MAX_DECIMAL_POINTS, + COLLECTION_NUMBER_LIMIT, CollectionId, CreateItemData, CreateFungibleData, CreateNftData, + CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT, MetaUpdatePermission, + TokenId, }; use frame_support::{assert_noop, assert_ok}; use sp_std::convert::TryInto; @@ -49,18 +50,30 @@ let saved_col_name: Vec = "Test1\0".encode_utf16().collect::>(); let saved_description: Vec = "TestDescription1\0".encode_utf16().collect::>(); let saved_prefix: Vec = b"token_prefix1\0".to_vec(); - assert_eq!(TemplateModule::collection_id(id).unwrap().owner, owner); assert_eq!( - TemplateModule::collection_id(id).unwrap().name, + >::get(id) + .unwrap() + .owner, + owner + ); + assert_eq!( + >::get(id).unwrap().name, saved_col_name ); - assert_eq!(TemplateModule::collection_id(id).unwrap().mode, *mode); assert_eq!( - TemplateModule::collection_id(id).unwrap().description, + >::get(id).unwrap().mode, + *mode + ); + assert_eq!( + >::get(id) + .unwrap() + .description, saved_description ); assert_eq!( - TemplateModule::collection_id(id).unwrap().token_prefix, + >::get(id) + .unwrap() + .token_prefix, saved_prefix ); id @@ -91,7 +104,7 @@ fn set_version_schema() { new_test_ext().execute_with(|| { let origin1 = Origin::signed(1); - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); assert_ok!(TemplateModule::set_schema_version( origin1, @@ -99,7 +112,7 @@ SchemaVersion::Unique )); assert_eq!( - TemplateModule::collection_id(collection_id) + >::get(collection_id) .unwrap() .schema_version, SchemaVersion::Unique @@ -131,11 +144,12 @@ #[test] fn create_nft_item() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let data = default_nft_data(); create_test_item(collection_id, &data.clone().into()); - let item = TemplateModule::nft_item_id(collection_id, 1).unwrap(); + + let item = >::get((collection_id, 1)).unwrap(); assert_eq!(item.const_data, data.const_data.into_inner()); assert_eq!(item.variable_data, data.variable_data.into_inner()); }); @@ -146,7 +160,7 @@ #[test] fn create_nft_multiple_items() { new_test_ext().execute_with(|| { - create_test_collection(&CollectionMode::NFT, 1); + create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); @@ -154,7 +168,7 @@ assert_ok!(TemplateModule::create_multiple_items( origin1, - 1, + CollectionId(1), account(1), items_data .clone() @@ -163,7 +177,11 @@ .collect() )); for (index, data) in items_data.into_iter().enumerate() { - let item = TemplateModule::nft_item_id(1, (index + 1) as TokenId).unwrap(); + let item = >::get(( + CollectionId(1), + TokenId((index + 1) as u32), + )) + .unwrap(); assert_eq!(item.const_data.to_vec(), data.const_data.into_inner()); assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner()); } @@ -173,27 +191,23 @@ #[test] fn create_refungible_item() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::ReFungible, 1); + let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1)); let data = default_re_fungible_data(); create_test_item(collection_id, &data.clone().into()); - let item = TemplateModule::refungible_item_id(collection_id, 1).unwrap(); + let item = >::get((collection_id, TokenId(1))); + let balance = + >::get((collection_id, TokenId(1), account(1))); assert_eq!(item.const_data, data.const_data.into_inner()); assert_eq!(item.variable_data, data.variable_data.into_inner()); - assert_eq!( - item.owner[0], - Ownership { - owner: account(1), - fraction: 1023 - } - ); + assert_eq!(balance, 1023); }); } #[test] fn create_multiple_refungible_items() { new_test_ext().execute_with(|| { - create_test_collection(&CollectionMode::ReFungible, 1); + create_test_collection(&CollectionMode::ReFungible, CollectionId(1)); let origin1 = Origin::signed(1); @@ -205,7 +219,7 @@ assert_ok!(TemplateModule::create_multiple_items( origin1, - 1, + CollectionId(1), account(1), items_data .clone() @@ -214,16 +228,15 @@ .collect() )); for (index, data) in items_data.into_iter().enumerate() { - let item = TemplateModule::refungible_item_id(1, (index + 1) as TokenId).unwrap(); + let item = >::get(( + CollectionId(1), + TokenId((index + 1) as u32), + )); + let balance = + >::get((CollectionId(1), TokenId(1), account(1))); assert_eq!(item.const_data.to_vec(), data.const_data.into_inner()); assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner()); - assert_eq!( - item.owner[0], - Ownership { - owner: account(1), - fraction: 1023 - } - ); + assert_eq!(balance, 1023); } }); } @@ -231,12 +244,15 @@ #[test] fn create_fungible_item() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1); + let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1)); let data = default_fungible_data(); create_test_item(collection_id, &data.into()); - assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).value, 5); + assert_eq!( + >::get((collection_id, account(1))), + 5 + ); }); } @@ -245,7 +261,7 @@ // new_test_ext().execute_with(|| { // default_limits(); -// create_test_collection(&CollectionMode::Fungible(3), 1); +// create_test_collection(&CollectionMode::Fungible(3), CollectionId(1)); // let origin1 = Origin::signed(1); @@ -269,7 +285,7 @@ #[test] fn transfer_fungible_item() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1); + let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -277,155 +293,287 @@ let data = default_fungible_data(); create_test_item(collection_id, &data.into()); - assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 5); - assert_eq!(TemplateModule::balance_count(1, 1), 5); + assert_eq!( + >::get((CollectionId(1), account(1))), + 5 + ); // change owner scenario - assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 5)); - assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 0); - assert_eq!(TemplateModule::balance_count(1, 1), 0); - assert_eq!(TemplateModule::balance_count(1, 2), 5); + assert_ok!(TemplateModule::transfer( + origin1, + account(2), + CollectionId(1), + TokenId(0), + 5 + )); + assert_eq!( + >::get((CollectionId(1), account(1))), + 0 + ); // split item scenario assert_ok!(TemplateModule::transfer( origin2.clone(), account(3), - 1, - 1, + CollectionId(1), + TokenId(0), 3 )); - assert_eq!(TemplateModule::balance_count(1, 2), 2); - assert_eq!(TemplateModule::balance_count(1, 3), 3); // split item and new owner has account scenario - assert_ok!(TemplateModule::transfer(origin2, account(3), 1, 1, 1)); - assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 1); - assert_eq!(TemplateModule::fungible_item_id(1, 3).value, 4); - assert_eq!(TemplateModule::balance_count(1, 2), 1); - assert_eq!(TemplateModule::balance_count(1, 3), 4); + assert_ok!(TemplateModule::transfer( + origin2, + account(3), + CollectionId(1), + TokenId(0), + 1 + )); + assert_eq!( + >::get((CollectionId(1), account(2))), + 1 + ); + assert_eq!( + >::get((CollectionId(1), account(3))), + 4 + ); }); } #[test] fn transfer_refungible_item() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::ReFungible, 1); + let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1)); + // Create RFT 1 in 1023 pieces for account 1 let data = default_re_fungible_data(); create_test_item(collection_id, &data.clone().into()); + let item = >::get((collection_id, TokenId(1))); + assert_eq!(item.const_data, data.const_data.into_inner()); + assert_eq!(item.variable_data, data.variable_data.into_inner()); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, TokenId(1), account(1))), + 1023 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); + // Account 1 transfers all 1023 pieces of RFT 1 to account 2 let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); - { - let item = TemplateModule::refungible_item_id(collection_id, 1).unwrap(); - assert_eq!(item.const_data, data.const_data.into_inner()); - assert_eq!(item.variable_data, data.variable_data.into_inner()); - assert_eq!( - item.owner[0], - Ownership { - owner: account(1), - fraction: 1023 - } - ); - } - assert_eq!(TemplateModule::balance_count(1, 1), 1023); - assert_eq!(TemplateModule::address_tokens(1, 1), [1]); - - // change owner scenario - assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1023)); + assert_ok!(TemplateModule::transfer( + origin1, + account(2), + CollectionId(1), + TokenId(1), + 1023 + )); assert_eq!( - TemplateModule::refungible_item_id(1, 1).unwrap().owner[0], - Ownership { - owner: account(2), - fraction: 1023 - } + >::get((collection_id, TokenId(1), account(2))), + 1023 + ); + assert_eq!( + >::get((collection_id, account(1))), + 0 + ); + assert_eq!( + >::get((collection_id, account(2))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + false + ); + assert_eq!( + >::get((collection_id, account(2), TokenId(1))), + true ); - assert_eq!(TemplateModule::balance_count(1, 1), 0); - assert_eq!(TemplateModule::balance_count(1, 2), 1023); - // assert_eq!(TemplateModule::address_tokens(1, 1), []); - assert_eq!(TemplateModule::address_tokens(1, 2), [1]); - // split item scenario + // Account 2 transfers 500 pieces of RFT 1 to account 3 assert_ok!(TemplateModule::transfer( origin2.clone(), account(3), - 1, - 1, + CollectionId(1), + TokenId(1), 500 )); - { - let item = TemplateModule::refungible_item_id(1, 1).unwrap(); - assert_eq!( - item.owner[0], - Ownership { - owner: account(2), - fraction: 523 - } - ); - assert_eq!( - item.owner[1], - Ownership { - owner: account(3), - fraction: 500 - } - ); - } - assert_eq!(TemplateModule::balance_count(1, 2), 523); - assert_eq!(TemplateModule::balance_count(1, 3), 500); - assert_eq!(TemplateModule::address_tokens(1, 2), [1]); - assert_eq!(TemplateModule::address_tokens(1, 3), [1]); + assert_eq!( + >::get((collection_id, TokenId(1), account(2))), + 523 + ); + assert_eq!( + >::get((collection_id, TokenId(1), account(3))), + 500 + ); + assert_eq!( + >::get((collection_id, account(2))), + 1 + ); + assert_eq!( + >::get((collection_id, account(3))), + 1 + ); + assert_eq!( + >::get((collection_id, account(2), TokenId(1))), + true + ); + assert_eq!( + >::get((collection_id, account(3), TokenId(1))), + true + ); - // split item and new owner has account scenario - assert_ok!(TemplateModule::transfer(origin2, account(3), 1, 1, 200)); - { - let item = TemplateModule::refungible_item_id(1, 1).unwrap(); - assert_eq!( - item.owner[0], - Ownership { - owner: account(2), - fraction: 323 - } - ); - assert_eq!( - item.owner[1], - Ownership { - owner: account(3), - fraction: 700 - } - ); - } - assert_eq!(TemplateModule::balance_count(1, 2), 323); - assert_eq!(TemplateModule::balance_count(1, 3), 700); - assert_eq!(TemplateModule::address_tokens(1, 2), [1]); - assert_eq!(TemplateModule::address_tokens(1, 3), [1]); + // Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance + assert_ok!(TemplateModule::transfer( + origin2, + account(3), + CollectionId(1), + TokenId(1), + 200 + )); + assert_eq!( + >::get((collection_id, TokenId(1), account(2))), + 323 + ); + assert_eq!( + >::get((collection_id, TokenId(1), account(3))), + 700 + ); + assert_eq!( + >::get((collection_id, account(2))), + 1 + ); + assert_eq!( + >::get((collection_id, account(3))), + 1 + ); + assert_eq!( + >::get((collection_id, account(2), TokenId(1))), + true + ); + assert_eq!( + >::get((collection_id, account(3), TokenId(1))), + true + ); }); } #[test] fn transfer_nft_item() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let data = default_nft_data(); create_test_item(collection_id, &data.into()); - assert_eq!(TemplateModule::balance_count(1, 1), 1); - assert_eq!(TemplateModule::address_tokens(1, 1), [1]); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); let origin1 = Origin::signed(1); // default scenario - assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1000)); - assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(2)); - assert_eq!(TemplateModule::balance_count(1, 1), 0); - assert_eq!(TemplateModule::balance_count(1, 2), 1); - // assert_eq!(TemplateModule::address_tokens(1, 1), []); - assert_eq!(TemplateModule::address_tokens(1, 2), [1]); + assert_ok!(TemplateModule::transfer( + origin1, + account(2), + CollectionId(1), + TokenId(1), + 1 + )); + assert_eq!( + >::get((collection_id, account(1))), + 0 + ); + assert_eq!( + >::get((collection_id, account(2))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + false + ); + assert_eq!( + >::get((collection_id, account(2), TokenId(1))), + true + ); + }); +} + +#[test] +fn transfer_nft_item_wrong_value() { + new_test_ext().execute_with(|| { + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); + + let data = default_nft_data(); + create_test_item(collection_id, &data.into()); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); + + let origin1 = Origin::signed(1); + + assert_noop!( + TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2) + .map_err(|e| e.error), + >::NonfungibleItemsHaveNoAmount + ); }); } #[test] +fn transfer_nft_item_zero_value() { + new_test_ext().execute_with(|| { + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); + + let data = default_nft_data(); + create_test_item(collection_id, &data.into()); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); + + let origin1 = Origin::signed(1); + + // Transferring 0 amount works on NFT... + assert_ok!(TemplateModule::transfer( + origin1, + account(2), + CollectionId(1), + TokenId(1), + 0 + )); + // ... and results in no transfer + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); + }); +} + +#[test] fn nft_approve_and_transfer_from() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let data = default_nft_data(); create_test_item(collection_id, &data.into()); @@ -433,197 +581,286 @@ let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); - assert_eq!(TemplateModule::balance_count(1, 1), 1); - assert_eq!(TemplateModule::address_tokens(1, 1), [1]); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); - // neg transfer + // neg transfer_from assert_noop!( - TemplateModule::transfer_from(origin2.clone(), account(1), account(2), 1, 1, 1), - Error::::NoPermission + TemplateModule::transfer_from( + origin2.clone(), + account(1), + account(2), + CollectionId(1), + TokenId(1), + 1 + ) + .map_err(|e| e.error), + CommonError::::TokenValueNotEnough ); // do approve - assert_ok!(TemplateModule::approve(origin1, account(2), 1, 1, 5)); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5); + assert_ok!(TemplateModule::approve( + origin1, + account(2), + CollectionId(1), + TokenId(1), + 1 + )); + assert_eq!( + >::get((CollectionId(1), TokenId(1))).unwrap(), + account(2) + ); assert_ok!(TemplateModule::transfer_from( origin2, account(1), account(3), - 1, - 1, + CollectionId(1), + TokenId(1), 1 )); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 4); + assert!( + >::get((CollectionId(1), TokenId(1))).is_none() + ); }); } #[test] fn nft_approve_and_transfer_from_allow_list() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); + // Create NFT 1 for account 1 let data = default_nft_data(); create_test_item(collection_id, &data.clone().into()); - assert_eq!( - &TemplateModule::nft_item_id(1, 1).unwrap().const_data, + &>::get((collection_id, TokenId(1))) + .unwrap() + .const_data, &data.const_data.into_inner() ); - assert_eq!(TemplateModule::balance_count(1, 1), 1); - assert_eq!(TemplateModule::address_tokens(1, 1), [1]); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); + // Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list assert_ok!(TemplateModule::set_mint_permission( origin1.clone(), - 1, + CollectionId(1), true )); assert_ok!(TemplateModule::set_public_access_mode( origin1.clone(), - 1, + CollectionId(1), AccessMode::AllowList )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(1) )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(2) )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(3) )); - // do approve + // Account 1 approves account 2 for NFT 1 assert_ok!(TemplateModule::approve( origin1.clone(), account(2), - 1, - 1, - 5 + CollectionId(1), + TokenId(1), + 1 )); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5); - assert_ok!(TemplateModule::approve(origin1, account(3), 1, 1, 5)); - assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5); + assert_eq!( + >::get((CollectionId(1), TokenId(1))).unwrap(), + account(2) + ); + // Account 2 transfers NFT 1 from account 1 to account 3 assert_ok!(TemplateModule::transfer_from( origin2, account(1), account(3), - 1, - 1, + CollectionId(1), + TokenId(1), 1 )); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 4); + assert!( + >::get((CollectionId(1), TokenId(1))).is_none() + ); }); } #[test] fn refungible_approve_and_transfer_from() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::ReFungible, 1); + let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); + // Create RFT 1 in 1023 pieces for account 1 let data = default_re_fungible_data(); create_test_item(collection_id, &data.into()); - assert_eq!(TemplateModule::balance_count(1, 1), 1023); - assert_eq!(TemplateModule::address_tokens(1, 1), [1]); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, TokenId(1), account(1))), + 1023 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); + // Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list assert_ok!(TemplateModule::set_mint_permission( origin1.clone(), - 1, + CollectionId(1), true )); assert_ok!(TemplateModule::set_public_access_mode( origin1.clone(), - 1, + CollectionId(1), AccessMode::AllowList )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(1) )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(2) )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(3) )); - // do approve - assert_ok!(TemplateModule::approve(origin1, account(2), 1, 1, 1023)); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1023); + // Account 1 approves account 2 for 1023 pieces of RFT 1 + assert_ok!(TemplateModule::approve( + origin1, + account(2), + CollectionId(1), + TokenId(1), + 1023 + )); + assert_eq!( + >::get(( + CollectionId(1), + TokenId(1), + account(1), + account(2) + )), + 1023 + ); + // Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3 assert_ok!(TemplateModule::transfer_from( origin2, account(1), account(3), - 1, - 1, + CollectionId(1), + TokenId(1), 100 )); - assert_eq!(TemplateModule::balance_count(1, 1), 923); - assert_eq!(TemplateModule::balance_count(1, 3), 100); - assert_eq!(TemplateModule::address_tokens(1, 1), [1]); - assert_eq!(TemplateModule::address_tokens(1, 3), [1]); - - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 923); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, account(3))), + 1 + ); + assert_eq!( + >::get((collection_id, TokenId(1), account(1))), + 923 + ); + assert_eq!( + >::get((collection_id, TokenId(1), account(3))), + 100 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); + assert_eq!( + >::get(( + CollectionId(1), + TokenId(1), + account(1), + account(2) + )), + 923 + ); }); } #[test] fn fungible_approve_and_transfer_from() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1); + let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1)); let data = default_fungible_data(); create_test_item(collection_id, &data.into()); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); - - assert_eq!(TemplateModule::balance_count(1, 1), 5); assert_ok!(TemplateModule::set_mint_permission( origin1.clone(), - 1, + CollectionId(1), true )); assert_ok!(TemplateModule::set_public_access_mode( origin1.clone(), - 1, + CollectionId(1), AccessMode::AllowList )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(1) )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(2) )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(3) )); @@ -631,31 +868,55 @@ assert_ok!(TemplateModule::approve( origin1.clone(), account(2), - 1, - 1, + CollectionId(1), + TokenId(0), 5 )); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5); - assert_ok!(TemplateModule::approve(origin1, account(3), 1, 1, 5)); - assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5); + assert_eq!( + >::get((CollectionId(1), account(1), account(2))), + 5 + ); + assert_ok!(TemplateModule::approve( + origin1, + account(3), + CollectionId(1), + TokenId(0), + 5 + )); + assert_eq!( + >::get((CollectionId(1), account(1), account(2))), + 5 + ); + assert_eq!( + >::get((CollectionId(1), account(1), account(3))), + 5 + ); assert_ok!(TemplateModule::transfer_from( origin2.clone(), account(1), account(3), - 1, - 1, + CollectionId(1), + TokenId(0), 4 )); - assert_eq!(TemplateModule::balance_count(1, 1), 1); - assert_eq!(TemplateModule::balance_count(1, 3), 4); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1); + assert_eq!( + >::get((CollectionId(1), account(1), account(2))), + 1 + ); assert_noop!( - TemplateModule::transfer_from(origin2, account(1), account(3), 1, 1, 4), - Error::::NoPermission + TemplateModule::transfer_from( + origin2, + account(1), + account(3), + CollectionId(1), + TokenId(0), + 4 + ) + .map_err(|e| e.error), + CommonError::::TokenValueNotEnough ); }); } @@ -663,7 +924,7 @@ #[test] fn change_collection_owner() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::change_collection_owner( @@ -672,7 +933,9 @@ 2 )); assert_eq!( - TemplateModule::collection_id(collection_id).unwrap().owner, + >::get(collection_id) + .unwrap() + .owner, 2 ); }); @@ -681,7 +944,7 @@ #[test] fn destroy_collection() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::destroy_collection(origin1, collection_id)); @@ -691,41 +954,74 @@ #[test] fn burn_nft_item() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); - assert_ok!(TemplateModule::add_collection_admin( + + let data = default_nft_data(); + create_test_item(collection_id, &data.into()); + + // check balance (collection with id = 1, user id = 1) + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + + // burn item + assert_ok!(TemplateModule::burn_item( origin1.clone(), collection_id, - account(2) + TokenId(1), + 1 )); + assert_eq!( + >::get((collection_id, account(1))), + 0 + ); + }); +} + +#[test] +fn burn_same_nft_item_twice() { + new_test_ext().execute_with(|| { + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); + + let origin1 = Origin::signed(1); let data = default_nft_data(); create_test_item(collection_id, &data.into()); // check balance (collection with id = 1, user id = 1) - assert_eq!(TemplateModule::balance_count(1, 1), 1); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); // burn item assert_ok!(TemplateModule::burn_item( origin1.clone(), collection_id, - 1, + TokenId(1), 1 )); + + // burn item again assert_noop!( - TemplateModule::burn_item(origin1, collection_id, 1, 1), - Error::::TokenNotFound + TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error), + CommonError::::TokenNotFound ); - assert_eq!(TemplateModule::balance_count(1, 1), 0); + assert_eq!( + >::get((collection_id, account(1))), + 0 + ); }); } #[test] fn burn_fungible_item() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1); + let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::add_collection_admin( @@ -738,23 +1034,62 @@ create_test_item(collection_id, &data.into()); // check balance (collection with id = 1, user id = 1) - assert_eq!(TemplateModule::balance_count(1, 1), 5); + assert_eq!( + >::get((collection_id, account(1))), + 5 + ); // burn item - assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5)); + assert_ok!(TemplateModule::burn_item( + origin1.clone(), + CollectionId(1), + TokenId(0), + 5 + )); assert_noop!( - TemplateModule::burn_item(origin1, 1, 1, 5), - Error::::TokenValueNotEnough + TemplateModule::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error), + CommonError::::TokenValueTooLow ); - assert_eq!(TemplateModule::balance_count(1, 1), 0); + assert_eq!( + >::get((collection_id, account(1))), + 0 + ); }); } #[test] +fn burn_fungible_item_with_token_id() { + new_test_ext().execute_with(|| { + let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1)); + + let origin1 = Origin::signed(1); + assert_ok!(TemplateModule::add_collection_admin( + origin1.clone(), + collection_id, + account(2) + )); + + let data = default_fungible_data(); + create_test_item(collection_id, &data.into()); + + // check balance (collection with id = 1, user id = 1) + assert_eq!( + >::get((collection_id, account(1))), + 5 + ); + + // Try to burn item using Token ID + assert_noop!( + TemplateModule::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error), + >::FungibleItemsHaveNoId + ); + }); +} +#[test] fn burn_refungible_item() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::ReFungible, 1); + let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::set_mint_permission( @@ -769,13 +1104,13 @@ )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + collection_id, account(1) )); assert_ok!(TemplateModule::add_collection_admin( origin1.clone(), - 1, + collection_id, account(2) )); @@ -783,29 +1118,43 @@ create_test_item(collection_id, &data.into()); // check balance (collection with id = 1, user id = 2) - assert_eq!(TemplateModule::balance_count(1, 1), 1023); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, TokenId(1), account(1))), + 1023 + ); // burn item - assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 1023)); + assert_ok!(TemplateModule::burn_item( + origin1.clone(), + collection_id, + TokenId(1), + 1023 + )); assert_noop!( - TemplateModule::burn_item(origin1, 1, 1, 1023), - Error::::TokenNotFound + TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1023) + .map_err(|e| e.error), + CommonError::::TokenValueTooLow ); - assert_eq!(TemplateModule::balance_count(1, 1), 0); + assert_eq!( + >::get((collection_id, TokenId(1), account(1))), + 0 + ); }); } #[test] fn add_collection_admin() { new_test_ext().execute_with(|| { - let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1); - create_test_collection_for_owner(&CollectionMode::NFT, 2, 2); - create_test_collection_for_owner(&CollectionMode::NFT, 3, 3); - + let collection1_id = + create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1)); let origin1 = Origin::signed(1); - // collection admin + // Add collection admins assert_ok!(TemplateModule::add_collection_admin( origin1.clone(), collection1_id, @@ -817,22 +1166,31 @@ account(3) )); - assert!(TemplateModule::admin_list_collection(collection1_id).contains(&account(2)),); - assert!(TemplateModule::admin_list_collection(collection1_id).contains(&account(3)),); + // Owner is not an admin by default + assert_eq!( + >::get((CollectionId(1), account(1))), + false + ); + assert!(>::get(( + CollectionId(1), + account(2) + ))); + assert!(>::get(( + CollectionId(1), + account(3) + ))); }); } #[test] fn remove_collection_admin() { new_test_ext().execute_with(|| { - let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1); - create_test_collection_for_owner(&CollectionMode::NFT, 2, 2); - create_test_collection_for_owner(&CollectionMode::NFT, 3, 3); - + let collection1_id = + create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); - // collection admin + // Add collection admins 2 and 3 assert_ok!(TemplateModule::add_collection_admin( origin1.clone(), collection1_id, @@ -844,31 +1202,54 @@ account(3) )); - assert!(TemplateModule::admin_list_collection(1).contains(&account(2)),); - assert!(TemplateModule::admin_list_collection(1).contains(&account(3)),); + assert!(>::get(( + CollectionId(1), + account(2) + ))); + assert!(>::get(( + CollectionId(1), + account(3) + ))); - // remove admin + // remove admin 3 assert_ok!(TemplateModule::remove_collection_admin( origin2, - 1, + CollectionId(1), account(3) )); - assert!(!TemplateModule::admin_list_collection(1).contains(&account(3)),); + + // 2 is still admin, 3 is not an admin anymore + assert!(>::get(( + CollectionId(1), + account(2) + ))); + assert_eq!( + >::get((CollectionId(1), account(3))), + false + ); }); } #[test] fn balance_of() { new_test_ext().execute_with(|| { - let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1); - let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2); - let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible, 3); + let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); + let fungible_collection_id = + create_test_collection(&CollectionMode::Fungible(3), CollectionId(2)); + let re_fungible_collection_id = + create_test_collection(&CollectionMode::ReFungible, CollectionId(3)); // check balance before - assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0); - assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0); assert_eq!( - TemplateModule::balance_count(re_fungible_collection_id, 1), + >::get((nft_collection_id, account(1))), + 0 + ); + assert_eq!( + >::get((fungible_collection_id, account(1))), + 0 + ); + assert_eq!( + >::get((re_fungible_collection_id, account(1))), 0 ); @@ -882,28 +1263,30 @@ create_test_item(re_fungible_collection_id, &re_fungible_data.into()); // check balance (collection with id = 1, user id = 1) - assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1); - assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 5); assert_eq!( - TemplateModule::balance_count(re_fungible_collection_id, 1), - 1023 + >::get((nft_collection_id, account(1))), + 1 ); assert_eq!( - TemplateModule::nft_item_id(nft_collection_id, 1) - .unwrap() - .owner, - account(1) + >::get((fungible_collection_id, account(1))), + 5 ); assert_eq!( - TemplateModule::fungible_item_id(fungible_collection_id, 1).value, - 5 + >::get((re_fungible_collection_id, account(1))), + 1 ); + assert_eq!( - TemplateModule::refungible_item_id(re_fungible_collection_id, 1) - .unwrap() - .owner[0] - .owner, - account(1) + >::get((nft_collection_id, account(1), TokenId(1))), + true + ); + assert_eq!( + >::get(( + re_fungible_collection_id, + account(1), + TokenId(1) + )), + true ); }); } @@ -911,7 +1294,7 @@ #[test] fn approve() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let data = default_nft_data(); create_test_item(collection_id, &data.into()); @@ -919,15 +1302,24 @@ let origin1 = Origin::signed(1); // approve - assert_ok!(TemplateModule::approve(origin1, account(2), 1, 1, 1)); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1); + assert_ok!(TemplateModule::approve( + origin1, + account(2), + CollectionId(1), + TokenId(1), + 1 + )); + assert_eq!( + >::get((CollectionId(1), TokenId(1))).unwrap(), + account(2) + ); }); } #[test] fn transfer_from() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -938,46 +1330,59 @@ assert_ok!(TemplateModule::approve( origin1.clone(), account(2), - 1, - 1, + CollectionId(1), + TokenId(1), 1 )); - assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1); + assert_eq!( + >::get((CollectionId(1), TokenId(1))).unwrap(), + account(2) + ); assert_ok!(TemplateModule::set_mint_permission( origin1.clone(), - 1, + CollectionId(1), true )); assert_ok!(TemplateModule::set_public_access_mode( origin1.clone(), - 1, + CollectionId(1), AccessMode::AllowList )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(1) )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + CollectionId(1), account(2) )); - assert_ok!(TemplateModule::add_to_allow_list(origin1, 1, account(3))); + assert_ok!(TemplateModule::add_to_allow_list( + origin1, + CollectionId(1), + account(3) + )); assert_ok!(TemplateModule::transfer_from( origin2, account(1), account(2), - 1, - 1, + CollectionId(1), + TokenId(1), 1 )); // after transfer - assert_eq!(TemplateModule::balance_count(1, 1), 0); - assert_eq!(TemplateModule::balance_count(1, 2), 1); + assert_eq!( + >::get((CollectionId(1), account(1))), + 0 + ); + assert_eq!( + >::get((CollectionId(1), account(2))), + 1 + ); }); } @@ -989,7 +1394,7 @@ #[test] fn owner_can_add_address_to_allow_list() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::add_to_allow_list( @@ -997,14 +1402,17 @@ collection_id, account(2) )); - assert!(TemplateModule::allow_list(collection_id, 2)); + assert!(>::get(( + collection_id, + account(2) + ))); }); } #[test] fn admin_can_add_address_to_allow_list() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -1018,19 +1426,22 @@ collection_id, account(3) )); - assert!(TemplateModule::allow_list(collection_id, 3)); + assert!(>::get(( + collection_id, + account(3) + ))); }); } #[test] fn nonprivileged_user_cannot_add_address_to_allow_list() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin2 = Origin::signed(2); assert_noop!( TemplateModule::add_to_allow_list(origin2, collection_id, account(3)), - Error::::NoPermission + CommonError::::NoPermission ); }); } @@ -1041,8 +1452,8 @@ let origin1 = Origin::signed(1); assert_noop!( - TemplateModule::add_to_allow_list(origin1, 1, account(2)), - Error::::CollectionNotFound + TemplateModule::add_to_allow_list(origin1, CollectionId(1), account(2)), + CommonError::::CollectionNotFound ); }); } @@ -1050,7 +1461,7 @@ #[test] fn nobody_can_add_address_to_allow_list_of_deleted_collection() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::destroy_collection( @@ -1059,7 +1470,7 @@ )); assert_noop!( TemplateModule::add_to_allow_list(origin1, collection_id, account(2)), - Error::::CollectionNotFound + CommonError::::CollectionNotFound ); }); } @@ -1068,7 +1479,7 @@ #[test] fn address_is_already_added_to_allow_list() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::add_to_allow_list( @@ -1081,14 +1492,17 @@ collection_id, account(2) )); - assert!(TemplateModule::allow_list(collection_id, 2)); + assert!(>::get(( + collection_id, + account(2) + ))); }); } #[test] fn owner_can_remove_address_from_allow_list() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::add_to_allow_list( @@ -1101,41 +1515,51 @@ collection_id, account(2) )); - assert!(!TemplateModule::allow_list(collection_id, 2)); + assert_eq!( + >::get((collection_id, account(2))), + false + ); }); } #[test] fn admin_can_remove_address_from_allow_list() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); + // Owner adds admin assert_ok!(TemplateModule::add_collection_admin( origin1.clone(), collection_id, account(2) )); + // Owner adds address 3 to allow list assert_ok!(TemplateModule::add_to_allow_list( origin1, collection_id, account(3) )); + + // Admin removes address 3 from allow list assert_ok!(TemplateModule::remove_from_allow_list( origin2, collection_id, account(3) )); - assert!(!TemplateModule::allow_list(collection_id, 3)); + assert_eq!( + >::get((collection_id, account(3))), + false + ); }); } #[test] fn nonprivileged_user_cannot_remove_address_from_allow_list() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -1146,9 +1570,12 @@ )); assert_noop!( TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)), - Error::::NoPermission + CommonError::::NoPermission ); - assert!(TemplateModule::allow_list(collection_id, 2)); + assert!(>::get(( + collection_id, + account(2) + ))); }); } @@ -1158,8 +1585,8 @@ let origin1 = Origin::signed(1); assert_noop!( - TemplateModule::remove_from_allow_list(origin1, 1, account(2)), - Error::::CollectionNotFound + TemplateModule::remove_from_allow_list(origin1, CollectionId(1), account(2)), + CommonError::::CollectionNotFound ); }); } @@ -1167,21 +1594,37 @@ #[test] fn nobody_can_remove_address_from_allow_list_of_deleted_collection() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); + // Add account 2 to allow list assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), collection_id, account(2) )); + + // Account 2 is in collection allow-list + assert!(>::get(( + collection_id, + account(2) + ))); + + // Destroy collection assert_ok!(TemplateModule::destroy_collection(origin1, collection_id)); + + // Attempt to remove account 2 from collection allow-list => error assert_noop!( TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)), - Error::::CollectionNotFound + CommonError::::CollectionNotFound + ); + + // Account 2 is not found in collection allow-list anyway + assert_eq!( + >::get((collection_id, account(2))), + false ); - assert!(!TemplateModule::allow_list(collection_id, 2)); }); } @@ -1189,7 +1632,7 @@ #[test] fn address_is_already_removed_from_allow_list() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::add_to_allow_list( @@ -1202,12 +1645,19 @@ collection_id, account(2) )); + assert_eq!( + >::get((collection_id, account(2))), + false + ); assert_ok!(TemplateModule::remove_from_allow_list( origin1, collection_id, account(2) )); - assert!(!TemplateModule::allow_list(collection_id, 2)); + assert_eq!( + >::get((collection_id, account(2))), + false + ); }); } @@ -1215,7 +1665,7 @@ #[test] fn allow_list_test_1() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); @@ -1234,8 +1684,9 @@ )); assert_noop!( - TemplateModule::transfer(origin1, account(3), 1, 1, 1), - Error::::AddresNotInAllowList + TemplateModule::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1) + .map_err(|e| e.error), + CommonError::::AddressNotInAllowlist ); }); } @@ -1243,7 +1694,7 @@ #[test] fn allow_list_test_2() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let data = default_nft_data(); @@ -1256,12 +1707,12 @@ )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + collection_id, account(1) )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + collection_id, account(2) )); @@ -1269,21 +1720,32 @@ assert_ok!(TemplateModule::approve( origin1.clone(), account(1), - 1, - 1, + collection_id, + TokenId(1), 1 )); - assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1); + assert_eq!( + >::get((CollectionId(1), TokenId(1))).unwrap(), + account(1) + ); assert_ok!(TemplateModule::remove_from_allow_list( origin1.clone(), - 1, + collection_id, account(1) )); assert_noop!( - TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1), - Error::::AddresNotInAllowList + TemplateModule::transfer_from( + origin1, + account(1), + account(3), + CollectionId(1), + TokenId(1), + 1 + ) + .map_err(|e| e.error), + CommonError::::AddressNotInAllowlist ); }); } @@ -1292,7 +1754,7 @@ #[test] fn allow_list_test_3() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); @@ -1306,13 +1768,14 @@ )); assert_ok!(TemplateModule::add_to_allow_list( origin1.clone(), - 1, + collection_id, account(1) )); assert_noop!( - TemplateModule::transfer(origin1, account(3), 1, 1, 1), - Error::::AddresNotInAllowList + TemplateModule::transfer(origin1, account(3), collection_id, TokenId(1), 1) + .map_err(|e| e.error), + CommonError::::AddressNotInAllowlist ); }); } @@ -1320,7 +1783,7 @@ #[test] fn allow_list_test_4() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); @@ -1347,11 +1810,14 @@ assert_ok!(TemplateModule::approve( origin1.clone(), account(1), - 1, - 1, + collection_id, + TokenId(1), 1 )); - assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1); + assert_eq!( + >::get((CollectionId(1), TokenId(1))).unwrap(), + account(1) + ); assert_ok!(TemplateModule::remove_from_allow_list( origin1.clone(), @@ -1360,8 +1826,16 @@ )); assert_noop!( - TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1), - Error::::AddresNotInAllowList + TemplateModule::transfer_from( + origin1, + account(1), + account(3), + collection_id, + TokenId(1), + 1 + ) + .map_err(|e| e.error), + CommonError::::AddressNotInAllowlist ); }); } @@ -1370,7 +1844,7 @@ #[test] fn allow_list_test_5() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); @@ -1383,8 +1857,9 @@ AccessMode::AllowList )); assert_noop!( - TemplateModule::burn_item(origin1.clone(), 1, 1, 5), - Error::::AddresNotInAllowList + TemplateModule::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1) + .map_err(|e| e.error), + CommonError::::AddressNotInAllowlist ); }); } @@ -1393,7 +1868,7 @@ #[test] fn allow_list_test_6() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); @@ -1408,8 +1883,9 @@ // do approve assert_noop!( - TemplateModule::approve(origin1, account(1), 1, 1, 5), - Error::::AddresNotInAllowList + TemplateModule::approve(origin1, account(1), CollectionId(1), TokenId(1), 1) + .map_err(|e| e.error), + CommonError::::AddressNotInAllowlist ); }); } @@ -1419,7 +1895,7 @@ #[test] fn allow_list_test_7() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let data = default_nft_data(); create_test_item(collection_id, &data.into()); @@ -1442,20 +1918,28 @@ account(2) )); - assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1)); + assert_ok!(TemplateModule::transfer( + origin1, + account(2), + CollectionId(1), + TokenId(1), + 1 + )); }); } #[test] fn allow_list_test_8() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); + // Create NFT for account 1 let data = default_nft_data(); create_test_item(collection_id, &data.into()); let origin1 = Origin::signed(1); + // Toggle Allow List mode and add accounts 1 and 2 assert_ok!(TemplateModule::set_public_access_mode( origin1.clone(), collection_id, @@ -1472,22 +1956,26 @@ account(2) )); - // do approve + // Sself-approve account 1 for NFT 1 assert_ok!(TemplateModule::approve( origin1.clone(), account(1), - 1, - 1, - 5 + CollectionId(1), + TokenId(1), + 1 )); - assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 5); + assert_eq!( + >::get((CollectionId(1), TokenId(1))).unwrap(), + account(1) + ); + // Transfer from 1 to 2 assert_ok!(TemplateModule::transfer_from( origin1, account(1), account(2), - 1, - 1, + CollectionId(1), + TokenId(1), 1 )); }); @@ -1497,7 +1985,7 @@ #[test] fn allow_list_test_9() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::set_public_access_mode( @@ -1520,7 +2008,7 @@ #[test] fn allow_list_test_10() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -1555,7 +2043,7 @@ #[test] fn allow_list_test_11() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -1577,8 +2065,14 @@ )); assert_noop!( - TemplateModule::create_item(origin2, 1, account(2), default_nft_data().into()), - Error::::PublicMintingNotAllowed + TemplateModule::create_item( + origin2, + CollectionId(1), + account(2), + default_nft_data().into() + ) + .map_err(|e| e.error), + CommonError::::PublicMintingNotAllowed ); }); } @@ -1587,7 +2081,7 @@ #[test] fn allow_list_test_12() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -1604,8 +2098,14 @@ )); assert_noop!( - TemplateModule::create_item(origin2, 1, account(2), default_nft_data().into()), - Error::::PublicMintingNotAllowed + TemplateModule::create_item( + origin2, + CollectionId(1), + account(2), + default_nft_data().into() + ) + .map_err(|e| e.error), + CommonError::::PublicMintingNotAllowed ); }); } @@ -1614,7 +2114,7 @@ #[test] fn allow_list_test_13() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); @@ -1638,7 +2138,7 @@ #[test] fn allow_list_test_14() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -1662,7 +2162,7 @@ assert_ok!(TemplateModule::create_item( origin2, - 1, + collection_id, account(2), default_nft_data().into() )); @@ -1673,7 +2173,7 @@ #[test] fn allow_list_test_15() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -1690,8 +2190,14 @@ )); assert_noop!( - TemplateModule::create_item(origin2, 1, account(2), default_nft_data().into()), - Error::::AddresNotInAllowList + TemplateModule::create_item( + origin2, + collection_id, + account(2), + default_nft_data().into() + ) + .map_err(|e| e.error), + CommonError::::AddressNotInAllowlist ); }); } @@ -1700,7 +2206,7 @@ #[test] fn allow_list_test_16() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -1723,7 +2229,7 @@ assert_ok!(TemplateModule::create_item( origin2, - 1, + collection_id, account(2), default_nft_data().into() )); @@ -1734,18 +2240,27 @@ #[test] fn total_number_collections_bound() { new_test_ext().execute_with(|| { - create_test_collection(&CollectionMode::NFT, 1); + create_test_collection(&CollectionMode::NFT, CollectionId(1)); }); } -// Total number of collections. Negotive test #[test] +fn create_max_collections() { + new_test_ext().execute_with(|| { + for i in 1..=COLLECTION_NUMBER_LIMIT { + create_test_collection(&CollectionMode::NFT, CollectionId(i)); + } + }); +} + +// Total number of collections. Negative test +#[test] fn total_number_collections_bound_neg() { new_test_ext().execute_with(|| { let origin1 = Origin::signed(1); - for i in 0..COLLECTION_NUMBER_LIMIT { - create_test_collection(&CollectionMode::NFT, i + 1); + for i in 1..=COLLECTION_NUMBER_LIMIT { + create_test_collection(&CollectionMode::NFT, CollectionId(i)); } let col_name1: Vec = "Test1\0".encode_utf16().collect::>(); @@ -1761,7 +2276,7 @@ token_prefix1, CollectionMode::NFT ), - Error::::TotalCollectionsLimitExceeded + CommonError::::TotalCollectionsLimitExceeded ); }); } @@ -1770,7 +2285,7 @@ #[test] fn owned_tokens_bound() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let data = default_nft_data(); create_test_item(collection_id, &data.clone().into()); @@ -1782,19 +2297,20 @@ #[test] fn owned_tokens_bound_neg() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); - for _ in 0..ACCOUNT_TOKEN_OWNERSHIP_LIMIT { + for _ in 1..=MAX_TOKEN_OWNERSHIP { let data = default_nft_data(); create_test_item(collection_id, &data.clone().into()); } let data = default_nft_data(); assert_noop!( - TemplateModule::create_item(origin1, 1, account(1), data.into()), - Error::::AccountTokenLimitExceeded + TemplateModule::create_item(origin1, CollectionId(1), account(1), data.into()) + .map_err(|e| e.error), + CommonError::::AccountTokenLimitExceeded ); }); } @@ -1803,7 +2319,7 @@ #[test] fn collection_admins_bound() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); @@ -1824,7 +2340,7 @@ #[test] fn collection_admins_bound_neg() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); @@ -1832,16 +2348,16 @@ assert_ok!(TemplateModule::add_collection_admin( origin1.clone(), collection_id, - account(2 + i) + account((2 + i).into()) )); } assert_noop!( TemplateModule::add_collection_admin( origin1, collection_id, - account(3 + COLLECTION_ADMINS_LIMIT) + account((3 + COLLECTION_ADMINS_LIMIT).into()) ), - Error::::CollectionAdminsLimitExceeded + CommonError::::CollectionAdminCountExceeded ); }); } @@ -1850,7 +2366,7 @@ #[test] fn set_const_on_chain_schema() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::set_const_on_chain_schema( @@ -1860,13 +2376,13 @@ )); assert_eq!( - TemplateModule::collection_id(collection_id) + >::get(collection_id) .unwrap() .const_on_chain_schema, b"test const on chain schema".to_vec() ); assert_eq!( - TemplateModule::collection_id(collection_id) + >::get(collection_id) .unwrap() .variable_on_chain_schema, b"".to_vec() @@ -1877,7 +2393,7 @@ #[test] fn set_variable_on_chain_schema() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); assert_ok!(TemplateModule::set_variable_on_chain_schema( @@ -1887,13 +2403,13 @@ )); assert_eq!( - TemplateModule::collection_id(collection_id) + >::get(collection_id) .unwrap() .const_on_chain_schema, b"".to_vec() ); assert_eq!( - TemplateModule::collection_id(collection_id) + >::get(collection_id) .unwrap() .variable_on_chain_schema, b"test variable on chain schema".to_vec() @@ -1904,23 +2420,23 @@ #[test] fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let data = default_nft_data(); - create_test_item(1, &data.into()); + create_test_item(CollectionId(1), &data.into()); let variable_data = b"test data".to_vec(); assert_ok!(TemplateModule::set_variable_meta_data( origin1, collection_id, - 1, + TokenId(1), variable_data.clone() )); assert_eq!( - TemplateModule::nft_item_id(collection_id, 1) + >::get((collection_id, 1)) .unwrap() .variable_data, variable_data @@ -1931,25 +2447,23 @@ #[test] fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::ReFungible, 1); + let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1)); let origin1 = Origin::signed(1); let data = default_re_fungible_data(); - create_test_item(1, &data.into()); + create_test_item(collection_id, &data.into()); let variable_data = b"test data".to_vec(); assert_ok!(TemplateModule::set_variable_meta_data( origin1, collection_id, - 1, + TokenId(1), variable_data.clone() )); assert_eq!( - TemplateModule::refungible_item_id(collection_id, 1) - .unwrap() - .variable_data, + >::get((collection_id, TokenId(1))).variable_data, variable_data ); }); @@ -1958,17 +2472,23 @@ #[test] fn set_variable_meta_data_on_fungible_token_fails() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1); + let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1)); let origin1 = Origin::signed(1); let data = default_fungible_data(); - create_test_item(1, &data.into()); + create_test_item(collection_id, &data.into()); let variable_data = b"test data".to_vec(); assert_noop!( - TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), - Error::::CantStoreMetadataInFungibleTokens + TemplateModule::set_variable_meta_data( + origin1, + collection_id, + TokenId(0), + variable_data + ) + .map_err(|e| e.error), + >::FungibleItemsDontHaveData ); }); } @@ -1976,17 +2496,23 @@ #[test] fn set_variable_meta_data_on_nft_token_fails_for_big_data() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let data = default_nft_data(); - create_test_item(1, &data.into()); + create_test_item(collection_id, &data.into()); let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec(); assert_noop!( - TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), - Error::::TokenVariableDataLimitExceeded + TemplateModule::set_variable_meta_data( + origin1, + collection_id, + TokenId(1), + variable_data + ) + .map_err(|e| e.error), + CommonError::::TokenVariableDataLimitExceeded ); }); } @@ -1994,17 +2520,23 @@ #[test] fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection(&CollectionMode::ReFungible, 1); + let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1)); let origin1 = Origin::signed(1); let data = default_re_fungible_data(); - create_test_item(1, &data.into()); + create_test_item(collection_id, &data.into()); let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec(); assert_noop!( - TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), - Error::::TokenVariableDataLimitExceeded + TemplateModule::set_variable_meta_data( + origin1, + collection_id, + TokenId(1), + variable_data + ) + .map_err(|e| e.error), + CommonError::::TokenVariableDataLimitExceeded ); }); } @@ -2014,12 +2546,12 @@ new_test_ext().execute_with(|| { //default_limits(); - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); let origin1 = Origin::signed(1); let data = default_nft_data(); - create_test_item(1, &data.into()); + create_test_item(collection_id, &data.into()); assert_ok!(TemplateModule::set_meta_update_permission_flag( origin1.clone(), @@ -2031,12 +2563,12 @@ assert_ok!(TemplateModule::set_variable_meta_data( origin1, collection_id, - 1, + TokenId(1), variable_data.clone() )); assert_eq!( - TemplateModule::nft_item_id(collection_id, 1) + >::get((collection_id, TokenId(1))) .unwrap() .variable_data, variable_data @@ -2047,7 +2579,8 @@ #[test] fn set_variable_meta_data_on_nft_with_item_owner_permission_flag_neg() { new_test_ext().execute_with(|| { - let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1); + let collection_id = + create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1)); let origin1 = Origin::signed(1); @@ -2063,7 +2596,7 @@ )); let data = default_nft_data(); - create_test_item(1, &data.into()); + create_test_item(collection_id, &data.into()); assert_ok!(TemplateModule::set_meta_update_permission_flag( origin1.clone(), @@ -2076,10 +2609,11 @@ TemplateModule::set_variable_meta_data( origin1, collection_id, - 1, + TokenId(1), variable_data.clone() - ), - Error::::TokenVariableDataLimitExceeded + ) + .map_err(|e| e.error), + CommonError::::TokenVariableDataLimitExceeded ); }) } @@ -2089,23 +2623,50 @@ new_test_ext().execute_with(|| { let origin1 = Origin::signed(1); - let collection_id = create_test_collection(&CollectionMode::NFT, 1); - assert_ok!(TemplateModule::set_transfers_enabled_flag(origin1, 1, true)); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); + assert_ok!(TemplateModule::set_transfers_enabled_flag( + origin1, + collection_id, + true + )); let data = default_nft_data(); create_test_item(collection_id, &data.into()); - assert_eq!(TemplateModule::balance_count(1, 1), 1); - assert_eq!(TemplateModule::address_tokens(1, 1), [1]); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); let origin1 = Origin::signed(1); // default scenario - assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1000)); - assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(2)); - assert_eq!(TemplateModule::balance_count(1, 1), 0); - assert_eq!(TemplateModule::balance_count(1, 2), 1); - - assert_eq!(TemplateModule::address_tokens(1, 2), [1]); + assert_ok!(TemplateModule::transfer( + origin1, + account(2), + collection_id, + TokenId(1), + 1 + )); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + false + ); + assert_eq!( + >::get((collection_id, account(2), TokenId(1))), + true + ); + assert_eq!( + >::get((collection_id, account(1))), + 0 + ); + assert_eq!( + >::get((collection_id, account(2))), + 1 + ); }); } @@ -2114,7 +2675,8 @@ new_test_ext().execute_with(|| { // default_limits(); - let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1); + let collection_id = + create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -2137,7 +2699,7 @@ )); let data = default_nft_data(); - create_test_item(1, &data.into()); + create_test_item(collection_id, &data.into()); assert_ok!(TemplateModule::set_meta_update_permission_flag( origin2.clone(), @@ -2149,12 +2711,12 @@ assert_ok!(TemplateModule::set_variable_meta_data( origin1, collection_id, - 1, + TokenId(1), variable_data.clone() )); assert_eq!( - TemplateModule::nft_item_id(collection_id, 1) + >::get((collection_id, 1)) .unwrap() .variable_data, variable_data @@ -2167,7 +2729,8 @@ new_test_ext().execute_with(|| { // default_limits(); - let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1); + let collection_id = + create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1)); let origin1 = Origin::signed(1); let origin2 = Origin::signed(2); @@ -2184,7 +2747,7 @@ )); let data = default_nft_data(); - create_test_item(1, &data.into()); + create_test_item(collection_id, &data.into()); assert_ok!(TemplateModule::set_meta_update_permission_flag( origin2.clone(), @@ -2197,10 +2760,11 @@ TemplateModule::set_variable_meta_data( origin1, collection_id, - 1, + TokenId(1), variable_data.clone() - ), - Error::::NoPermission + ) + .map_err(|e| e.error), + CommonError::::NoPermission ); }); } @@ -2210,7 +2774,8 @@ new_test_ext().execute_with(|| { // default_limits(); - let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1); + let collection_id = + create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1)); let origin2 = Origin::signed(2); @@ -2225,7 +2790,7 @@ collection_id, MetaUpdatePermission::Admin ), - Error::::MetadataFlagFrozen + CommonError::::MetadataFlagFrozen ); }); } @@ -2235,11 +2800,12 @@ new_test_ext().execute_with(|| { // default_limits(); - let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1); + let collection_id = + create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1)); let origin1 = Origin::signed(1); let data = default_nft_data(); - create_test_item(1, &data.into()); + create_test_item(collection_id, &data.into()); assert_ok!(TemplateModule::set_meta_update_permission_flag( origin1.clone(), @@ -2252,10 +2818,11 @@ TemplateModule::set_variable_meta_data( origin1.clone(), collection_id, - 1, + TokenId(1), variable_data.clone() - ), - Error::::MetadataUpdateDenied + ) + .map_err(|e| e.error), + CommonError::::NoPermission ); }); } @@ -2265,27 +2832,47 @@ new_test_ext().execute_with(|| { let origin1 = Origin::signed(1); - let collection_id = create_test_collection(&CollectionMode::NFT, 1); + let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1)); assert_ok!(TemplateModule::set_transfers_enabled_flag( - origin1, 1, false + origin1, + collection_id, + false )); let data = default_nft_data(); create_test_item(collection_id, &data.into()); - assert_eq!(TemplateModule::balance_count(1, 1), 1); - assert_eq!(TemplateModule::address_tokens(1, 1), [1]); + assert_eq!( + >::get((collection_id, account(1))), + 1 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); let origin1 = Origin::signed(1); // default scenario assert_noop!( - TemplateModule::transfer(origin1, account(2), 1, 1, 1000), - Error::::TransferNotAllowed + TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1) + .map_err(|e| e.error), + CommonError::::TransferNotAllowed + ); + assert_eq!( + >::get((collection_id, account(1))), + 1 ); - assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(1)); - assert_eq!(TemplateModule::balance_count(1, 1), 1); - assert_eq!(TemplateModule::balance_count(1, 2), 0); - - assert_eq!(TemplateModule::address_tokens(1, 1), [1]); + assert_eq!( + >::get((collection_id, account(2))), + 0 + ); + assert_eq!( + >::get((collection_id, account(1), TokenId(1))), + true + ); + assert_eq!( + >::get((collection_id, account(2), TokenId(1))), + false + ); }); } --- a/primitives/data-structs/src/lib.rs +++ b/primitives/data-structs/src/lib.rs @@ -29,10 +29,14 @@ pub const MAX_DECIMAL_POINTS: DecimalPoints = 30; pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000; pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000; -pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000; +pub const MAX_TOKEN_OWNERSHIP: u32 = if cfg!(not(feature = "limit-testing")) { + 10_000_000 +} else { + 10 +}; pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) { - 100000 + 100_000 } else { 10 }; @@ -44,7 +48,7 @@ pub const COLLECTION_ADMINS_LIMIT: u32 = 5; pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX; pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) { - 1000000 + 1_000_000 } else { 10 }; -- gitstuff