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

1// Tests to be written here2use super::*;3use crate::mock::*;4use crate::{AccessMode, ApprovePermissions, CollectionMode,5    Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData,6    CollectionId, TokenId}; //Err7use frame_support::{assert_noop, assert_ok};8use frame_system::{ RawOrigin };910fn default_collection_numbers_limit() -> u32 {11    1012}1314fn default_limits() {15    assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 16            collection_numbers_limit: default_collection_numbers_limit(),17            account_token_ownership_limit: 10,18            collections_admins_limit: 5,19            custom_data_limit: 2048,20            nft_sponsor_transfer_timeout: 15,21            fungible_sponsor_transfer_timeout: 15,22            refungible_sponsor_transfer_timeout: 15,          23        }));24}2526fn default_nft_data() -> CreateNftData {27    CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }28}2930fn default_fungible_data () -> CreateFungibleData {31    CreateFungibleData { }32}3334fn default_re_fungible_data () -> CreateReFungibleData {35    CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }36}3738fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64, id: CollectionId) -> CollectionId {39    let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();40    let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();41    let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();4243    let origin1 = Origin::signed(owner);44    assert_ok!(TemplateModule::create_collection(45            origin1.clone(),46            col_name1.clone(),47            col_desc1.clone(),48            token_prefix1.clone(),49            mode.clone()50        ));5152    let saved_col_name: Vec<u16> = "Test1\0\0".encode_utf16().collect::<Vec<u16>>();53    let saved_description: Vec<u16> = "TestDescription1\0\0".encode_utf16().collect::<Vec<u16>>();54    let saved_prefix: Vec<u8> = b"token_prefix1\0\0".to_vec();55    assert_eq!(TemplateModule::collection(id).owner, owner);56    assert_eq!(TemplateModule::collection(id).name, saved_col_name);57    assert_eq!(TemplateModule::collection(id).mode, *mode);58    assert_eq!(TemplateModule::collection(id).description, saved_description);59    assert_eq!(TemplateModule::collection(id).token_prefix, saved_prefix);60    id61}6263fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {64    create_test_collection_for_owner(&mode, 1, id)65}6667fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {68    let origin1 = Origin::signed(1);69    assert_ok!(TemplateModule::create_item(70            origin1.clone(),71            collection_id,72            1,73            data.clone()74        ));7576}7778// Use cases tests region79// #region80#[test]81fn create_nft_item() {82    new_test_ext().execute_with(|| {83        default_limits();84        let collection_id = create_test_collection(&CollectionMode::NFT, 1);85        86        let data = default_nft_data();87        create_test_item(collection_id, &data.clone().into());88        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);89        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);90    });91}9293// Use cases tests region94// #region95#[test]96fn create_nft_multiple_items() {97    new_test_ext().execute_with(|| {98        default_limits();99        100        create_test_collection(&CollectionMode::NFT, 1);101102        let origin1 = Origin::signed(1);103104        let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];105106        assert_ok!(TemplateModule::create_multiple_items(107            origin1.clone(),108            1,109            1,110            items_data.clone().into_iter().map(|d| { d.into() }).collect()111        ));112        for (index, data) in items_data.iter().enumerate() {113            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as TokenId).const_data.to_vec(), data.const_data);114            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as TokenId).variable_data.to_vec(), data.variable_data);115        }116    });117}118119#[test]120fn create_refungible_item() {121    new_test_ext().execute_with(|| {122        default_limits();123        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);124125        let data = default_re_fungible_data();126        create_test_item(collection_id, &data.clone().into());127        assert_eq!(128            TemplateModule::refungible_item_id(collection_id, 1).const_data,129            data.const_data130        );131        assert_eq!(132            TemplateModule::refungible_item_id(collection_id, 1).variable_data,133            data.variable_data134        );135        assert_eq!(136            TemplateModule::refungible_item_id(collection_id, 1).owner[0],137            Ownership {138                owner: 1,139                fraction: 1000140            }141        );142    });143}144145#[test]146fn create_multiple_refungible_items() {147    new_test_ext().execute_with(|| {148        default_limits();149        150        create_test_collection(&CollectionMode::ReFungible(3), 1);151152        let origin1 = Origin::signed(1);153154        let items_data = vec![default_re_fungible_data(), default_re_fungible_data(), default_re_fungible_data()];155156        assert_ok!(TemplateModule::create_multiple_items(157            origin1.clone(),158            1,159            1,160            items_data.clone().into_iter().map(|d| { d.into() }).collect()161        ));162        for (index, data) in items_data.iter().enumerate() {163164            let item = TemplateModule::refungible_item_id(1, (index + 1) as TokenId);165            assert_eq!(item.const_data.to_vec(), data.const_data);166            assert_eq!(item.variable_data.to_vec(), data.variable_data);167            assert_eq!(168                item.owner[0],169                Ownership {170                    owner: 1,171                    fraction: 1000172                }173            );174        }175    });176}177178#[test]179fn create_fungible_item() {180    new_test_ext().execute_with(|| {181        default_limits();182        183        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);184185        let data = default_fungible_data();186        create_test_item(collection_id, &data.into());187188        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);189    });190}191192#[test]193fn create_multiple_fungible_items() {194    new_test_ext().execute_with(|| {195        default_limits();196197        create_test_collection(&CollectionMode::Fungible(3), 1);198199        let origin1 = Origin::signed(1);200201        let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];202203        assert_ok!(TemplateModule::create_multiple_items(204            origin1.clone(),205            1,206            1,207            items_data.clone().into_iter().map(|d| { d.into() }).collect()208        ));209        210        for (index, _) in items_data.iter().enumerate() {211            assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).owner, 1);212        }213        assert_eq!(TemplateModule::balance_count(1, 1), 3000);214        assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);215    });216}217218#[test]219fn transfer_fungible_item() {220    new_test_ext().execute_with(|| {221        default_limits();222        223        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);224225        let origin1 = Origin::signed(1);226        let origin2 = Origin::signed(2);227228        let data = default_fungible_data();229        create_test_item(collection_id, &data.into());230231        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);232        assert_eq!(TemplateModule::balance_count(1, 1), 1000);233        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);234235        // change owner scenario236        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));237        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);238        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);239        assert_eq!(TemplateModule::balance_count(1, 1), 0);240        assert_eq!(TemplateModule::balance_count(1, 2), 1000);241        // assert_eq!(TemplateModule::address_tokens(1, 1), []);242        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);243244        // split item scenario245        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));246        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);247        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);248        assert_eq!(TemplateModule::balance_count(1, 2), 500);249        assert_eq!(TemplateModule::balance_count(1, 3), 500);250        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);251        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);252253        // split item and new owner has account scenario254        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));255        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);256        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);257        assert_eq!(TemplateModule::balance_count(1, 2), 300);258        assert_eq!(TemplateModule::balance_count(1, 3), 700);259        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);260        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);261    });262}263264#[test]265fn transfer_refungible_item() {266    new_test_ext().execute_with(|| {267        default_limits();268        269        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);270271        let data = default_re_fungible_data();272        create_test_item(collection_id, &data.clone().into());273274        let origin1 = Origin::signed(1);275        let origin2 = Origin::signed(2);276        assert_eq!(277            TemplateModule::refungible_item_id(collection_id, 1).const_data,278            data.const_data279        );280        assert_eq!(281            TemplateModule::refungible_item_id(collection_id, 1).variable_data,282            data.variable_data283        );284        assert_eq!(285            TemplateModule::refungible_item_id(collection_id, 1).owner[0],286            Ownership {287                owner: 1,288                fraction: 1000289            }290        );291        assert_eq!(TemplateModule::balance_count(1, 1), 1000);292        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);293294        // change owner scenario295        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));296        assert_eq!(297            TemplateModule::refungible_item_id(1, 1).owner[0],298            Ownership {299                owner: 2,300                fraction: 1000301            }302        );303        assert_eq!(TemplateModule::balance_count(1, 1), 0);304        assert_eq!(TemplateModule::balance_count(1, 2), 1000);305        // assert_eq!(TemplateModule::address_tokens(1, 1), []);306        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);307308        // split item scenario309        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));310        assert_eq!(311            TemplateModule::refungible_item_id(1, 1).owner[0],312            Ownership {313                owner: 2,314                fraction: 500315            }316        );317        assert_eq!(318            TemplateModule::refungible_item_id(1, 1).owner[1],319            Ownership {320                owner: 3,321                fraction: 500322            }323        );324        assert_eq!(TemplateModule::balance_count(1, 2), 500);325        assert_eq!(TemplateModule::balance_count(1, 3), 500);326        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);327        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);328329        // split item and new owner has account scenario330        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));331        assert_eq!(332            TemplateModule::refungible_item_id(1, 1).owner[0],333            Ownership {334                owner: 2,335                fraction: 300336            }337        );338        assert_eq!(339            TemplateModule::refungible_item_id(1, 1).owner[1],340            Ownership {341                owner: 3,342                fraction: 700343            }344        );345        assert_eq!(TemplateModule::balance_count(1, 2), 300);346        assert_eq!(TemplateModule::balance_count(1, 3), 700);347        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);348        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);349    });350}351352#[test]353fn transfer_nft_item() {354    new_test_ext().execute_with(|| {355        default_limits();356        357        let collection_id = create_test_collection(&CollectionMode::NFT, 1);358359        let data = default_nft_data();360        create_test_item(collection_id, &data.into());361        assert_eq!(TemplateModule::balance_count(1, 1), 1);362        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);363364        let origin1 = Origin::signed(1);365        // default scenario366        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));367        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);368        assert_eq!(TemplateModule::balance_count(1, 1), 0);369        assert_eq!(TemplateModule::balance_count(1, 2), 1);370        // assert_eq!(TemplateModule::address_tokens(1, 1), []);371        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);372    });373}374375#[test]376fn nft_approve_and_transfer_from() {377    new_test_ext().execute_with(|| {378        default_limits();379        380        let collection_id = create_test_collection(&CollectionMode::NFT, 1);381382        let data = default_nft_data();383        create_test_item(collection_id, &data.into());384385        let origin1 = Origin::signed(1);386        let origin2 = Origin::signed(2);387388        assert_eq!(TemplateModule::balance_count(1, 1), 1);389        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);390391        // neg transfer392        assert_noop!(TemplateModule::transfer_from(393            origin2.clone(),394            1,395            2,396            1,397            1,398            1), Error::<Test>::NoPermission);399400        // do approve401        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));402        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);403        assert_eq!(404            TemplateModule::approved(1, (1, 1))[0],405            ApprovePermissions {406                approved: 2,407                amount: 100000000408            }409        );410411        assert_ok!(TemplateModule::transfer_from(412            origin2.clone(),413            1,414            2,415            1,416            1,417            1418        ));419        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);420    });421}422423#[test]424fn nft_approve_and_transfer_from_white_list() {425    new_test_ext().execute_with(|| {426        default_limits();427        428        let collection_id = create_test_collection(&CollectionMode::NFT, 1);429430        let origin1 = Origin::signed(1);431        let origin2 = Origin::signed(2);432433        let data = default_nft_data();434        create_test_item(collection_id, &data.clone().into());435436        assert_eq!(TemplateModule::nft_item_id(1, 1).const_data, data.const_data);437        assert_eq!(TemplateModule::balance_count(1, 1), 1);438        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);439440        assert_ok!(TemplateModule::set_mint_permission(441            origin1.clone(),442            1,443            true444        ));445        assert_ok!(TemplateModule::set_public_access_mode(446            origin1.clone(),447            1,448            AccessMode::WhiteList449        ));450        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));451        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));452        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));453454        // do approve455        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));456        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);457        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));458        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);459        assert_eq!(460            TemplateModule::approved(1, (1, 1))[0],461            ApprovePermissions {462                approved: 2,463                amount: 100000000464            }465        );466467        assert_ok!(TemplateModule::transfer_from(468            origin2.clone(),469            1,470            3,471            1,472            1,473            1474        ));475        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);476    });477}478479#[test]480fn refungible_approve_and_transfer_from() {481    new_test_ext().execute_with(|| {482        default_limits();483        484        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);485        486        let origin1 = Origin::signed(1);487        let origin2 = Origin::signed(2);488489        let data = default_re_fungible_data();490        create_test_item(collection_id, &data.into());491492        assert_eq!(TemplateModule::balance_count(1, 1), 1000);493        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);494495        assert_ok!(TemplateModule::set_mint_permission(496            origin1.clone(),497            1,498            true499        ));500        assert_ok!(TemplateModule::set_public_access_mode(501            origin1.clone(),502            1,503            AccessMode::WhiteList504        ));505        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));506        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));507        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));508509        // do approve510        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));511        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);512        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));513        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);514        assert_eq!(515            TemplateModule::approved(1, (1, 1))[0],516            ApprovePermissions {517                approved: 2,518                amount: 100000000519            }520        );521522        assert_ok!(TemplateModule::transfer_from(523            origin2.clone(),524            1,525            3,526            1,527            1,528            100529        ));530        assert_eq!(TemplateModule::balance_count(1, 1), 900);531        assert_eq!(TemplateModule::balance_count(1, 3), 100);532        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);533        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);534535        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);536        assert_eq!(537            TemplateModule::approved(1, (1, 1))[0],538            ApprovePermissions {539                approved: 3,540                amount: 100000000541            }542        );543    });544}545546#[test]547fn fungible_approve_and_transfer_from() {548    new_test_ext().execute_with(|| {549        default_limits();550        551        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);552        553        let data = default_fungible_data();554        create_test_item(collection_id, &data.into());555556        let origin1 = Origin::signed(1);557        let origin2 = Origin::signed(2);558559        assert_eq!(TemplateModule::balance_count(1, 1), 1000);560        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);561562        assert_ok!(TemplateModule::set_mint_permission(563            origin1.clone(),564            1,565            true566        ));567        assert_ok!(TemplateModule::set_public_access_mode(568            origin1.clone(),569            1,570            AccessMode::WhiteList571        ));572        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));573        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));574        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));575576        // do approve577        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));578        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);579        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));580        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);581        assert_eq!(582            TemplateModule::approved(1, (1, 1))[0],583            ApprovePermissions {584                approved: 2,585                amount: 100000000586            }587        );588589        assert_ok!(TemplateModule::transfer_from(590            origin2.clone(),591            1,592            3,593            1,594            1,595            100596        ));597        assert_eq!(TemplateModule::balance_count(1, 1), 900);598        assert_eq!(TemplateModule::balance_count(1, 3), 100);599        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);600        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);601602        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);603        assert_eq!(604            TemplateModule::approved(1, (1, 1))[0],605            ApprovePermissions {606                approved: 3,607                amount: 100000000608            }609        );610611        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));612        assert_ok!(TemplateModule::transfer_from(613            origin2.clone(),614            1,615            3,616            1,617            1,618            900619        ));620        assert_eq!(TemplateModule::balance_count(1, 1), 0);621        assert_eq!(TemplateModule::balance_count(1, 3), 1000);622        // assert_eq!(TemplateModule::address_tokens(1, 1), []);623        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);624625        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);626    });627}628629#[test]630fn change_collection_owner() {631    new_test_ext().execute_with(|| {632        default_limits();633        634        let collection_id = create_test_collection(&CollectionMode::NFT, 1);635        636        let origin1 = Origin::signed(1);637        assert_ok!(TemplateModule::change_collection_owner(638            origin1.clone(),639            collection_id,640            2641        ));642        assert_eq!(TemplateModule::collection(collection_id).owner, 2);643    });644}645646#[test]647fn destroy_collection() {648    new_test_ext().execute_with(|| {649        default_limits();650        651        let collection_id = create_test_collection(&CollectionMode::NFT, 1);652        653        let origin1 = Origin::signed(1);654        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));655    });656}657658#[test]659fn burn_nft_item() {660    new_test_ext().execute_with(|| {661        default_limits();662        663        let collection_id = create_test_collection(&CollectionMode::NFT, 1);664665        let origin1 = Origin::signed(1);666        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));667        668        let data = default_nft_data();669        create_test_item(collection_id, &data.into());670671        // check balance (collection with id = 1, user id = 1)672        assert_eq!(TemplateModule::balance_count(1, 1), 1);673674        // burn item675        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));676        assert_noop!(677            TemplateModule::burn_item(origin1.clone(), 1, 1),678            Error::<Test>::TokenNotFound679        );680681        assert_eq!(TemplateModule::balance_count(1, 1), 0);682    });683}684685#[test]686fn burn_fungible_item() {687    new_test_ext().execute_with(|| {688        default_limits();689        690        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);691        692        let origin1 = Origin::signed(1);693        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));694        695        let data = default_fungible_data();696        create_test_item(collection_id, &data.into());697698        // check balance (collection with id = 1, user id = 1)699        assert_eq!(TemplateModule::balance_count(1, 1), 1000);700701        // burn item702        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));703        assert_noop!(704            TemplateModule::burn_item(origin1.clone(), 1, 1),705            Error::<Test>::TokenNotFound706        );707708        assert_eq!(TemplateModule::balance_count(1, 1), 0);709    });710}711712#[test]713fn burn_refungible_item() {714    new_test_ext().execute_with(|| {715        default_limits();716        717        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);718        let origin1 = Origin::signed(1);719720        assert_ok!(TemplateModule::set_mint_permission(721            origin1.clone(),722            collection_id,723            true724        ));725        assert_ok!(TemplateModule::set_public_access_mode(726            origin1.clone(),727            collection_id,728            AccessMode::WhiteList729        ));730        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));731732        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));733        734        let data = default_re_fungible_data();735        create_test_item(collection_id, &data.into());736737        // check balance (collection with id = 1, user id = 2)738        assert_eq!(TemplateModule::balance_count(1, 1), 1000);739740        // burn item741        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));742        assert_noop!(743            TemplateModule::burn_item(origin1.clone(), 1, 1),744            Error::<Test>::TokenNotFound745        );746747        assert_eq!(TemplateModule::balance_count(1, 1), 0);748    });749}750751#[test]752fn add_collection_admin() {753    new_test_ext().execute_with(|| {754        default_limits();755        756        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);757        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);758        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);759        760        let origin1 = Origin::signed(1);761762        // collection admin763        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));764        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));765766        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);767        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);768    });769}770771#[test]772fn remove_collection_admin() {773    new_test_ext().execute_with(|| {774        default_limits();775        776        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);777        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);778        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);779780        let origin1 = Origin::signed(1);781        let origin2 = Origin::signed(2);782783        // collection admin784        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));785        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));786787        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);788        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);789790        // remove admin791        assert_ok!(TemplateModule::remove_collection_admin(792            origin2.clone(),793            1,794            3795        ));796        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);797    });798}799800#[test]801fn balance_of() {802    new_test_ext().execute_with(|| {803        default_limits();804        805        let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);806        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);807        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3), 3);808        809        // check balance before810        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);811        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);812        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);813814        let nft_data = default_nft_data();815        create_test_item(nft_collection_id, &nft_data.into());816        817        let fungible_data = default_fungible_data();818        create_test_item(fungible_collection_id, &fungible_data.into());819        820        let re_fungible_data = default_re_fungible_data();821        create_test_item(re_fungible_collection_id, &re_fungible_data.into());822823        // check balance (collection with id = 1, user id = 1)824        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);825        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);826        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);827        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);828        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);829        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);830    });831}832833#[test]834fn approve() {835    new_test_ext().execute_with(|| {836        default_limits();837        838        let collection_id = create_test_collection(&CollectionMode::NFT, 1);839        840        let data = default_nft_data();841        create_test_item(collection_id, &data.into());842843        let origin1 = Origin::signed(1);844        845        // approve846        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));847        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);848    });849}850851#[test]852fn transfer_from() {853    new_test_ext().execute_with(|| {854        default_limits();855        856        let collection_id = create_test_collection(&CollectionMode::NFT, 1);857        let origin1 = Origin::signed(1);858        let origin2 = Origin::signed(2);859860        let data = default_nft_data();861        create_test_item(collection_id, &data.into());862863        // approve864        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));865        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);866867        assert_ok!(TemplateModule::set_mint_permission(868            origin1.clone(),869            1,870            true871        ));872        assert_ok!(TemplateModule::set_public_access_mode(873            origin1.clone(),874            1,875            AccessMode::WhiteList876        ));877        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));878        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));879        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));880881        assert_ok!(TemplateModule::transfer_from(882            origin2.clone(),883            1,884            2,885            1,886            1,887            1888        ));889890        // after transfer891        assert_eq!(TemplateModule::balance_count(1, 1), 0);892        assert_eq!(TemplateModule::balance_count(1, 2), 1);893    });894}895896// #endregion897898// Coverage tests region899// #region900901#[test]902fn owner_can_add_address_to_white_list() {903    new_test_ext().execute_with(|| {904        default_limits();905        906        let collection_id = create_test_collection(&CollectionMode::NFT, 1);907908        let origin1 = Origin::signed(1);909        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));910        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);911    });912}913914#[test]915fn admin_can_add_address_to_white_list() {916    new_test_ext().execute_with(|| {917        default_limits();918        919        let collection_id = create_test_collection(&CollectionMode::NFT, 1);920        let origin1 = Origin::signed(1);921        let origin2 = Origin::signed(2);922923        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));924        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));925        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);926    });927}928929#[test]930fn nonprivileged_user_cannot_add_address_to_white_list() {931    new_test_ext().execute_with(|| {932        default_limits();933        934        let collection_id = create_test_collection(&CollectionMode::NFT, 1);935936        let origin2 = Origin::signed(2);937        assert_noop!(938            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),939            Error::<Test>::NoPermission940        );941    });942}943944#[test]945fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {946    new_test_ext().execute_with(|| {947        default_limits();948949        let origin1 = Origin::signed(1);950951        assert_noop!(952            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),953            Error::<Test>::CollectionNotFound954        );955    });956}957958#[test]959fn nobody_can_add_address_to_white_list_of_deleted_collection() {960    new_test_ext().execute_with(|| {961        default_limits();962        963        let collection_id = create_test_collection(&CollectionMode::NFT, 1);964965        let origin1 = Origin::signed(1);966        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));967        assert_noop!(968            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),969            Error::<Test>::CollectionNotFound970        );971    });972}973974// If address is already added to white list, nothing happens975#[test]976fn address_is_already_added_to_white_list() {977    new_test_ext().execute_with(|| {978        default_limits();979        980        let collection_id = create_test_collection(&CollectionMode::NFT, 1);981        let origin1 = Origin::signed(1);982        983        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));984        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));985        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);986        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);987    });988}989990#[test]991fn owner_can_remove_address_from_white_list() {992    new_test_ext().execute_with(|| {993        default_limits();994        995        let collection_id = create_test_collection(&CollectionMode::NFT, 1);996997        let origin1 = Origin::signed(1);998        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));999        assert_ok!(TemplateModule::remove_from_white_list(1000            origin1.clone(),1001            collection_id,1002            21003        ));1004        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1005    });1006}10071008#[test]1009fn admin_can_remove_address_from_white_list() {1010    new_test_ext().execute_with(|| {1011        default_limits();1012        1013        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1014        let origin1 = Origin::signed(1);1015        let origin2 = Origin::signed(2);10161017        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));10181019        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));1020        assert_ok!(TemplateModule::remove_from_white_list(1021            origin2.clone(),1022            collection_id,1023            31024        ));1025        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1026    });1027}10281029#[test]1030fn nonprivileged_user_cannot_remove_address_from_white_list() {1031    new_test_ext().execute_with(|| {1032        default_limits();1033        1034        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1035        let origin1 = Origin::signed(1);1036        let origin2 = Origin::signed(2);10371038        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1039        assert_noop!(1040            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1041            Error::<Test>::NoPermission1042        );1043        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);1044    });1045}10461047#[test]1048fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1049    new_test_ext().execute_with(|| {1050        default_limits();1051        let origin1 = Origin::signed(1);10521053        assert_noop!(1054            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),1055            Error::<Test>::CollectionNotFound1056        );1057    });1058}10591060#[test]1061fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1062    new_test_ext().execute_with(|| {1063        default_limits();1064        1065        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1066        let origin1 = Origin::signed(1);1067        let origin2 = Origin::signed(2);10681069        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1070        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));1071        assert_noop!(1072            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1073            Error::<Test>::CollectionNotFound1074        );1075        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1076    });1077}10781079// If address is already removed from white list, nothing happens1080#[test]1081fn address_is_already_removed_from_white_list() {1082    new_test_ext().execute_with(|| {1083        default_limits();1084        1085        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1086        let origin1 = Origin::signed(1);10871088        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1089        assert_ok!(TemplateModule::remove_from_white_list(1090            origin1.clone(),1091            collection_id,1092            21093        ));1094        assert_ok!(TemplateModule::remove_from_white_list(1095            origin1.clone(),1096            collection_id,1097            21098        ));1099        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1100    });1101}11021103// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1104#[test]1105fn white_list_test_1() {1106    new_test_ext().execute_with(|| {1107        default_limits();1108        1109        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11101111        let origin1 = Origin::signed(1);1112        1113        let data = default_nft_data();1114        create_test_item(collection_id, &data.into());11151116        assert_ok!(TemplateModule::set_public_access_mode(1117            origin1.clone(),1118            collection_id,1119            AccessMode::WhiteList1120        ));1121        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11221123        assert_noop!(1124            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1125            Error::<Test>::AddresNotInWhiteList1126        );1127    });1128}11291130#[test]1131fn white_list_test_2() {1132    new_test_ext().execute_with(|| {1133        default_limits();1134        1135        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1136        let origin1 = Origin::signed(1);1137        1138        let data = default_nft_data();1139        create_test_item(collection_id, &data.into());11401141        assert_ok!(TemplateModule::set_public_access_mode(1142            origin1.clone(),1143            collection_id,1144            AccessMode::WhiteList1145        ));1146        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1147        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));11481149        // do approve1150        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1151        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);11521153        assert_ok!(TemplateModule::remove_from_white_list(1154            origin1.clone(),1155            1,1156            11157        ));11581159        assert_noop!(1160            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1161            Error::<Test>::AddresNotInWhiteList1162        );1163    });1164}11651166// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1167#[test]1168fn white_list_test_3() {1169    new_test_ext().execute_with(|| {1170        default_limits();1171        1172        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11731174        let origin1 = Origin::signed(1);1175        1176        let data = default_nft_data();1177        create_test_item(collection_id, &data.into());11781179        assert_ok!(TemplateModule::set_public_access_mode(1180            origin1.clone(),1181            collection_id,1182            AccessMode::WhiteList1183        ));1184        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));11851186        assert_noop!(1187            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1188            Error::<Test>::AddresNotInWhiteList1189        );1190    });1191}11921193#[test]1194fn white_list_test_4() {1195    new_test_ext().execute_with(|| {1196        default_limits();1197        1198        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11991200        let origin1 = Origin::signed(1);12011202        let data = default_nft_data();1203        create_test_item(collection_id, &data.into());12041205        assert_ok!(TemplateModule::set_public_access_mode(1206            origin1.clone(),1207            collection_id,1208            AccessMode::WhiteList1209        ));1210        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1211        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12121213        // do approve1214        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1215        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);12161217        assert_ok!(TemplateModule::remove_from_white_list(1218            origin1.clone(),1219            collection_id,1220            21221        ));12221223        assert_noop!(1224            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1225            Error::<Test>::AddresNotInWhiteList1226        );1227    });1228}12291230// 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)1231#[test]1232fn white_list_test_5() {1233    new_test_ext().execute_with(|| {1234        default_limits();1235        1236        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12371238        let origin1 = Origin::signed(1);12391240        let data = default_nft_data();1241        create_test_item(collection_id, &data.into());12421243        assert_ok!(TemplateModule::set_public_access_mode(1244            origin1.clone(),1245            collection_id,1246            AccessMode::WhiteList1247        ));1248        assert_noop!(1249            TemplateModule::burn_item(origin1.clone(), 1, 1),1250            Error::<Test>::AddresNotInWhiteList1251        );1252    });1253}12541255// If Public Access mode is set to WhiteList, oken transfers can’t be Approved by a non-whitelisted address (see Approve method).1256#[test]1257fn white_list_test_6() {1258    new_test_ext().execute_with(|| {1259        default_limits();1260        1261        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12621263        let origin1 = Origin::signed(1);1264        assert_ok!(TemplateModule::set_public_access_mode(1265            origin1.clone(),1266            collection_id,1267            AccessMode::WhiteList1268        ));12691270        // do approve1271        assert_noop!(1272            TemplateModule::approve(origin1.clone(), 1, 1, 1),1273            Error::<Test>::AddresNotInWhiteList1274        );1275    });1276}12771278// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1279//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1280#[test]1281fn white_list_test_7() {1282    new_test_ext().execute_with(|| {1283        default_limits();1284        1285        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12861287        let data = default_nft_data();1288        create_test_item(collection_id, &data.into());1289        1290        let origin1 = Origin::signed(1);12911292        assert_ok!(TemplateModule::set_public_access_mode(1293            origin1.clone(),1294            collection_id,1295            AccessMode::WhiteList1296        ));1297        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1298        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12991300        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1301    });1302}13031304#[test]1305fn white_list_test_8() {1306    new_test_ext().execute_with(|| {1307        default_limits();1308        1309        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13101311        let data = default_nft_data();1312        create_test_item(collection_id, &data.into());1313        1314        let origin1 = Origin::signed(1);13151316        assert_ok!(TemplateModule::set_public_access_mode(1317            origin1.clone(),1318            collection_id,1319            AccessMode::WhiteList1320        ));1321        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1322        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13231324        // do approve1325        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1326        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);13271328        assert_ok!(TemplateModule::transfer_from(1329            origin1.clone(),1330            1,1331            2,1332            1,1333            1,1334            11335        ));1336    });1337}13381339// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1340#[test]1341fn white_list_test_9() {1342    new_test_ext().execute_with(|| {1343        default_limits();1344        1345        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1346        let origin1 = Origin::signed(1);13471348        assert_ok!(TemplateModule::set_public_access_mode(1349            origin1.clone(),1350            collection_id,1351            AccessMode::WhiteList1352        ));1353        assert_ok!(TemplateModule::set_mint_permission(1354            origin1.clone(),1355            collection_id,1356            false1357        ));13581359        let data = default_nft_data();1360        create_test_item(collection_id, &data.into());1361    });1362}13631364// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1365#[test]1366fn white_list_test_10() {1367    new_test_ext().execute_with(|| {1368        default_limits();1369        1370        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13711372        let origin1 = Origin::signed(1);1373        let origin2 = Origin::signed(2);13741375        assert_ok!(TemplateModule::set_public_access_mode(1376            origin1.clone(),1377            collection_id,1378            AccessMode::WhiteList1379        ));1380        assert_ok!(TemplateModule::set_mint_permission(1381            origin1.clone(),1382            collection_id,1383            false1384        ));13851386        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));13871388        assert_ok!(TemplateModule::create_item(1389            origin2.clone(),1390            collection_id,1391            2,1392            default_nft_data().into()1393        ));1394    });1395}13961397// 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.1398#[test]1399fn white_list_test_11() {1400    new_test_ext().execute_with(|| {1401        default_limits();1402        1403        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14041405        let origin1 = Origin::signed(1);1406        let origin2 = Origin::signed(2);14071408        assert_ok!(TemplateModule::set_public_access_mode(1409            origin1.clone(),1410            collection_id,1411            AccessMode::WhiteList1412        ));1413        assert_ok!(TemplateModule::set_mint_permission(1414            origin1.clone(),1415            collection_id,1416            false1417        ));1418        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14191420        assert_noop!(1421            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1422            Error::<Test>::PublicMintingNotAllowed1423        );1424    });1425}14261427// 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.1428#[test]1429fn white_list_test_12() {1430    new_test_ext().execute_with(|| {1431        default_limits();1432        1433        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14341435        let origin1 = Origin::signed(1);1436        let origin2 = Origin::signed(2);14371438        assert_ok!(TemplateModule::set_public_access_mode(1439            origin1.clone(),1440            collection_id,1441            AccessMode::WhiteList1442        ));1443        assert_ok!(TemplateModule::set_mint_permission(1444            origin1.clone(),1445            collection_id,1446            false1447        ));14481449        assert_noop!(1450            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1451            Error::<Test>::PublicMintingNotAllowed1452        );1453    });1454}14551456// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1457#[test]1458fn white_list_test_13() {1459    new_test_ext().execute_with(|| {1460        default_limits();1461        1462        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14631464        let origin1 = Origin::signed(1);14651466        assert_ok!(TemplateModule::set_public_access_mode(1467            origin1.clone(),1468            collection_id,1469            AccessMode::WhiteList1470        ));1471        assert_ok!(TemplateModule::set_mint_permission(1472            origin1.clone(),1473            collection_id,1474            true1475        ));14761477        let data = default_nft_data();1478        create_test_item(collection_id, &data.into());1479    });1480}14811482// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1483#[test]1484fn white_list_test_14() {1485    new_test_ext().execute_with(|| {1486        default_limits();1487        1488        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14891490        let origin1 = Origin::signed(1);1491        let origin2 = Origin::signed(2);14921493        assert_ok!(TemplateModule::set_public_access_mode(1494            origin1.clone(),1495            collection_id,1496            AccessMode::WhiteList1497        ));1498        assert_ok!(TemplateModule::set_mint_permission(1499            origin1.clone(),1500            collection_id,1501            true1502        ));15031504        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));15051506        assert_ok!(TemplateModule::create_item(1507            origin2.clone(),1508            1,1509            2,1510            default_nft_data().into()1511        ));1512    });1513}15141515// 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.1516#[test]1517fn white_list_test_15() {1518    new_test_ext().execute_with(|| {1519        default_limits();1520        1521        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15221523        let origin1 = Origin::signed(1);1524        let origin2 = Origin::signed(2);15251526        assert_ok!(TemplateModule::set_public_access_mode(1527            origin1.clone(),1528            collection_id,1529            AccessMode::WhiteList1530        ));1531        assert_ok!(TemplateModule::set_mint_permission(1532            origin1.clone(),1533            collection_id,1534            true1535        ));15361537        assert_noop!(1538            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1539            Error::<Test>::AddresNotInWhiteList1540        );1541    });1542}15431544// 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.1545#[test]1546fn white_list_test_16() {1547    new_test_ext().execute_with(|| {1548        default_limits();1549        1550        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15511552        let origin1 = Origin::signed(1);1553        let origin2 = Origin::signed(2);15541555        assert_ok!(TemplateModule::set_public_access_mode(1556            origin1.clone(),1557            collection_id,1558            AccessMode::WhiteList1559        ));1560        assert_ok!(TemplateModule::set_mint_permission(1561            origin1.clone(),1562            collection_id,1563            true1564        ));1565        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));15661567        assert_ok!(TemplateModule::create_item(1568            origin2.clone(),1569            1,1570            2,1571            default_nft_data().into()1572        ));1573    });1574}15751576// Total number of collections. Positive test1577#[test]1578fn total_number_collections_bound() {1579    new_test_ext().execute_with(|| {1580        default_limits();1581        1582        create_test_collection(&CollectionMode::NFT, 1);1583    });1584}15851586// Total number of collections. Negotive test1587#[test]1588fn total_number_collections_bound_neg() {1589    new_test_ext().execute_with(|| {1590        default_limits();15911592        let origin1 = Origin::signed(1);15931594        for i in 0..default_collection_numbers_limit() {1595            create_test_collection(&CollectionMode::NFT, i + 1);1596        }15971598        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1599        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1600        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();16011602        // 11-th collection in chain. Expects error1603        assert_noop!(TemplateModule::create_collection(1604            origin1.clone(),1605            col_name1.clone(),1606            col_desc1.clone(),1607            token_prefix1.clone(),1608            CollectionMode::NFT1609        ), Error::<Test>::TotalCollectionsLimitExceeded);1610    });1611}16121613// Owned tokens by a single address. Positive test1614#[test]1615fn owned_tokens_bound() {1616    new_test_ext().execute_with(|| {1617        default_limits();1618        1619        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16201621        let data = default_nft_data();1622        create_test_item(collection_id, &data.clone().into());1623        create_test_item(collection_id, &data.into());1624    });1625}16261627// Owned tokens by a single address. Negotive test1628#[test]1629fn owned_tokens_bound_neg() {1630    new_test_ext().execute_with(|| {1631        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1632            collection_numbers_limit: 10,1633            account_token_ownership_limit: 1,1634            collections_admins_limit: 5,1635            custom_data_limit: 2048,1636            nft_sponsor_transfer_timeout: 15,1637            fungible_sponsor_transfer_timeout: 15,1638            refungible_sponsor_transfer_timeout: 15,          1639        }));1640        1641        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16421643        let origin1 = Origin::signed(1);1644        let data = default_nft_data();1645        create_test_item(collection_id, &data.clone().into());16461647        assert_noop!(TemplateModule::create_item(1648            origin1.clone(),1649            1,1650            1,1651            data.into()1652        ),  Error::<Test>::AddressOwnershipLimitExceeded);1653    });1654}16551656// Number of collection admins. Positive test1657#[test]1658fn collection_admins_bound() {1659    new_test_ext().execute_with(|| {1660        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1661            collection_numbers_limit: 10,1662            account_token_ownership_limit: 10,1663            collections_admins_limit: 2,1664            custom_data_limit: 2048,1665            nft_sponsor_transfer_timeout: 15,1666            fungible_sponsor_transfer_timeout: 15,1667            refungible_sponsor_transfer_timeout: 15,          1668        }));1669        1670        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16711672        let origin1 = Origin::signed(1);1673        1674        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1675        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1676    });1677}16781679// Number of collection admins. Negotive test1680#[test]1681fn collection_admins_bound_neg() {1682    new_test_ext().execute_with(|| {1683        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1684            collection_numbers_limit: 10,1685            account_token_ownership_limit: 1,1686            collections_admins_limit: 1,1687            custom_data_limit: 2048,1688            nft_sponsor_transfer_timeout: 15,1689            fungible_sponsor_transfer_timeout: 15,1690            refungible_sponsor_transfer_timeout: 15,          1691        }));1692        1693        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16941695        let origin1 = Origin::signed(1);16961697        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1698        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), Error::<Test>::CollectionAdminsLimitExceeded);1699    });1700}17011702// NFT custom data size. Negative test const_data.1703#[test]1704fn custom_data_size_nft_const_data_bound_neg() {1705    new_test_ext().execute_with(|| {1706        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1707            collection_numbers_limit: 10,1708            account_token_ownership_limit: 10,1709            collections_admins_limit: 5,1710            custom_data_limit: 2,1711            nft_sponsor_transfer_timeout: 15,1712            fungible_sponsor_transfer_timeout: 15,1713            refungible_sponsor_transfer_timeout: 15,          1714        }));1715        1716        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17171718        let origin1 = Origin::signed(1);1719        let too_big_const_data = CreateItemData::NFT(CreateNftData{1720            const_data: vec![1, 2, 3, 4],1721            variable_data: vec![]1722        });17231724        assert_noop!(TemplateModule::create_item(1725            origin1.clone(),1726            collection_id,1727            1,1728            too_big_const_data1729        ), Error::<Test>::TokenConstDataLimitExceeded);1730    });1731}17321733// NFT custom data size. Negative test variable_data.1734#[test]1735fn custom_data_size_nft_variable_data_bound_neg() {1736    new_test_ext().execute_with(|| {1737        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1738            collection_numbers_limit: 10,1739            account_token_ownership_limit: 10,1740            collections_admins_limit: 5,1741            custom_data_limit: 2,1742            nft_sponsor_transfer_timeout: 15,1743            fungible_sponsor_transfer_timeout: 15,1744            refungible_sponsor_transfer_timeout: 15,          1745        }));17461747        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17481749        let origin1 = Origin::signed(1);1750        let too_big_const_data = CreateItemData::NFT(CreateNftData{1751            const_data: vec![],1752            variable_data: vec![1, 2, 3, 4]1753        });17541755        assert_noop!(TemplateModule::create_item(1756            origin1.clone(),1757            collection_id,1758            1,1759            too_big_const_data1760        ), Error::<Test>::TokenVariableDataLimitExceeded);1761    });1762}17631764// Re fungible custom data size. Negative test const_data.1765#[test]1766fn custom_data_size_re_fungible_const_data_bound_neg() {1767    new_test_ext().execute_with(|| {1768        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1769            collection_numbers_limit: 10,1770            account_token_ownership_limit: 10,1771            collections_admins_limit: 5,1772            custom_data_limit: 2,1773            nft_sponsor_transfer_timeout: 15,1774            fungible_sponsor_transfer_timeout: 15,1775            refungible_sponsor_transfer_timeout: 15,          1776        }));17771778        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17791780        let origin1 = Origin::signed(1);1781        let too_big_const_data = CreateItemData::NFT(CreateNftData{1782            const_data: vec![1, 2, 3, 4],1783            variable_data: vec![]1784        });17851786        assert_noop!(TemplateModule::create_item(1787            origin1.clone(),1788            collection_id,1789            1,1790            too_big_const_data1791        ), Error::<Test>::TokenConstDataLimitExceeded);1792    });1793}17941795// Re fungible custom data size. Negative test variable_data.1796#[test]1797fn custom_data_size_re_fungible_variable_data_bound_neg() {1798    new_test_ext().execute_with(|| {1799        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1800            collection_numbers_limit: 10,1801            account_token_ownership_limit: 10,1802            collections_admins_limit: 5,1803            custom_data_limit: 2,1804            nft_sponsor_transfer_timeout: 15,1805            fungible_sponsor_transfer_timeout: 15,1806            refungible_sponsor_transfer_timeout: 15,          1807        }));18081809        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18101811        let origin1 = Origin::signed(1);1812        let too_big_const_data = CreateItemData::NFT(CreateNftData{1813            const_data: vec![],1814            variable_data: vec![1, 2, 3, 4]1815        });18161817        assert_noop!(TemplateModule::create_item(1818            origin1.clone(),1819            collection_id,1820            1,1821            too_big_const_data1822        ), Error::<Test>::TokenVariableDataLimitExceeded);1823    });1824}1825// #endregion18261827#[test]1828fn set_const_on_chain_schema() {1829    new_test_ext().execute_with(|| {1830        default_limits();18311832        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18331834        let origin1 = Origin::signed(1);1835        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, b"test const on chain schema".to_vec()));18361837        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"test const on chain schema".to_vec());1838        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"".to_vec());1839    });1840}18411842#[test]1843fn set_variable_on_chain_schema() {1844    new_test_ext().execute_with(|| {1845        default_limits();1846        1847        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18481849        let origin1 = Origin::signed(1);1850        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, b"test variable on chain schema".to_vec()));18511852        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"".to_vec());1853        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"test variable on chain schema".to_vec());1854    });1855}18561857#[test]1858fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1859    new_test_ext().execute_with(|| {1860        default_limits();18611862        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18631864        let origin1 = Origin::signed(1);1865        1866        let data = default_nft_data();1867        create_test_item(1, &data.into());1868        1869        let variable_data = b"test set_variable_meta_data method.".to_vec();1870        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));18711872        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, variable_data);1873    });1874}18751876#[test]1877fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1878    new_test_ext().execute_with(|| {1879        default_limits();18801881        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);18821883        let origin1 = Origin::signed(1);18841885        let data = default_re_fungible_data();1886        create_test_item(1, &data.into());18871888        let variable_data = b"test set_variable_meta_data method.".to_vec();1889        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));18901891        assert_eq!(TemplateModule::refungible_item_id(collection_id, 1).variable_data, variable_data);1892    });1893}189418951896#[test]1897fn set_variable_meta_data_on_fungible_token_fails() {1898    new_test_ext().execute_with(|| {1899        default_limits();19001901        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);19021903        let origin1 = Origin::signed(1);19041905        let data = default_fungible_data();1906        create_test_item(1, &data.into());19071908        let variable_data = b"test set_variable_meta_data method.".to_vec();1909        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()), Error::<Test>::CantStoreMetadataInFungibleTokens);1910    });1911}19121913#[test]1914fn set_variable_meta_data_on_nft_token_fails_for_big_data() {1915    new_test_ext().execute_with(|| {1916        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1917            collection_numbers_limit: default_collection_numbers_limit(),1918            account_token_ownership_limit: 10,1919            collections_admins_limit: 5,1920            custom_data_limit: 10,1921            nft_sponsor_transfer_timeout: 15,1922            fungible_sponsor_transfer_timeout: 15,1923            refungible_sponsor_transfer_timeout: 15,          1924        }));19251926        let collection_id = create_test_collection(&CollectionMode::NFT, 1);19271928        let origin1 = Origin::signed(1);19291930        let data = default_nft_data();1931        create_test_item(1, &data.into());19321933        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1934        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);1935    });1936}19371938#[test]1939fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {1940    new_test_ext().execute_with(|| {1941        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1942            collection_numbers_limit: default_collection_numbers_limit(),1943            account_token_ownership_limit: 10,1944            collections_admins_limit: 5,1945            custom_data_limit: 10,1946            nft_sponsor_transfer_timeout: 15,1947            fungible_sponsor_transfer_timeout: 15,1948            refungible_sponsor_transfer_timeout: 15,          1949        }));195019511952        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);19531954        let origin1 = Origin::signed(1);19551956        let data = default_re_fungible_data();1957        create_test_item(1, &data.into());19581959        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1960        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);1961    });1962}