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        // neg transfer296        assert_noop!(TemplateModule::transfer_from(297            origin2.clone(),298            1,299            2,300            1,301            1,302            1), "Only item owner, collection owner and admins can modify items");303304        // do approve305        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));306        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);307        assert_eq!(308            TemplateModule::approved(1, (1, 1))[0],309            ApprovePermissions {310                approved: 2,311                amount: 100000000312            }313        );314315        assert_ok!(TemplateModule::transfer_from(316            origin2.clone(),317            1,318            2,319            1,320            1,321            1322        ));323        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);324    });325}326327#[test]328fn nft_approve_and_transfer_from_white_list() {329    new_test_ext().execute_with(|| {330        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();331        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();332        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();333        let mode: CollectionMode = CollectionMode::NFT(2000);334335        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 336            collection_numbers_limit: 10,337            account_token_ownership_limit: 10,338            collections_admins_limit: 5,339            custom_data_limit: 2048,340            nft_sponsor_transfer_timeout: 15,341            fungible_sponsor_transfer_timeout: 15,342            refungible_sponsor_transfer_timeout: 15,          343        }));344345        let origin1 = Origin::signed(1);346        let origin2 = Origin::signed(2);347        assert_ok!(TemplateModule::create_collection(348            origin1.clone(),349            col_name1.clone(),350            col_desc1.clone(),351            token_prefix1.clone(),352            mode353        ));354        assert_eq!(TemplateModule::collection(1).owner, 1);355356        assert_ok!(TemplateModule::create_item(357            origin1.clone(),358            1,359            [1, 2, 3].to_vec(),360            1361        ));362        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());363        assert_eq!(TemplateModule::balance_count(1, 1), 1);364        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);365366        assert_ok!(TemplateModule::set_mint_permission(367            origin1.clone(),368            1,369            true370        ));371        assert_ok!(TemplateModule::set_public_access_mode(372            origin1.clone(),373            1,374            AccessMode::WhiteList375        ));376        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));377        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));378        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));379380        // do approve381        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));382        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);383        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));384        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);385        assert_eq!(386            TemplateModule::approved(1, (1, 1))[0],387            ApprovePermissions {388                approved: 2,389                amount: 100000000390            }391        );392393        assert_ok!(TemplateModule::transfer_from(394            origin2.clone(),395            1,396            3,397            1,398            1,399            1400        ));401        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);402    });403}404405#[test]406fn refungible_approve_and_transfer_from() {407    new_test_ext().execute_with(|| {408        default_limits();409        410        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));411        412        let origin1 = Origin::signed(1);413        let origin2 = Origin::signed(2);414415        let data = default_re_fungible_data();416        create_test_item(collection_id, &data);417418        assert_eq!(TemplateModule::balance_count(1, 1), 1000);419        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);420421        assert_ok!(TemplateModule::set_mint_permission(422            origin1.clone(),423            1,424            true425        ));426        assert_ok!(TemplateModule::set_public_access_mode(427            origin1.clone(),428            1,429            AccessMode::WhiteList430        ));431        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));432        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));433        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));434435        // do approve436        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));437        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);438        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));439        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);440        assert_eq!(441            TemplateModule::approved(1, (1, 1))[0],442            ApprovePermissions {443                approved: 2,444                amount: 100000000445            }446        );447448        assert_ok!(TemplateModule::transfer_from(449            origin2.clone(),450            1,451            3,452            1,453            1,454            100455        ));456        assert_eq!(TemplateModule::balance_count(1, 1), 900);457        assert_eq!(TemplateModule::balance_count(1, 3), 100);458        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);459        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);460461        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);462        assert_eq!(463            TemplateModule::approved(1, (1, 1))[0],464            ApprovePermissions {465                approved: 3,466                amount: 100000000467            }468        );469    });470}471472#[test]473fn fungible_approve_and_transfer_from() {474    new_test_ext().execute_with(|| {475        default_limits();476        477        let collection_id = create_test_collection(&CollectionMode::Fungible(3));478        479        let data = default_fungible_data();480        create_test_item(collection_id, &data);481482        let origin1 = Origin::signed(1);483        let origin2 = Origin::signed(2);484485        assert_eq!(TemplateModule::balance_count(1, 1), 1000);486        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);487488        assert_ok!(TemplateModule::set_mint_permission(489            origin1.clone(),490            1,491            true492        ));493        assert_ok!(TemplateModule::set_public_access_mode(494            origin1.clone(),495            1,496            AccessMode::WhiteList497        ));498        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));499        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));500        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));501502        // do approve503        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));504        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);505        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));506        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);507        assert_eq!(508            TemplateModule::approved(1, (1, 1))[0],509            ApprovePermissions {510                approved: 2,511                amount: 100000000512            }513        );514515        assert_ok!(TemplateModule::transfer_from(516            origin2.clone(),517            1,518            3,519            1,520            1,521            100522        ));523        assert_eq!(TemplateModule::balance_count(1, 1), 900);524        assert_eq!(TemplateModule::balance_count(1, 3), 100);525        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);526        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);527528        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);529        assert_eq!(530            TemplateModule::approved(1, (1, 1))[0],531            ApprovePermissions {532                approved: 3,533                amount: 100000000534            }535        );536537        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));538        assert_ok!(TemplateModule::transfer_from(539            origin2.clone(),540            1,541            3,542            1,543            1,544            900545        ));546        assert_eq!(TemplateModule::balance_count(1, 1), 0);547        assert_eq!(TemplateModule::balance_count(1, 3), 1000);548        // assert_eq!(TemplateModule::address_tokens(1, 1), []);549        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);550551        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);552    });553}554555#[test]556fn change_collection_owner() {557    new_test_ext().execute_with(|| {558        default_limits();559        560        let collection_id = create_test_collection(&CollectionMode::NFT);561        562        let origin1 = Origin::signed(1);563        assert_ok!(TemplateModule::change_collection_owner(564            origin1.clone(),565            collection_id,566            2567        ));568        assert_eq!(TemplateModule::collection(collection_id).owner, 2);569    });570}571572#[test]573fn destroy_collection() {574    new_test_ext().execute_with(|| {575        default_limits();576        577        let collection_id = create_test_collection(&CollectionMode::NFT);578        579        let origin1 = Origin::signed(1);580        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));581    });582}583584#[test]585fn burn_nft_item() {586    new_test_ext().execute_with(|| {587        default_limits();588        589        let collection_id = create_test_collection(&CollectionMode::NFT);590591        let origin1 = Origin::signed(1);592        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));593        594        let data = default_nft_data();595        create_test_item(collection_id, &data);596597        // check balance (collection with id = 1, user id = 1)598        assert_eq!(TemplateModule::balance_count(1, 1), 1);599600        // burn item601        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));602        assert_noop!(603            TemplateModule::burn_item(origin1.clone(), 1, 1),604            "Item does not exists"605        );606607        assert_eq!(TemplateModule::balance_count(1, 1), 0);608    });609}610611#[test]612fn burn_fungible_item() {613    new_test_ext().execute_with(|| {614        default_limits();615        616        let collection_id = create_test_collection(&CollectionMode::Fungible(3));617        618        let origin1 = Origin::signed(1);619        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));620        621        let data = default_fungible_data();622        create_test_item(collection_id, &data);623624        // check balance (collection with id = 1, user id = 1)625        assert_eq!(TemplateModule::balance_count(1, 1), 1000);626627        // burn item628        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));629        assert_noop!(630            TemplateModule::burn_item(origin1.clone(), 1, 1),631            "Item does not exists"632        );633634        assert_eq!(TemplateModule::balance_count(1, 1), 0);635    });636}637638#[test]639fn burn_refungible_item() {640    new_test_ext().execute_with(|| {641        default_limits();642        643        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));644        let origin1 = Origin::signed(1);645        let origin2 = Origin::signed(2);646647        assert_ok!(TemplateModule::set_mint_permission(648            origin1.clone(),649            collection_id,650            true651        ));652        assert_ok!(TemplateModule::set_public_access_mode(653            origin1.clone(),654            collection_id,655            AccessMode::WhiteList656        ));657        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));658659        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));660        661        let data = default_re_fungible_data();662        create_test_item(collection_id, &data);663664        // check balance (collection with id = 1, user id = 2)665        assert_eq!(TemplateModule::balance_count(1, 1), 1000);666667        // burn item668        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));669        assert_noop!(670            TemplateModule::burn_item(origin1.clone(), 1, 1),671            "Item does not exists"672        );673674        assert_eq!(TemplateModule::balance_count(1, 1), 0);675    });676}677678#[test]679fn add_collection_admin() {680    new_test_ext().execute_with(|| {681        default_limits();682        683        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1);684        create_test_collection_for_owner(&CollectionMode::NFT, 2);685        create_test_collection_for_owner(&CollectionMode::NFT, 3);686        687        let origin1 = Origin::signed(1);688689        // collection admin690        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));691        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));692693        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);694        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);695    });696}697698#[test]699fn remove_collection_admin() {700    new_test_ext().execute_with(|| {701        default_limits();702        703        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1);704        create_test_collection_for_owner(&CollectionMode::NFT, 2);705        create_test_collection_for_owner(&CollectionMode::NFT, 3);706707        let origin1 = Origin::signed(1);708        let origin2 = Origin::signed(2);709710        // collection admin711        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));712        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));713714        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);715        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);716717        // remove admin718        assert_ok!(TemplateModule::remove_collection_admin(719            origin2.clone(),720            1,721            3722        ));723        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);724    });725}726727#[test]728fn balance_of() {729    new_test_ext().execute_with(|| {730        default_limits();731        732        let nft_collection_id = create_test_collection(&CollectionMode::NFT);733        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3));734        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3));735        736        let origin1 = Origin::signed(1);737738        // check balance before739        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);740        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);741        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);742743        let nft_data = default_nft_data();744        create_test_item(nft_collection_id, &nft_data);745        746        let fungible_data = default_fungible_data();747        create_test_item(fungible_collection_id, &fungible_data);748        749        let re_fungible_data = default_re_fungible_data();750        create_test_item(re_fungible_collection_id, &re_fungible_data);751752        // check balance (collection with id = 1, user id = 1)753        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);754        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);755        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);756        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);757        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);758        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);759    });760}761762#[test]763fn approve() {764    new_test_ext().execute_with(|| {765        default_limits();766        767        let collection_id = create_test_collection(&CollectionMode::NFT);768        769        let data = default_nft_data();770        create_test_item(collection_id, &data);771772        let origin1 = Origin::signed(1);773        774        // approve775        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));776        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);777    });778}779780#[test]781fn transfer_from() {782    new_test_ext().execute_with(|| {783        default_limits();784        785        let collection_id = create_test_collection(&CollectionMode::NFT);786        let origin1 = Origin::signed(1);787        let origin2 = Origin::signed(2);788789        let data = default_nft_data();790        create_test_item(collection_id, &data);791792        // approve793        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));794        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);795796        assert_ok!(TemplateModule::set_mint_permission(797            origin1.clone(),798            1,799            true800        ));801        assert_ok!(TemplateModule::set_public_access_mode(802            origin1.clone(),803            1,804            AccessMode::WhiteList805        ));806        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));807        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));808        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));809810        assert_ok!(TemplateModule::transfer_from(811            origin2.clone(),812            1,813            2,814            1,815            1,816            1817        ));818819        // after transfer820        assert_eq!(TemplateModule::balance_count(1, 1), 0);821        assert_eq!(TemplateModule::balance_count(1, 2), 1);822    });823}824825// #endregion826827// Coverage tests region828// #region829830#[test]831fn owner_can_add_address_to_white_list() {832    new_test_ext().execute_with(|| {833        default_limits();834        835        let collection_id = create_test_collection(&CollectionMode::NFT);836837        let origin1 = Origin::signed(1);838        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));839        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);840    });841}842843#[test]844fn admin_can_add_address_to_white_list() {845    new_test_ext().execute_with(|| {846        default_limits();847        848        let collection_id = create_test_collection(&CollectionMode::NFT);849        let origin1 = Origin::signed(1);850        let origin2 = Origin::signed(2);851852        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));853        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));854        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);855    });856}857858#[test]859fn nonprivileged_user_cannot_add_address_to_white_list() {860    new_test_ext().execute_with(|| {861        default_limits();862        863        let collection_id = create_test_collection(&CollectionMode::NFT);864865        let origin2 = Origin::signed(2);866        assert_noop!(867            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),868            "You do not have permissions to modify this collection"869        );870    });871}872873#[test]874fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {875    new_test_ext().execute_with(|| {876        default_limits();877878        let origin1 = Origin::signed(1);879880        assert_noop!(881            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),882            "This collection does not exist"883        );884    });885}886887#[test]888fn nobody_can_add_address_to_white_list_of_deleted_collection() {889    new_test_ext().execute_with(|| {890        default_limits();891        892        let collection_id = create_test_collection(&CollectionMode::NFT);893894        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));895        assert_noop!(896            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),897            "This collection does not exist"898        );899    });900}901902// If address is already added to white list, nothing happens903#[test]904fn address_is_already_added_to_white_list() {905    new_test_ext().execute_with(|| {906        default_limits();907        908        let collection_id = create_test_collection(&CollectionMode::NFT);909        let origin1 = Origin::signed(1);910        911        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));912        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));913        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);914        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);915    });916}917918#[test]919fn owner_can_remove_address_from_white_list() {920    new_test_ext().execute_with(|| {921        default_limits();922        923        let collection_id = create_test_collection(&CollectionMode::NFT);924925        let origin1 = Origin::signed(1);926        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));927        assert_ok!(TemplateModule::remove_from_white_list(928            origin1.clone(),929            collection_id,930            2931        ));932        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);933    });934}935936#[test]937fn admin_can_remove_address_from_white_list() {938    new_test_ext().execute_with(|| {939        default_limits();940        941        let collection_id = create_test_collection(&CollectionMode::NFT);942        let origin1 = Origin::signed(1);943        let origin2 = Origin::signed(2);944945        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));946947        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));948        assert_ok!(TemplateModule::remove_from_white_list(949            origin2.clone(),950            collection_id,951            3952        ));953        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);954    });955}956957#[test]958fn nonprivileged_user_cannot_remove_address_from_white_list() {959    new_test_ext().execute_with(|| {960        default_limits();961        962        let collection_id = create_test_collection(&CollectionMode::NFT);963        let origin1 = Origin::signed(1);964        let origin2 = Origin::signed(2);965966        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));967        assert_noop!(968            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),969            "You do not have permissions to modify this collection"970        );971        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);972    });973}974975#[test]976fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {977    new_test_ext().execute_with(|| {978        default_limits();979        let origin1 = Origin::signed(1);980981        assert_noop!(982            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),983            "This collection does not exist"984        );985    });986}987988#[test]989fn nobody_can_remove_address_from_white_list_of_deleted_collection() {990    new_test_ext().execute_with(|| {991        default_limits();992        993        let collection_id = create_test_collection(&CollectionMode::NFT);994        let origin1 = Origin::signed(1);995        let origin2 = Origin::signed(2);996997        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));998        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));999        assert_noop!(1000            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1001            "This collection does not exist"1002        );1003        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1004    });1005}10061007// If address is already removed from white list, nothing happens1008#[test]1009fn address_is_already_removed_from_white_list() {1010    new_test_ext().execute_with(|| {1011        default_limits();1012        1013        let collection_id = create_test_collection(&CollectionMode::NFT);1014        let origin1 = Origin::signed(1);10151016        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1017        assert_ok!(TemplateModule::remove_from_white_list(1018            origin1.clone(),1019            collection_id,1020            21021        ));1022        assert_ok!(TemplateModule::remove_from_white_list(1023            origin1.clone(),1024            collection_id,1025            21026        ));1027        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1028    });1029}10301031// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1032#[test]1033fn white_list_test_1() {1034    new_test_ext().execute_with(|| {1035        default_limits();1036        1037        let collection_id = create_test_collection(&CollectionMode::NFT);10381039        let origin1 = Origin::signed(1);1040        1041        let data = default_nft_data();1042        create_test_item(collection_id, &data);10431044        assert_ok!(TemplateModule::set_public_access_mode(1045            origin1.clone(),1046            collection_id,1047            AccessMode::WhiteList1048        ));1049        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));10501051        assert_noop!(1052            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1053            "Address is not in white list"1054        );1055    });1056}10571058#[test]1059fn white_list_test_2() {1060    new_test_ext().execute_with(|| {1061        default_limits();1062        1063        let collection_id = create_test_collection(&CollectionMode::NFT);1064        let origin1 = Origin::signed(1);1065        1066        let data = default_nft_data();1067        create_test_item(collection_id, &data);10681069        assert_ok!(TemplateModule::set_public_access_mode(1070            origin1.clone(),1071            collection_id,1072            AccessMode::WhiteList1073        ));1074        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1075        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));10761077        // do approve1078        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1079        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);10801081        assert_ok!(TemplateModule::remove_from_white_list(1082            origin1.clone(),1083            1,1084            11085        ));10861087        assert_noop!(1088            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1089            "Address is not in white list"1090        );1091    });1092}10931094// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1095#[test]1096fn white_list_test_3() {1097    new_test_ext().execute_with(|| {1098        default_limits();1099        1100        let collection_id = create_test_collection(&CollectionMode::NFT);11011102        let origin1 = Origin::signed(1);1103        1104        let data = default_nft_data();1105        create_test_item(collection_id, &data);11061107        assert_ok!(TemplateModule::set_public_access_mode(1108            origin1.clone(),1109            collection_id,1110            AccessMode::WhiteList1111        ));1112        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));11131114        assert_noop!(1115            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1116            "Address is not in white list"1117        );1118    });1119}11201121#[test]1122fn white_list_test_4() {1123    new_test_ext().execute_with(|| {1124        default_limits();1125        1126        let collection_id = create_test_collection(&CollectionMode::NFT);11271128        let origin1 = Origin::signed(1);11291130        let data = default_nft_data();1131        create_test_item(collection_id, &data);11321133        assert_ok!(TemplateModule::set_public_access_mode(1134            origin1.clone(),1135            collection_id,1136            AccessMode::WhiteList1137        ));1138        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1139        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11401141        // do approve1142        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1143        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);11441145        assert_ok!(TemplateModule::remove_from_white_list(1146            origin1.clone(),1147            collection_id,1148            21149        ));11501151        assert_noop!(1152            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1153            "Address is not in white list"1154        );1155    });1156}11571158// 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)1159#[test]1160fn white_list_test_5() {1161    new_test_ext().execute_with(|| {1162        default_limits();1163        1164        let collection_id = create_test_collection(&CollectionMode::NFT);11651166        let origin1 = Origin::signed(1);11671168        let data = default_nft_data();1169        create_test_item(collection_id, &data);11701171        assert_ok!(TemplateModule::set_public_access_mode(1172            origin1.clone(),1173            collection_id,1174            AccessMode::WhiteList1175        ));1176        assert_noop!(1177            TemplateModule::burn_item(origin1.clone(), 1, 1),1178            "Address is not in white list"1179        );1180    });1181}11821183// If Public Access mode is set to WhiteList, oken transfers can’t be Approved by a non-whitelisted address (see Approve method).1184#[test]1185fn white_list_test_6() {1186    new_test_ext().execute_with(|| {1187        default_limits();1188        1189        let collection_id = create_test_collection(&CollectionMode::NFT);11901191        let origin1 = Origin::signed(1);1192        assert_ok!(TemplateModule::set_public_access_mode(1193            origin1.clone(),1194            collection_id,1195            AccessMode::WhiteList1196        ));11971198        // do approve1199        assert_noop!(1200            TemplateModule::approve(origin1.clone(), 1, 1, 1),1201            "Address is not in white list"1202        );1203    });1204}12051206// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1207//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1208#[test]1209fn white_list_test_7() {1210    new_test_ext().execute_with(|| {1211        default_limits();1212        1213        let collection_id = create_test_collection(&CollectionMode::NFT);12141215        let data = default_nft_data();1216        create_test_item(collection_id, &data);1217        1218        let origin1 = Origin::signed(1);12191220        assert_ok!(TemplateModule::set_public_access_mode(1221            origin1.clone(),1222            collection_id,1223            AccessMode::WhiteList1224        ));1225        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1226        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12271228        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1229    });1230}12311232#[test]1233fn white_list_test_8() {1234    new_test_ext().execute_with(|| {1235        default_limits();1236        1237        let collection_id = create_test_collection(&CollectionMode::NFT);12381239        let data = default_nft_data();1240        create_test_item(collection_id, &data);1241        1242        let origin1 = Origin::signed(1);12431244        assert_ok!(TemplateModule::set_public_access_mode(1245            origin1.clone(),1246            collection_id,1247            AccessMode::WhiteList1248        ));1249        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1250        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12511252        // do approve1253        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1254        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);12551256        assert_ok!(TemplateModule::transfer_from(1257            origin1.clone(),1258            1,1259            2,1260            1,1261            1,1262            11263        ));1264    });1265}12661267// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1268#[test]1269fn white_list_test_9() {1270    new_test_ext().execute_with(|| {1271        default_limits();1272        1273        let collection_id = create_test_collection(&CollectionMode::NFT);1274        let origin1 = Origin::signed(1);12751276        assert_ok!(TemplateModule::set_public_access_mode(1277            origin1.clone(),1278            collection_id,1279            AccessMode::WhiteList1280        ));1281        assert_ok!(TemplateModule::set_mint_permission(1282            origin1.clone(),1283            collection_id,1284            false1285        ));12861287        let data = default_nft_data();1288        create_test_item(collection_id, &data);1289    });1290}12911292// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1293#[test]1294fn white_list_test_10() {1295    new_test_ext().execute_with(|| {1296        default_limits();1297        1298        let collection_id = create_test_collection(&CollectionMode::NFT);12991300        let origin1 = Origin::signed(1);1301        let origin2 = Origin::signed(2);13021303        assert_ok!(TemplateModule::set_public_access_mode(1304            origin1.clone(),1305            collection_id,1306            AccessMode::WhiteList1307        ));1308        assert_ok!(TemplateModule::set_mint_permission(1309            origin1.clone(),1310            collection_id,1311            false1312        ));13131314        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));13151316        assert_ok!(TemplateModule::create_item(1317            origin2.clone(),1318            collection_id,1319            2,1320            default_nft_data()1321        ));1322    });1323}13241325// 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.1326#[test]1327fn white_list_test_11() {1328    new_test_ext().execute_with(|| {1329        default_limits();1330        1331        let collection_id = create_test_collection(&CollectionMode::NFT);13321333        let origin1 = Origin::signed(1);1334        let origin2 = Origin::signed(2);13351336        assert_ok!(TemplateModule::set_public_access_mode(1337            origin1.clone(),1338            collection_id,1339            AccessMode::WhiteList1340        ));1341        assert_ok!(TemplateModule::set_mint_permission(1342            origin1.clone(),1343            collection_id,1344            false1345        ));1346        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13471348        assert_noop!(1349            TemplateModule::create_item(origin2.clone(), 1, vec![1, 2, 3], 2),1350            "Public minting is not allowed for this collection"1351        );1352    });1353}13541355// 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.1356#[test]1357fn white_list_test_12() {1358    new_test_ext().execute_with(|| {1359        default_limits();1360        1361        let collection_id = create_test_collection(&CollectionMode::NFT);13621363        let origin1 = Origin::signed(1);1364        let origin2 = Origin::signed(2);13651366        assert_ok!(TemplateModule::set_public_access_mode(1367            origin1.clone(),1368            collection_id,1369            AccessMode::WhiteList1370        ));1371        assert_ok!(TemplateModule::set_mint_permission(1372            origin1.clone(),1373            collection_id,1374            false1375        ));13761377        assert_noop!(1378            TemplateModule::create_item(origin2.clone(), 1, vec![1, 2, 3], 2),1379            "Public minting is not allowed for this collection"1380        );1381    });1382}13831384// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1385#[test]1386fn white_list_test_13() {1387    new_test_ext().execute_with(|| {1388        default_limits();1389        1390        let collection_id = create_test_collection(&CollectionMode::NFT);13911392        let origin1 = Origin::signed(1);13931394        assert_ok!(TemplateModule::set_public_access_mode(1395            origin1.clone(),1396            collection_id,1397            AccessMode::WhiteList1398        ));1399        assert_ok!(TemplateModule::set_mint_permission(1400            origin1.clone(),1401            collection_id,1402            true1403        ));14041405        let data = default_nft_data();1406        create_test_item(collection_id, &data);1407    });1408}14091410// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1411#[test]1412fn white_list_test_14() {1413    new_test_ext().execute_with(|| {1414        default_limits();1415        1416        let collection_id = create_test_collection(&CollectionMode::NFT);14171418        let origin1 = Origin::signed(1);1419        let origin2 = Origin::signed(2);14201421        assert_ok!(TemplateModule::set_public_access_mode(1422            origin1.clone(),1423            collection_id,1424            AccessMode::WhiteList1425        ));1426        assert_ok!(TemplateModule::set_mint_permission(1427            origin1.clone(),1428            collection_id,1429            true1430        ));14311432        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));14331434        assert_ok!(TemplateModule::create_item(1435            origin2.clone(),1436            1,1437            2,1438            default_nft_data()1439        ));1440    });1441}14421443// 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.1444#[test]1445fn white_list_test_15() {1446    new_test_ext().execute_with(|| {1447        default_limits();1448        1449        let collection_id = create_test_collection(&CollectionMode::NFT);14501451        let origin1 = Origin::signed(1);1452        let origin2 = Origin::signed(2);14531454        assert_ok!(TemplateModule::set_public_access_mode(1455            origin1.clone(),1456            collection_id,1457            AccessMode::WhiteList1458        ));1459        assert_ok!(TemplateModule::set_mint_permission(1460            origin1.clone(),1461            collection_id,1462            true1463        ));14641465        assert_noop!(1466            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data()),1467            "Address is not in white list"1468        );1469    });1470}14711472// 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.1473#[test]1474fn white_list_test_16() {1475    new_test_ext().execute_with(|| {1476        default_limits();1477        1478        let collection_id = create_test_collection(&CollectionMode::NFT);14791480        let origin1 = Origin::signed(1);1481        let origin2 = Origin::signed(2);14821483        assert_ok!(TemplateModule::set_public_access_mode(1484            origin1.clone(),1485            collection_id,1486            AccessMode::WhiteList1487        ));1488        assert_ok!(TemplateModule::set_mint_permission(1489            origin1.clone(),1490            collection_id,1491            true1492        ));1493        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14941495        assert_ok!(TemplateModule::create_item(1496            origin2.clone(),1497            1,1498            2,1499            default_nft_data()1500        ));1501    });1502}15031504// Total number of collections. Positive test1505#[test]1506fn total_number_collections_bound() {1507    new_test_ext().execute_with(|| {1508        default_limits();1509        1510        create_test_collection(&CollectionMode::NFT);1511    });1512}15131514// Total number of collections. Negotive test1515#[test]1516fn total_number_collections_bound_neg() {1517    new_test_ext().execute_with(|| {1518        default_limits();15191520        let origin1 = Origin::signed(1);15211522        for _ in 0..default_collection_numbers_limit() {1523            create_test_collection(&CollectionMode::NFT)1524        }15251526        // 11-th collection in chain. Expects error1527        assert_noop!(TemplateModule::create_collection(1528            origin1.clone(),1529            col_name1.clone(),1530            col_desc1.clone(),1531            token_prefix1.clone(),1532            mode.clone()1533        ), "Total collections bound exceeded");1534    });1535}15361537// Owned tokens by a single address. Positive test1538#[test]1539fn owned_tokens_bound() {1540    new_test_ext().execute_with(|| {1541        default_limits();1542        1543        let collection_id = create_test_collection(&CollectionMode::NFT);15441545        let data = default_nft_data();1546        create_test_item(collection_id, &data);1547        create_test_item(collection_id, &data);1548    });1549}15501551// Owned tokens by a single address. Negotive test1552#[test]1553fn owned_tokens_bound_neg() {1554    new_test_ext().execute_with(|| {1555        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1556            collection_numbers_limit: 10,1557            account_token_ownership_limit: 1,1558            collections_admins_limit: 5,1559            custom_data_limit: 2048,1560            nft_sponsor_transfer_timeout: 15,1561            fungible_sponsor_transfer_timeout: 15,1562            refungible_sponsor_transfer_timeout: 15,          1563        }));1564        1565        let collection_id = create_test_collection(&CollectionMode::NFT);15661567        let origin1 = Origin::signed(1);1568        let data = default_nft_data();1569        create_test_item(collection_id, &data);15701571        assert_noop!(TemplateModule::create_item(1572            origin1.clone(),1573            1,1574            1,1575            data1576        ), "Owned tokens by a single address bound exceeded");1577    });1578}15791580// Number of collection admins. Positive test1581#[test]1582fn collection_admins_bound() {1583    new_test_ext().execute_with(|| {1584        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1585            collection_numbers_limit: 10,1586            account_token_ownership_limit: 10,1587            collections_admins_limit: 2,1588            custom_data_limit: 2048,1589            nft_sponsor_transfer_timeout: 15,1590            fungible_sponsor_transfer_timeout: 15,1591            refungible_sponsor_transfer_timeout: 15,          1592        }));1593        1594        let collection_id = create_test_collection(&CollectionMode::NFT);15951596        let origin1 = Origin::signed(1);1597        1598        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1599        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1600    });1601}16021603// Number of collection admins. Negotive test1604#[test]1605fn collection_admins_bound_neg() {1606    new_test_ext().execute_with(|| {1607        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1608            collection_numbers_limit: 10,1609            account_token_ownership_limit: 1,1610            collections_admins_limit: 1,1611            custom_data_limit: 2048,1612            nft_sponsor_transfer_timeout: 15,1613            fungible_sponsor_transfer_timeout: 15,1614            refungible_sponsor_transfer_timeout: 15,          1615        }));1616        1617        let collection_id = create_test_collection(&CollectionMode::NFT);16181619        let origin1 = Origin::signed(1);16201621        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1622        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), "Number of collection admins bound exceeded");1623    });1624}16251626// NFT custom data size. Negative test const_data.1627#[test]1628fn custom_data_size_nft_const_data_bound_neg() {1629    new_test_ext().execute_with(|| {1630        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1631            collection_numbers_limit: 10,1632            account_token_ownership_limit: 10,1633            collections_admins_limit: 5,1634            custom_data_limit: 2,1635            nft_sponsor_transfer_timeout: 15,1636            fungible_sponsor_transfer_timeout: 15,1637            refungible_sponsor_transfer_timeout: 15,          1638        }));1639        1640        let collection_id = create_test_collection(&CollectionMode::NFT);16411642        let origin1 = Origin::signed(1);1643        let too_big_const_data = CreateItemData::NFT(CreateNftData{1644            const_data: vec![1, 2, 3, 4],1645            variable_data: vec![]1646        });16471648        assert_noop!(TemplateModule::create_item(1649            origin1.clone(),1650            collection_id,1651            1,1652            too_big_const_data1653        ), "const_data exceeded data limit: 2.");1654    });1655}16561657// NFT custom data size. Negative test variable_data.1658#[test]1659fn custom_data_size_nft_variable_data_bound_neg() {1660    new_test_ext().execute_with(|| {1661        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1662            collection_numbers_limit: 10,1663            account_token_ownership_limit: 10,1664            collections_admins_limit: 5,1665            custom_data_limit: 2,1666            nft_sponsor_transfer_timeout: 15,1667            fungible_sponsor_transfer_timeout: 15,1668            refungible_sponsor_transfer_timeout: 15,          1669        }));16701671        let collection_id = create_test_collection(&CollectionMode::NFT);16721673        let origin1 = Origin::signed(1);1674        let too_big_const_data = CreateItemData::NFT(CreateNftData{1675            const_data: vec![],1676            variable_data: vec![1, 2, 3, 4]1677        });16781679        assert_noop!(TemplateModule::create_item(1680            origin1.clone(),1681            collection_id,1682            1,1683            too_big_const_data1684        ), "variable_data exceeded data limit: 2.");1685    });1686}16871688// Re fungible custom data size. Negative test const_data.1689#[test]1690fn custom_data_size_re_fungible_const_data_bound_neg() {1691    new_test_ext().execute_with(|| {1692        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1693            collection_numbers_limit: 10,1694            account_token_ownership_limit: 10,1695            collections_admins_limit: 5,1696            custom_data_limit: 2,1697            nft_sponsor_transfer_timeout: 15,1698            fungible_sponsor_transfer_timeout: 15,1699            refungible_sponsor_transfer_timeout: 15,          1700        }));17011702        let collection_id = create_test_collection(&CollectionMode::NFT);17031704        let origin1 = Origin::signed(1);1705        let too_big_const_data = CreateItemData::NFT(CreateNftData{1706            const_data: vec![1, 2, 3, 4],1707            variable_data: vec![]1708        });17091710        assert_noop!(TemplateModule::create_item(1711            origin1.clone(),1712            collection_id,1713            1,1714            too_big_const_data1715        ), "const_data exceeded data limit: 2.");1716    });1717}17181719// Re fungible custom data size. Negative test variable_data.1720#[test]1721fn custom_data_size_re_fungible_variable_data_bound_neg() {1722    new_test_ext().execute_with(|| {1723        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1724            collection_numbers_limit: 10,1725            account_token_ownership_limit: 10,1726            collections_admins_limit: 5,1727            custom_data_limit: 2,1728            nft_sponsor_transfer_timeout: 15,1729            fungible_sponsor_transfer_timeout: 15,1730            refungible_sponsor_transfer_timeout: 15,          1731        }));17321733        let collection_id = create_test_collection(&CollectionMode::NFT);17341735        let origin1 = Origin::signed(1);1736        let too_big_const_data = CreateItemData::NFT(CreateNftData{1737            const_data: vec![],1738            variable_data: vec![1, 2, 3, 4]1739        });17401741        assert_noop!(TemplateModule::create_item(1742            origin1.clone(),1743            collection_id,1744            1,1745            too_big_const_data1746        ), "variable_data exceeded data limit: 2.");1747    });1748}1749// #endregion17501751#[test]1752fn set_const_on_chain_schema() {1753    new_test_ext().execute_with(|| {1754        default_limits();17551756        let collection_id = create_test_collection(&CollectionMode::NFT);17571758        let origin1 = Origin::signed(1);1759        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, "test const on chain schema".to_vec()));17601761        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, "test const on chain schema".to_vec());1762        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, "".to_vec());1763    });1764}17651766#[test]1767fn set_variable_on_chain_schema() {1768    new_test_ext().execute_with(|| {1769        default_limits();1770        1771        let collection_id = create_test_collection(&CollectionMode::NFT);17721773        let origin1 = Origin::signed(1);1774        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, "test variable on chain schema".to_vec()));17751776        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, "".to_vec());1777        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, "test variable on chain schema".to_vec());1778    });1779}