git.delta.rocks / unique-network / refs/commits / 0954b32db3b2

1// Tests to be written here2use super::*;3use crate::mock::*;4use crate::{AccessMode, CollectionMode,5    Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData,6    CollectionId, TokenId, MAX_DECIMAL_POINTS};7use frame_support::{assert_noop, assert_ok};8use frame_system::{ RawOrigin };910fn default_collection_numbers_limit() -> u32 {11    1012}1314fn default_limits() {15    assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {16            collection_numbers_limit: default_collection_numbers_limit(),17            account_token_ownership_limit: 10,18            collections_admins_limit: 5,19            custom_data_limit: 2048,20            nft_sponsor_transfer_timeout: 15,21            fungible_sponsor_transfer_timeout: 15,22            refungible_sponsor_transfer_timeout: 15,23            const_on_chain_schema_limit: 1024,24            offchain_schema_limit: 1024,25            variable_on_chain_schema_limit: 1024,26        }));27}2829fn default_nft_data() -> CreateNftData {30    CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }31}3233fn default_fungible_data () -> CreateFungibleData {34    CreateFungibleData { value: 5 }35}3637fn default_re_fungible_data () -> CreateReFungibleData {38    CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }39}4041fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64, id: CollectionId) -> CollectionId {42    let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();43    let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();44    let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();4546    let origin1 = Origin::signed(owner);47    assert_ok!(TemplateModule::create_collection(48            origin1.clone(),49            col_name1.clone(),50            col_desc1.clone(),51            token_prefix1.clone(),52            mode.clone()53        ));5455    let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();56    let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();57    let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();58    assert_eq!(TemplateModule::collection(id).owner, owner);59    assert_eq!(TemplateModule::collection(id).name, saved_col_name);60    assert_eq!(TemplateModule::collection(id).mode, *mode);61    assert_eq!(TemplateModule::collection(id).description, saved_description);62    assert_eq!(TemplateModule::collection(id).token_prefix, saved_prefix);63    id64}6566fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {67    create_test_collection_for_owner(&mode, 1, id)68}6970fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {71    let origin1 = Origin::signed(1);72    assert_ok!(TemplateModule::create_item(73            origin1.clone(),74            collection_id,75            1,76            data.clone()77        ));7879}8081// Use cases tests region82// #region8384#[test]85fn set_version_schema() {86    new_test_ext().execute_with(|| {87        default_limits();88        let origin1 = Origin::signed(1);89        let collection_id = create_test_collection(&CollectionMode::NFT, 1);90        91        assert_ok!(TemplateModule::set_schema_version(origin1, collection_id, SchemaVersion::Unique));92        assert_eq!(TemplateModule::collection(collection_id).schema_version, SchemaVersion::Unique);93    });94}9596#[test]97fn create_fungible_collection_fails_with_large_decimal_numbers() {98    new_test_ext().execute_with(|| {99        default_limits();100101        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();102        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();103        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();104105        let origin1 = Origin::signed(1);106        assert_noop!(TemplateModule::create_collection(107            origin1,108            col_name1,109            col_desc1,110            token_prefix1,111            CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1)112        ), Error::<Test>::CollectionDecimalPointLimitExceeded);113    });    114}115116#[test]117fn create_re_fungible_collection_fails_with_large_decimal_numbers() {118    new_test_ext().execute_with(|| {119        default_limits();120121        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();122        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();123        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();124125        let origin1 = Origin::signed(1);126        assert_noop!(TemplateModule::create_collection(127            origin1,128            col_name1,129            col_desc1,130            token_prefix1,131            CollectionMode::ReFungible(MAX_DECIMAL_POINTS + 1)132        ), Error::<Test>::CollectionDecimalPointLimitExceeded);133    });134}135136#[test]137fn create_nft_item() {138    new_test_ext().execute_with(|| {139        default_limits();140        let collection_id = create_test_collection(&CollectionMode::NFT, 1);141        142        let data = default_nft_data();143        create_test_item(collection_id, &data.clone().into());144        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);145        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);146    });147}148149// Use cases tests region150// #region151#[test]152fn create_nft_multiple_items() {153    new_test_ext().execute_with(|| {154        default_limits();155        156        create_test_collection(&CollectionMode::NFT, 1);157158        let origin1 = Origin::signed(1);159160        let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];161162        assert_ok!(TemplateModule::create_multiple_items(163            origin1.clone(),164            1,165            1,166            items_data.clone().into_iter().map(|d| { d.into() }).collect()167        ));168        for (index, data) in items_data.iter().enumerate() {169            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as TokenId).const_data.to_vec(), data.const_data);170            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as TokenId).variable_data.to_vec(), data.variable_data);171        }172    });173}174175#[test]176fn create_refungible_item() {177    new_test_ext().execute_with(|| {178        default_limits();179        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);180181        let data = default_re_fungible_data();182        create_test_item(collection_id, &data.clone().into());183        assert_eq!(184            TemplateModule::refungible_item_id(collection_id, 1).const_data,185            data.const_data186        );187        assert_eq!(188            TemplateModule::refungible_item_id(collection_id, 1).variable_data,189            data.variable_data190        );191        assert_eq!(192            TemplateModule::refungible_item_id(collection_id, 1).owner[0],193            Ownership {194                owner: 1,195                fraction: 1000196            }197        );198    });199}200201#[test]202fn create_multiple_refungible_items() {203    new_test_ext().execute_with(|| {204        default_limits();205        206        create_test_collection(&CollectionMode::ReFungible(3), 1);207208        let origin1 = Origin::signed(1);209210        let items_data = vec![default_re_fungible_data(), default_re_fungible_data(), default_re_fungible_data()];211212        assert_ok!(TemplateModule::create_multiple_items(213            origin1.clone(),214            1,215            1,216            items_data.clone().into_iter().map(|d| { d.into() }).collect()217        ));218        for (index, data) in items_data.iter().enumerate() {219220            let item = TemplateModule::refungible_item_id(1, (index + 1) as TokenId);221            assert_eq!(item.const_data.to_vec(), data.const_data);222            assert_eq!(item.variable_data.to_vec(), data.variable_data);223            assert_eq!(224                item.owner[0],225                Ownership {226                    owner: 1,227                    fraction: 1000228                }229            );230        }231    });232}233234#[test]235fn create_fungible_item() {236    new_test_ext().execute_with(|| {237        default_limits();238        239        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);240241        let data = default_fungible_data();242        create_test_item(collection_id, &data.into());243244        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).value, 5);245    });246}247248//#[test]249// fn create_multiple_fungible_items() {250//     new_test_ext().execute_with(|| {251//         default_limits();252253//         create_test_collection(&CollectionMode::Fungible(3), 1);254255//         let origin1 = Origin::signed(1);256257//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];258259//         assert_ok!(TemplateModule::create_multiple_items(260//             origin1.clone(),261//             1,262//             1,263//             items_data.clone().into_iter().map(|d| { d.into() }).collect()264//         ));265        266//         for (index, _) in items_data.iter().enumerate() {267//             assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).value, 5);268//         }269//         assert_eq!(TemplateModule::balance_count(1, 1), 3000);270//         assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);271//     });272// }273274#[test]275fn transfer_fungible_item() {276    new_test_ext().execute_with(|| {277        default_limits();278        279        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);280281        let origin1 = Origin::signed(1);282        let origin2 = Origin::signed(2);283284        let data = default_fungible_data();285        create_test_item(collection_id, &data.into());286287        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 5);288        assert_eq!(TemplateModule::balance_count(1, 1), 5);289290        // change owner scenario291        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 5));292        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 0);293        assert_eq!(TemplateModule::balance_count(1, 1), 0);294        assert_eq!(TemplateModule::balance_count(1, 2), 5);295296        // split item scenario297        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 3));298        assert_eq!(TemplateModule::balance_count(1, 2), 2);299        assert_eq!(TemplateModule::balance_count(1, 3), 3);300301        // split item and new owner has account scenario302        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 1));303        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 1);304        assert_eq!(TemplateModule::fungible_item_id(1, 3).value, 4);305        assert_eq!(TemplateModule::balance_count(1, 2), 1);306        assert_eq!(TemplateModule::balance_count(1, 3), 4);307    });308}309310#[test]311fn transfer_refungible_item() {312    new_test_ext().execute_with(|| {313        default_limits();314        315        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);316317        let data = default_re_fungible_data();318        create_test_item(collection_id, &data.clone().into());319320        let origin1 = Origin::signed(1);321        let origin2 = Origin::signed(2);322        assert_eq!(323            TemplateModule::refungible_item_id(collection_id, 1).const_data,324            data.const_data325        );326        assert_eq!(327            TemplateModule::refungible_item_id(collection_id, 1).variable_data,328            data.variable_data329        );330        assert_eq!(331            TemplateModule::refungible_item_id(collection_id, 1).owner[0],332            Ownership {333                owner: 1,334                fraction: 1000335            }336        );337        assert_eq!(TemplateModule::balance_count(1, 1), 1000);338        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);339340        // change owner scenario341        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));342        assert_eq!(343            TemplateModule::refungible_item_id(1, 1).owner[0],344            Ownership {345                owner: 2,346                fraction: 1000347            }348        );349        assert_eq!(TemplateModule::balance_count(1, 1), 0);350        assert_eq!(TemplateModule::balance_count(1, 2), 1000);351        // assert_eq!(TemplateModule::address_tokens(1, 1), []);352        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);353354        // split item scenario355        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));356        assert_eq!(357            TemplateModule::refungible_item_id(1, 1).owner[0],358            Ownership {359                owner: 2,360                fraction: 500361            }362        );363        assert_eq!(364            TemplateModule::refungible_item_id(1, 1).owner[1],365            Ownership {366                owner: 3,367                fraction: 500368            }369        );370        assert_eq!(TemplateModule::balance_count(1, 2), 500);371        assert_eq!(TemplateModule::balance_count(1, 3), 500);372        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);373        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);374375        // split item and new owner has account scenario376        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));377        assert_eq!(378            TemplateModule::refungible_item_id(1, 1).owner[0],379            Ownership {380                owner: 2,381                fraction: 300382            }383        );384        assert_eq!(385            TemplateModule::refungible_item_id(1, 1).owner[1],386            Ownership {387                owner: 3,388                fraction: 700389            }390        );391        assert_eq!(TemplateModule::balance_count(1, 2), 300);392        assert_eq!(TemplateModule::balance_count(1, 3), 700);393        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);394        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);395    });396}397398#[test]399fn transfer_nft_item() {400    new_test_ext().execute_with(|| {401        default_limits();402        403        let collection_id = create_test_collection(&CollectionMode::NFT, 1);404405        let data = default_nft_data();406        create_test_item(collection_id, &data.into());407        assert_eq!(TemplateModule::balance_count(1, 1), 1);408        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);409410        let origin1 = Origin::signed(1);411        // default scenario412        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));413        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);414        assert_eq!(TemplateModule::balance_count(1, 1), 0);415        assert_eq!(TemplateModule::balance_count(1, 2), 1);416        // assert_eq!(TemplateModule::address_tokens(1, 1), []);417        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);418    });419}420421#[test]422fn nft_approve_and_transfer_from() {423    new_test_ext().execute_with(|| {424        default_limits();425        426        let collection_id = create_test_collection(&CollectionMode::NFT, 1);427428        let data = default_nft_data();429        create_test_item(collection_id, &data.into());430431        let origin1 = Origin::signed(1);432        let origin2 = Origin::signed(2);433434        assert_eq!(TemplateModule::balance_count(1, 1), 1);435        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);436437        // neg transfer438        assert_noop!(TemplateModule::transfer_from(439            origin2.clone(),440            1,441            2,442            1,443            1,444            1), Error::<Test>::NoPermission);445446        // do approve447        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));448        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);449        assert_eq!(450            TemplateModule::approved(1, (1, 1, 2)),451            5452        );453454        assert_ok!(TemplateModule::transfer_from(455            origin2.clone(),456            1,457            2,458            1,459            1,460            1461        ));462        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 4);463    });464}465466#[test]467fn nft_approve_and_transfer_from_white_list() {468    new_test_ext().execute_with(|| {469        default_limits();470        471        let collection_id = create_test_collection(&CollectionMode::NFT, 1);472473        let origin1 = Origin::signed(1);474        let origin2 = Origin::signed(2);475476        let data = default_nft_data();477        create_test_item(collection_id, &data.clone().into());478479        assert_eq!(TemplateModule::nft_item_id(1, 1).const_data, data.const_data);480        assert_eq!(TemplateModule::balance_count(1, 1), 1);481        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);482483        assert_ok!(TemplateModule::set_mint_permission(484            origin1.clone(),485            1,486            true487        ));488        assert_ok!(TemplateModule::set_public_access_mode(489            origin1.clone(),490            1,491            AccessMode::WhiteList492        ));493        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));494        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));495        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));496497        // do approve498        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));499        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);500        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 5));501        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);502503        assert_ok!(TemplateModule::transfer_from(504            origin2.clone(),505            1,506            3,507            1,508            1,509            1510        ));511        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 4);512    });513}514515#[test]516fn refungible_approve_and_transfer_from() {517    new_test_ext().execute_with(|| {518        default_limits();519        520        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);521        522        let origin1 = Origin::signed(1);523        let origin2 = Origin::signed(2);524525        let data = default_re_fungible_data();526        create_test_item(collection_id, &data.into());527528        assert_eq!(TemplateModule::balance_count(1, 1), 1000);529        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);530531        assert_ok!(TemplateModule::set_mint_permission(532            origin1.clone(),533            1,534            true535        ));536        assert_ok!(TemplateModule::set_public_access_mode(537            origin1.clone(),538            1,539            AccessMode::WhiteList540        ));541        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));542        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));543        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));544545        // do approve546        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));547        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);548        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 1000));549        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 1000);550551        assert_ok!(TemplateModule::transfer_from(552            origin2.clone(),553            1,554            3,555            1,556            1,557            100558        ));559        assert_eq!(TemplateModule::balance_count(1, 1), 900);560        assert_eq!(TemplateModule::balance_count(1, 3), 100);561        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);562        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);563564        assert_eq!(565            TemplateModule::approved(1, (1, 1, 3)),566            900567        );568    });569}570571#[test]572fn fungible_approve_and_transfer_from() {573    new_test_ext().execute_with(|| {574        default_limits();575        576        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);577        578        let data = default_fungible_data();579        create_test_item(collection_id, &data.into());580581        let origin1 = Origin::signed(1);582        let origin2 = Origin::signed(2);583584        assert_eq!(TemplateModule::balance_count(1, 1), 5);585586        assert_ok!(TemplateModule::set_mint_permission(587            origin1.clone(),588            1,589            true590        ));591        assert_ok!(TemplateModule::set_public_access_mode(592            origin1.clone(),593            1,594            AccessMode::WhiteList595        ));596        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));597        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));598        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));599600        // do approve601        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));602        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);603        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 5));604        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);605        assert_eq!(606            TemplateModule::approved(1, (1, 1, 2)),607            5608        );609610        assert_ok!(TemplateModule::transfer_from(611            origin2.clone(),612            1,613            3,614            1,615            1,616            4617        ));618        assert_eq!(TemplateModule::balance_count(1, 1), 1);619        assert_eq!(TemplateModule::balance_count(1, 3), 4);620621        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);622        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 1);623624        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));625        assert_noop!(TemplateModule::transfer_from(626            origin2.clone(),627            1,628            3,629            1,630            1,631            4632        ), Error::<Test>::TokenValueNotEnough);633    });634}635636#[test]637fn change_collection_owner() {638    new_test_ext().execute_with(|| {639        default_limits();640        641        let collection_id = create_test_collection(&CollectionMode::NFT, 1);642        643        let origin1 = Origin::signed(1);644        assert_ok!(TemplateModule::change_collection_owner(645            origin1.clone(),646            collection_id,647            2648        ));649        assert_eq!(TemplateModule::collection(collection_id).owner, 2);650    });651}652653#[test]654fn destroy_collection() {655    new_test_ext().execute_with(|| {656        default_limits();657        658        let collection_id = create_test_collection(&CollectionMode::NFT, 1);659        660        let origin1 = Origin::signed(1);661        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));662    });663}664665#[test]666fn burn_nft_item() {667    new_test_ext().execute_with(|| {668        default_limits();669        670        let collection_id = create_test_collection(&CollectionMode::NFT, 1);671672        let origin1 = Origin::signed(1);673        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));674        675        let data = default_nft_data();676        create_test_item(collection_id, &data.into());677678        // check balance (collection with id = 1, user id = 1)679        assert_eq!(TemplateModule::balance_count(1, 1), 1);680681        // burn item682        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));683        assert_noop!(684            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),685            Error::<Test>::TokenNotFound686        );687688        assert_eq!(TemplateModule::balance_count(1, 1), 0);689    });690}691692#[test]693fn burn_fungible_item() {694    new_test_ext().execute_with(|| {695        default_limits();696        697        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);698        699        let origin1 = Origin::signed(1);700        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));701        702        let data = default_fungible_data();703        create_test_item(collection_id, &data.into());704705        // check balance (collection with id = 1, user id = 1)706        assert_eq!(TemplateModule::balance_count(1, 1), 5);707708        // burn item709        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));710        assert_noop!(711            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),712            Error::<Test>::TokenNotFound713        );714715        assert_eq!(TemplateModule::balance_count(1, 1), 0);716    });717}718719#[test]720fn burn_refungible_item() {721    new_test_ext().execute_with(|| {722        default_limits();723        724        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);725        let origin1 = Origin::signed(1);726727        assert_ok!(TemplateModule::set_mint_permission(728            origin1.clone(),729            collection_id,730            true731        ));732        assert_ok!(TemplateModule::set_public_access_mode(733            origin1.clone(),734            collection_id,735            AccessMode::WhiteList736        ));737        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));738739        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));740        741        let data = default_re_fungible_data();742        create_test_item(collection_id, &data.into());743744        // check balance (collection with id = 1, user id = 2)745        assert_eq!(TemplateModule::balance_count(1, 1), 1000);746747        // burn item748        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 1000));749        assert_noop!(750            TemplateModule::burn_item(origin1.clone(), 1, 1, 1000),751            Error::<Test>::TokenNotFound752        );753754        assert_eq!(TemplateModule::balance_count(1, 1), 0);755    });756}757758#[test]759fn add_collection_admin() {760    new_test_ext().execute_with(|| {761        default_limits();762        763        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);764        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);765        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);766        767        let origin1 = Origin::signed(1);768769        // collection admin770        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));771        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));772773        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);774        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);775    });776}777778#[test]779fn remove_collection_admin() {780    new_test_ext().execute_with(|| {781        default_limits();782        783        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);784        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);785        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);786787        let origin1 = Origin::signed(1);788        let origin2 = Origin::signed(2);789790        // collection admin791        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));792        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));793794        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);795        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);796797        // remove admin798        assert_ok!(TemplateModule::remove_collection_admin(799            origin2.clone(),800            1,801            3802        ));803        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);804    });805}806807#[test]808fn balance_of() {809    new_test_ext().execute_with(|| {810        default_limits();811        812        let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);813        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);814        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3), 3);815        816        // check balance before817        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);818        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);819        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);820821        let nft_data = default_nft_data();822        create_test_item(nft_collection_id, &nft_data.into());823        824        let fungible_data = default_fungible_data();825        create_test_item(fungible_collection_id, &fungible_data.into());826        827        let re_fungible_data = default_re_fungible_data();828        create_test_item(re_fungible_collection_id, &re_fungible_data.into());829830        // check balance (collection with id = 1, user id = 1)831        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);832        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 5);833        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);834        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);835        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).value, 5);836        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);837    });838}839840#[test]841fn approve() {842    new_test_ext().execute_with(|| {843        default_limits();844        845        let collection_id = create_test_collection(&CollectionMode::NFT, 1);846        847        let data = default_nft_data();848        create_test_item(collection_id, &data.into());849850        let origin1 = Origin::signed(1);851        852        // approve853        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 1));854        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);855    });856}857858#[test]859fn transfer_from() {860    new_test_ext().execute_with(|| {861        default_limits();862        863        let collection_id = create_test_collection(&CollectionMode::NFT, 1);864        let origin1 = Origin::signed(1);865        let origin2 = Origin::signed(2);866867        let data = default_nft_data();868        create_test_item(collection_id, &data.into());869870        // approve871        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 1));872        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);873874        assert_ok!(TemplateModule::set_mint_permission(875            origin1.clone(),876            1,877            true878        ));879        assert_ok!(TemplateModule::set_public_access_mode(880            origin1.clone(),881            1,882            AccessMode::WhiteList883        ));884        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));885        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));886        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));887888        assert_ok!(TemplateModule::transfer_from(889            origin2.clone(),890            1,891            2,892            1,893            1,894            1895        ));896897        // after transfer898        assert_eq!(TemplateModule::balance_count(1, 1), 0);899        assert_eq!(TemplateModule::balance_count(1, 2), 1);900    });901}902903// #endregion904905// Coverage tests region906// #region907908#[test]909fn owner_can_add_address_to_white_list() {910    new_test_ext().execute_with(|| {911        default_limits();912        913        let collection_id = create_test_collection(&CollectionMode::NFT, 1);914915        let origin1 = Origin::signed(1);916        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));917        assert_eq!(TemplateModule::white_list(collection_id, 2), true);918    });919}920921#[test]922fn admin_can_add_address_to_white_list() {923    new_test_ext().execute_with(|| {924        default_limits();925        926        let collection_id = create_test_collection(&CollectionMode::NFT, 1);927        let origin1 = Origin::signed(1);928        let origin2 = Origin::signed(2);929930        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));931        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));932        assert_eq!(TemplateModule::white_list(collection_id, 3), true);933    });934}935936#[test]937fn nonprivileged_user_cannot_add_address_to_white_list() {938    new_test_ext().execute_with(|| {939        default_limits();940        941        let collection_id = create_test_collection(&CollectionMode::NFT, 1);942943        let origin2 = Origin::signed(2);944        assert_noop!(945            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),946            Error::<Test>::NoPermission947        );948    });949}950951#[test]952fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {953    new_test_ext().execute_with(|| {954        default_limits();955956        let origin1 = Origin::signed(1);957958        assert_noop!(959            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),960            Error::<Test>::CollectionNotFound961        );962    });963}964965#[test]966fn nobody_can_add_address_to_white_list_of_deleted_collection() {967    new_test_ext().execute_with(|| {968        default_limits();969        970        let collection_id = create_test_collection(&CollectionMode::NFT, 1);971972        let origin1 = Origin::signed(1);973        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));974        assert_noop!(975            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),976            Error::<Test>::CollectionNotFound977        );978    });979}980981// If address is already added to white list, nothing happens982#[test]983fn address_is_already_added_to_white_list() {984    new_test_ext().execute_with(|| {985        default_limits();986        987        let collection_id = create_test_collection(&CollectionMode::NFT, 1);988        let origin1 = Origin::signed(1);989        990        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));991        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));992        assert_eq!(TemplateModule::white_list(collection_id, 2), true);993    });994}995996#[test]997fn owner_can_remove_address_from_white_list() {998    new_test_ext().execute_with(|| {999        default_limits();1000        1001        let collection_id = create_test_collection(&CollectionMode::NFT, 1);10021003        let origin1 = Origin::signed(1);1004        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1005        assert_ok!(TemplateModule::remove_from_white_list(1006            origin1.clone(),1007            collection_id,1008            21009        ));1010        assert_eq!(TemplateModule::white_list(collection_id, 2), false);1011    });1012}10131014#[test]1015fn admin_can_remove_address_from_white_list() {1016    new_test_ext().execute_with(|| {1017        default_limits();1018        1019        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1020        let origin1 = Origin::signed(1);1021        let origin2 = Origin::signed(2);10221023        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));10241025        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));1026        assert_ok!(TemplateModule::remove_from_white_list(1027            origin2.clone(),1028            collection_id,1029            31030        ));1031        assert_eq!(TemplateModule::white_list(collection_id, 3), false);1032    });1033}10341035#[test]1036fn nonprivileged_user_cannot_remove_address_from_white_list() {1037    new_test_ext().execute_with(|| {1038        default_limits();1039        1040        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1041        let origin1 = Origin::signed(1);1042        let origin2 = Origin::signed(2);10431044        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1045        assert_noop!(1046            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1047            Error::<Test>::NoPermission1048        );1049        assert_eq!(TemplateModule::white_list(collection_id, 2), true);1050    });1051}10521053#[test]1054fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1055    new_test_ext().execute_with(|| {1056        default_limits();1057        let origin1 = Origin::signed(1);10581059        assert_noop!(1060            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),1061            Error::<Test>::CollectionNotFound1062        );1063    });1064}10651066#[test]1067fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1068    new_test_ext().execute_with(|| {1069        default_limits();1070        1071        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1072        let origin1 = Origin::signed(1);1073        let origin2 = Origin::signed(2);10741075        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1076        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));1077        assert_noop!(1078            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1079            Error::<Test>::CollectionNotFound1080        );1081        assert_eq!(TemplateModule::white_list(collection_id, 2), false);1082    });1083}10841085// If address is already removed from white list, nothing happens1086#[test]1087fn address_is_already_removed_from_white_list() {1088    new_test_ext().execute_with(|| {1089        default_limits();1090        1091        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1092        let origin1 = Origin::signed(1);10931094        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1095        assert_ok!(TemplateModule::remove_from_white_list(1096            origin1.clone(),1097            collection_id,1098            21099        ));1100        assert_ok!(TemplateModule::remove_from_white_list(1101            origin1.clone(),1102            collection_id,1103            21104        ));1105        assert_eq!(TemplateModule::white_list(collection_id, 2), false);1106    });1107}11081109// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1110#[test]1111fn white_list_test_1() {1112    new_test_ext().execute_with(|| {1113        default_limits();1114        1115        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11161117        let origin1 = Origin::signed(1);1118        1119        let data = default_nft_data();1120        create_test_item(collection_id, &data.into());11211122        assert_ok!(TemplateModule::set_public_access_mode(1123            origin1.clone(),1124            collection_id,1125            AccessMode::WhiteList1126        ));1127        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11281129        assert_noop!(1130            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1131            Error::<Test>::AddresNotInWhiteList1132        );1133    });1134}11351136#[test]1137fn white_list_test_2() {1138    new_test_ext().execute_with(|| {1139        default_limits();1140        1141        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1142        let origin1 = Origin::signed(1);1143        1144        let data = default_nft_data();1145        create_test_item(collection_id, &data.into());11461147        assert_ok!(TemplateModule::set_public_access_mode(1148            origin1.clone(),1149            collection_id,1150            AccessMode::WhiteList1151        ));1152        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1153        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));11541155        // do approve1156        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 1));1157        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);11581159        assert_ok!(TemplateModule::remove_from_white_list(1160            origin1.clone(),1161            1,1162            11163        ));11641165        assert_noop!(1166            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1167            Error::<Test>::AddresNotInWhiteList1168        );1169    });1170}11711172// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1173#[test]1174fn white_list_test_3() {1175    new_test_ext().execute_with(|| {1176        default_limits();1177        1178        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11791180        let origin1 = Origin::signed(1);1181        1182        let data = default_nft_data();1183        create_test_item(collection_id, &data.into());11841185        assert_ok!(TemplateModule::set_public_access_mode(1186            origin1.clone(),1187            collection_id,1188            AccessMode::WhiteList1189        ));1190        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));11911192        assert_noop!(1193            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1194            Error::<Test>::AddresNotInWhiteList1195        );1196    });1197}11981199#[test]1200fn white_list_test_4() {1201    new_test_ext().execute_with(|| {1202        default_limits();1203        1204        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12051206        let origin1 = Origin::signed(1);12071208        let data = default_nft_data();1209        create_test_item(collection_id, &data.into());12101211        assert_ok!(TemplateModule::set_public_access_mode(1212            origin1.clone(),1213            collection_id,1214            AccessMode::WhiteList1215        ));1216        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1217        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12181219        // do approve1220        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 1));1221        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);12221223        assert_ok!(TemplateModule::remove_from_white_list(1224            origin1.clone(),1225            collection_id,1226            21227        ));12281229        assert_noop!(1230            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1231            Error::<Test>::AddresNotInWhiteList1232        );1233    });1234}12351236// If Public Access mode is set to WhiteList, tokens can’t be destroyed by a non-whitelisted address (even if it owned them before enabling WhiteList mode)1237#[test]1238fn white_list_test_5() {1239    new_test_ext().execute_with(|| {1240        default_limits();1241        1242        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12431244        let origin1 = Origin::signed(1);12451246        let data = default_nft_data();1247        create_test_item(collection_id, &data.into());12481249        assert_ok!(TemplateModule::set_public_access_mode(1250            origin1.clone(),1251            collection_id,1252            AccessMode::WhiteList1253        ));1254        assert_noop!(1255            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),1256            Error::<Test>::AddresNotInWhiteList1257        );1258    });1259}12601261// If Public Access mode is set to WhiteList, token transfers can’t be Approved by a non-whitelisted address (see Approve method).1262#[test]1263fn white_list_test_6() {1264    new_test_ext().execute_with(|| {1265        default_limits();1266        1267        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12681269        let origin1 = Origin::signed(1);12701271        let data = default_nft_data();1272        create_test_item(collection_id, &data.into());12731274        assert_ok!(TemplateModule::set_public_access_mode(1275            origin1.clone(),1276            collection_id,1277            AccessMode::WhiteList1278        ));12791280        // do approve1281        assert_noop!(1282            TemplateModule::approve(origin1.clone(), 1, 1, 1, 5),1283            Error::<Test>::AddresNotInWhiteList1284        );1285    });1286}12871288// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1289//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1290#[test]1291fn white_list_test_7() {1292    new_test_ext().execute_with(|| {1293        default_limits();1294        1295        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12961297        let data = default_nft_data();1298        create_test_item(collection_id, &data.into());1299        1300        let origin1 = Origin::signed(1);13011302        assert_ok!(TemplateModule::set_public_access_mode(1303            origin1.clone(),1304            collection_id,1305            AccessMode::WhiteList1306        ));1307        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1308        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13091310        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1311    });1312}13131314#[test]1315fn white_list_test_8() {1316    new_test_ext().execute_with(|| {1317        default_limits();1318        1319        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13201321        let data = default_nft_data();1322        create_test_item(collection_id, &data.into());1323        1324        let origin1 = Origin::signed(1);13251326        assert_ok!(TemplateModule::set_public_access_mode(1327            origin1.clone(),1328            collection_id,1329            AccessMode::WhiteList1330        ));1331        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1332        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13331334        // do approve1335        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 5));1336        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 5);13371338        assert_ok!(TemplateModule::transfer_from(1339            origin1.clone(),1340            1,1341            2,1342            1,1343            1,1344            11345        ));1346    });1347}13481349// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1350#[test]1351fn white_list_test_9() {1352    new_test_ext().execute_with(|| {1353        default_limits();1354        1355        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1356        let origin1 = Origin::signed(1);13571358        assert_ok!(TemplateModule::set_public_access_mode(1359            origin1.clone(),1360            collection_id,1361            AccessMode::WhiteList1362        ));1363        assert_ok!(TemplateModule::set_mint_permission(1364            origin1.clone(),1365            collection_id,1366            false1367        ));13681369        let data = default_nft_data();1370        create_test_item(collection_id, &data.into());1371    });1372}13731374// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1375#[test]1376fn white_list_test_10() {1377    new_test_ext().execute_with(|| {1378        default_limits();1379        1380        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13811382        let origin1 = Origin::signed(1);1383        let origin2 = Origin::signed(2);13841385        assert_ok!(TemplateModule::set_public_access_mode(1386            origin1.clone(),1387            collection_id,1388            AccessMode::WhiteList1389        ));1390        assert_ok!(TemplateModule::set_mint_permission(1391            origin1.clone(),1392            collection_id,1393            false1394        ));13951396        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));13971398        assert_ok!(TemplateModule::create_item(1399            origin2.clone(),1400            collection_id,1401            2,1402            default_nft_data().into()1403        ));1404    });1405}14061407// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and white listed address.1408#[test]1409fn white_list_test_11() {1410    new_test_ext().execute_with(|| {1411        default_limits();1412        1413        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14141415        let origin1 = Origin::signed(1);1416        let origin2 = Origin::signed(2);14171418        assert_ok!(TemplateModule::set_public_access_mode(1419            origin1.clone(),1420            collection_id,1421            AccessMode::WhiteList1422        ));1423        assert_ok!(TemplateModule::set_mint_permission(1424            origin1.clone(),1425            collection_id,1426            false1427        ));1428        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14291430        assert_noop!(1431            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1432            Error::<Test>::PublicMintingNotAllowed1433        );1434    });1435}14361437// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-white listed address.1438#[test]1439fn white_list_test_12() {1440    new_test_ext().execute_with(|| {1441        default_limits();1442        1443        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14441445        let origin1 = Origin::signed(1);1446        let origin2 = Origin::signed(2);14471448        assert_ok!(TemplateModule::set_public_access_mode(1449            origin1.clone(),1450            collection_id,1451            AccessMode::WhiteList1452        ));1453        assert_ok!(TemplateModule::set_mint_permission(1454            origin1.clone(),1455            collection_id,1456            false1457        ));14581459        assert_noop!(1460            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1461            Error::<Test>::PublicMintingNotAllowed1462        );1463    });1464}14651466// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1467#[test]1468fn white_list_test_13() {1469    new_test_ext().execute_with(|| {1470        default_limits();1471        1472        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14731474        let origin1 = Origin::signed(1);14751476        assert_ok!(TemplateModule::set_public_access_mode(1477            origin1.clone(),1478            collection_id,1479            AccessMode::WhiteList1480        ));1481        assert_ok!(TemplateModule::set_mint_permission(1482            origin1.clone(),1483            collection_id,1484            true1485        ));14861487        let data = default_nft_data();1488        create_test_item(collection_id, &data.into());1489    });1490}14911492// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1493#[test]1494fn white_list_test_14() {1495    new_test_ext().execute_with(|| {1496        default_limits();1497        1498        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14991500        let origin1 = Origin::signed(1);1501        let origin2 = Origin::signed(2);15021503        assert_ok!(TemplateModule::set_public_access_mode(1504            origin1.clone(),1505            collection_id,1506            AccessMode::WhiteList1507        ));1508        assert_ok!(TemplateModule::set_mint_permission(1509            origin1.clone(),1510            collection_id,1511            true1512        ));15131514        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));15151516        assert_ok!(TemplateModule::create_item(1517            origin2.clone(),1518            1,1519            2,1520            default_nft_data().into()1521        ));1522    });1523}15241525// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens cannot be created by non-privileged and non-white listed address.1526#[test]1527fn white_list_test_15() {1528    new_test_ext().execute_with(|| {1529        default_limits();1530        1531        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15321533        let origin1 = Origin::signed(1);1534        let origin2 = Origin::signed(2);15351536        assert_ok!(TemplateModule::set_public_access_mode(1537            origin1.clone(),1538            collection_id,1539            AccessMode::WhiteList1540        ));1541        assert_ok!(TemplateModule::set_mint_permission(1542            origin1.clone(),1543            collection_id,1544            true1545        ));15461547        assert_noop!(1548            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1549            Error::<Test>::AddresNotInWhiteList1550        );1551    });1552}15531554// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by non-privileged and white listed address.1555#[test]1556fn white_list_test_16() {1557    new_test_ext().execute_with(|| {1558        default_limits();1559        1560        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15611562        let origin1 = Origin::signed(1);1563        let origin2 = Origin::signed(2);15641565        assert_ok!(TemplateModule::set_public_access_mode(1566            origin1.clone(),1567            collection_id,1568            AccessMode::WhiteList1569        ));1570        assert_ok!(TemplateModule::set_mint_permission(1571            origin1.clone(),1572            collection_id,1573            true1574        ));1575        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));15761577        assert_ok!(TemplateModule::create_item(1578            origin2.clone(),1579            1,1580            2,1581            default_nft_data().into()1582        ));1583    });1584}15851586// Total number of collections. Positive test1587#[test]1588fn total_number_collections_bound() {1589    new_test_ext().execute_with(|| {1590        default_limits();1591        1592        create_test_collection(&CollectionMode::NFT, 1);1593    });1594}15951596// Total number of collections. Negotive test1597#[test]1598fn total_number_collections_bound_neg() {1599    new_test_ext().execute_with(|| {1600        default_limits();16011602        let origin1 = Origin::signed(1);16031604        for i in 0..default_collection_numbers_limit() {1605            create_test_collection(&CollectionMode::NFT, i + 1);1606        }16071608        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1609        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1610        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();16111612        // 11-th collection in chain. Expects error1613        assert_noop!(TemplateModule::create_collection(1614            origin1.clone(),1615            col_name1.clone(),1616            col_desc1.clone(),1617            token_prefix1.clone(),1618            CollectionMode::NFT1619        ), Error::<Test>::TotalCollectionsLimitExceeded);1620    });1621}16221623// Owned tokens by a single address. Positive test1624#[test]1625fn owned_tokens_bound() {1626    new_test_ext().execute_with(|| {1627        default_limits();1628        1629        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16301631        let data = default_nft_data();1632        create_test_item(collection_id, &data.clone().into());1633        create_test_item(collection_id, &data.into());1634    });1635}16361637// Owned tokens by a single address. Negotive test1638#[test]1639fn owned_tokens_bound_neg() {1640    new_test_ext().execute_with(|| {1641        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1642            collection_numbers_limit: 10,1643            account_token_ownership_limit: 1,1644            collections_admins_limit: 5,1645            custom_data_limit: 2048,1646            nft_sponsor_transfer_timeout: 15,1647            fungible_sponsor_transfer_timeout: 15,1648            refungible_sponsor_transfer_timeout: 15,1649            const_on_chain_schema_limit: 1024,1650            offchain_schema_limit: 1024,1651            variable_on_chain_schema_limit: 1024,1652        }));1653        1654        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16551656        let origin1 = Origin::signed(1);1657        let data = default_nft_data();1658        create_test_item(collection_id, &data.clone().into());16591660        assert_noop!(TemplateModule::create_item(1661            origin1.clone(),1662            1,1663            1,1664            data.into()1665        ),  Error::<Test>::AddressOwnershipLimitExceeded);1666    });1667}16681669// Number of collection admins. Positive test1670#[test]1671fn collection_admins_bound() {1672    new_test_ext().execute_with(|| {1673        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1674            collection_numbers_limit: 10,1675            account_token_ownership_limit: 10,1676            collections_admins_limit: 2,1677            custom_data_limit: 2048,1678            nft_sponsor_transfer_timeout: 15,1679            fungible_sponsor_transfer_timeout: 15,1680            refungible_sponsor_transfer_timeout: 15,1681            const_on_chain_schema_limit: 1024,1682            offchain_schema_limit: 1024,1683            variable_on_chain_schema_limit: 1024,1684        }));1685        1686        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16871688        let origin1 = Origin::signed(1);1689        1690        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1691        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1692    });1693}16941695// Number of collection admins. Negotive test1696#[test]1697fn collection_admins_bound_neg() {1698    new_test_ext().execute_with(|| {1699        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1700            collection_numbers_limit: 10,1701            account_token_ownership_limit: 1,1702            collections_admins_limit: 1,1703            custom_data_limit: 2048,1704            nft_sponsor_transfer_timeout: 15,1705            fungible_sponsor_transfer_timeout: 15,1706            refungible_sponsor_transfer_timeout: 15,1707            const_on_chain_schema_limit: 1024,1708            offchain_schema_limit: 1024,1709            variable_on_chain_schema_limit: 1024,1710        }));1711        1712        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17131714        let origin1 = Origin::signed(1);17151716        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1717        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), Error::<Test>::CollectionAdminsLimitExceeded);1718    });1719}17201721// NFT custom data size. Negative test const_data.1722#[test]1723fn custom_data_size_nft_const_data_bound_neg() {1724    new_test_ext().execute_with(|| {1725        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1726            collection_numbers_limit: 10,1727            account_token_ownership_limit: 10,1728            collections_admins_limit: 5,1729            custom_data_limit: 2,1730            nft_sponsor_transfer_timeout: 15,1731            fungible_sponsor_transfer_timeout: 15,1732            refungible_sponsor_transfer_timeout: 15,1733            const_on_chain_schema_limit: 1024,1734            offchain_schema_limit: 1024,1735            variable_on_chain_schema_limit: 1024,1736        }));1737        1738        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17391740        let origin1 = Origin::signed(1);1741        let too_big_const_data = CreateItemData::NFT(CreateNftData{1742            const_data: vec![1, 2, 3, 4],1743            variable_data: vec![]1744        });17451746        assert_noop!(TemplateModule::create_item(1747            origin1.clone(),1748            collection_id,1749            1,1750            too_big_const_data1751        ), Error::<Test>::TokenConstDataLimitExceeded);1752    });1753}17541755// NFT custom data size. Negative test variable_data.1756#[test]1757fn custom_data_size_nft_variable_data_bound_neg() {1758    new_test_ext().execute_with(|| {1759        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1760            collection_numbers_limit: 10,1761            account_token_ownership_limit: 10,1762            collections_admins_limit: 5,1763            custom_data_limit: 2,1764            nft_sponsor_transfer_timeout: 15,1765            fungible_sponsor_transfer_timeout: 15,1766            refungible_sponsor_transfer_timeout: 15,1767            const_on_chain_schema_limit: 1024,1768            offchain_schema_limit: 1024,1769            variable_on_chain_schema_limit: 1024,1770        }));17711772        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17731774        let origin1 = Origin::signed(1);1775        let too_big_const_data = CreateItemData::NFT(CreateNftData{1776            const_data: vec![],1777            variable_data: vec![1, 2, 3, 4]1778        });17791780        assert_noop!(TemplateModule::create_item(1781            origin1.clone(),1782            collection_id,1783            1,1784            too_big_const_data1785        ), Error::<Test>::TokenVariableDataLimitExceeded);1786    });1787}17881789// Re fungible custom data size. Negative test const_data.1790#[test]1791fn custom_data_size_re_fungible_const_data_bound_neg() {1792    new_test_ext().execute_with(|| {1793        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1794            collection_numbers_limit: 10,1795            account_token_ownership_limit: 10,1796            collections_admins_limit: 5,1797            custom_data_limit: 2,1798            nft_sponsor_transfer_timeout: 15,1799            fungible_sponsor_transfer_timeout: 15,1800            refungible_sponsor_transfer_timeout: 15,1801            const_on_chain_schema_limit: 1024,1802            offchain_schema_limit: 1024,1803            variable_on_chain_schema_limit: 1024,1804        }));18051806        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18071808        let origin1 = Origin::signed(1);1809        let too_big_const_data = CreateItemData::NFT(CreateNftData{1810            const_data: vec![1, 2, 3, 4],1811            variable_data: vec![]1812        });18131814        assert_noop!(TemplateModule::create_item(1815            origin1.clone(),1816            collection_id,1817            1,1818            too_big_const_data1819        ), Error::<Test>::TokenConstDataLimitExceeded);1820    });1821}18221823// Re fungible custom data size. Negative test variable_data.1824#[test]1825fn custom_data_size_re_fungible_variable_data_bound_neg() {1826    new_test_ext().execute_with(|| {1827        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1828            collection_numbers_limit: 10,1829            account_token_ownership_limit: 10,1830            collections_admins_limit: 5,1831            custom_data_limit: 2,1832            nft_sponsor_transfer_timeout: 15,1833            fungible_sponsor_transfer_timeout: 15,1834            refungible_sponsor_transfer_timeout: 15,1835            const_on_chain_schema_limit: 1024,1836            offchain_schema_limit: 1024,1837            variable_on_chain_schema_limit: 1024,1838        }));18391840        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18411842        let origin1 = Origin::signed(1);1843        let too_big_const_data = CreateItemData::NFT(CreateNftData{1844            const_data: vec![],1845            variable_data: vec![1, 2, 3, 4]1846        });18471848        assert_noop!(TemplateModule::create_item(1849            origin1.clone(),1850            collection_id,1851            1,1852            too_big_const_data1853        ), Error::<Test>::TokenVariableDataLimitExceeded);1854    });1855}1856// #endregion18571858#[test]1859fn set_const_on_chain_schema() {1860    new_test_ext().execute_with(|| {1861        default_limits();18621863        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18641865        let origin1 = Origin::signed(1);1866        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, b"test const on chain schema".to_vec()));18671868        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"test const on chain schema".to_vec());1869        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"".to_vec());1870    });1871}18721873#[test]1874fn set_variable_on_chain_schema() {1875    new_test_ext().execute_with(|| {1876        default_limits();1877        1878        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18791880        let origin1 = Origin::signed(1);1881        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, b"test variable on chain schema".to_vec()));18821883        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"".to_vec());1884        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"test variable on chain schema".to_vec());1885    });1886}18871888#[test]1889fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1890    new_test_ext().execute_with(|| {1891        default_limits();18921893        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18941895        let origin1 = Origin::signed(1);1896        1897        let data = default_nft_data();1898        create_test_item(1, &data.into());1899        1900        let variable_data = b"test set_variable_meta_data method.".to_vec();1901        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));19021903        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, variable_data);1904    });1905}19061907#[test]1908fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1909    new_test_ext().execute_with(|| {1910        default_limits();19111912        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);19131914        let origin1 = Origin::signed(1);19151916        let data = default_re_fungible_data();1917        create_test_item(1, &data.into());19181919        let variable_data = b"test set_variable_meta_data method.".to_vec();1920        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));19211922        assert_eq!(TemplateModule::refungible_item_id(collection_id, 1).variable_data, variable_data);1923    });1924}192519261927#[test]1928fn set_variable_meta_data_on_fungible_token_fails() {1929    new_test_ext().execute_with(|| {1930        default_limits();19311932        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);19331934        let origin1 = Origin::signed(1);19351936        let data = default_fungible_data();1937        create_test_item(1, &data.into());19381939        let variable_data = b"test set_variable_meta_data method.".to_vec();1940        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()), Error::<Test>::CantStoreMetadataInFungibleTokens);1941    });1942}19431944#[test]1945fn set_variable_meta_data_on_nft_token_fails_for_big_data() {1946    new_test_ext().execute_with(|| {1947        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1948            collection_numbers_limit: default_collection_numbers_limit(),1949            account_token_ownership_limit: 10,1950            collections_admins_limit: 5,1951            custom_data_limit: 10,1952            nft_sponsor_transfer_timeout: 15,1953            fungible_sponsor_transfer_timeout: 15,1954            refungible_sponsor_transfer_timeout: 15,1955            const_on_chain_schema_limit: 1024,1956            offchain_schema_limit: 1024,1957            variable_on_chain_schema_limit: 1024,1958        }));19591960        let collection_id = create_test_collection(&CollectionMode::NFT, 1);19611962        let origin1 = Origin::signed(1);19631964        let data = default_nft_data();1965        create_test_item(1, &data.into());19661967        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1968        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);1969    });1970}19711972#[test]1973fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {1974    new_test_ext().execute_with(|| {1975        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1976            collection_numbers_limit: default_collection_numbers_limit(),1977            account_token_ownership_limit: 10,1978            collections_admins_limit: 5,1979            custom_data_limit: 10,1980            nft_sponsor_transfer_timeout: 15,1981            fungible_sponsor_transfer_timeout: 15,1982            refungible_sponsor_transfer_timeout: 15,1983            const_on_chain_schema_limit: 1024,1984            offchain_schema_limit: 1024,1985            variable_on_chain_schema_limit: 1024,1986        }));198719881989        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);19901991        let origin1 = Origin::signed(1);19921993        let data = default_re_fungible_data();1994        create_test_item(1, &data.into());19951996        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1997        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);1998    });1999}