git.delta.rocks / unique-network / refs/commits / 3950758e00c3

1// Tests to be written here2use crate::mock::*;3use crate::{AccessMode, ApprovePermissions, CollectionMode, Ownership, ChainLimits, CreateItemData, NftItemType, 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() -> CreateItemData {24    CreateItemData::NFT(CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })25}2627fn default_fungible_data () -> CreateItemData {28    CreateItemData::Fungible(CreateFungibleData { })29}3031fn default_re_fungible_data () -> CreateItemData {32    CreateItemData::ReFungible(CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })33}3435fn create_test_collection_for_owner(mode: &CollectionMode, owner: 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 collection_id = TemplateModule::nextCollectionID();41    let origin1 = Origin::signed(owner);42    assert_ok!(TemplateModule::create_collection(43            origin1.clone(),44            col_name1.clone(),45            col_desc1.clone(),46            token_prefix1.clone(),47            mode48        ));49    assert_eq!(TemplateModule::collection(collection_id).owner, owner);50    return collection_id;51}5253fn create_test_collection(mode: &CollectionMode) -> u64 {54    return create_test_collection_for_owner(&mode, 1);55}5657fn create_test_item(collection_id: u64, data: &CreateItemData) {58    let origin1 = Origin::signed(1);59    assert_ok!(TemplateModule::create_item(60            origin1.clone(),61            collection_id,62            1,63            data.clone()64        ));6566}6768// Use cases tests region69// #region70#[test]71fn create_nft_item() {72    new_test_ext().execute_with(|| {73        default_limits();74        let collection_id = create_test_collection(&CollectionMode::NFT);7576        let data = default_nft_data();77        create_test_item(collection_id, &data);78        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);79        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);80    });81}8283#[test]84fn create_refungible_item() {85    new_test_ext().execute_with(|| {86        default_limits();87        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));8889        let data = default_re_fungible_data();90        create_test_item(collection_id, &data);91        assert_eq!(92            TemplateModule::refungible_item_id(collection_id, 1).const_data,93            data.const_data94        );95        assert_eq!(96            TemplateModule::refungible_item_id(collection_id, 1).variable_data,97            data.variable_data98        );99        assert_eq!(100            TemplateModule::refungible_item_id(collection_id, 1).owner[0],101            Ownership {102                owner: 1,103                fraction: 1000104            }105        );106    });107}108109#[test]110fn create_fungible_item() {111    new_test_ext().execute_with(|| {112        let collection_id = create_test_collection(&CollectionMode::Fungible(3));113114        let data = default_fungible_data();115        create_test_item(collection_id, &data);116117        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);118        assert_eq!(TemplateModule::balance_count(1, 1), 1000);119        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);120    });121}122123#[test]124fn transfer_fungible_item() {125    new_test_ext().execute_with(|| {126        default_limits();127        128        let collection_id = create_test_collection(&CollectionMode::Fungible(3));129130        let origin1 = Origin::signed(1);131        let origin2 = Origin::signed(2);132133        let data = default_fungible_data();134        create_test_item(collection_id, &data);135136        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);137        assert_eq!(TemplateModule::balance_count(1, 1), 1000);138        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);139140        // change owner scenario141        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));142        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);143        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);144        assert_eq!(TemplateModule::balance_count(1, 1), 0);145        assert_eq!(TemplateModule::balance_count(1, 2), 1000);146        // assert_eq!(TemplateModule::address_tokens(1, 1), []);147        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);148149        // split item scenario150        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));151        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);152        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);153        assert_eq!(TemplateModule::balance_count(1, 2), 500);154        assert_eq!(TemplateModule::balance_count(1, 3), 500);155        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);156        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);157158        // split item and new owner has account scenario159        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));160        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);161        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);162        assert_eq!(TemplateModule::balance_count(1, 2), 300);163        assert_eq!(TemplateModule::balance_count(1, 3), 700);164        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);165        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);166    });167}168169#[test]170fn transfer_refungible_item() {171    new_test_ext().execute_with(|| {172        default_limits();173        174        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));175176        let data = default_re_fungible_data();177        create_test_item(collection_id, &data);178179        let origin1 = Origin::signed(1);180        let origin2 = Origin::signed(2);181        assert_eq!(182            TemplateModule::refungible_item_id(collection_id, 1).const_data,183            data.const_data184        );185        assert_eq!(186            TemplateModule::refungible_item_id(collection_id, 1).variable_data,187            data.variable_data188        );189        assert_eq!(190            TemplateModule::refungible_item_id(collection_id, 1).owner[0],191            Ownership {192                owner: 1,193                fraction: 1000194            }195        );196        assert_eq!(TemplateModule::balance_count(1, 1), 1000);197        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);198199        // change owner scenario200        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));201        assert_eq!(202            TemplateModule::refungible_item_id(1, 1).owner[0],203            Ownership {204                owner: 2,205                fraction: 1000206            }207        );208        assert_eq!(TemplateModule::balance_count(1, 1), 0);209        assert_eq!(TemplateModule::balance_count(1, 2), 1000);210        // assert_eq!(TemplateModule::address_tokens(1, 1), []);211        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);212213        // split item scenario214        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));215        assert_eq!(216            TemplateModule::refungible_item_id(1, 1).owner[0],217            Ownership {218                owner: 2,219                fraction: 500220            }221        );222        assert_eq!(223            TemplateModule::refungible_item_id(1, 1).owner[1],224            Ownership {225                owner: 3,226                fraction: 500227            }228        );229        assert_eq!(TemplateModule::balance_count(1, 2), 500);230        assert_eq!(TemplateModule::balance_count(1, 3), 500);231        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);232        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);233234        // split item and new owner has account scenario235        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));236        assert_eq!(237            TemplateModule::refungible_item_id(1, 1).owner[0],238            Ownership {239                owner: 2,240                fraction: 300241            }242        );243        assert_eq!(244            TemplateModule::refungible_item_id(1, 1).owner[1],245            Ownership {246                owner: 3,247                fraction: 700248            }249        );250        assert_eq!(TemplateModule::balance_count(1, 2), 300);251        assert_eq!(TemplateModule::balance_count(1, 3), 700);252        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);253        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);254    });255}256257#[test]258fn transfer_nft_item() {259    new_test_ext().execute_with(|| {260        default_limits();261        262        let collection_id = create_test_collection(&CollectionMode::NFT);263264        let data = default_nft_data();265        create_test_item(collection_id, &data);266        assert_eq!(TemplateModule::balance_count(1, 1), 1);267        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);268269        // default scenario270        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));271        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);272        assert_eq!(TemplateModule::balance_count(1, 1), 0);273        assert_eq!(TemplateModule::balance_count(1, 2), 1);274        // assert_eq!(TemplateModule::address_tokens(1, 1), []);275        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);276    });277}278279#[test]280fn nft_approve_and_transfer_from() {281    new_test_ext().execute_with(|| {282        default_limits();283        284        let collection_id = create_test_collection(&CollectionMode::NFT);285286        let data = default_nft_data();287        create_test_item(collection_id, &data);288289        let origin1 = Origin::signed(1);290        let origin2 = Origin::signed(2);291292        assert_eq!(TemplateModule::balance_count(1, 1), 1);293        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);294295        assert_ok!(TemplateModule::set_mint_permission(296            origin1.clone(),297            1,298            true299        ));300        assert_ok!(TemplateModule::set_public_access_mode(301            origin1.clone(),302            1,303            AccessMode::WhiteList304        ));305        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));306        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));307        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));308309        // do approve310        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));311        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);312        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));313        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);314        assert_eq!(315            TemplateModule::approved(1, (1, 1))[0],316            ApprovePermissions {317                approved: 2,318                amount: 100000000319            }320        );321322        assert_ok!(TemplateModule::transfer_from(323            origin2.clone(),324            1,325            3,326            1,327            1,328            1329        ));330        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);331    });332}333334#[test]335fn refungible_approve_and_transfer_from() {336    new_test_ext().execute_with(|| {337        default_limits();338        339        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));340        341        let origin1 = Origin::signed(1);342        let origin2 = Origin::signed(2);343344        let data = default_re_fungible_data();345        create_test_item(collection_id, &data);346347        assert_eq!(TemplateModule::balance_count(1, 1), 1000);348        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);349350        assert_ok!(TemplateModule::set_mint_permission(351            origin1.clone(),352            1,353            true354        ));355        assert_ok!(TemplateModule::set_public_access_mode(356            origin1.clone(),357            1,358            AccessMode::WhiteList359        ));360        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));361        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));362        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));363364        // do approve365        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));366        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);367        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));368        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);369        assert_eq!(370            TemplateModule::approved(1, (1, 1))[0],371            ApprovePermissions {372                approved: 2,373                amount: 100000000374            }375        );376377        assert_ok!(TemplateModule::transfer_from(378            origin2.clone(),379            1,380            3,381            1,382            1,383            100384        ));385        assert_eq!(TemplateModule::balance_count(1, 1), 900);386        assert_eq!(TemplateModule::balance_count(1, 3), 100);387        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);388        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);389390        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);391        assert_eq!(392            TemplateModule::approved(1, (1, 1))[0],393            ApprovePermissions {394                approved: 3,395                amount: 100000000396            }397        );398    });399}400401#[test]402fn fungible_approve_and_transfer_from() {403    new_test_ext().execute_with(|| {404        default_limits();405        406        let collection_id = create_test_collection(&CollectionMode::Fungible(3));407        408        let data = default_fungible_data();409        create_test_item(collection_id, &data);410411        let origin1 = Origin::signed(1);412        let origin2 = Origin::signed(2);413414        assert_eq!(TemplateModule::balance_count(1, 1), 1000);415        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);416417        assert_ok!(TemplateModule::set_mint_permission(418            origin1.clone(),419            1,420            true421        ));422        assert_ok!(TemplateModule::set_public_access_mode(423            origin1.clone(),424            1,425            AccessMode::WhiteList426        ));427        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));428        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));429        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));430431        // do approve432        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));433        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);434        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));435        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);436        assert_eq!(437            TemplateModule::approved(1, (1, 1))[0],438            ApprovePermissions {439                approved: 2,440                amount: 100000000441            }442        );443444        assert_ok!(TemplateModule::transfer_from(445            origin2.clone(),446            1,447            3,448            1,449            1,450            100451        ));452        assert_eq!(TemplateModule::balance_count(1, 1), 900);453        assert_eq!(TemplateModule::balance_count(1, 3), 100);454        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);455        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);456457        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);458        assert_eq!(459            TemplateModule::approved(1, (1, 1))[0],460            ApprovePermissions {461                approved: 3,462                amount: 100000000463            }464        );465466        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));467        assert_ok!(TemplateModule::transfer_from(468            origin2.clone(),469            1,470            3,471            1,472            1,473            900474        ));475        assert_eq!(TemplateModule::balance_count(1, 1), 0);476        assert_eq!(TemplateModule::balance_count(1, 3), 1000);477        // assert_eq!(TemplateModule::address_tokens(1, 1), []);478        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);479480        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);481    });482}483484#[test]485fn change_collection_owner() {486    new_test_ext().execute_with(|| {487        default_limits();488        489        let collection_id = create_test_collection(&CollectionMode::NFT);490        491        let origin1 = Origin::signed(1);492        assert_ok!(TemplateModule::change_collection_owner(493            origin1.clone(),494            collection_id,495            2496        ));497        assert_eq!(TemplateModule::collection(collection_id).owner, 2);498    });499}500501#[test]502fn destroy_collection() {503    new_test_ext().execute_with(|| {504        default_limits();505        506        let collection_id = create_test_collection(&CollectionMode::NFT);507        508        let origin1 = Origin::signed(1);509        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));510    });511}512513#[test]514fn burn_nft_item() {515    new_test_ext().execute_with(|| {516        default_limits();517        518        let collection_id = create_test_collection(&CollectionMode::NFT);519520        let origin1 = Origin::signed(1);521        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));522        523        let data = default_nft_data();524        create_test_item(collection_id, &data);525526        // check balance (collection with id = 1, user id = 1)527        assert_eq!(TemplateModule::balance_count(1, 1), 1);528529        // burn item530        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));531        assert_noop!(532            TemplateModule::burn_item(origin1.clone(), 1, 1),533            "Item does not exists"534        );535536        assert_eq!(TemplateModule::balance_count(1, 1), 0);537    });538}539540#[test]541fn burn_fungible_item() {542    new_test_ext().execute_with(|| {543        default_limits();544        545        let collection_id = create_test_collection(&CollectionMode::Fungible(3));546        547        let origin1 = Origin::signed(1);548        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));549        550        let data = default_fungible_data();551        create_test_item(collection_id, &data);552553        // check balance (collection with id = 1, user id = 1)554        assert_eq!(TemplateModule::balance_count(1, 1), 1000);555556        // burn item557        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));558        assert_noop!(559            TemplateModule::burn_item(origin1.clone(), 1, 1),560            "Item does not exists"561        );562563        assert_eq!(TemplateModule::balance_count(1, 1), 0);564    });565}566567#[test]568fn burn_refungible_item() {569    new_test_ext().execute_with(|| {570        default_limits();571        572        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));573        let origin1 = Origin::signed(1);574        let origin2 = Origin::signed(2);575576        assert_ok!(TemplateModule::set_mint_permission(577            origin1.clone(),578            collection_id,579            true580        ));581        assert_ok!(TemplateModule::set_public_access_mode(582            origin1.clone(),583            collection_id,584            AccessMode::WhiteList585        ));586        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));587588        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));589        590        let data = default_re_fungible_data();591        create_test_item(collection_id, &data);592593        // check balance (collection with id = 1, user id = 2)594        assert_eq!(TemplateModule::balance_count(1, 1), 1000);595596        // burn item597        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));598        assert_noop!(599            TemplateModule::burn_item(origin1.clone(), 1, 1),600            "Item does not exists"601        );602603        assert_eq!(TemplateModule::balance_count(1, 1), 0);604    });605}606607#[test]608fn add_collection_admin() {609    new_test_ext().execute_with(|| {610        default_limits();611        612        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1);613        create_test_collection_for_owner(&CollectionMode::NFT, 2);614        create_test_collection_for_owner(&CollectionMode::NFT, 3);615        616        let origin1 = Origin::signed(1);617618        // collection admin619        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));620        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));621622        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);623        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);624    });625}626627#[test]628fn remove_collection_admin() {629    new_test_ext().execute_with(|| {630        default_limits();631        632        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1);633        create_test_collection_for_owner(&CollectionMode::NFT, 2);634        create_test_collection_for_owner(&CollectionMode::NFT, 3);635636        let origin1 = Origin::signed(1);637        let origin2 = Origin::signed(2);638639        // collection admin640        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));641        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));642643        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);644        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);645646        // remove admin647        assert_ok!(TemplateModule::remove_collection_admin(648            origin2.clone(),649            1,650            3651        ));652        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);653    });654}655656#[test]657fn balance_of() {658    new_test_ext().execute_with(|| {659        default_limits();660        661        let nft_collection_id = create_test_collection(&CollectionMode::NFT);662        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3));663        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3));664        665        let origin1 = Origin::signed(1);666667        // check balance before668        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);669        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);670        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);671672        let nft_data = default_nft_data();673        create_test_item(nft_collection_id, &nft_data);674        675        let fungible_data = default_fungible_data();676        create_test_item(fungible_collection_id, &fungible_data);677        678        let re_fungible_data = default_re_fungible_data();679        create_test_item(re_fungible_collection_id, &re_fungible_data);680681        // check balance (collection with id = 1, user id = 1)682        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);683        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);684        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);685        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);686        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);687        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);688    });689}690691#[test]692fn approve() {693    new_test_ext().execute_with(|| {694        default_limits();695        696        let collection_id = create_test_collection(&CollectionMode::NFT);697        698        let data = default_nft_data();699        create_test_item(collection_id, &data);700701        let origin1 = Origin::signed(1);702        703        // approve704        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));705        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);706    });707}708709#[test]710fn transfer_from() {711    new_test_ext().execute_with(|| {712        default_limits();713        714        let collection_id = create_test_collection(&CollectionMode::NFT);715        let origin1 = Origin::signed(1);716        let origin2 = Origin::signed(2);717718        let data = default_nft_data();719        create_test_item(collection_id, &data);720721        // approve722        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));723        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);724725        assert_ok!(TemplateModule::set_mint_permission(726            origin1.clone(),727            1,728            true729        ));730        assert_ok!(TemplateModule::set_public_access_mode(731            origin1.clone(),732            1,733            AccessMode::WhiteList734        ));735        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));736        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));737        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));738739        assert_ok!(TemplateModule::transfer_from(740            origin2.clone(),741            1,742            2,743            1,744            1,745            1746        ));747748        // after transfer749        assert_eq!(TemplateModule::balance_count(1, 1), 0);750        assert_eq!(TemplateModule::balance_count(1, 2), 1);751    });752}753754// #endregion755756// Coverage tests region757// #region758759#[test]760fn owner_can_add_address_to_white_list() {761    new_test_ext().execute_with(|| {762        default_limits();763        764        let collection_id = create_test_collection(&CollectionMode::NFT);765766        let origin1 = Origin::signed(1);767        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));768        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);769    });770}771772#[test]773fn admin_can_add_address_to_white_list() {774    new_test_ext().execute_with(|| {775        default_limits();776        777        let collection_id = create_test_collection(&CollectionMode::NFT);778        let origin1 = Origin::signed(1);779        let origin2 = Origin::signed(2);780781        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));782        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));783        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);784    });785}786787#[test]788fn nonprivileged_user_cannot_add_address_to_white_list() {789    new_test_ext().execute_with(|| {790        default_limits();791        792        let collection_id = create_test_collection(&CollectionMode::NFT);793794        let origin2 = Origin::signed(2);795        assert_noop!(796            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),797            "You do not have permissions to modify this collection"798        );799    });800}801802#[test]803fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {804    new_test_ext().execute_with(|| {805        default_limits();806807        let origin1 = Origin::signed(1);808809        assert_noop!(810            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),811            "This collection does not exist"812        );813    });814}815816#[test]817fn nobody_can_add_address_to_white_list_of_deleted_collection() {818    new_test_ext().execute_with(|| {819        default_limits();820        821        let collection_id = create_test_collection(&CollectionMode::NFT);822823        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));824        assert_noop!(825            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),826            "This collection does not exist"827        );828    });829}830831// If address is already added to white list, nothing happens832#[test]833fn address_is_already_added_to_white_list() {834    new_test_ext().execute_with(|| {835        default_limits();836        837        let collection_id = create_test_collection(&CollectionMode::NFT);838        let origin1 = Origin::signed(1);839        840        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));841        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));842        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);843        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);844    });845}846847#[test]848fn owner_can_remove_address_from_white_list() {849    new_test_ext().execute_with(|| {850        default_limits();851        852        let collection_id = create_test_collection(&CollectionMode::NFT);853854        let origin1 = Origin::signed(1);855        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));856        assert_ok!(TemplateModule::remove_from_white_list(857            origin1.clone(),858            collection_id,859            2860        ));861        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);862    });863}864865#[test]866fn admin_can_remove_address_from_white_list() {867    new_test_ext().execute_with(|| {868        default_limits();869        870        let collection_id = create_test_collection(&CollectionMode::NFT);871        let origin1 = Origin::signed(1);872        let origin2 = Origin::signed(2);873874        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));875876        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));877        assert_ok!(TemplateModule::remove_from_white_list(878            origin2.clone(),879            collection_id,880            3881        ));882        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);883    });884}885886#[test]887fn nonprivileged_user_cannot_remove_address_from_white_list() {888    new_test_ext().execute_with(|| {889        default_limits();890        891        let collection_id = create_test_collection(&CollectionMode::NFT);892        let origin1 = Origin::signed(1);893        let origin2 = Origin::signed(2);894895        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));896        assert_noop!(897            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),898            "You do not have permissions to modify this collection"899        );900        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);901    });902}903904#[test]905fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {906    new_test_ext().execute_with(|| {907        default_limits();908        let origin1 = Origin::signed(1);909910        assert_noop!(911            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),912            "This collection does not exist"913        );914    });915}916917#[test]918fn nobody_can_remove_address_from_white_list_of_deleted_collection() {919    new_test_ext().execute_with(|| {920        default_limits();921        922        let collection_id = create_test_collection(&CollectionMode::NFT);923        let origin1 = Origin::signed(1);924        let origin2 = Origin::signed(2);925926        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));927        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));928        assert_noop!(929            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),930            "This collection does not exist"931        );932        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);933    });934}935936// If address is already removed from white list, nothing happens937#[test]938fn address_is_already_removed_from_white_list() {939    new_test_ext().execute_with(|| {940        default_limits();941        942        let collection_id = create_test_collection(&CollectionMode::NFT);943        let origin1 = Origin::signed(1);944945        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));946        assert_ok!(TemplateModule::remove_from_white_list(947            origin1.clone(),948            collection_id,949            2950        ));951        assert_ok!(TemplateModule::remove_from_white_list(952            origin1.clone(),953            collection_id,954            2955        ));956        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);957    });958}959960// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)961#[test]962fn white_list_test_1() {963    new_test_ext().execute_with(|| {964        default_limits();965        966        let collection_id = create_test_collection(&CollectionMode::NFT);967968        let origin1 = Origin::signed(1);969        970        let data = default_nft_data();971        create_test_item(collection_id, &data);972973        assert_ok!(TemplateModule::set_public_access_mode(974            origin1.clone(),975            collection_id,976            AccessMode::WhiteList977        ));978        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));979980        assert_noop!(981            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),982            "Address is not in white list"983        );984    });985}986987#[test]988fn white_list_test_2() {989    new_test_ext().execute_with(|| {990        default_limits();991        992        let collection_id = create_test_collection(&CollectionMode::NFT);993        let origin1 = Origin::signed(1);994        995        let data = default_nft_data();996        create_test_item(collection_id, &data);997998        assert_ok!(TemplateModule::set_public_access_mode(999            origin1.clone(),1000            collection_id,1001            AccessMode::WhiteList1002        ));1003        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1004        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));10051006        // do approve1007        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1008        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);10091010        assert_ok!(TemplateModule::remove_from_white_list(1011            origin1.clone(),1012            1,1013            11014        ));10151016        assert_noop!(1017            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1018            "Address is not in white list"1019        );1020    });1021}10221023// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1024#[test]1025fn white_list_test_3() {1026    new_test_ext().execute_with(|| {1027        default_limits();1028        1029        let collection_id = create_test_collection(&CollectionMode::NFT);10301031        let origin1 = Origin::signed(1);1032        1033        let data = default_nft_data();1034        create_test_item(collection_id, &data);10351036        assert_ok!(TemplateModule::set_public_access_mode(1037            origin1.clone(),1038            collection_id,1039            AccessMode::WhiteList1040        ));1041        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));10421043        assert_noop!(1044            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1045            "Address is not in white list"1046        );1047    });1048}10491050#[test]1051fn white_list_test_4() {1052    new_test_ext().execute_with(|| {1053        default_limits();1054        1055        let collection_id = create_test_collection(&CollectionMode::NFT);10561057        let origin1 = Origin::signed(1);10581059        let data = default_nft_data();1060        create_test_item(collection_id, &data);10611062        assert_ok!(TemplateModule::set_public_access_mode(1063            origin1.clone(),1064            collection_id,1065            AccessMode::WhiteList1066        ));1067        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1068        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));10691070        // do approve1071        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1072        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);10731074        assert_ok!(TemplateModule::remove_from_white_list(1075            origin1.clone(),1076            collection_id,1077            21078        ));10791080        assert_noop!(1081            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1082            "Address is not in white list"1083        );1084    });1085}10861087// 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)1088#[test]1089fn white_list_test_5() {1090    new_test_ext().execute_with(|| {1091        default_limits();1092        1093        let collection_id = create_test_collection(&CollectionMode::NFT);10941095        let origin1 = Origin::signed(1);10961097        let data = default_nft_data();1098        create_test_item(collection_id, &data);10991100        assert_ok!(TemplateModule::set_public_access_mode(1101            origin1.clone(),1102            collection_id,1103            AccessMode::WhiteList1104        ));1105        assert_noop!(1106            TemplateModule::burn_item(origin1.clone(), 1, 1),1107            "Address is not in white list"1108        );1109    });1110}11111112// If Public Access mode is set to WhiteList, oken transfers can’t be Approved by a non-whitelisted address (see Approve method).1113#[test]1114fn white_list_test_6() {1115    new_test_ext().execute_with(|| {1116        default_limits();1117        1118        let collection_id = create_test_collection(&CollectionMode::NFT);11191120        let origin1 = Origin::signed(1);1121        assert_ok!(TemplateModule::set_public_access_mode(1122            origin1.clone(),1123            collection_id,1124            AccessMode::WhiteList1125        ));11261127        // do approve1128        assert_noop!(1129            TemplateModule::approve(origin1.clone(), 1, 1, 1),1130            "Address is not in white list"1131        );1132    });1133}11341135// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1136//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1137#[test]1138fn white_list_test_7() {1139    new_test_ext().execute_with(|| {1140        default_limits();1141        1142        let collection_id = create_test_collection(&CollectionMode::NFT);11431144        let data = default_nft_data();1145        create_test_item(collection_id, &data);1146        1147        let origin1 = Origin::signed(1);11481149        assert_ok!(TemplateModule::set_public_access_mode(1150            origin1.clone(),1151            collection_id,1152            AccessMode::WhiteList1153        ));1154        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1155        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11561157        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1158    });1159}11601161#[test]1162fn white_list_test_8() {1163    new_test_ext().execute_with(|| {1164        default_limits();1165        1166        let collection_id = create_test_collection(&CollectionMode::NFT);11671168        let data = default_nft_data();1169        create_test_item(collection_id, &data);1170        1171        let origin1 = Origin::signed(1);11721173        assert_ok!(TemplateModule::set_public_access_mode(1174            origin1.clone(),1175            collection_id,1176            AccessMode::WhiteList1177        ));1178        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1179        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11801181        // do approve1182        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1183        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);11841185        assert_ok!(TemplateModule::transfer_from(1186            origin1.clone(),1187            1,1188            2,1189            1,1190            1,1191            11192        ));1193    });1194}11951196// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1197#[test]1198fn white_list_test_9() {1199    new_test_ext().execute_with(|| {1200        default_limits();1201        1202        let collection_id = create_test_collection(&CollectionMode::NFT);1203        let origin1 = Origin::signed(1);12041205        assert_ok!(TemplateModule::set_public_access_mode(1206            origin1.clone(),1207            collection_id,1208            AccessMode::WhiteList1209        ));1210        assert_ok!(TemplateModule::set_mint_permission(1211            origin1.clone(),1212            collection_id,1213            false1214        ));12151216        let data = default_nft_data();1217        create_test_item(collection_id, &data);1218    });1219}12201221// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1222#[test]1223fn white_list_test_10() {1224    new_test_ext().execute_with(|| {1225        default_limits();1226        1227        let collection_id = create_test_collection(&CollectionMode::NFT);12281229        let origin1 = Origin::signed(1);1230        let origin2 = Origin::signed(2);12311232        assert_ok!(TemplateModule::set_public_access_mode(1233            origin1.clone(),1234            collection_id,1235            AccessMode::WhiteList1236        ));1237        assert_ok!(TemplateModule::set_mint_permission(1238            origin1.clone(),1239            collection_id,1240            false1241        ));12421243        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));12441245        assert_ok!(TemplateModule::create_item(1246            origin2.clone(),1247            collection_id,1248            2,1249            default_nft_data()1250        ));1251    });1252}12531254// 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.1255#[test]1256fn white_list_test_11() {1257    new_test_ext().execute_with(|| {1258        default_limits();1259        1260        let collection_id = create_test_collection(&CollectionMode::NFT);12611262        let origin1 = Origin::signed(1);1263        let origin2 = Origin::signed(2);12641265        assert_ok!(TemplateModule::set_public_access_mode(1266            origin1.clone(),1267            collection_id,1268            AccessMode::WhiteList1269        ));1270        assert_ok!(TemplateModule::set_mint_permission(1271            origin1.clone(),1272            collection_id,1273            false1274        ));1275        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12761277        assert_noop!(1278            TemplateModule::create_item(origin2.clone(), 1, vec![1, 2, 3], 2),1279            "Public minting is not allowed for this collection"1280        );1281    });1282}12831284// 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.1285#[test]1286fn white_list_test_12() {1287    new_test_ext().execute_with(|| {1288        default_limits();1289        1290        let collection_id = create_test_collection(&CollectionMode::NFT);12911292        let origin1 = Origin::signed(1);1293        let origin2 = Origin::signed(2);12941295        assert_ok!(TemplateModule::set_public_access_mode(1296            origin1.clone(),1297            collection_id,1298            AccessMode::WhiteList1299        ));1300        assert_ok!(TemplateModule::set_mint_permission(1301            origin1.clone(),1302            collection_id,1303            false1304        ));13051306        assert_noop!(1307            TemplateModule::create_item(origin2.clone(), 1, vec![1, 2, 3], 2),1308            "Public minting is not allowed for this collection"1309        );1310    });1311}13121313// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1314#[test]1315fn white_list_test_13() {1316    new_test_ext().execute_with(|| {1317        default_limits();1318        1319        let collection_id = create_test_collection(&CollectionMode::NFT);13201321        let origin1 = Origin::signed(1);13221323        assert_ok!(TemplateModule::set_public_access_mode(1324            origin1.clone(),1325            collection_id,1326            AccessMode::WhiteList1327        ));1328        assert_ok!(TemplateModule::set_mint_permission(1329            origin1.clone(),1330            collection_id,1331            true1332        ));13331334        let data = default_nft_data();1335        create_test_item(collection_id, &data);1336    });1337}13381339// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1340#[test]1341fn white_list_test_14() {1342    new_test_ext().execute_with(|| {1343        default_limits();1344        1345        let collection_id = create_test_collection(&CollectionMode::NFT);13461347        let origin1 = Origin::signed(1);1348        let origin2 = Origin::signed(2);13491350        assert_ok!(TemplateModule::set_public_access_mode(1351            origin1.clone(),1352            collection_id,1353            AccessMode::WhiteList1354        ));1355        assert_ok!(TemplateModule::set_mint_permission(1356            origin1.clone(),1357            collection_id,1358            true1359        ));13601361        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));13621363        assert_ok!(TemplateModule::create_item(1364            origin2.clone(),1365            1,1366            2,1367            default_nft_data()1368        ));1369    });1370}13711372// 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.1373#[test]1374fn white_list_test_15() {1375    new_test_ext().execute_with(|| {1376        default_limits();1377        1378        let collection_id = create_test_collection(&CollectionMode::NFT);13791380        let origin1 = Origin::signed(1);1381        let origin2 = Origin::signed(2);13821383        assert_ok!(TemplateModule::set_public_access_mode(1384            origin1.clone(),1385            collection_id,1386            AccessMode::WhiteList1387        ));1388        assert_ok!(TemplateModule::set_mint_permission(1389            origin1.clone(),1390            collection_id,1391            true1392        ));13931394        assert_noop!(1395            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data()),1396            "Address is not in white list"1397        );1398    });1399}14001401// 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.1402#[test]1403fn white_list_test_16() {1404    new_test_ext().execute_with(|| {1405        default_limits();1406        1407        let collection_id = create_test_collection(&CollectionMode::NFT);14081409        let origin1 = Origin::signed(1);1410        let origin2 = Origin::signed(2);14111412        assert_ok!(TemplateModule::set_public_access_mode(1413            origin1.clone(),1414            collection_id,1415            AccessMode::WhiteList1416        ));1417        assert_ok!(TemplateModule::set_mint_permission(1418            origin1.clone(),1419            collection_id,1420            true1421        ));1422        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14231424        assert_ok!(TemplateModule::create_item(1425            origin2.clone(),1426            1,1427            2,1428            default_nft_data()1429        ));1430    });1431}14321433// Total number of collections. Positive test1434#[test]1435fn total_number_collections_bound() {1436    new_test_ext().execute_with(|| {1437        default_limits();1438        1439        create_test_collection(&CollectionMode::NFT);1440    });1441}14421443// Total number of collections. Negotive test1444#[test]1445fn total_number_collections_bound_neg() {1446    new_test_ext().execute_with(|| {1447        default_limits();14481449        let origin1 = Origin::signed(1);14501451        for _ in 0..default_collection_numbers_limit() {1452            create_test_collection(&CollectionMode::NFT)1453        }14541455        // 11-th collection in chain. Expects error1456        assert_noop!(TemplateModule::create_collection(1457            origin1.clone(),1458            col_name1.clone(),1459            col_desc1.clone(),1460            token_prefix1.clone(),1461            mode.clone()1462        ), "Total collections bound exceeded");1463    });1464}14651466// Owned tokens by a single address. Positive test1467#[test]1468fn owned_tokens_bound() {1469    new_test_ext().execute_with(|| {1470        default_limits();1471        1472        let collection_id = create_test_collection(&CollectionMode::NFT);14731474        let data = default_nft_data();1475        create_test_item(collection_id, &data);1476        create_test_item(collection_id, &data);1477    });1478}14791480// Owned tokens by a single address. Negotive test1481#[test]1482fn owned_tokens_bound_neg() {1483    new_test_ext().execute_with(|| {1484        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1485            collection_numbers_limit: 10,1486            account_token_ownership_limit: 1,1487            collections_admins_limit: 5,1488            custom_data_limit: 2048,1489            nft_sponsor_transfer_timeout: 15,1490            fungible_sponsor_transfer_timeout: 15,1491            refungible_sponsor_transfer_timeout: 15,          1492        }));1493        1494        let collection_id = create_test_collection(&CollectionMode::NFT);14951496        let origin1 = Origin::signed(1);1497        let data = default_nft_data();1498        create_test_item(collection_id, &data);14991500        assert_noop!(TemplateModule::create_item(1501            origin1.clone(),1502            1,1503            1,1504            data1505        ), "Owned tokens by a single address bound exceeded");1506    });1507}15081509// Number of collection admins. Positive test1510#[test]1511fn collection_admins_bound() {1512    new_test_ext().execute_with(|| {1513        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1514            collection_numbers_limit: 10,1515            account_token_ownership_limit: 10,1516            collections_admins_limit: 2,1517            custom_data_limit: 2048,1518            nft_sponsor_transfer_timeout: 15,1519            fungible_sponsor_transfer_timeout: 15,1520            refungible_sponsor_transfer_timeout: 15,          1521        }));1522        1523        let collection_id = create_test_collection(&CollectionMode::NFT);15241525        let origin1 = Origin::signed(1);1526        1527        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1528        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1529    });1530}15311532// Number of collection admins. Negotive test1533#[test]1534fn collection_admins_bound_neg() {1535    new_test_ext().execute_with(|| {1536        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1537            collection_numbers_limit: 10,1538            account_token_ownership_limit: 1,1539            collections_admins_limit: 1,1540            custom_data_limit: 2048,1541            nft_sponsor_transfer_timeout: 15,1542            fungible_sponsor_transfer_timeout: 15,1543            refungible_sponsor_transfer_timeout: 15,          1544        }));1545        1546        let collection_id = create_test_collection(&CollectionMode::NFT);15471548        let origin1 = Origin::signed(1);15491550        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1551        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), "Number of collection admins bound exceeded");1552    });1553}15541555// NFT custom data size. Negative test const_data.1556#[test]1557fn custom_data_size_nft_const_data_bound_neg() {1558    new_test_ext().execute_with(|| {1559        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1560            collection_numbers_limit: 10,1561            account_token_ownership_limit: 10,1562            collections_admins_limit: 5,1563            custom_data_limit: 2,1564            nft_sponsor_transfer_timeout: 15,1565            fungible_sponsor_transfer_timeout: 15,1566            refungible_sponsor_transfer_timeout: 15,          1567        }));1568        1569        let collection_id = create_test_collection(&CollectionMode::NFT);15701571        let origin1 = Origin::signed(1);1572        let too_big_const_data = CreateItemData::NFT(CreateNftData{1573            const_data: vec![1, 2, 3, 4],1574            variable_data: vec![]1575        });15761577        assert_noop!(TemplateModule::create_item(1578            origin1.clone(),1579            collection_id,1580            1,1581            too_big_const_data1582        ), "const_data exceeded data limit: 2.");1583    });1584}15851586// NFT custom data size. Negative test variable_data.1587#[test]1588fn custom_data_size_nft_variable_data_bound_neg() {1589    new_test_ext().execute_with(|| {1590        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1591            collection_numbers_limit: 10,1592            account_token_ownership_limit: 10,1593            collections_admins_limit: 5,1594            custom_data_limit: 2,1595            nft_sponsor_transfer_timeout: 15,1596            fungible_sponsor_transfer_timeout: 15,1597            refungible_sponsor_transfer_timeout: 15,          1598        }));15991600        let collection_id = create_test_collection(&CollectionMode::NFT);16011602        let origin1 = Origin::signed(1);1603        let too_big_const_data = CreateItemData::NFT(CreateNftData{1604            const_data: vec![],1605            variable_data: vec![1, 2, 3, 4]1606        });16071608        assert_noop!(TemplateModule::create_item(1609            origin1.clone(),1610            collection_id,1611            1,1612            too_big_const_data1613        ), "variable_data exceeded data limit: 2.");1614    });1615}16161617// Re fungible custom data size. Negative test const_data.1618#[test]1619fn custom_data_size_re_fungible_const_data_bound_neg() {1620    new_test_ext().execute_with(|| {1621        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1622            collection_numbers_limit: 10,1623            account_token_ownership_limit: 10,1624            collections_admins_limit: 5,1625            custom_data_limit: 2,1626            nft_sponsor_transfer_timeout: 15,1627            fungible_sponsor_transfer_timeout: 15,1628            refungible_sponsor_transfer_timeout: 15,          1629        }));16301631        let collection_id = create_test_collection(&CollectionMode::NFT);16321633        let origin1 = Origin::signed(1);1634        let too_big_const_data = CreateItemData::NFT(CreateNftData{1635            const_data: vec![1, 2, 3, 4],1636            variable_data: vec![]1637        });16381639        assert_noop!(TemplateModule::create_item(1640            origin1.clone(),1641            collection_id,1642            1,1643            too_big_const_data1644        ), "const_data exceeded data limit: 2.");1645    });1646}16471648// Re fungible custom data size. Negative test variable_data.1649#[test]1650fn custom_data_size_re_fungible_variable_data_bound_neg() {1651    new_test_ext().execute_with(|| {1652        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1653            collection_numbers_limit: 10,1654            account_token_ownership_limit: 10,1655            collections_admins_limit: 5,1656            custom_data_limit: 2,1657            nft_sponsor_transfer_timeout: 15,1658            fungible_sponsor_transfer_timeout: 15,1659            refungible_sponsor_transfer_timeout: 15,          1660        }));16611662        let collection_id = create_test_collection(&CollectionMode::NFT);16631664        let origin1 = Origin::signed(1);1665        let too_big_const_data = CreateItemData::NFT(CreateNftData{1666            const_data: vec![],1667            variable_data: vec![1, 2, 3, 4]1668        });16691670        assert_noop!(TemplateModule::create_item(1671            origin1.clone(),1672            collection_id,1673            1,1674            too_big_const_data1675        ), "variable_data exceeded data limit: 2.");1676    });1677}1678// #endregion16791680#[test]1681fn set_const_on_chain_schema() {1682    new_test_ext().execute_with(|| {1683        default_limits();16841685        let collection_id = create_test_collection(&CollectionMode::NFT);16861687        let origin1 = Origin::signed(1);1688        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, "test const on chain schema".to_vec()));16891690        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, "test const on chain schema".to_vec());1691        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, "".to_vec());1692    });1693}16941695#[test]1696fn set_variable_on_chain_schema() {1697    new_test_ext().execute_with(|| {1698        default_limits();1699        1700        let collection_id = create_test_collection(&CollectionMode::NFT);17011702        let origin1 = Origin::signed(1);1703        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, "test variable on chain schema".to_vec()));17041705        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, "".to_vec());1706        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, "test variable on chain schema".to_vec());1707    });1708}