git.delta.rocks / unique-network / refs/commits / a2aea5c6b4a4

1// Tests to be written here2use crate::mock::*;3use crate::{AccessMode, ApprovePermissions, CollectionMode, Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData};4use frame_support::{assert_noop, assert_ok};5use frame_system::{ RawOrigin };67fn default_collection_numbers_limit() -> u64 {8    109}1011fn default_limits() {12    assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 13            collection_numbers_limit: default_collection_numbers_limit(),14            account_token_ownership_limit: 10,15            collections_admins_limit: 5,16            custom_data_limit: 2048,17            nft_sponsor_transfer_timeout: 15,18            fungible_sponsor_transfer_timeout: 15,19            refungible_sponsor_transfer_timeout: 15,          20        }));21}2223fn default_nft_data() -> CreateNftData {24    CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }25}2627fn default_fungible_data () -> CreateFungibleData {28    CreateFungibleData { }29}3031fn default_re_fungible_data () -> CreateReFungibleData {32    CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }33}3435fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64, id: u64) -> u64 {36    let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();37    let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();38    let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();3940    let origin1 = Origin::signed(owner);41    assert_ok!(TemplateModule::create_collection(42            origin1.clone(),43            col_name1.clone(),44            col_desc1.clone(),45            token_prefix1.clone(),46            mode.clone()47        ));4849    let saved_col_name: Vec<u16> = "Test1\0\0".encode_utf16().collect::<Vec<u16>>();50    let saved_description: Vec<u16> = "TestDescription1\0\0".encode_utf16().collect::<Vec<u16>>();51    let saved_prefix: Vec<u8> = b"token_prefix1\0\0".to_vec();52    assert_eq!(TemplateModule::collection(id).owner, owner);53    assert_eq!(TemplateModule::collection(id).name, saved_col_name);54    assert_eq!(TemplateModule::collection(id).mode, *mode);55    assert_eq!(TemplateModule::collection(id).description, saved_description);56    assert_eq!(TemplateModule::collection(id).token_prefix, saved_prefix);57    id58}5960fn create_test_collection(mode: &CollectionMode, id: u64) -> u64 {61    create_test_collection_for_owner(&mode, 1, id)62}6364fn create_test_item(collection_id: u64, data: &CreateItemData) {65    let origin1 = Origin::signed(1);66    assert_ok!(TemplateModule::create_item(67            origin1.clone(),68            collection_id,69            1,70            data.clone()71        ));7273}7475// Use cases tests region76// #region77#[test]78fn create_nft_item() {79    new_test_ext().execute_with(|| {80        default_limits();81        let collection_id = create_test_collection(&CollectionMode::NFT, 1);82        83        let data = default_nft_data();84        create_test_item(collection_id, &data.clone().into());85        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);86        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);87    });88}8990#[test]91fn create_refungible_item() {92    new_test_ext().execute_with(|| {93        default_limits();94        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);9596        let data = default_re_fungible_data();97        create_test_item(collection_id, &data.clone().into());98        assert_eq!(99            TemplateModule::refungible_item_id(collection_id, 1).const_data,100            data.const_data101        );102        assert_eq!(103            TemplateModule::refungible_item_id(collection_id, 1).variable_data,104            data.variable_data105        );106        assert_eq!(107            TemplateModule::refungible_item_id(collection_id, 1).owner[0],108            Ownership {109                owner: 1,110                fraction: 1000111            }112        );113    });114}115116#[test]117fn create_fungible_item() {118    new_test_ext().execute_with(|| {119        default_limits();120        121        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);122123        let data = default_fungible_data();124        create_test_item(collection_id, &data.into());125126        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);127        assert_eq!(TemplateModule::balance_count(1, 1), 1000);128        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);129    });130}131132#[test]133fn transfer_fungible_item() {134    new_test_ext().execute_with(|| {135        default_limits();136        137        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);138139        let origin1 = Origin::signed(1);140        let origin2 = Origin::signed(2);141142        let data = default_fungible_data();143        create_test_item(collection_id, &data.into());144145        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);146        assert_eq!(TemplateModule::balance_count(1, 1), 1000);147        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);148149        // change owner scenario150        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));151        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);152        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);153        assert_eq!(TemplateModule::balance_count(1, 1), 0);154        assert_eq!(TemplateModule::balance_count(1, 2), 1000);155        // assert_eq!(TemplateModule::address_tokens(1, 1), []);156        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);157158        // split item scenario159        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));160        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);161        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);162        assert_eq!(TemplateModule::balance_count(1, 2), 500);163        assert_eq!(TemplateModule::balance_count(1, 3), 500);164        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);165        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);166167        // split item and new owner has account scenario168        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));169        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);170        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);171        assert_eq!(TemplateModule::balance_count(1, 2), 300);172        assert_eq!(TemplateModule::balance_count(1, 3), 700);173        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);174        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);175    });176}177178#[test]179fn transfer_refungible_item() {180    new_test_ext().execute_with(|| {181        default_limits();182        183        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);184185        let data = default_re_fungible_data();186        create_test_item(collection_id, &data.clone().into());187188        let origin1 = Origin::signed(1);189        let origin2 = Origin::signed(2);190        assert_eq!(191            TemplateModule::refungible_item_id(collection_id, 1).const_data,192            data.const_data193        );194        assert_eq!(195            TemplateModule::refungible_item_id(collection_id, 1).variable_data,196            data.variable_data197        );198        assert_eq!(199            TemplateModule::refungible_item_id(collection_id, 1).owner[0],200            Ownership {201                owner: 1,202                fraction: 1000203            }204        );205        assert_eq!(TemplateModule::balance_count(1, 1), 1000);206        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);207208        // change owner scenario209        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));210        assert_eq!(211            TemplateModule::refungible_item_id(1, 1).owner[0],212            Ownership {213                owner: 2,214                fraction: 1000215            }216        );217        assert_eq!(TemplateModule::balance_count(1, 1), 0);218        assert_eq!(TemplateModule::balance_count(1, 2), 1000);219        // assert_eq!(TemplateModule::address_tokens(1, 1), []);220        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);221222        // split item scenario223        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));224        assert_eq!(225            TemplateModule::refungible_item_id(1, 1).owner[0],226            Ownership {227                owner: 2,228                fraction: 500229            }230        );231        assert_eq!(232            TemplateModule::refungible_item_id(1, 1).owner[1],233            Ownership {234                owner: 3,235                fraction: 500236            }237        );238        assert_eq!(TemplateModule::balance_count(1, 2), 500);239        assert_eq!(TemplateModule::balance_count(1, 3), 500);240        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);241        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);242243        // split item and new owner has account scenario244        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));245        assert_eq!(246            TemplateModule::refungible_item_id(1, 1).owner[0],247            Ownership {248                owner: 2,249                fraction: 300250            }251        );252        assert_eq!(253            TemplateModule::refungible_item_id(1, 1).owner[1],254            Ownership {255                owner: 3,256                fraction: 700257            }258        );259        assert_eq!(TemplateModule::balance_count(1, 2), 300);260        assert_eq!(TemplateModule::balance_count(1, 3), 700);261        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);262        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);263    });264}265266#[test]267fn transfer_nft_item() {268    new_test_ext().execute_with(|| {269        default_limits();270        271        let collection_id = create_test_collection(&CollectionMode::NFT, 1);272273        let data = default_nft_data();274        create_test_item(collection_id, &data.into());275        assert_eq!(TemplateModule::balance_count(1, 1), 1);276        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);277278        let origin1 = Origin::signed(1);279        // default scenario280        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));281        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);282        assert_eq!(TemplateModule::balance_count(1, 1), 0);283        assert_eq!(TemplateModule::balance_count(1, 2), 1);284        // assert_eq!(TemplateModule::address_tokens(1, 1), []);285        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);286    });287}288289#[test]290fn nft_approve_and_transfer_from() {291    new_test_ext().execute_with(|| {292        default_limits();293        294        let collection_id = create_test_collection(&CollectionMode::NFT, 1);295296        let data = default_nft_data();297        create_test_item(collection_id, &data.into());298299        let origin1 = Origin::signed(1);300        let origin2 = Origin::signed(2);301302        assert_eq!(TemplateModule::balance_count(1, 1), 1);303        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);304305        // neg transfer306        assert_noop!(TemplateModule::transfer_from(307            origin2.clone(),308            1,309            2,310            1,311            1,312            1), "Only item owner, collection owner and admins can modify items");313314        // do approve315        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));316        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);317        assert_eq!(318            TemplateModule::approved(1, (1, 1))[0],319            ApprovePermissions {320                approved: 2,321                amount: 100000000322            }323        );324325        assert_ok!(TemplateModule::transfer_from(326            origin2.clone(),327            1,328            2,329            1,330            1,331            1332        ));333        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);334    });335}336337#[test]338fn nft_approve_and_transfer_from_white_list() {339    new_test_ext().execute_with(|| {340        default_limits();341        342        let collection_id = create_test_collection(&CollectionMode::NFT, 1);343344        let origin1 = Origin::signed(1);345        let origin2 = Origin::signed(2);346347        let data = default_nft_data();348        create_test_item(collection_id, &data.clone().into());349350        assert_eq!(TemplateModule::nft_item_id(1, 1).const_data, data.const_data);351        assert_eq!(TemplateModule::balance_count(1, 1), 1);352        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);353354        assert_ok!(TemplateModule::set_mint_permission(355            origin1.clone(),356            1,357            true358        ));359        assert_ok!(TemplateModule::set_public_access_mode(360            origin1.clone(),361            1,362            AccessMode::WhiteList363        ));364        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));365        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));366        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));367368        // do approve369        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));370        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);371        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));372        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);373        assert_eq!(374            TemplateModule::approved(1, (1, 1))[0],375            ApprovePermissions {376                approved: 2,377                amount: 100000000378            }379        );380381        assert_ok!(TemplateModule::transfer_from(382            origin2.clone(),383            1,384            3,385            1,386            1,387            1388        ));389        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);390    });391}392393#[test]394fn refungible_approve_and_transfer_from() {395    new_test_ext().execute_with(|| {396        default_limits();397        398        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);399        400        let origin1 = Origin::signed(1);401        let origin2 = Origin::signed(2);402403        let data = default_re_fungible_data();404        create_test_item(collection_id, &data.into());405406        assert_eq!(TemplateModule::balance_count(1, 1), 1000);407        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);408409        assert_ok!(TemplateModule::set_mint_permission(410            origin1.clone(),411            1,412            true413        ));414        assert_ok!(TemplateModule::set_public_access_mode(415            origin1.clone(),416            1,417            AccessMode::WhiteList418        ));419        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));420        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));421        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));422423        // do approve424        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));425        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);426        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));427        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);428        assert_eq!(429            TemplateModule::approved(1, (1, 1))[0],430            ApprovePermissions {431                approved: 2,432                amount: 100000000433            }434        );435436        assert_ok!(TemplateModule::transfer_from(437            origin2.clone(),438            1,439            3,440            1,441            1,442            100443        ));444        assert_eq!(TemplateModule::balance_count(1, 1), 900);445        assert_eq!(TemplateModule::balance_count(1, 3), 100);446        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);447        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);448449        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);450        assert_eq!(451            TemplateModule::approved(1, (1, 1))[0],452            ApprovePermissions {453                approved: 3,454                amount: 100000000455            }456        );457    });458}459460#[test]461fn fungible_approve_and_transfer_from() {462    new_test_ext().execute_with(|| {463        default_limits();464        465        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);466        467        let data = default_fungible_data();468        create_test_item(collection_id, &data.into());469470        let origin1 = Origin::signed(1);471        let origin2 = Origin::signed(2);472473        assert_eq!(TemplateModule::balance_count(1, 1), 1000);474        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);475476        assert_ok!(TemplateModule::set_mint_permission(477            origin1.clone(),478            1,479            true480        ));481        assert_ok!(TemplateModule::set_public_access_mode(482            origin1.clone(),483            1,484            AccessMode::WhiteList485        ));486        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));487        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));488        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));489490        // do approve491        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));492        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);493        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));494        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);495        assert_eq!(496            TemplateModule::approved(1, (1, 1))[0],497            ApprovePermissions {498                approved: 2,499                amount: 100000000500            }501        );502503        assert_ok!(TemplateModule::transfer_from(504            origin2.clone(),505            1,506            3,507            1,508            1,509            100510        ));511        assert_eq!(TemplateModule::balance_count(1, 1), 900);512        assert_eq!(TemplateModule::balance_count(1, 3), 100);513        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);514        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);515516        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);517        assert_eq!(518            TemplateModule::approved(1, (1, 1))[0],519            ApprovePermissions {520                approved: 3,521                amount: 100000000522            }523        );524525        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));526        assert_ok!(TemplateModule::transfer_from(527            origin2.clone(),528            1,529            3,530            1,531            1,532            900533        ));534        assert_eq!(TemplateModule::balance_count(1, 1), 0);535        assert_eq!(TemplateModule::balance_count(1, 3), 1000);536        // assert_eq!(TemplateModule::address_tokens(1, 1), []);537        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);538539        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);540    });541}542543#[test]544fn change_collection_owner() {545    new_test_ext().execute_with(|| {546        default_limits();547        548        let collection_id = create_test_collection(&CollectionMode::NFT, 1);549        550        let origin1 = Origin::signed(1);551        assert_ok!(TemplateModule::change_collection_owner(552            origin1.clone(),553            collection_id,554            2555        ));556        assert_eq!(TemplateModule::collection(collection_id).owner, 2);557    });558}559560#[test]561fn destroy_collection() {562    new_test_ext().execute_with(|| {563        default_limits();564        565        let collection_id = create_test_collection(&CollectionMode::NFT, 1);566        567        let origin1 = Origin::signed(1);568        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));569    });570}571572#[test]573fn burn_nft_item() {574    new_test_ext().execute_with(|| {575        default_limits();576        577        let collection_id = create_test_collection(&CollectionMode::NFT, 1);578579        let origin1 = Origin::signed(1);580        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));581        582        let data = default_nft_data();583        create_test_item(collection_id, &data.into());584585        // check balance (collection with id = 1, user id = 1)586        assert_eq!(TemplateModule::balance_count(1, 1), 1);587588        // burn item589        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));590        assert_noop!(591            TemplateModule::burn_item(origin1.clone(), 1, 1),592            "Item does not exists"593        );594595        assert_eq!(TemplateModule::balance_count(1, 1), 0);596    });597}598599#[test]600fn burn_fungible_item() {601    new_test_ext().execute_with(|| {602        default_limits();603        604        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);605        606        let origin1 = Origin::signed(1);607        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));608        609        let data = default_fungible_data();610        create_test_item(collection_id, &data.into());611612        // check balance (collection with id = 1, user id = 1)613        assert_eq!(TemplateModule::balance_count(1, 1), 1000);614615        // burn item616        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));617        assert_noop!(618            TemplateModule::burn_item(origin1.clone(), 1, 1),619            "Item does not exists"620        );621622        assert_eq!(TemplateModule::balance_count(1, 1), 0);623    });624}625626#[test]627fn burn_refungible_item() {628    new_test_ext().execute_with(|| {629        default_limits();630        631        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);632        let origin1 = Origin::signed(1);633634        assert_ok!(TemplateModule::set_mint_permission(635            origin1.clone(),636            collection_id,637            true638        ));639        assert_ok!(TemplateModule::set_public_access_mode(640            origin1.clone(),641            collection_id,642            AccessMode::WhiteList643        ));644        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));645646        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));647        648        let data = default_re_fungible_data();649        create_test_item(collection_id, &data.into());650651        // check balance (collection with id = 1, user id = 2)652        assert_eq!(TemplateModule::balance_count(1, 1), 1000);653654        // burn item655        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));656        assert_noop!(657            TemplateModule::burn_item(origin1.clone(), 1, 1),658            "Item does not exists"659        );660661        assert_eq!(TemplateModule::balance_count(1, 1), 0);662    });663}664665#[test]666fn add_collection_admin() {667    new_test_ext().execute_with(|| {668        default_limits();669        670        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);671        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);672        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);673        674        let origin1 = Origin::signed(1);675676        // collection admin677        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));678        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));679680        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);681        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);682    });683}684685#[test]686fn remove_collection_admin() {687    new_test_ext().execute_with(|| {688        default_limits();689        690        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);691        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);692        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);693694        let origin1 = Origin::signed(1);695        let origin2 = Origin::signed(2);696697        // collection admin698        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));699        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));700701        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);702        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);703704        // remove admin705        assert_ok!(TemplateModule::remove_collection_admin(706            origin2.clone(),707            1,708            3709        ));710        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);711    });712}713714#[test]715fn balance_of() {716    new_test_ext().execute_with(|| {717        default_limits();718        719        let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);720        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);721        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3), 3);722        723        // check balance before724        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);725        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);726        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);727728        let nft_data = default_nft_data();729        create_test_item(nft_collection_id, &nft_data.into());730        731        let fungible_data = default_fungible_data();732        create_test_item(fungible_collection_id, &fungible_data.into());733        734        let re_fungible_data = default_re_fungible_data();735        create_test_item(re_fungible_collection_id, &re_fungible_data.into());736737        // check balance (collection with id = 1, user id = 1)738        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);739        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);740        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);741        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);742        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);743        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);744    });745}746747#[test]748fn approve() {749    new_test_ext().execute_with(|| {750        default_limits();751        752        let collection_id = create_test_collection(&CollectionMode::NFT, 1);753        754        let data = default_nft_data();755        create_test_item(collection_id, &data.into());756757        let origin1 = Origin::signed(1);758        759        // approve760        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));761        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);762    });763}764765#[test]766fn transfer_from() {767    new_test_ext().execute_with(|| {768        default_limits();769        770        let collection_id = create_test_collection(&CollectionMode::NFT, 1);771        let origin1 = Origin::signed(1);772        let origin2 = Origin::signed(2);773774        let data = default_nft_data();775        create_test_item(collection_id, &data.into());776777        // approve778        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));779        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);780781        assert_ok!(TemplateModule::set_mint_permission(782            origin1.clone(),783            1,784            true785        ));786        assert_ok!(TemplateModule::set_public_access_mode(787            origin1.clone(),788            1,789            AccessMode::WhiteList790        ));791        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));792        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));793        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));794795        assert_ok!(TemplateModule::transfer_from(796            origin2.clone(),797            1,798            2,799            1,800            1,801            1802        ));803804        // after transfer805        assert_eq!(TemplateModule::balance_count(1, 1), 0);806        assert_eq!(TemplateModule::balance_count(1, 2), 1);807    });808}809810// #endregion811812// Coverage tests region813// #region814815#[test]816fn owner_can_add_address_to_white_list() {817    new_test_ext().execute_with(|| {818        default_limits();819        820        let collection_id = create_test_collection(&CollectionMode::NFT, 1);821822        let origin1 = Origin::signed(1);823        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));824        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);825    });826}827828#[test]829fn admin_can_add_address_to_white_list() {830    new_test_ext().execute_with(|| {831        default_limits();832        833        let collection_id = create_test_collection(&CollectionMode::NFT, 1);834        let origin1 = Origin::signed(1);835        let origin2 = Origin::signed(2);836837        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));838        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));839        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);840    });841}842843#[test]844fn nonprivileged_user_cannot_add_address_to_white_list() {845    new_test_ext().execute_with(|| {846        default_limits();847        848        let collection_id = create_test_collection(&CollectionMode::NFT, 1);849850        let origin2 = Origin::signed(2);851        assert_noop!(852            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),853            "You do not have permissions to modify this collection"854        );855    });856}857858#[test]859fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {860    new_test_ext().execute_with(|| {861        default_limits();862863        let origin1 = Origin::signed(1);864865        assert_noop!(866            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),867            "This collection does not exist"868        );869    });870}871872#[test]873fn nobody_can_add_address_to_white_list_of_deleted_collection() {874    new_test_ext().execute_with(|| {875        default_limits();876        877        let collection_id = create_test_collection(&CollectionMode::NFT, 1);878879        let origin1 = Origin::signed(1);880        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));881        assert_noop!(882            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),883            "This collection does not exist"884        );885    });886}887888// If address is already added to white list, nothing happens889#[test]890fn address_is_already_added_to_white_list() {891    new_test_ext().execute_with(|| {892        default_limits();893        894        let collection_id = create_test_collection(&CollectionMode::NFT, 1);895        let origin1 = Origin::signed(1);896        897        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));898        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));899        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);900        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);901    });902}903904#[test]905fn owner_can_remove_address_from_white_list() {906    new_test_ext().execute_with(|| {907        default_limits();908        909        let collection_id = create_test_collection(&CollectionMode::NFT, 1);910911        let origin1 = Origin::signed(1);912        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));913        assert_ok!(TemplateModule::remove_from_white_list(914            origin1.clone(),915            collection_id,916            2917        ));918        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);919    });920}921922#[test]923fn admin_can_remove_address_from_white_list() {924    new_test_ext().execute_with(|| {925        default_limits();926        927        let collection_id = create_test_collection(&CollectionMode::NFT, 1);928        let origin1 = Origin::signed(1);929        let origin2 = Origin::signed(2);930931        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));932933        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));934        assert_ok!(TemplateModule::remove_from_white_list(935            origin2.clone(),936            collection_id,937            3938        ));939        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);940    });941}942943#[test]944fn nonprivileged_user_cannot_remove_address_from_white_list() {945    new_test_ext().execute_with(|| {946        default_limits();947        948        let collection_id = create_test_collection(&CollectionMode::NFT, 1);949        let origin1 = Origin::signed(1);950        let origin2 = Origin::signed(2);951952        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));953        assert_noop!(954            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),955            "You do not have permissions to modify this collection"956        );957        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);958    });959}960961#[test]962fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {963    new_test_ext().execute_with(|| {964        default_limits();965        let origin1 = Origin::signed(1);966967        assert_noop!(968            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),969            "This collection does not exist"970        );971    });972}973974#[test]975fn nobody_can_remove_address_from_white_list_of_deleted_collection() {976    new_test_ext().execute_with(|| {977        default_limits();978        979        let collection_id = create_test_collection(&CollectionMode::NFT, 1);980        let origin1 = Origin::signed(1);981        let origin2 = Origin::signed(2);982983        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));984        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));985        assert_noop!(986            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),987            "This collection does not exist"988        );989        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);990    });991}992993// If address is already removed from white list, nothing happens994#[test]995fn address_is_already_removed_from_white_list() {996    new_test_ext().execute_with(|| {997        default_limits();998        999        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1000        let origin1 = Origin::signed(1);10011002        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1003        assert_ok!(TemplateModule::remove_from_white_list(1004            origin1.clone(),1005            collection_id,1006            21007        ));1008        assert_ok!(TemplateModule::remove_from_white_list(1009            origin1.clone(),1010            collection_id,1011            21012        ));1013        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1014    });1015}10161017// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1018#[test]1019fn white_list_test_1() {1020    new_test_ext().execute_with(|| {1021        default_limits();1022        1023        let collection_id = create_test_collection(&CollectionMode::NFT, 1);10241025        let origin1 = Origin::signed(1);1026        1027        let data = default_nft_data();1028        create_test_item(collection_id, &data.into());10291030        assert_ok!(TemplateModule::set_public_access_mode(1031            origin1.clone(),1032            collection_id,1033            AccessMode::WhiteList1034        ));1035        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));10361037        assert_noop!(1038            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1039            "Address is not in white list"1040        );1041    });1042}10431044#[test]1045fn white_list_test_2() {1046    new_test_ext().execute_with(|| {1047        default_limits();1048        1049        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1050        let origin1 = Origin::signed(1);1051        1052        let data = default_nft_data();1053        create_test_item(collection_id, &data.into());10541055        assert_ok!(TemplateModule::set_public_access_mode(1056            origin1.clone(),1057            collection_id,1058            AccessMode::WhiteList1059        ));1060        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1061        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));10621063        // do approve1064        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1065        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);10661067        assert_ok!(TemplateModule::remove_from_white_list(1068            origin1.clone(),1069            1,1070            11071        ));10721073        assert_noop!(1074            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1075            "Address is not in white list"1076        );1077    });1078}10791080// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1081#[test]1082fn white_list_test_3() {1083    new_test_ext().execute_with(|| {1084        default_limits();1085        1086        let collection_id = create_test_collection(&CollectionMode::NFT, 1);10871088        let origin1 = Origin::signed(1);1089        1090        let data = default_nft_data();1091        create_test_item(collection_id, &data.into());10921093        assert_ok!(TemplateModule::set_public_access_mode(1094            origin1.clone(),1095            collection_id,1096            AccessMode::WhiteList1097        ));1098        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));10991100        assert_noop!(1101            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1102            "Address is not in white list"1103        );1104    });1105}11061107#[test]1108fn white_list_test_4() {1109    new_test_ext().execute_with(|| {1110        default_limits();1111        1112        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11131114        let origin1 = Origin::signed(1);11151116        let data = default_nft_data();1117        create_test_item(collection_id, &data.into());11181119        assert_ok!(TemplateModule::set_public_access_mode(1120            origin1.clone(),1121            collection_id,1122            AccessMode::WhiteList1123        ));1124        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1125        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11261127        // do approve1128        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1129        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);11301131        assert_ok!(TemplateModule::remove_from_white_list(1132            origin1.clone(),1133            collection_id,1134            21135        ));11361137        assert_noop!(1138            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1139            "Address is not in white list"1140        );1141    });1142}11431144// 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)1145#[test]1146fn white_list_test_5() {1147    new_test_ext().execute_with(|| {1148        default_limits();1149        1150        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11511152        let origin1 = Origin::signed(1);11531154        let data = default_nft_data();1155        create_test_item(collection_id, &data.into());11561157        assert_ok!(TemplateModule::set_public_access_mode(1158            origin1.clone(),1159            collection_id,1160            AccessMode::WhiteList1161        ));1162        assert_noop!(1163            TemplateModule::burn_item(origin1.clone(), 1, 1),1164            "Address is not in white list"1165        );1166    });1167}11681169// If Public Access mode is set to WhiteList, oken transfers can’t be Approved by a non-whitelisted address (see Approve method).1170#[test]1171fn white_list_test_6() {1172    new_test_ext().execute_with(|| {1173        default_limits();1174        1175        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11761177        let origin1 = Origin::signed(1);1178        assert_ok!(TemplateModule::set_public_access_mode(1179            origin1.clone(),1180            collection_id,1181            AccessMode::WhiteList1182        ));11831184        // do approve1185        assert_noop!(1186            TemplateModule::approve(origin1.clone(), 1, 1, 1),1187            "Address is not in white list"1188        );1189    });1190}11911192// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1193//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1194#[test]1195fn white_list_test_7() {1196    new_test_ext().execute_with(|| {1197        default_limits();1198        1199        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12001201        let data = default_nft_data();1202        create_test_item(collection_id, &data.into());1203        1204        let origin1 = Origin::signed(1);12051206        assert_ok!(TemplateModule::set_public_access_mode(1207            origin1.clone(),1208            collection_id,1209            AccessMode::WhiteList1210        ));1211        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1212        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12131214        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1215    });1216}12171218#[test]1219fn white_list_test_8() {1220    new_test_ext().execute_with(|| {1221        default_limits();1222        1223        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12241225        let data = default_nft_data();1226        create_test_item(collection_id, &data.into());1227        1228        let origin1 = Origin::signed(1);12291230        assert_ok!(TemplateModule::set_public_access_mode(1231            origin1.clone(),1232            collection_id,1233            AccessMode::WhiteList1234        ));1235        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1236        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12371238        // do approve1239        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1240        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);12411242        assert_ok!(TemplateModule::transfer_from(1243            origin1.clone(),1244            1,1245            2,1246            1,1247            1,1248            11249        ));1250    });1251}12521253// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1254#[test]1255fn white_list_test_9() {1256    new_test_ext().execute_with(|| {1257        default_limits();1258        1259        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1260        let origin1 = Origin::signed(1);12611262        assert_ok!(TemplateModule::set_public_access_mode(1263            origin1.clone(),1264            collection_id,1265            AccessMode::WhiteList1266        ));1267        assert_ok!(TemplateModule::set_mint_permission(1268            origin1.clone(),1269            collection_id,1270            false1271        ));12721273        let data = default_nft_data();1274        create_test_item(collection_id, &data.into());1275    });1276}12771278// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1279#[test]1280fn white_list_test_10() {1281    new_test_ext().execute_with(|| {1282        default_limits();1283        1284        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12851286        let origin1 = Origin::signed(1);1287        let origin2 = Origin::signed(2);12881289        assert_ok!(TemplateModule::set_public_access_mode(1290            origin1.clone(),1291            collection_id,1292            AccessMode::WhiteList1293        ));1294        assert_ok!(TemplateModule::set_mint_permission(1295            origin1.clone(),1296            collection_id,1297            false1298        ));12991300        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));13011302        assert_ok!(TemplateModule::create_item(1303            origin2.clone(),1304            collection_id,1305            2,1306            default_nft_data().into()1307        ));1308    });1309}13101311// 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.1312#[test]1313fn white_list_test_11() {1314    new_test_ext().execute_with(|| {1315        default_limits();1316        1317        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13181319        let origin1 = Origin::signed(1);1320        let origin2 = Origin::signed(2);13211322        assert_ok!(TemplateModule::set_public_access_mode(1323            origin1.clone(),1324            collection_id,1325            AccessMode::WhiteList1326        ));1327        assert_ok!(TemplateModule::set_mint_permission(1328            origin1.clone(),1329            collection_id,1330            false1331        ));1332        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13331334        assert_noop!(1335            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1336            "Public minting is not allowed for this collection."1337        );1338    });1339}13401341// 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.1342#[test]1343fn white_list_test_12() {1344    new_test_ext().execute_with(|| {1345        default_limits();1346        1347        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13481349        let origin1 = Origin::signed(1);1350        let origin2 = Origin::signed(2);13511352        assert_ok!(TemplateModule::set_public_access_mode(1353            origin1.clone(),1354            collection_id,1355            AccessMode::WhiteList1356        ));1357        assert_ok!(TemplateModule::set_mint_permission(1358            origin1.clone(),1359            collection_id,1360            false1361        ));13621363        assert_noop!(1364            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1365            "Public minting is not allowed for this collection."1366        );1367    });1368}13691370// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1371#[test]1372fn white_list_test_13() {1373    new_test_ext().execute_with(|| {1374        default_limits();1375        1376        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13771378        let origin1 = Origin::signed(1);13791380        assert_ok!(TemplateModule::set_public_access_mode(1381            origin1.clone(),1382            collection_id,1383            AccessMode::WhiteList1384        ));1385        assert_ok!(TemplateModule::set_mint_permission(1386            origin1.clone(),1387            collection_id,1388            true1389        ));13901391        let data = default_nft_data();1392        create_test_item(collection_id, &data.into());1393    });1394}13951396// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1397#[test]1398fn white_list_test_14() {1399    new_test_ext().execute_with(|| {1400        default_limits();1401        1402        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14031404        let origin1 = Origin::signed(1);1405        let origin2 = Origin::signed(2);14061407        assert_ok!(TemplateModule::set_public_access_mode(1408            origin1.clone(),1409            collection_id,1410            AccessMode::WhiteList1411        ));1412        assert_ok!(TemplateModule::set_mint_permission(1413            origin1.clone(),1414            collection_id,1415            true1416        ));14171418        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));14191420        assert_ok!(TemplateModule::create_item(1421            origin2.clone(),1422            1,1423            2,1424            default_nft_data().into()1425        ));1426    });1427}14281429// 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.1430#[test]1431fn white_list_test_15() {1432    new_test_ext().execute_with(|| {1433        default_limits();1434        1435        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14361437        let origin1 = Origin::signed(1);1438        let origin2 = Origin::signed(2);14391440        assert_ok!(TemplateModule::set_public_access_mode(1441            origin1.clone(),1442            collection_id,1443            AccessMode::WhiteList1444        ));1445        assert_ok!(TemplateModule::set_mint_permission(1446            origin1.clone(),1447            collection_id,1448            true1449        ));14501451        assert_noop!(1452            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1453            "Address is not in white list"1454        );1455    });1456}14571458// 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.1459#[test]1460fn white_list_test_16() {1461    new_test_ext().execute_with(|| {1462        default_limits();1463        1464        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14651466        let origin1 = Origin::signed(1);1467        let origin2 = Origin::signed(2);14681469        assert_ok!(TemplateModule::set_public_access_mode(1470            origin1.clone(),1471            collection_id,1472            AccessMode::WhiteList1473        ));1474        assert_ok!(TemplateModule::set_mint_permission(1475            origin1.clone(),1476            collection_id,1477            true1478        ));1479        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14801481        assert_ok!(TemplateModule::create_item(1482            origin2.clone(),1483            1,1484            2,1485            default_nft_data().into()1486        ));1487    });1488}14891490// Total number of collections. Positive test1491#[test]1492fn total_number_collections_bound() {1493    new_test_ext().execute_with(|| {1494        default_limits();1495        1496        create_test_collection(&CollectionMode::NFT, 1);1497    });1498}14991500// Total number of collections. Negotive test1501#[test]1502fn total_number_collections_bound_neg() {1503    new_test_ext().execute_with(|| {1504        default_limits();15051506        let origin1 = Origin::signed(1);15071508        for i in 0..default_collection_numbers_limit() {1509            create_test_collection(&CollectionMode::NFT, i + 1);1510        }15111512        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1513        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1514        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();15151516        // 11-th collection in chain. Expects error1517        assert_noop!(TemplateModule::create_collection(1518            origin1.clone(),1519            col_name1.clone(),1520            col_desc1.clone(),1521            token_prefix1.clone(),1522            CollectionMode::NFT1523        ), "Total collections bound exceeded");1524    });1525}15261527// Owned tokens by a single address. Positive test1528#[test]1529fn owned_tokens_bound() {1530    new_test_ext().execute_with(|| {1531        default_limits();1532        1533        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15341535        let data = default_nft_data();1536        create_test_item(collection_id, &data.clone().into());1537        create_test_item(collection_id, &data.into());1538    });1539}15401541// Owned tokens by a single address. Negotive test1542#[test]1543fn owned_tokens_bound_neg() {1544    new_test_ext().execute_with(|| {1545        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1546            collection_numbers_limit: 10,1547            account_token_ownership_limit: 1,1548            collections_admins_limit: 5,1549            custom_data_limit: 2048,1550            nft_sponsor_transfer_timeout: 15,1551            fungible_sponsor_transfer_timeout: 15,1552            refungible_sponsor_transfer_timeout: 15,          1553        }));1554        1555        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15561557        let origin1 = Origin::signed(1);1558        let data = default_nft_data();1559        create_test_item(collection_id, &data.clone().into());15601561        assert_noop!(TemplateModule::create_item(1562            origin1.clone(),1563            1,1564            1,1565            data.into()1566        ), "Owned tokens by a single address bound exceeded");1567    });1568}15691570// Number of collection admins. Positive test1571#[test]1572fn collection_admins_bound() {1573    new_test_ext().execute_with(|| {1574        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1575            collection_numbers_limit: 10,1576            account_token_ownership_limit: 10,1577            collections_admins_limit: 2,1578            custom_data_limit: 2048,1579            nft_sponsor_transfer_timeout: 15,1580            fungible_sponsor_transfer_timeout: 15,1581            refungible_sponsor_transfer_timeout: 15,          1582        }));1583        1584        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15851586        let origin1 = Origin::signed(1);1587        1588        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1589        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1590    });1591}15921593// Number of collection admins. Negotive test1594#[test]1595fn collection_admins_bound_neg() {1596    new_test_ext().execute_with(|| {1597        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1598            collection_numbers_limit: 10,1599            account_token_ownership_limit: 1,1600            collections_admins_limit: 1,1601            custom_data_limit: 2048,1602            nft_sponsor_transfer_timeout: 15,1603            fungible_sponsor_transfer_timeout: 15,1604            refungible_sponsor_transfer_timeout: 15,          1605        }));1606        1607        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16081609        let origin1 = Origin::signed(1);16101611        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1612        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), "Number of collection admins bound exceeded");1613    });1614}16151616// NFT custom data size. Negative test const_data.1617#[test]1618fn custom_data_size_nft_const_data_bound_neg() {1619    new_test_ext().execute_with(|| {1620        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1621            collection_numbers_limit: 10,1622            account_token_ownership_limit: 10,1623            collections_admins_limit: 5,1624            custom_data_limit: 2,1625            nft_sponsor_transfer_timeout: 15,1626            fungible_sponsor_transfer_timeout: 15,1627            refungible_sponsor_transfer_timeout: 15,          1628        }));1629        1630        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16311632        let origin1 = Origin::signed(1);1633        let too_big_const_data = CreateItemData::NFT(CreateNftData{1634            const_data: vec![1, 2, 3, 4],1635            variable_data: vec![]1636        });16371638        assert_noop!(TemplateModule::create_item(1639            origin1.clone(),1640            collection_id,1641            1,1642            too_big_const_data1643        ), "const_data exceeded data limit.");1644    });1645}16461647// NFT custom data size. Negative test variable_data.1648#[test]1649fn custom_data_size_nft_variable_data_bound_neg() {1650    new_test_ext().execute_with(|| {1651        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1652            collection_numbers_limit: 10,1653            account_token_ownership_limit: 10,1654            collections_admins_limit: 5,1655            custom_data_limit: 2,1656            nft_sponsor_transfer_timeout: 15,1657            fungible_sponsor_transfer_timeout: 15,1658            refungible_sponsor_transfer_timeout: 15,          1659        }));16601661        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16621663        let origin1 = Origin::signed(1);1664        let too_big_const_data = CreateItemData::NFT(CreateNftData{1665            const_data: vec![],1666            variable_data: vec![1, 2, 3, 4]1667        });16681669        assert_noop!(TemplateModule::create_item(1670            origin1.clone(),1671            collection_id,1672            1,1673            too_big_const_data1674        ), "variable_data exceeded data limit.");1675    });1676}16771678// Re fungible custom data size. Negative test const_data.1679#[test]1680fn custom_data_size_re_fungible_const_data_bound_neg() {1681    new_test_ext().execute_with(|| {1682        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1683            collection_numbers_limit: 10,1684            account_token_ownership_limit: 10,1685            collections_admins_limit: 5,1686            custom_data_limit: 2,1687            nft_sponsor_transfer_timeout: 15,1688            fungible_sponsor_transfer_timeout: 15,1689            refungible_sponsor_transfer_timeout: 15,          1690        }));16911692        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16931694        let origin1 = Origin::signed(1);1695        let too_big_const_data = CreateItemData::NFT(CreateNftData{1696            const_data: vec![1, 2, 3, 4],1697            variable_data: vec![]1698        });16991700        assert_noop!(TemplateModule::create_item(1701            origin1.clone(),1702            collection_id,1703            1,1704            too_big_const_data1705        ), "const_data exceeded data limit.");1706    });1707}17081709// Re fungible custom data size. Negative test variable_data.1710#[test]1711fn custom_data_size_re_fungible_variable_data_bound_neg() {1712    new_test_ext().execute_with(|| {1713        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1714            collection_numbers_limit: 10,1715            account_token_ownership_limit: 10,1716            collections_admins_limit: 5,1717            custom_data_limit: 2,1718            nft_sponsor_transfer_timeout: 15,1719            fungible_sponsor_transfer_timeout: 15,1720            refungible_sponsor_transfer_timeout: 15,          1721        }));17221723        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17241725        let origin1 = Origin::signed(1);1726        let too_big_const_data = CreateItemData::NFT(CreateNftData{1727            const_data: vec![],1728            variable_data: vec![1, 2, 3, 4]1729        });17301731        assert_noop!(TemplateModule::create_item(1732            origin1.clone(),1733            collection_id,1734            1,1735            too_big_const_data1736        ), "variable_data exceeded data limit.");1737    });1738}1739// #endregion17401741#[test]1742fn set_const_on_chain_schema() {1743    new_test_ext().execute_with(|| {1744        default_limits();17451746        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17471748        let origin1 = Origin::signed(1);1749        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, b"test const on chain schema".to_vec()));17501751        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"test const on chain schema".to_vec());1752        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"".to_vec());1753    });1754}17551756#[test]1757fn set_variable_on_chain_schema() {1758    new_test_ext().execute_with(|| {1759        default_limits();1760        1761        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17621763        let origin1 = Origin::signed(1);1764        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, b"test variable on chain schema".to_vec()));17651766        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"".to_vec());1767        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"test variable on chain schema".to_vec());1768    });1769}17701771#[test]1772fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1773    new_test_ext().execute_with(|| {1774        default_limits();17751776        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17771778        let origin1 = Origin::signed(1);1779        1780        let data = default_nft_data();1781        create_test_item(1, &data.into());1782        1783        let variable_data = b"test set_variable_meta_data method.".to_vec();1784        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));17851786        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, variable_data);1787    });1788}17891790#[test]1791fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1792    new_test_ext().execute_with(|| {1793        default_limits();17941795        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);17961797        let origin1 = Origin::signed(1);17981799        let data = default_re_fungible_data();1800        create_test_item(1, &data.into());18011802        let variable_data = b"test set_variable_meta_data method.".to_vec();1803        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));18041805        assert_eq!(TemplateModule::refungible_item_id(collection_id, 1).variable_data, variable_data);1806    });1807}180818091810#[test]1811fn set_variable_meta_data_on_fungible_token_fails() {1812    new_test_ext().execute_with(|| {1813        default_limits();18141815        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);18161817        let origin1 = Origin::signed(1);18181819        let data = default_fungible_data();1820        create_test_item(1, &data.into());18211822        let variable_data = b"test set_variable_meta_data method.".to_vec();1823        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()), "Can't store metadata in fungible tokens.");1824    });1825}