git.delta.rocks / unique-network / refs/commits / 71e3eed44117

1// Tests to be written here2use super::*;3use crate::mock::*;4use crate::{AccessMode, ApprovePermissions, CollectionMode,5     Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData}; //Err6use frame_support::{assert_noop, assert_ok};7use frame_system::{ RawOrigin };89fn default_collection_numbers_limit() -> u64 {10    1011}1213fn default_limits() {14    assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 15            collection_numbers_limit: default_collection_numbers_limit(),16            account_token_ownership_limit: 10,17            collections_admins_limit: 5,18            custom_data_limit: 2048,19            nft_sponsor_transfer_timeout: 15,20            fungible_sponsor_transfer_timeout: 15,21            refungible_sponsor_transfer_timeout: 15,          22        }));23}2425fn default_nft_data() -> CreateNftData {26    CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }27}2829fn default_fungible_data () -> CreateFungibleData {30    CreateFungibleData { }31}3233fn default_re_fungible_data () -> CreateReFungibleData {34    CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }35}3637fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64, id: u64) -> u64 {38    let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();39    let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();40    let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();4142    let origin1 = Origin::signed(owner);43    assert_ok!(TemplateModule::create_collection(44            origin1.clone(),45            col_name1.clone(),46            col_desc1.clone(),47            token_prefix1.clone(),48            mode.clone()49        ));5051    let saved_col_name: Vec<u16> = "Test1\0\0".encode_utf16().collect::<Vec<u16>>();52    let saved_description: Vec<u16> = "TestDescription1\0\0".encode_utf16().collect::<Vec<u16>>();53    let saved_prefix: Vec<u8> = b"token_prefix1\0\0".to_vec();54    assert_eq!(TemplateModule::collection(id).owner, owner);55    assert_eq!(TemplateModule::collection(id).name, saved_col_name);56    assert_eq!(TemplateModule::collection(id).mode, *mode);57    assert_eq!(TemplateModule::collection(id).description, saved_description);58    assert_eq!(TemplateModule::collection(id).token_prefix, saved_prefix);59    id60}6162fn create_test_collection(mode: &CollectionMode, id: u64) -> u64 {63    create_test_collection_for_owner(&mode, 1, id)64}6566fn create_test_item(collection_id: u64, data: &CreateItemData) {67    let origin1 = Origin::signed(1);68    assert_ok!(TemplateModule::create_item(69            origin1.clone(),70            collection_id,71            1,72            data.clone()73        ));7475}7677// Use cases tests region78// #region79#[test]80fn create_nft_item() {81    new_test_ext().execute_with(|| {82        default_limits();83        let collection_id = create_test_collection(&CollectionMode::NFT, 1);84        85        let data = default_nft_data();86        create_test_item(collection_id, &data.clone().into());87        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);88        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);89    });90}9192// Use cases tests region93// #region94#[test]95fn create_nft_multiple_items() {96    new_test_ext().execute_with(|| {97        default_limits();98        99        create_test_collection(&CollectionMode::NFT, 1);100101        let origin1 = Origin::signed(1);102103        let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];104105        assert_ok!(TemplateModule::create_multiple_items(106            origin1.clone(),107            1,108            1,109            items_data.clone().into_iter().map(|d| { d.into() }).collect()110        ));111        for (index, data) in items_data.iter().enumerate() {112            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as u64).const_data.to_vec(), data.const_data);113            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as u64).variable_data.to_vec(), data.variable_data);114        }115    });116}117118#[test]119fn create_refungible_item() {120    new_test_ext().execute_with(|| {121        default_limits();122        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);123124        let data = default_re_fungible_data();125        create_test_item(collection_id, &data.clone().into());126        assert_eq!(127            TemplateModule::refungible_item_id(collection_id, 1).const_data,128            data.const_data129        );130        assert_eq!(131            TemplateModule::refungible_item_id(collection_id, 1).variable_data,132            data.variable_data133        );134        assert_eq!(135            TemplateModule::refungible_item_id(collection_id, 1).owner[0],136            Ownership {137                owner: 1,138                fraction: 1000139            }140        );141    });142}143144#[test]145fn create_multiple_refungible_items() {146    new_test_ext().execute_with(|| {147        default_limits();148        149        create_test_collection(&CollectionMode::ReFungible(3), 1);150151        let origin1 = Origin::signed(1);152153        let items_data = vec![default_re_fungible_data(), default_re_fungible_data(), default_re_fungible_data()];154155        assert_ok!(TemplateModule::create_multiple_items(156            origin1.clone(),157            1,158            1,159            items_data.clone().into_iter().map(|d| { d.into() }).collect()160        ));161        for (index, data) in items_data.iter().enumerate() {162163            let item = TemplateModule::refungible_item_id(1, (index + 1) as u64);164            assert_eq!(item.const_data.to_vec(), data.const_data);165            assert_eq!(item.variable_data.to_vec(), data.variable_data);166            assert_eq!(167                item.owner[0],168                Ownership {169                    owner: 1,170                    fraction: 1000171                }172            );173        }174    });175}176177#[test]178fn create_fungible_item() {179    new_test_ext().execute_with(|| {180        default_limits();181        182        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);183184        let data = default_fungible_data();185        create_test_item(collection_id, &data.into());186187        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);188    });189}190191#[test]192fn create_multiple_fungible_items() {193    new_test_ext().execute_with(|| {194        default_limits();195196        create_test_collection(&CollectionMode::Fungible(3), 1);197198        let origin1 = Origin::signed(1);199200        let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];201202        assert_ok!(TemplateModule::create_multiple_items(203            origin1.clone(),204            1,205            1,206            items_data.clone().into_iter().map(|d| { d.into() }).collect()207        ));208        209        for (index, _) in items_data.iter().enumerate() {210            assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as u64).owner, 1);211        }212        assert_eq!(TemplateModule::balance_count(1, 1), 3000);213        assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);214    });215}216217#[test]218fn transfer_fungible_item() {219    new_test_ext().execute_with(|| {220        default_limits();221        222        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);223224        let origin1 = Origin::signed(1);225        let origin2 = Origin::signed(2);226227        let data = default_fungible_data();228        create_test_item(collection_id, &data.into());229230        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);231        assert_eq!(TemplateModule::balance_count(1, 1), 1000);232        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);233234        // change owner scenario235        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));236        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);237        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);238        assert_eq!(TemplateModule::balance_count(1, 1), 0);239        assert_eq!(TemplateModule::balance_count(1, 2), 1000);240        // assert_eq!(TemplateModule::address_tokens(1, 1), []);241        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);242243        // split item scenario244        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));245        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);246        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);247        assert_eq!(TemplateModule::balance_count(1, 2), 500);248        assert_eq!(TemplateModule::balance_count(1, 3), 500);249        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);250        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);251252        // split item and new owner has account scenario253        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));254        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);255        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);256        assert_eq!(TemplateModule::balance_count(1, 2), 300);257        assert_eq!(TemplateModule::balance_count(1, 3), 700);258        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);259        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);260    });261}262263#[test]264fn transfer_refungible_item() {265    new_test_ext().execute_with(|| {266        default_limits();267        268        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);269270        let data = default_re_fungible_data();271        create_test_item(collection_id, &data.clone().into());272273        let origin1 = Origin::signed(1);274        let origin2 = Origin::signed(2);275        assert_eq!(276            TemplateModule::refungible_item_id(collection_id, 1).const_data,277            data.const_data278        );279        assert_eq!(280            TemplateModule::refungible_item_id(collection_id, 1).variable_data,281            data.variable_data282        );283        assert_eq!(284            TemplateModule::refungible_item_id(collection_id, 1).owner[0],285            Ownership {286                owner: 1,287                fraction: 1000288            }289        );290        assert_eq!(TemplateModule::balance_count(1, 1), 1000);291        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);292293        // change owner scenario294        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));295        assert_eq!(296            TemplateModule::refungible_item_id(1, 1).owner[0],297            Ownership {298                owner: 2,299                fraction: 1000300            }301        );302        assert_eq!(TemplateModule::balance_count(1, 1), 0);303        assert_eq!(TemplateModule::balance_count(1, 2), 1000);304        // assert_eq!(TemplateModule::address_tokens(1, 1), []);305        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);306307        // split item scenario308        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));309        assert_eq!(310            TemplateModule::refungible_item_id(1, 1).owner[0],311            Ownership {312                owner: 2,313                fraction: 500314            }315        );316        assert_eq!(317            TemplateModule::refungible_item_id(1, 1).owner[1],318            Ownership {319                owner: 3,320                fraction: 500321            }322        );323        assert_eq!(TemplateModule::balance_count(1, 2), 500);324        assert_eq!(TemplateModule::balance_count(1, 3), 500);325        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);326        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);327328        // split item and new owner has account scenario329        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));330        assert_eq!(331            TemplateModule::refungible_item_id(1, 1).owner[0],332            Ownership {333                owner: 2,334                fraction: 300335            }336        );337        assert_eq!(338            TemplateModule::refungible_item_id(1, 1).owner[1],339            Ownership {340                owner: 3,341                fraction: 700342            }343        );344        assert_eq!(TemplateModule::balance_count(1, 2), 300);345        assert_eq!(TemplateModule::balance_count(1, 3), 700);346        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);347        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);348    });349}350351#[test]352fn transfer_nft_item() {353    new_test_ext().execute_with(|| {354        default_limits();355        356        let collection_id = create_test_collection(&CollectionMode::NFT, 1);357358        let data = default_nft_data();359        create_test_item(collection_id, &data.into());360        assert_eq!(TemplateModule::balance_count(1, 1), 1);361        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);362363        let origin1 = Origin::signed(1);364        // default scenario365        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));366        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);367        assert_eq!(TemplateModule::balance_count(1, 1), 0);368        assert_eq!(TemplateModule::balance_count(1, 2), 1);369        // assert_eq!(TemplateModule::address_tokens(1, 1), []);370        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);371    });372}373374#[test]375fn nft_approve_and_transfer_from() {376    new_test_ext().execute_with(|| {377        default_limits();378        379        let collection_id = create_test_collection(&CollectionMode::NFT, 1);380381        let data = default_nft_data();382        create_test_item(collection_id, &data.into());383384        let origin1 = Origin::signed(1);385        let origin2 = Origin::signed(2);386387        assert_eq!(TemplateModule::balance_count(1, 1), 1);388        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);389390        // neg transfer391        assert_noop!(TemplateModule::transfer_from(392            origin2.clone(),393            1,394            2,395            1,396            1,397            1), Error::<Test>::NoPermission);398399        // do approve400        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));401        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);402        assert_eq!(403            TemplateModule::approved(1, (1, 1))[0],404            ApprovePermissions {405                approved: 2,406                amount: 100000000407            }408        );409410        assert_ok!(TemplateModule::transfer_from(411            origin2.clone(),412            1,413            2,414            1,415            1,416            1417        ));418        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);419    });420}421422#[test]423fn nft_approve_and_transfer_from_white_list() {424    new_test_ext().execute_with(|| {425        default_limits();426        427        let collection_id = create_test_collection(&CollectionMode::NFT, 1);428429        let origin1 = Origin::signed(1);430        let origin2 = Origin::signed(2);431432        let data = default_nft_data();433        create_test_item(collection_id, &data.clone().into());434435        assert_eq!(TemplateModule::nft_item_id(1, 1).const_data, data.const_data);436        assert_eq!(TemplateModule::balance_count(1, 1), 1);437        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);438439        assert_ok!(TemplateModule::set_mint_permission(440            origin1.clone(),441            1,442            true443        ));444        assert_ok!(TemplateModule::set_public_access_mode(445            origin1.clone(),446            1,447            AccessMode::WhiteList448        ));449        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));450        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));451        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));452453        // do approve454        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));455        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);456        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));457        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);458        assert_eq!(459            TemplateModule::approved(1, (1, 1))[0],460            ApprovePermissions {461                approved: 2,462                amount: 100000000463            }464        );465466        assert_ok!(TemplateModule::transfer_from(467            origin2.clone(),468            1,469            3,470            1,471            1,472            1473        ));474        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);475    });476}477478#[test]479fn refungible_approve_and_transfer_from() {480    new_test_ext().execute_with(|| {481        default_limits();482        483        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);484        485        let origin1 = Origin::signed(1);486        let origin2 = Origin::signed(2);487488        let data = default_re_fungible_data();489        create_test_item(collection_id, &data.into());490491        assert_eq!(TemplateModule::balance_count(1, 1), 1000);492        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);493494        assert_ok!(TemplateModule::set_mint_permission(495            origin1.clone(),496            1,497            true498        ));499        assert_ok!(TemplateModule::set_public_access_mode(500            origin1.clone(),501            1,502            AccessMode::WhiteList503        ));504        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));505        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));506        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));507508        // do approve509        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));510        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);511        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));512        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);513        assert_eq!(514            TemplateModule::approved(1, (1, 1))[0],515            ApprovePermissions {516                approved: 2,517                amount: 100000000518            }519        );520521        assert_ok!(TemplateModule::transfer_from(522            origin2.clone(),523            1,524            3,525            1,526            1,527            100528        ));529        assert_eq!(TemplateModule::balance_count(1, 1), 900);530        assert_eq!(TemplateModule::balance_count(1, 3), 100);531        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);532        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);533534        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);535        assert_eq!(536            TemplateModule::approved(1, (1, 1))[0],537            ApprovePermissions {538                approved: 3,539                amount: 100000000540            }541        );542    });543}544545#[test]546fn fungible_approve_and_transfer_from() {547    new_test_ext().execute_with(|| {548        default_limits();549        550        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);551        552        let data = default_fungible_data();553        create_test_item(collection_id, &data.into());554555        let origin1 = Origin::signed(1);556        let origin2 = Origin::signed(2);557558        assert_eq!(TemplateModule::balance_count(1, 1), 1000);559        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);560561        assert_ok!(TemplateModule::set_mint_permission(562            origin1.clone(),563            1,564            true565        ));566        assert_ok!(TemplateModule::set_public_access_mode(567            origin1.clone(),568            1,569            AccessMode::WhiteList570        ));571        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));572        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));573        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));574575        // do approve576        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));577        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);578        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));579        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);580        assert_eq!(581            TemplateModule::approved(1, (1, 1))[0],582            ApprovePermissions {583                approved: 2,584                amount: 100000000585            }586        );587588        assert_ok!(TemplateModule::transfer_from(589            origin2.clone(),590            1,591            3,592            1,593            1,594            100595        ));596        assert_eq!(TemplateModule::balance_count(1, 1), 900);597        assert_eq!(TemplateModule::balance_count(1, 3), 100);598        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);599        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);600601        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);602        assert_eq!(603            TemplateModule::approved(1, (1, 1))[0],604            ApprovePermissions {605                approved: 3,606                amount: 100000000607            }608        );609610        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));611        assert_ok!(TemplateModule::transfer_from(612            origin2.clone(),613            1,614            3,615            1,616            1,617            900618        ));619        assert_eq!(TemplateModule::balance_count(1, 1), 0);620        assert_eq!(TemplateModule::balance_count(1, 3), 1000);621        // assert_eq!(TemplateModule::address_tokens(1, 1), []);622        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);623624        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);625    });626}627628#[test]629fn change_collection_owner() {630    new_test_ext().execute_with(|| {631        default_limits();632        633        let collection_id = create_test_collection(&CollectionMode::NFT, 1);634        635        let origin1 = Origin::signed(1);636        assert_ok!(TemplateModule::change_collection_owner(637            origin1.clone(),638            collection_id,639            2640        ));641        assert_eq!(TemplateModule::collection(collection_id).owner, 2);642    });643}644645#[test]646fn destroy_collection() {647    new_test_ext().execute_with(|| {648        default_limits();649        650        let collection_id = create_test_collection(&CollectionMode::NFT, 1);651        652        let origin1 = Origin::signed(1);653        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));654    });655}656657#[test]658fn burn_nft_item() {659    new_test_ext().execute_with(|| {660        default_limits();661        662        let collection_id = create_test_collection(&CollectionMode::NFT, 1);663664        let origin1 = Origin::signed(1);665        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));666        667        let data = default_nft_data();668        create_test_item(collection_id, &data.into());669670        // check balance (collection with id = 1, user id = 1)671        assert_eq!(TemplateModule::balance_count(1, 1), 1);672673        // burn item674        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));675        assert_noop!(676            TemplateModule::burn_item(origin1.clone(), 1, 1),677            Error::<Test>::TokenNotFound678        );679680        assert_eq!(TemplateModule::balance_count(1, 1), 0);681    });682}683684#[test]685fn burn_fungible_item() {686    new_test_ext().execute_with(|| {687        default_limits();688        689        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);690        691        let origin1 = Origin::signed(1);692        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));693        694        let data = default_fungible_data();695        create_test_item(collection_id, &data.into());696697        // check balance (collection with id = 1, user id = 1)698        assert_eq!(TemplateModule::balance_count(1, 1), 1000);699700        // burn item701        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));702        assert_noop!(703            TemplateModule::burn_item(origin1.clone(), 1, 1),704            Error::<Test>::TokenNotFound705        );706707        assert_eq!(TemplateModule::balance_count(1, 1), 0);708    });709}710711#[test]712fn burn_refungible_item() {713    new_test_ext().execute_with(|| {714        default_limits();715        716        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);717        let origin1 = Origin::signed(1);718719        assert_ok!(TemplateModule::set_mint_permission(720            origin1.clone(),721            collection_id,722            true723        ));724        assert_ok!(TemplateModule::set_public_access_mode(725            origin1.clone(),726            collection_id,727            AccessMode::WhiteList728        ));729        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));730731        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));732        733        let data = default_re_fungible_data();734        create_test_item(collection_id, &data.into());735736        // check balance (collection with id = 1, user id = 2)737        assert_eq!(TemplateModule::balance_count(1, 1), 1000);738739        // burn item740        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));741        assert_noop!(742            TemplateModule::burn_item(origin1.clone(), 1, 1),743            Error::<Test>::TokenNotFound744        );745746        assert_eq!(TemplateModule::balance_count(1, 1), 0);747    });748}749750#[test]751fn add_collection_admin() {752    new_test_ext().execute_with(|| {753        default_limits();754        755        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);756        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);757        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);758        759        let origin1 = Origin::signed(1);760761        // collection admin762        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));763        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));764765        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);766        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);767    });768}769770#[test]771fn remove_collection_admin() {772    new_test_ext().execute_with(|| {773        default_limits();774        775        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);776        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);777        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);778779        let origin1 = Origin::signed(1);780        let origin2 = Origin::signed(2);781782        // collection admin783        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));784        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));785786        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);787        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);788789        // remove admin790        assert_ok!(TemplateModule::remove_collection_admin(791            origin2.clone(),792            1,793            3794        ));795        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);796    });797}798799#[test]800fn balance_of() {801    new_test_ext().execute_with(|| {802        default_limits();803        804        let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);805        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);806        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3), 3);807        808        // check balance before809        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);810        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);811        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);812813        let nft_data = default_nft_data();814        create_test_item(nft_collection_id, &nft_data.into());815        816        let fungible_data = default_fungible_data();817        create_test_item(fungible_collection_id, &fungible_data.into());818        819        let re_fungible_data = default_re_fungible_data();820        create_test_item(re_fungible_collection_id, &re_fungible_data.into());821822        // check balance (collection with id = 1, user id = 1)823        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);824        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);825        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);826        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);827        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);828        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);829    });830}831832#[test]833fn approve() {834    new_test_ext().execute_with(|| {835        default_limits();836        837        let collection_id = create_test_collection(&CollectionMode::NFT, 1);838        839        let data = default_nft_data();840        create_test_item(collection_id, &data.into());841842        let origin1 = Origin::signed(1);843        844        // approve845        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));846        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);847    });848}849850#[test]851fn transfer_from() {852    new_test_ext().execute_with(|| {853        default_limits();854        855        let collection_id = create_test_collection(&CollectionMode::NFT, 1);856        let origin1 = Origin::signed(1);857        let origin2 = Origin::signed(2);858859        let data = default_nft_data();860        create_test_item(collection_id, &data.into());861862        // approve863        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));864        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);865866        assert_ok!(TemplateModule::set_mint_permission(867            origin1.clone(),868            1,869            true870        ));871        assert_ok!(TemplateModule::set_public_access_mode(872            origin1.clone(),873            1,874            AccessMode::WhiteList875        ));876        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));877        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));878        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));879880        assert_ok!(TemplateModule::transfer_from(881            origin2.clone(),882            1,883            2,884            1,885            1,886            1887        ));888889        // after transfer890        assert_eq!(TemplateModule::balance_count(1, 1), 0);891        assert_eq!(TemplateModule::balance_count(1, 2), 1);892    });893}894895// #endregion896897// Coverage tests region898// #region899900#[test]901fn owner_can_add_address_to_white_list() {902    new_test_ext().execute_with(|| {903        default_limits();904        905        let collection_id = create_test_collection(&CollectionMode::NFT, 1);906907        let origin1 = Origin::signed(1);908        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));909        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);910    });911}912913#[test]914fn admin_can_add_address_to_white_list() {915    new_test_ext().execute_with(|| {916        default_limits();917        918        let collection_id = create_test_collection(&CollectionMode::NFT, 1);919        let origin1 = Origin::signed(1);920        let origin2 = Origin::signed(2);921922        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));923        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));924        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);925    });926}927928#[test]929fn nonprivileged_user_cannot_add_address_to_white_list() {930    new_test_ext().execute_with(|| {931        default_limits();932        933        let collection_id = create_test_collection(&CollectionMode::NFT, 1);934935        let origin2 = Origin::signed(2);936        assert_noop!(937            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),938            Error::<Test>::NoPermission939        );940    });941}942943#[test]944fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {945    new_test_ext().execute_with(|| {946        default_limits();947948        let origin1 = Origin::signed(1);949950        assert_noop!(951            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),952            Error::<Test>::CollectionNotFound953        );954    });955}956957#[test]958fn nobody_can_add_address_to_white_list_of_deleted_collection() {959    new_test_ext().execute_with(|| {960        default_limits();961        962        let collection_id = create_test_collection(&CollectionMode::NFT, 1);963964        let origin1 = Origin::signed(1);965        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));966        assert_noop!(967            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),968            Error::<Test>::CollectionNotFound969        );970    });971}972973// If address is already added to white list, nothing happens974#[test]975fn address_is_already_added_to_white_list() {976    new_test_ext().execute_with(|| {977        default_limits();978        979        let collection_id = create_test_collection(&CollectionMode::NFT, 1);980        let origin1 = Origin::signed(1);981        982        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));983        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));984        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);985        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);986    });987}988989#[test]990fn owner_can_remove_address_from_white_list() {991    new_test_ext().execute_with(|| {992        default_limits();993        994        let collection_id = create_test_collection(&CollectionMode::NFT, 1);995996        let origin1 = Origin::signed(1);997        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));998        assert_ok!(TemplateModule::remove_from_white_list(999            origin1.clone(),1000            collection_id,1001            21002        ));1003        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1004    });1005}10061007#[test]1008fn admin_can_remove_address_from_white_list() {1009    new_test_ext().execute_with(|| {1010        default_limits();1011        1012        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1013        let origin1 = Origin::signed(1);1014        let origin2 = Origin::signed(2);10151016        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));10171018        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));1019        assert_ok!(TemplateModule::remove_from_white_list(1020            origin2.clone(),1021            collection_id,1022            31023        ));1024        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1025    });1026}10271028#[test]1029fn nonprivileged_user_cannot_remove_address_from_white_list() {1030    new_test_ext().execute_with(|| {1031        default_limits();1032        1033        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1034        let origin1 = Origin::signed(1);1035        let origin2 = Origin::signed(2);10361037        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1038        assert_noop!(1039            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1040            Error::<Test>::NoPermission1041        );1042        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);1043    });1044}10451046#[test]1047fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1048    new_test_ext().execute_with(|| {1049        default_limits();1050        let origin1 = Origin::signed(1);10511052        assert_noop!(1053            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),1054            Error::<Test>::CollectionNotFound1055        );1056    });1057}10581059#[test]1060fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1061    new_test_ext().execute_with(|| {1062        default_limits();1063        1064        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1065        let origin1 = Origin::signed(1);1066        let origin2 = Origin::signed(2);10671068        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1069        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));1070        assert_noop!(1071            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1072            Error::<Test>::CollectionNotFound1073        );1074        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1075    });1076}10771078// If address is already removed from white list, nothing happens1079#[test]1080fn address_is_already_removed_from_white_list() {1081    new_test_ext().execute_with(|| {1082        default_limits();1083        1084        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1085        let origin1 = Origin::signed(1);10861087        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1088        assert_ok!(TemplateModule::remove_from_white_list(1089            origin1.clone(),1090            collection_id,1091            21092        ));1093        assert_ok!(TemplateModule::remove_from_white_list(1094            origin1.clone(),1095            collection_id,1096            21097        ));1098        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1099    });1100}11011102// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1103#[test]1104fn white_list_test_1() {1105    new_test_ext().execute_with(|| {1106        default_limits();1107        1108        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11091110        let origin1 = Origin::signed(1);1111        1112        let data = default_nft_data();1113        create_test_item(collection_id, &data.into());11141115        assert_ok!(TemplateModule::set_public_access_mode(1116            origin1.clone(),1117            collection_id,1118            AccessMode::WhiteList1119        ));1120        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11211122        assert_noop!(1123            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1124            Error::<Test>::AddresNotInWhiteList1125        );1126    });1127}11281129#[test]1130fn white_list_test_2() {1131    new_test_ext().execute_with(|| {1132        default_limits();1133        1134        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1135        let origin1 = Origin::signed(1);1136        1137        let data = default_nft_data();1138        create_test_item(collection_id, &data.into());11391140        assert_ok!(TemplateModule::set_public_access_mode(1141            origin1.clone(),1142            collection_id,1143            AccessMode::WhiteList1144        ));1145        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1146        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));11471148        // do approve1149        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1150        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);11511152        assert_ok!(TemplateModule::remove_from_white_list(1153            origin1.clone(),1154            1,1155            11156        ));11571158        assert_noop!(1159            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1160            Error::<Test>::AddresNotInWhiteList1161        );1162    });1163}11641165// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1166#[test]1167fn white_list_test_3() {1168    new_test_ext().execute_with(|| {1169        default_limits();1170        1171        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11721173        let origin1 = Origin::signed(1);1174        1175        let data = default_nft_data();1176        create_test_item(collection_id, &data.into());11771178        assert_ok!(TemplateModule::set_public_access_mode(1179            origin1.clone(),1180            collection_id,1181            AccessMode::WhiteList1182        ));1183        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));11841185        assert_noop!(1186            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1187            Error::<Test>::AddresNotInWhiteList1188        );1189    });1190}11911192#[test]1193fn white_list_test_4() {1194    new_test_ext().execute_with(|| {1195        default_limits();1196        1197        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11981199        let origin1 = Origin::signed(1);12001201        let data = default_nft_data();1202        create_test_item(collection_id, &data.into());12031204        assert_ok!(TemplateModule::set_public_access_mode(1205            origin1.clone(),1206            collection_id,1207            AccessMode::WhiteList1208        ));1209        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1210        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12111212        // do approve1213        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1214        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);12151216        assert_ok!(TemplateModule::remove_from_white_list(1217            origin1.clone(),1218            collection_id,1219            21220        ));12211222        assert_noop!(1223            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1224            Error::<Test>::AddresNotInWhiteList1225        );1226    });1227}12281229// 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)1230#[test]1231fn white_list_test_5() {1232    new_test_ext().execute_with(|| {1233        default_limits();1234        1235        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12361237        let origin1 = Origin::signed(1);12381239        let data = default_nft_data();1240        create_test_item(collection_id, &data.into());12411242        assert_ok!(TemplateModule::set_public_access_mode(1243            origin1.clone(),1244            collection_id,1245            AccessMode::WhiteList1246        ));1247        assert_noop!(1248            TemplateModule::burn_item(origin1.clone(), 1, 1),1249            Error::<Test>::AddresNotInWhiteList1250        );1251    });1252}12531254// If Public Access mode is set to WhiteList, oken transfers can’t be Approved by a non-whitelisted address (see Approve method).1255#[test]1256fn white_list_test_6() {1257    new_test_ext().execute_with(|| {1258        default_limits();1259        1260        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12611262        let origin1 = Origin::signed(1);1263        assert_ok!(TemplateModule::set_public_access_mode(1264            origin1.clone(),1265            collection_id,1266            AccessMode::WhiteList1267        ));12681269        // do approve1270        assert_noop!(1271            TemplateModule::approve(origin1.clone(), 1, 1, 1),1272            Error::<Test>::AddresNotInWhiteList1273        );1274    });1275}12761277// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1278//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1279#[test]1280fn white_list_test_7() {1281    new_test_ext().execute_with(|| {1282        default_limits();1283        1284        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12851286        let data = default_nft_data();1287        create_test_item(collection_id, &data.into());1288        1289        let origin1 = Origin::signed(1);12901291        assert_ok!(TemplateModule::set_public_access_mode(1292            origin1.clone(),1293            collection_id,1294            AccessMode::WhiteList1295        ));1296        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1297        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12981299        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1300    });1301}13021303#[test]1304fn white_list_test_8() {1305    new_test_ext().execute_with(|| {1306        default_limits();1307        1308        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13091310        let data = default_nft_data();1311        create_test_item(collection_id, &data.into());1312        1313        let origin1 = Origin::signed(1);13141315        assert_ok!(TemplateModule::set_public_access_mode(1316            origin1.clone(),1317            collection_id,1318            AccessMode::WhiteList1319        ));1320        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1321        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13221323        // do approve1324        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1325        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);13261327        assert_ok!(TemplateModule::transfer_from(1328            origin1.clone(),1329            1,1330            2,1331            1,1332            1,1333            11334        ));1335    });1336}13371338// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1339#[test]1340fn white_list_test_9() {1341    new_test_ext().execute_with(|| {1342        default_limits();1343        1344        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1345        let origin1 = Origin::signed(1);13461347        assert_ok!(TemplateModule::set_public_access_mode(1348            origin1.clone(),1349            collection_id,1350            AccessMode::WhiteList1351        ));1352        assert_ok!(TemplateModule::set_mint_permission(1353            origin1.clone(),1354            collection_id,1355            false1356        ));13571358        let data = default_nft_data();1359        create_test_item(collection_id, &data.into());1360    });1361}13621363// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1364#[test]1365fn white_list_test_10() {1366    new_test_ext().execute_with(|| {1367        default_limits();1368        1369        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13701371        let origin1 = Origin::signed(1);1372        let origin2 = Origin::signed(2);13731374        assert_ok!(TemplateModule::set_public_access_mode(1375            origin1.clone(),1376            collection_id,1377            AccessMode::WhiteList1378        ));1379        assert_ok!(TemplateModule::set_mint_permission(1380            origin1.clone(),1381            collection_id,1382            false1383        ));13841385        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));13861387        assert_ok!(TemplateModule::create_item(1388            origin2.clone(),1389            collection_id,1390            2,1391            default_nft_data().into()1392        ));1393    });1394}13951396// 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.1397#[test]1398fn white_list_test_11() {1399    new_test_ext().execute_with(|| {1400        default_limits();1401        1402        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14031404        let origin1 = Origin::signed(1);1405        let origin2 = Origin::signed(2);14061407        assert_ok!(TemplateModule::set_public_access_mode(1408            origin1.clone(),1409            collection_id,1410            AccessMode::WhiteList1411        ));1412        assert_ok!(TemplateModule::set_mint_permission(1413            origin1.clone(),1414            collection_id,1415            false1416        ));1417        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14181419        assert_noop!(1420            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1421            Error::<Test>::PublicMintingNotAllowed1422        );1423    });1424}14251426// 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.1427#[test]1428fn white_list_test_12() {1429    new_test_ext().execute_with(|| {1430        default_limits();1431        1432        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14331434        let origin1 = Origin::signed(1);1435        let origin2 = Origin::signed(2);14361437        assert_ok!(TemplateModule::set_public_access_mode(1438            origin1.clone(),1439            collection_id,1440            AccessMode::WhiteList1441        ));1442        assert_ok!(TemplateModule::set_mint_permission(1443            origin1.clone(),1444            collection_id,1445            false1446        ));14471448        assert_noop!(1449            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1450            Error::<Test>::PublicMintingNotAllowed1451        );1452    });1453}14541455// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1456#[test]1457fn white_list_test_13() {1458    new_test_ext().execute_with(|| {1459        default_limits();1460        1461        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14621463        let origin1 = Origin::signed(1);14641465        assert_ok!(TemplateModule::set_public_access_mode(1466            origin1.clone(),1467            collection_id,1468            AccessMode::WhiteList1469        ));1470        assert_ok!(TemplateModule::set_mint_permission(1471            origin1.clone(),1472            collection_id,1473            true1474        ));14751476        let data = default_nft_data();1477        create_test_item(collection_id, &data.into());1478    });1479}14801481// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1482#[test]1483fn white_list_test_14() {1484    new_test_ext().execute_with(|| {1485        default_limits();1486        1487        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14881489        let origin1 = Origin::signed(1);1490        let origin2 = Origin::signed(2);14911492        assert_ok!(TemplateModule::set_public_access_mode(1493            origin1.clone(),1494            collection_id,1495            AccessMode::WhiteList1496        ));1497        assert_ok!(TemplateModule::set_mint_permission(1498            origin1.clone(),1499            collection_id,1500            true1501        ));15021503        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));15041505        assert_ok!(TemplateModule::create_item(1506            origin2.clone(),1507            1,1508            2,1509            default_nft_data().into()1510        ));1511    });1512}15131514// 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.1515#[test]1516fn white_list_test_15() {1517    new_test_ext().execute_with(|| {1518        default_limits();1519        1520        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15211522        let origin1 = Origin::signed(1);1523        let origin2 = Origin::signed(2);15241525        assert_ok!(TemplateModule::set_public_access_mode(1526            origin1.clone(),1527            collection_id,1528            AccessMode::WhiteList1529        ));1530        assert_ok!(TemplateModule::set_mint_permission(1531            origin1.clone(),1532            collection_id,1533            true1534        ));15351536        assert_noop!(1537            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1538            Error::<Test>::AddresNotInWhiteList1539        );1540    });1541}15421543// 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.1544#[test]1545fn white_list_test_16() {1546    new_test_ext().execute_with(|| {1547        default_limits();1548        1549        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15501551        let origin1 = Origin::signed(1);1552        let origin2 = Origin::signed(2);15531554        assert_ok!(TemplateModule::set_public_access_mode(1555            origin1.clone(),1556            collection_id,1557            AccessMode::WhiteList1558        ));1559        assert_ok!(TemplateModule::set_mint_permission(1560            origin1.clone(),1561            collection_id,1562            true1563        ));1564        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));15651566        assert_ok!(TemplateModule::create_item(1567            origin2.clone(),1568            1,1569            2,1570            default_nft_data().into()1571        ));1572    });1573}15741575// Total number of collections. Positive test1576#[test]1577fn total_number_collections_bound() {1578    new_test_ext().execute_with(|| {1579        default_limits();1580        1581        create_test_collection(&CollectionMode::NFT, 1);1582    });1583}15841585// Total number of collections. Negotive test1586#[test]1587fn total_number_collections_bound_neg() {1588    new_test_ext().execute_with(|| {1589        default_limits();15901591        let origin1 = Origin::signed(1);15921593        for i in 0..default_collection_numbers_limit() {1594            create_test_collection(&CollectionMode::NFT, i + 1);1595        }15961597        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1598        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1599        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();16001601        // 11-th collection in chain. Expects error1602        assert_noop!(TemplateModule::create_collection(1603            origin1.clone(),1604            col_name1.clone(),1605            col_desc1.clone(),1606            token_prefix1.clone(),1607            CollectionMode::NFT1608        ), Error::<Test>::TotalCollectionsLimitExceeded);1609    });1610}16111612// Owned tokens by a single address. Positive test1613#[test]1614fn owned_tokens_bound() {1615    new_test_ext().execute_with(|| {1616        default_limits();1617        1618        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16191620        let data = default_nft_data();1621        create_test_item(collection_id, &data.clone().into());1622        create_test_item(collection_id, &data.into());1623    });1624}16251626// Owned tokens by a single address. Negotive test1627#[test]1628fn owned_tokens_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: 1,1633            collections_admins_limit: 5,1634            custom_data_limit: 2048,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, 1);16411642        let origin1 = Origin::signed(1);1643        let data = default_nft_data();1644        create_test_item(collection_id, &data.clone().into());16451646        assert_noop!(TemplateModule::create_item(1647            origin1.clone(),1648            1,1649            1,1650            data.into()1651        ),  Error::<Test>::AddressOwnershipLimitExceeded);1652    });1653}16541655// Number of collection admins. Positive test1656#[test]1657fn collection_admins_bound() {1658    new_test_ext().execute_with(|| {1659        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1660            collection_numbers_limit: 10,1661            account_token_ownership_limit: 10,1662            collections_admins_limit: 2,1663            custom_data_limit: 2048,1664            nft_sponsor_transfer_timeout: 15,1665            fungible_sponsor_transfer_timeout: 15,1666            refungible_sponsor_transfer_timeout: 15,          1667        }));1668        1669        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16701671        let origin1 = Origin::signed(1);1672        1673        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1674        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1675    });1676}16771678// Number of collection admins. Negotive test1679#[test]1680fn collection_admins_bound_neg() {1681    new_test_ext().execute_with(|| {1682        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1683            collection_numbers_limit: 10,1684            account_token_ownership_limit: 1,1685            collections_admins_limit: 1,1686            custom_data_limit: 2048,1687            nft_sponsor_transfer_timeout: 15,1688            fungible_sponsor_transfer_timeout: 15,1689            refungible_sponsor_transfer_timeout: 15,          1690        }));1691        1692        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16931694        let origin1 = Origin::signed(1);16951696        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1697        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), Error::<Test>::CollectionAdminsLimitExceeded);1698    });1699}17001701// NFT custom data size. Negative test const_data.1702#[test]1703fn custom_data_size_nft_const_data_bound_neg() {1704    new_test_ext().execute_with(|| {1705        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1706            collection_numbers_limit: 10,1707            account_token_ownership_limit: 10,1708            collections_admins_limit: 5,1709            custom_data_limit: 2,1710            nft_sponsor_transfer_timeout: 15,1711            fungible_sponsor_transfer_timeout: 15,1712            refungible_sponsor_transfer_timeout: 15,          1713        }));1714        1715        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17161717        let origin1 = Origin::signed(1);1718        let too_big_const_data = CreateItemData::NFT(CreateNftData{1719            const_data: vec![1, 2, 3, 4],1720            variable_data: vec![]1721        });17221723        assert_noop!(TemplateModule::create_item(1724            origin1.clone(),1725            collection_id,1726            1,1727            too_big_const_data1728        ), Error::<Test>::TokenConstDataLimitExceeded);1729    });1730}17311732// NFT custom data size. Negative test variable_data.1733#[test]1734fn custom_data_size_nft_variable_data_bound_neg() {1735    new_test_ext().execute_with(|| {1736        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1737            collection_numbers_limit: 10,1738            account_token_ownership_limit: 10,1739            collections_admins_limit: 5,1740            custom_data_limit: 2,1741            nft_sponsor_transfer_timeout: 15,1742            fungible_sponsor_transfer_timeout: 15,1743            refungible_sponsor_transfer_timeout: 15,          1744        }));17451746        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17471748        let origin1 = Origin::signed(1);1749        let too_big_const_data = CreateItemData::NFT(CreateNftData{1750            const_data: vec![],1751            variable_data: vec![1, 2, 3, 4]1752        });17531754        assert_noop!(TemplateModule::create_item(1755            origin1.clone(),1756            collection_id,1757            1,1758            too_big_const_data1759        ), Error::<Test>::TokenVariableDataLimitExceeded);1760    });1761}17621763// Re fungible custom data size. Negative test const_data.1764#[test]1765fn custom_data_size_re_fungible_const_data_bound_neg() {1766    new_test_ext().execute_with(|| {1767        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1768            collection_numbers_limit: 10,1769            account_token_ownership_limit: 10,1770            collections_admins_limit: 5,1771            custom_data_limit: 2,1772            nft_sponsor_transfer_timeout: 15,1773            fungible_sponsor_transfer_timeout: 15,1774            refungible_sponsor_transfer_timeout: 15,          1775        }));17761777        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17781779        let origin1 = Origin::signed(1);1780        let too_big_const_data = CreateItemData::NFT(CreateNftData{1781            const_data: vec![1, 2, 3, 4],1782            variable_data: vec![]1783        });17841785        assert_noop!(TemplateModule::create_item(1786            origin1.clone(),1787            collection_id,1788            1,1789            too_big_const_data1790        ), Error::<Test>::TokenConstDataLimitExceeded);1791    });1792}17931794// Re fungible custom data size. Negative test variable_data.1795#[test]1796fn custom_data_size_re_fungible_variable_data_bound_neg() {1797    new_test_ext().execute_with(|| {1798        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1799            collection_numbers_limit: 10,1800            account_token_ownership_limit: 10,1801            collections_admins_limit: 5,1802            custom_data_limit: 2,1803            nft_sponsor_transfer_timeout: 15,1804            fungible_sponsor_transfer_timeout: 15,1805            refungible_sponsor_transfer_timeout: 15,          1806        }));18071808        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18091810        let origin1 = Origin::signed(1);1811        let too_big_const_data = CreateItemData::NFT(CreateNftData{1812            const_data: vec![],1813            variable_data: vec![1, 2, 3, 4]1814        });18151816        assert_noop!(TemplateModule::create_item(1817            origin1.clone(),1818            collection_id,1819            1,1820            too_big_const_data1821        ), Error::<Test>::TokenVariableDataLimitExceeded);1822    });1823}1824// #endregion18251826#[test]1827fn set_const_on_chain_schema() {1828    new_test_ext().execute_with(|| {1829        default_limits();18301831        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18321833        let origin1 = Origin::signed(1);1834        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, b"test const on chain schema".to_vec()));18351836        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"test const on chain schema".to_vec());1837        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"".to_vec());1838    });1839}18401841#[test]1842fn set_variable_on_chain_schema() {1843    new_test_ext().execute_with(|| {1844        default_limits();1845        1846        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18471848        let origin1 = Origin::signed(1);1849        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, b"test variable on chain schema".to_vec()));18501851        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"".to_vec());1852        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"test variable on chain schema".to_vec());1853    });1854}18551856#[test]1857fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1858    new_test_ext().execute_with(|| {1859        default_limits();18601861        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18621863        let origin1 = Origin::signed(1);1864        1865        let data = default_nft_data();1866        create_test_item(1, &data.into());1867        1868        let variable_data = b"test set_variable_meta_data method.".to_vec();1869        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));18701871        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, variable_data);1872    });1873}18741875#[test]1876fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1877    new_test_ext().execute_with(|| {1878        default_limits();18791880        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);18811882        let origin1 = Origin::signed(1);18831884        let data = default_re_fungible_data();1885        create_test_item(1, &data.into());18861887        let variable_data = b"test set_variable_meta_data method.".to_vec();1888        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));18891890        assert_eq!(TemplateModule::refungible_item_id(collection_id, 1).variable_data, variable_data);1891    });1892}189318941895#[test]1896fn set_variable_meta_data_on_fungible_token_fails() {1897    new_test_ext().execute_with(|| {1898        default_limits();18991900        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);19011902        let origin1 = Origin::signed(1);19031904        let data = default_fungible_data();1905        create_test_item(1, &data.into());19061907        let variable_data = b"test set_variable_meta_data method.".to_vec();1908        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()), Error::<Test>::CantStoreMetadataInFungibleTokens);1909    });1910}19111912#[test]1913fn set_variable_meta_data_on_nft_token_fails_for_big_data() {1914    new_test_ext().execute_with(|| {1915        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1916            collection_numbers_limit: default_collection_numbers_limit(),1917            account_token_ownership_limit: 10,1918            collections_admins_limit: 5,1919            custom_data_limit: 10,1920            nft_sponsor_transfer_timeout: 15,1921            fungible_sponsor_transfer_timeout: 15,1922            refungible_sponsor_transfer_timeout: 15,          1923        }));19241925        let collection_id = create_test_collection(&CollectionMode::NFT, 1);19261927        let origin1 = Origin::signed(1);19281929        let data = default_nft_data();1930        create_test_item(1, &data.into());19311932        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1933        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);1934    });1935}19361937#[test]1938fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {1939    new_test_ext().execute_with(|| {1940        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1941            collection_numbers_limit: default_collection_numbers_limit(),1942            account_token_ownership_limit: 10,1943            collections_admins_limit: 5,1944            custom_data_limit: 10,1945            nft_sponsor_transfer_timeout: 15,1946            fungible_sponsor_transfer_timeout: 15,1947            refungible_sponsor_transfer_timeout: 15,          1948        }));194919501951        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);19521953        let origin1 = Origin::signed(1);19541955        let data = default_re_fungible_data();1956        create_test_item(1, &data.into());19571958        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1959        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);1960    });1961}