git.delta.rocks / unique-network / refs/commits / 61a5f4d037b9

1// Tests to be written here2use crate::mock::*;3use crate::{AccessMode, ApprovePermissions, CollectionMode, Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData};4use frame_support::{assert_noop, assert_ok};5use frame_system::{ RawOrigin };67fn default_collection_numbers_limit() -> u64 {8    109}1011fn default_limits() {12    assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 13            collection_numbers_limit: default_collection_numbers_limit(),14            account_token_ownership_limit: 10,15            collections_admins_limit: 5,16            custom_data_limit: 2048,17            nft_sponsor_transfer_timeout: 15,18            fungible_sponsor_transfer_timeout: 15,19            refungible_sponsor_transfer_timeout: 15,          20        }));21}2223fn default_nft_data() -> CreateNftData {24    CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }25}2627fn default_fungible_data () -> CreateFungibleData {28    CreateFungibleData { }29}3031fn default_re_fungible_data () -> CreateReFungibleData {32    CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }33}3435fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64, id: u64) -> u64 {36    let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();37    let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();38    let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();3940    let origin1 = Origin::signed(owner);41    assert_ok!(TemplateModule::create_collection(42            origin1.clone(),43            col_name1.clone(),44            col_desc1.clone(),45            token_prefix1.clone(),46            mode.clone()47        ));4849    let saved_col_name: Vec<u16> = "Test1\0\0".encode_utf16().collect::<Vec<u16>>();50    let saved_description: Vec<u16> = "TestDescription1\0\0".encode_utf16().collect::<Vec<u16>>();51    let saved_prefix: Vec<u8> = b"token_prefix1\0\0".to_vec();52    assert_eq!(TemplateModule::collection(id).owner, owner);53    assert_eq!(TemplateModule::collection(id).name, saved_col_name);54    assert_eq!(TemplateModule::collection(id).mode, *mode);55    assert_eq!(TemplateModule::collection(id).description, saved_description);56    assert_eq!(TemplateModule::collection(id).token_prefix, saved_prefix);57    id58}5960fn create_test_collection(mode: &CollectionMode, id: u64) -> u64 {61    create_test_collection_for_owner(&mode, 1, id)62}6364fn create_test_item(collection_id: u64, data: &CreateItemData) {65    let origin1 = Origin::signed(1);66    assert_ok!(TemplateModule::create_item(67            origin1.clone(),68            collection_id,69            1,70            data.clone()71        ));7273}7475// Use cases tests region76// #region77#[test]78fn create_nft_item() {79    new_test_ext().execute_with(|| {80        default_limits();81        let collection_id = create_test_collection(&CollectionMode::NFT, 1);82        83        let data = default_nft_data();84        create_test_item(collection_id, &data.clone().into());85        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);86        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);87    });88}8990// Use cases tests region91// #region92#[test]93fn create_nft_multiple_items() {94    new_test_ext().execute_with(|| {95        default_limits();96        97        create_test_collection(&CollectionMode::NFT, 1);9899        let origin1 = Origin::signed(1);100101        let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];102103        assert_ok!(TemplateModule::create_multiple_items(104            origin1.clone(),105            1,106            1,107            items_data.clone().into_iter().map(|d| { d.into() }).collect()108        ));109        for (index, data) in items_data.iter().enumerate() {110            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as u64).const_data.to_vec(), data.const_data);111            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as u64).variable_data.to_vec(), data.variable_data);112        }113    });114}115116#[test]117fn create_refungible_item() {118    new_test_ext().execute_with(|| {119        default_limits();120        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);121122        let data = default_re_fungible_data();123        create_test_item(collection_id, &data.clone().into());124        assert_eq!(125            TemplateModule::refungible_item_id(collection_id, 1).const_data,126            data.const_data127        );128        assert_eq!(129            TemplateModule::refungible_item_id(collection_id, 1).variable_data,130            data.variable_data131        );132        assert_eq!(133            TemplateModule::refungible_item_id(collection_id, 1).owner[0],134            Ownership {135                owner: 1,136                fraction: 1000137            }138        );139    });140}141142#[test]143fn create_multiple_refungible_items() {144    new_test_ext().execute_with(|| {145        default_limits();146        147        create_test_collection(&CollectionMode::ReFungible(3), 1);148149        let origin1 = Origin::signed(1);150151        let items_data = vec![default_re_fungible_data(), default_re_fungible_data(), default_re_fungible_data()];152153        assert_ok!(TemplateModule::create_multiple_items(154            origin1.clone(),155            1,156            1,157            items_data.clone().into_iter().map(|d| { d.into() }).collect()158        ));159        for (index, data) in items_data.iter().enumerate() {160161            let item = TemplateModule::refungible_item_id(1, (index + 1) as u64);162            assert_eq!(item.const_data.to_vec(), data.const_data);163            assert_eq!(item.variable_data.to_vec(), data.variable_data);164            assert_eq!(165                item.owner[0],166                Ownership {167                    owner: 1,168                    fraction: 1000169                }170            );171        }172    });173}174175#[test]176fn create_fungible_item() {177    new_test_ext().execute_with(|| {178        default_limits();179        180        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);181182        let data = default_fungible_data();183        create_test_item(collection_id, &data.into());184185        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);186    });187}188189#[test]190fn create_multiple_fungible_items() {191    new_test_ext().execute_with(|| {192        default_limits();193194        create_test_collection(&CollectionMode::Fungible(3), 1);195196        let origin1 = Origin::signed(1);197198        let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];199200        assert_ok!(TemplateModule::create_multiple_items(201            origin1.clone(),202            1,203            1,204            items_data.clone().into_iter().map(|d| { d.into() }).collect()205        ));206        207        for (index, _) in items_data.iter().enumerate() {208            assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as u64).owner, 1);209        }210        assert_eq!(TemplateModule::balance_count(1, 1), 3000);211        assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);212    });213}214215#[test]216fn transfer_fungible_item() {217    new_test_ext().execute_with(|| {218        default_limits();219        220        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);221222        let origin1 = Origin::signed(1);223        let origin2 = Origin::signed(2);224225        let data = default_fungible_data();226        create_test_item(collection_id, &data.into());227228        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);229        assert_eq!(TemplateModule::balance_count(1, 1), 1000);230        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);231232        // change owner scenario233        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));234        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);235        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);236        assert_eq!(TemplateModule::balance_count(1, 1), 0);237        assert_eq!(TemplateModule::balance_count(1, 2), 1000);238        // assert_eq!(TemplateModule::address_tokens(1, 1), []);239        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);240241        // split item scenario242        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));243        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);244        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);245        assert_eq!(TemplateModule::balance_count(1, 2), 500);246        assert_eq!(TemplateModule::balance_count(1, 3), 500);247        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);248        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);249250        // split item and new owner has account scenario251        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));252        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);253        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);254        assert_eq!(TemplateModule::balance_count(1, 2), 300);255        assert_eq!(TemplateModule::balance_count(1, 3), 700);256        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);257        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);258    });259}260261#[test]262fn transfer_refungible_item() {263    new_test_ext().execute_with(|| {264        default_limits();265        266        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);267268        let data = default_re_fungible_data();269        create_test_item(collection_id, &data.clone().into());270271        let origin1 = Origin::signed(1);272        let origin2 = Origin::signed(2);273        assert_eq!(274            TemplateModule::refungible_item_id(collection_id, 1).const_data,275            data.const_data276        );277        assert_eq!(278            TemplateModule::refungible_item_id(collection_id, 1).variable_data,279            data.variable_data280        );281        assert_eq!(282            TemplateModule::refungible_item_id(collection_id, 1).owner[0],283            Ownership {284                owner: 1,285                fraction: 1000286            }287        );288        assert_eq!(TemplateModule::balance_count(1, 1), 1000);289        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);290291        // change owner scenario292        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));293        assert_eq!(294            TemplateModule::refungible_item_id(1, 1).owner[0],295            Ownership {296                owner: 2,297                fraction: 1000298            }299        );300        assert_eq!(TemplateModule::balance_count(1, 1), 0);301        assert_eq!(TemplateModule::balance_count(1, 2), 1000);302        // assert_eq!(TemplateModule::address_tokens(1, 1), []);303        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);304305        // split item scenario306        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));307        assert_eq!(308            TemplateModule::refungible_item_id(1, 1).owner[0],309            Ownership {310                owner: 2,311                fraction: 500312            }313        );314        assert_eq!(315            TemplateModule::refungible_item_id(1, 1).owner[1],316            Ownership {317                owner: 3,318                fraction: 500319            }320        );321        assert_eq!(TemplateModule::balance_count(1, 2), 500);322        assert_eq!(TemplateModule::balance_count(1, 3), 500);323        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);324        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);325326        // split item and new owner has account scenario327        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));328        assert_eq!(329            TemplateModule::refungible_item_id(1, 1).owner[0],330            Ownership {331                owner: 2,332                fraction: 300333            }334        );335        assert_eq!(336            TemplateModule::refungible_item_id(1, 1).owner[1],337            Ownership {338                owner: 3,339                fraction: 700340            }341        );342        assert_eq!(TemplateModule::balance_count(1, 2), 300);343        assert_eq!(TemplateModule::balance_count(1, 3), 700);344        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);345        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);346    });347}348349#[test]350fn transfer_nft_item() {351    new_test_ext().execute_with(|| {352        default_limits();353        354        let collection_id = create_test_collection(&CollectionMode::NFT, 1);355356        let data = default_nft_data();357        create_test_item(collection_id, &data.into());358        assert_eq!(TemplateModule::balance_count(1, 1), 1);359        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);360361        let origin1 = Origin::signed(1);362        // default scenario363        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));364        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);365        assert_eq!(TemplateModule::balance_count(1, 1), 0);366        assert_eq!(TemplateModule::balance_count(1, 2), 1);367        // assert_eq!(TemplateModule::address_tokens(1, 1), []);368        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);369    });370}371372#[test]373fn nft_approve_and_transfer_from() {374    new_test_ext().execute_with(|| {375        default_limits();376        377        let collection_id = create_test_collection(&CollectionMode::NFT, 1);378379        let data = default_nft_data();380        create_test_item(collection_id, &data.into());381382        let origin1 = Origin::signed(1);383        let origin2 = Origin::signed(2);384385        assert_eq!(TemplateModule::balance_count(1, 1), 1);386        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);387388        // neg transfer389        assert_noop!(TemplateModule::transfer_from(390            origin2.clone(),391            1,392            2,393            1,394            1,395            1), "Only item owner, collection owner and admins can modify items");396397        // do approve398        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));399        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);400        assert_eq!(401            TemplateModule::approved(1, (1, 1))[0],402            ApprovePermissions {403                approved: 2,404                amount: 100000000405            }406        );407408        assert_ok!(TemplateModule::transfer_from(409            origin2.clone(),410            1,411            2,412            1,413            1,414            1415        ));416        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);417    });418}419420#[test]421fn nft_approve_and_transfer_from_white_list() {422    new_test_ext().execute_with(|| {423        default_limits();424        425        let collection_id = create_test_collection(&CollectionMode::NFT, 1);426427        let origin1 = Origin::signed(1);428        let origin2 = Origin::signed(2);429430        let data = default_nft_data();431        create_test_item(collection_id, &data.clone().into());432433        assert_eq!(TemplateModule::nft_item_id(1, 1).const_data, data.const_data);434        assert_eq!(TemplateModule::balance_count(1, 1), 1);435        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);436437        assert_ok!(TemplateModule::set_mint_permission(438            origin1.clone(),439            1,440            true441        ));442        assert_ok!(TemplateModule::set_public_access_mode(443            origin1.clone(),444            1,445            AccessMode::WhiteList446        ));447        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));448        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));449        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));450451        // do approve452        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));453        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);454        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));455        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);456        assert_eq!(457            TemplateModule::approved(1, (1, 1))[0],458            ApprovePermissions {459                approved: 2,460                amount: 100000000461            }462        );463464        assert_ok!(TemplateModule::transfer_from(465            origin2.clone(),466            1,467            3,468            1,469            1,470            1471        ));472        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);473    });474}475476#[test]477fn refungible_approve_and_transfer_from() {478    new_test_ext().execute_with(|| {479        default_limits();480        481        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);482        483        let origin1 = Origin::signed(1);484        let origin2 = Origin::signed(2);485486        let data = default_re_fungible_data();487        create_test_item(collection_id, &data.into());488489        assert_eq!(TemplateModule::balance_count(1, 1), 1000);490        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);491492        assert_ok!(TemplateModule::set_mint_permission(493            origin1.clone(),494            1,495            true496        ));497        assert_ok!(TemplateModule::set_public_access_mode(498            origin1.clone(),499            1,500            AccessMode::WhiteList501        ));502        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));503        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));504        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));505506        // do approve507        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));508        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);509        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));510        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);511        assert_eq!(512            TemplateModule::approved(1, (1, 1))[0],513            ApprovePermissions {514                approved: 2,515                amount: 100000000516            }517        );518519        assert_ok!(TemplateModule::transfer_from(520            origin2.clone(),521            1,522            3,523            1,524            1,525            100526        ));527        assert_eq!(TemplateModule::balance_count(1, 1), 900);528        assert_eq!(TemplateModule::balance_count(1, 3), 100);529        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);530        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);531532        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);533        assert_eq!(534            TemplateModule::approved(1, (1, 1))[0],535            ApprovePermissions {536                approved: 3,537                amount: 100000000538            }539        );540    });541}542543#[test]544fn fungible_approve_and_transfer_from() {545    new_test_ext().execute_with(|| {546        default_limits();547        548        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);549        550        let data = default_fungible_data();551        create_test_item(collection_id, &data.into());552553        let origin1 = Origin::signed(1);554        let origin2 = Origin::signed(2);555556        assert_eq!(TemplateModule::balance_count(1, 1), 1000);557        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);558559        assert_ok!(TemplateModule::set_mint_permission(560            origin1.clone(),561            1,562            true563        ));564        assert_ok!(TemplateModule::set_public_access_mode(565            origin1.clone(),566            1,567            AccessMode::WhiteList568        ));569        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));570        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));571        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));572573        // do approve574        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));575        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);576        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));577        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);578        assert_eq!(579            TemplateModule::approved(1, (1, 1))[0],580            ApprovePermissions {581                approved: 2,582                amount: 100000000583            }584        );585586        assert_ok!(TemplateModule::transfer_from(587            origin2.clone(),588            1,589            3,590            1,591            1,592            100593        ));594        assert_eq!(TemplateModule::balance_count(1, 1), 900);595        assert_eq!(TemplateModule::balance_count(1, 3), 100);596        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);597        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);598599        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);600        assert_eq!(601            TemplateModule::approved(1, (1, 1))[0],602            ApprovePermissions {603                approved: 3,604                amount: 100000000605            }606        );607608        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));609        assert_ok!(TemplateModule::transfer_from(610            origin2.clone(),611            1,612            3,613            1,614            1,615            900616        ));617        assert_eq!(TemplateModule::balance_count(1, 1), 0);618        assert_eq!(TemplateModule::balance_count(1, 3), 1000);619        // assert_eq!(TemplateModule::address_tokens(1, 1), []);620        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);621622        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);623    });624}625626#[test]627fn change_collection_owner() {628    new_test_ext().execute_with(|| {629        default_limits();630        631        let collection_id = create_test_collection(&CollectionMode::NFT, 1);632        633        let origin1 = Origin::signed(1);634        assert_ok!(TemplateModule::change_collection_owner(635            origin1.clone(),636            collection_id,637            2638        ));639        assert_eq!(TemplateModule::collection(collection_id).owner, 2);640    });641}642643#[test]644fn destroy_collection() {645    new_test_ext().execute_with(|| {646        default_limits();647        648        let collection_id = create_test_collection(&CollectionMode::NFT, 1);649        650        let origin1 = Origin::signed(1);651        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));652    });653}654655#[test]656fn burn_nft_item() {657    new_test_ext().execute_with(|| {658        default_limits();659        660        let collection_id = create_test_collection(&CollectionMode::NFT, 1);661662        let origin1 = Origin::signed(1);663        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));664        665        let data = default_nft_data();666        create_test_item(collection_id, &data.into());667668        // check balance (collection with id = 1, user id = 1)669        assert_eq!(TemplateModule::balance_count(1, 1), 1);670671        // burn item672        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));673        assert_noop!(674            TemplateModule::burn_item(origin1.clone(), 1, 1),675            "Item does not exists"676        );677678        assert_eq!(TemplateModule::balance_count(1, 1), 0);679    });680}681682#[test]683fn burn_fungible_item() {684    new_test_ext().execute_with(|| {685        default_limits();686        687        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);688        689        let origin1 = Origin::signed(1);690        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));691        692        let data = default_fungible_data();693        create_test_item(collection_id, &data.into());694695        // check balance (collection with id = 1, user id = 1)696        assert_eq!(TemplateModule::balance_count(1, 1), 1000);697698        // burn item699        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));700        assert_noop!(701            TemplateModule::burn_item(origin1.clone(), 1, 1),702            "Item does not exists"703        );704705        assert_eq!(TemplateModule::balance_count(1, 1), 0);706    });707}708709#[test]710fn burn_refungible_item() {711    new_test_ext().execute_with(|| {712        default_limits();713        714        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);715        let origin1 = Origin::signed(1);716717        assert_ok!(TemplateModule::set_mint_permission(718            origin1.clone(),719            collection_id,720            true721        ));722        assert_ok!(TemplateModule::set_public_access_mode(723            origin1.clone(),724            collection_id,725            AccessMode::WhiteList726        ));727        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));728729        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));730        731        let data = default_re_fungible_data();732        create_test_item(collection_id, &data.into());733734        // check balance (collection with id = 1, user id = 2)735        assert_eq!(TemplateModule::balance_count(1, 1), 1000);736737        // burn item738        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));739        assert_noop!(740            TemplateModule::burn_item(origin1.clone(), 1, 1),741            "Item does not exists"742        );743744        assert_eq!(TemplateModule::balance_count(1, 1), 0);745    });746}747748#[test]749fn add_collection_admin() {750    new_test_ext().execute_with(|| {751        default_limits();752        753        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);754        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);755        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);756        757        let origin1 = Origin::signed(1);758759        // collection admin760        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));761        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));762763        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);764        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);765    });766}767768#[test]769fn remove_collection_admin() {770    new_test_ext().execute_with(|| {771        default_limits();772        773        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);774        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);775        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);776777        let origin1 = Origin::signed(1);778        let origin2 = Origin::signed(2);779780        // collection admin781        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));782        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));783784        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);785        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);786787        // remove admin788        assert_ok!(TemplateModule::remove_collection_admin(789            origin2.clone(),790            1,791            3792        ));793        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);794    });795}796797#[test]798fn balance_of() {799    new_test_ext().execute_with(|| {800        default_limits();801        802        let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);803        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);804        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3), 3);805        806        // check balance before807        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);808        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);809        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);810811        let nft_data = default_nft_data();812        create_test_item(nft_collection_id, &nft_data.into());813        814        let fungible_data = default_fungible_data();815        create_test_item(fungible_collection_id, &fungible_data.into());816        817        let re_fungible_data = default_re_fungible_data();818        create_test_item(re_fungible_collection_id, &re_fungible_data.into());819820        // check balance (collection with id = 1, user id = 1)821        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);822        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);823        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);824        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);825        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);826        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);827    });828}829830#[test]831fn approve() {832    new_test_ext().execute_with(|| {833        default_limits();834        835        let collection_id = create_test_collection(&CollectionMode::NFT, 1);836        837        let data = default_nft_data();838        create_test_item(collection_id, &data.into());839840        let origin1 = Origin::signed(1);841        842        // approve843        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));844        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);845    });846}847848#[test]849fn transfer_from() {850    new_test_ext().execute_with(|| {851        default_limits();852        853        let collection_id = create_test_collection(&CollectionMode::NFT, 1);854        let origin1 = Origin::signed(1);855        let origin2 = Origin::signed(2);856857        let data = default_nft_data();858        create_test_item(collection_id, &data.into());859860        // approve861        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));862        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);863864        assert_ok!(TemplateModule::set_mint_permission(865            origin1.clone(),866            1,867            true868        ));869        assert_ok!(TemplateModule::set_public_access_mode(870            origin1.clone(),871            1,872            AccessMode::WhiteList873        ));874        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));875        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));876        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));877878        assert_ok!(TemplateModule::transfer_from(879            origin2.clone(),880            1,881            2,882            1,883            1,884            1885        ));886887        // after transfer888        assert_eq!(TemplateModule::balance_count(1, 1), 0);889        assert_eq!(TemplateModule::balance_count(1, 2), 1);890    });891}892893// #endregion894895// Coverage tests region896// #region897898#[test]899fn owner_can_add_address_to_white_list() {900    new_test_ext().execute_with(|| {901        default_limits();902        903        let collection_id = create_test_collection(&CollectionMode::NFT, 1);904905        let origin1 = Origin::signed(1);906        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));907        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);908    });909}910911#[test]912fn admin_can_add_address_to_white_list() {913    new_test_ext().execute_with(|| {914        default_limits();915        916        let collection_id = create_test_collection(&CollectionMode::NFT, 1);917        let origin1 = Origin::signed(1);918        let origin2 = Origin::signed(2);919920        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));921        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));922        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);923    });924}925926#[test]927fn nonprivileged_user_cannot_add_address_to_white_list() {928    new_test_ext().execute_with(|| {929        default_limits();930        931        let collection_id = create_test_collection(&CollectionMode::NFT, 1);932933        let origin2 = Origin::signed(2);934        assert_noop!(935            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),936            "You do not have permissions to modify this collection"937        );938    });939}940941#[test]942fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {943    new_test_ext().execute_with(|| {944        default_limits();945946        let origin1 = Origin::signed(1);947948        assert_noop!(949            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),950            "This collection does not exist"951        );952    });953}954955#[test]956fn nobody_can_add_address_to_white_list_of_deleted_collection() {957    new_test_ext().execute_with(|| {958        default_limits();959        960        let collection_id = create_test_collection(&CollectionMode::NFT, 1);961962        let origin1 = Origin::signed(1);963        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));964        assert_noop!(965            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),966            "This collection does not exist"967        );968    });969}970971// If address is already added to white list, nothing happens972#[test]973fn address_is_already_added_to_white_list() {974    new_test_ext().execute_with(|| {975        default_limits();976        977        let collection_id = create_test_collection(&CollectionMode::NFT, 1);978        let origin1 = Origin::signed(1);979        980        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));981        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));982        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);983        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);984    });985}986987#[test]988fn owner_can_remove_address_from_white_list() {989    new_test_ext().execute_with(|| {990        default_limits();991        992        let collection_id = create_test_collection(&CollectionMode::NFT, 1);993994        let origin1 = Origin::signed(1);995        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));996        assert_ok!(TemplateModule::remove_from_white_list(997            origin1.clone(),998            collection_id,999            21000        ));1001        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1002    });1003}10041005#[test]1006fn admin_can_remove_address_from_white_list() {1007    new_test_ext().execute_with(|| {1008        default_limits();1009        1010        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1011        let origin1 = Origin::signed(1);1012        let origin2 = Origin::signed(2);10131014        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));10151016        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));1017        assert_ok!(TemplateModule::remove_from_white_list(1018            origin2.clone(),1019            collection_id,1020            31021        ));1022        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1023    });1024}10251026#[test]1027fn nonprivileged_user_cannot_remove_address_from_white_list() {1028    new_test_ext().execute_with(|| {1029        default_limits();1030        1031        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1032        let origin1 = Origin::signed(1);1033        let origin2 = Origin::signed(2);10341035        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1036        assert_noop!(1037            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1038            "You do not have permissions to modify this collection"1039        );1040        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);1041    });1042}10431044#[test]1045fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1046    new_test_ext().execute_with(|| {1047        default_limits();1048        let origin1 = Origin::signed(1);10491050        assert_noop!(1051            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),1052            "This collection does not exist"1053        );1054    });1055}10561057#[test]1058fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1059    new_test_ext().execute_with(|| {1060        default_limits();1061        1062        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1063        let origin1 = Origin::signed(1);1064        let origin2 = Origin::signed(2);10651066        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1067        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));1068        assert_noop!(1069            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1070            "This collection does not exist"1071        );1072        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1073    });1074}10751076// If address is already removed from white list, nothing happens1077#[test]1078fn address_is_already_removed_from_white_list() {1079    new_test_ext().execute_with(|| {1080        default_limits();1081        1082        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1083        let origin1 = Origin::signed(1);10841085        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1086        assert_ok!(TemplateModule::remove_from_white_list(1087            origin1.clone(),1088            collection_id,1089            21090        ));1091        assert_ok!(TemplateModule::remove_from_white_list(1092            origin1.clone(),1093            collection_id,1094            21095        ));1096        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1097    });1098}10991100// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1101#[test]1102fn white_list_test_1() {1103    new_test_ext().execute_with(|| {1104        default_limits();1105        1106        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11071108        let origin1 = Origin::signed(1);1109        1110        let data = default_nft_data();1111        create_test_item(collection_id, &data.into());11121113        assert_ok!(TemplateModule::set_public_access_mode(1114            origin1.clone(),1115            collection_id,1116            AccessMode::WhiteList1117        ));1118        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11191120        assert_noop!(1121            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1122            "Address is not in white list"1123        );1124    });1125}11261127#[test]1128fn white_list_test_2() {1129    new_test_ext().execute_with(|| {1130        default_limits();1131        1132        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1133        let origin1 = Origin::signed(1);1134        1135        let data = default_nft_data();1136        create_test_item(collection_id, &data.into());11371138        assert_ok!(TemplateModule::set_public_access_mode(1139            origin1.clone(),1140            collection_id,1141            AccessMode::WhiteList1142        ));1143        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1144        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));11451146        // do approve1147        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1148        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);11491150        assert_ok!(TemplateModule::remove_from_white_list(1151            origin1.clone(),1152            1,1153            11154        ));11551156        assert_noop!(1157            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1158            "Address is not in white list"1159        );1160    });1161}11621163// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1164#[test]1165fn white_list_test_3() {1166    new_test_ext().execute_with(|| {1167        default_limits();1168        1169        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11701171        let origin1 = Origin::signed(1);1172        1173        let data = default_nft_data();1174        create_test_item(collection_id, &data.into());11751176        assert_ok!(TemplateModule::set_public_access_mode(1177            origin1.clone(),1178            collection_id,1179            AccessMode::WhiteList1180        ));1181        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));11821183        assert_noop!(1184            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1185            "Address is not in white list"1186        );1187    });1188}11891190#[test]1191fn white_list_test_4() {1192    new_test_ext().execute_with(|| {1193        default_limits();1194        1195        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11961197        let origin1 = Origin::signed(1);11981199        let data = default_nft_data();1200        create_test_item(collection_id, &data.into());12011202        assert_ok!(TemplateModule::set_public_access_mode(1203            origin1.clone(),1204            collection_id,1205            AccessMode::WhiteList1206        ));1207        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1208        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12091210        // do approve1211        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1212        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);12131214        assert_ok!(TemplateModule::remove_from_white_list(1215            origin1.clone(),1216            collection_id,1217            21218        ));12191220        assert_noop!(1221            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1222            "Address is not in white list"1223        );1224    });1225}12261227// 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)1228#[test]1229fn white_list_test_5() {1230    new_test_ext().execute_with(|| {1231        default_limits();1232        1233        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12341235        let origin1 = Origin::signed(1);12361237        let data = default_nft_data();1238        create_test_item(collection_id, &data.into());12391240        assert_ok!(TemplateModule::set_public_access_mode(1241            origin1.clone(),1242            collection_id,1243            AccessMode::WhiteList1244        ));1245        assert_noop!(1246            TemplateModule::burn_item(origin1.clone(), 1, 1),1247            "Address is not in white list"1248        );1249    });1250}12511252// If Public Access mode is set to WhiteList, oken transfers can’t be Approved by a non-whitelisted address (see Approve method).1253#[test]1254fn white_list_test_6() {1255    new_test_ext().execute_with(|| {1256        default_limits();1257        1258        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12591260        let origin1 = Origin::signed(1);1261        assert_ok!(TemplateModule::set_public_access_mode(1262            origin1.clone(),1263            collection_id,1264            AccessMode::WhiteList1265        ));12661267        // do approve1268        assert_noop!(1269            TemplateModule::approve(origin1.clone(), 1, 1, 1),1270            "Address is not in white list"1271        );1272    });1273}12741275// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1276//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1277#[test]1278fn white_list_test_7() {1279    new_test_ext().execute_with(|| {1280        default_limits();1281        1282        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12831284        let data = default_nft_data();1285        create_test_item(collection_id, &data.into());1286        1287        let origin1 = Origin::signed(1);12881289        assert_ok!(TemplateModule::set_public_access_mode(1290            origin1.clone(),1291            collection_id,1292            AccessMode::WhiteList1293        ));1294        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1295        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12961297        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1298    });1299}13001301#[test]1302fn white_list_test_8() {1303    new_test_ext().execute_with(|| {1304        default_limits();1305        1306        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13071308        let data = default_nft_data();1309        create_test_item(collection_id, &data.into());1310        1311        let origin1 = Origin::signed(1);13121313        assert_ok!(TemplateModule::set_public_access_mode(1314            origin1.clone(),1315            collection_id,1316            AccessMode::WhiteList1317        ));1318        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1319        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13201321        // do approve1322        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1323        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);13241325        assert_ok!(TemplateModule::transfer_from(1326            origin1.clone(),1327            1,1328            2,1329            1,1330            1,1331            11332        ));1333    });1334}13351336// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1337#[test]1338fn white_list_test_9() {1339    new_test_ext().execute_with(|| {1340        default_limits();1341        1342        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1343        let origin1 = Origin::signed(1);13441345        assert_ok!(TemplateModule::set_public_access_mode(1346            origin1.clone(),1347            collection_id,1348            AccessMode::WhiteList1349        ));1350        assert_ok!(TemplateModule::set_mint_permission(1351            origin1.clone(),1352            collection_id,1353            false1354        ));13551356        let data = default_nft_data();1357        create_test_item(collection_id, &data.into());1358    });1359}13601361// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1362#[test]1363fn white_list_test_10() {1364    new_test_ext().execute_with(|| {1365        default_limits();1366        1367        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13681369        let origin1 = Origin::signed(1);1370        let origin2 = Origin::signed(2);13711372        assert_ok!(TemplateModule::set_public_access_mode(1373            origin1.clone(),1374            collection_id,1375            AccessMode::WhiteList1376        ));1377        assert_ok!(TemplateModule::set_mint_permission(1378            origin1.clone(),1379            collection_id,1380            false1381        ));13821383        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));13841385        assert_ok!(TemplateModule::create_item(1386            origin2.clone(),1387            collection_id,1388            2,1389            default_nft_data().into()1390        ));1391    });1392}13931394// 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.1395#[test]1396fn white_list_test_11() {1397    new_test_ext().execute_with(|| {1398        default_limits();1399        1400        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14011402        let origin1 = Origin::signed(1);1403        let origin2 = Origin::signed(2);14041405        assert_ok!(TemplateModule::set_public_access_mode(1406            origin1.clone(),1407            collection_id,1408            AccessMode::WhiteList1409        ));1410        assert_ok!(TemplateModule::set_mint_permission(1411            origin1.clone(),1412            collection_id,1413            false1414        ));1415        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14161417        assert_noop!(1418            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1419            "Public minting is not allowed for this collection"1420        );1421    });1422}14231424// 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.1425#[test]1426fn white_list_test_12() {1427    new_test_ext().execute_with(|| {1428        default_limits();1429        1430        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14311432        let origin1 = Origin::signed(1);1433        let origin2 = Origin::signed(2);14341435        assert_ok!(TemplateModule::set_public_access_mode(1436            origin1.clone(),1437            collection_id,1438            AccessMode::WhiteList1439        ));1440        assert_ok!(TemplateModule::set_mint_permission(1441            origin1.clone(),1442            collection_id,1443            false1444        ));14451446        assert_noop!(1447            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1448            "Public minting is not allowed for this collection"1449        );1450    });1451}14521453// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1454#[test]1455fn white_list_test_13() {1456    new_test_ext().execute_with(|| {1457        default_limits();1458        1459        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14601461        let origin1 = Origin::signed(1);14621463        assert_ok!(TemplateModule::set_public_access_mode(1464            origin1.clone(),1465            collection_id,1466            AccessMode::WhiteList1467        ));1468        assert_ok!(TemplateModule::set_mint_permission(1469            origin1.clone(),1470            collection_id,1471            true1472        ));14731474        let data = default_nft_data();1475        create_test_item(collection_id, &data.into());1476    });1477}14781479// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1480#[test]1481fn white_list_test_14() {1482    new_test_ext().execute_with(|| {1483        default_limits();1484        1485        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14861487        let origin1 = Origin::signed(1);1488        let origin2 = Origin::signed(2);14891490        assert_ok!(TemplateModule::set_public_access_mode(1491            origin1.clone(),1492            collection_id,1493            AccessMode::WhiteList1494        ));1495        assert_ok!(TemplateModule::set_mint_permission(1496            origin1.clone(),1497            collection_id,1498            true1499        ));15001501        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));15021503        assert_ok!(TemplateModule::create_item(1504            origin2.clone(),1505            1,1506            2,1507            default_nft_data().into()1508        ));1509    });1510}15111512// 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.1513#[test]1514fn white_list_test_15() {1515    new_test_ext().execute_with(|| {1516        default_limits();1517        1518        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15191520        let origin1 = Origin::signed(1);1521        let origin2 = Origin::signed(2);15221523        assert_ok!(TemplateModule::set_public_access_mode(1524            origin1.clone(),1525            collection_id,1526            AccessMode::WhiteList1527        ));1528        assert_ok!(TemplateModule::set_mint_permission(1529            origin1.clone(),1530            collection_id,1531            true1532        ));15331534        assert_noop!(1535            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1536            "Address is not in white list"1537        );1538    });1539}15401541// 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.1542#[test]1543fn white_list_test_16() {1544    new_test_ext().execute_with(|| {1545        default_limits();1546        1547        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15481549        let origin1 = Origin::signed(1);1550        let origin2 = Origin::signed(2);15511552        assert_ok!(TemplateModule::set_public_access_mode(1553            origin1.clone(),1554            collection_id,1555            AccessMode::WhiteList1556        ));1557        assert_ok!(TemplateModule::set_mint_permission(1558            origin1.clone(),1559            collection_id,1560            true1561        ));1562        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));15631564        assert_ok!(TemplateModule::create_item(1565            origin2.clone(),1566            1,1567            2,1568            default_nft_data().into()1569        ));1570    });1571}15721573// Total number of collections. Positive test1574#[test]1575fn total_number_collections_bound() {1576    new_test_ext().execute_with(|| {1577        default_limits();1578        1579        create_test_collection(&CollectionMode::NFT, 1);1580    });1581}15821583// Total number of collections. Negotive test1584#[test]1585fn total_number_collections_bound_neg() {1586    new_test_ext().execute_with(|| {1587        default_limits();15881589        let origin1 = Origin::signed(1);15901591        for i in 0..default_collection_numbers_limit() {1592            create_test_collection(&CollectionMode::NFT, i + 1);1593        }15941595        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1596        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1597        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();15981599        // 11-th collection in chain. Expects error1600        assert_noop!(TemplateModule::create_collection(1601            origin1.clone(),1602            col_name1.clone(),1603            col_desc1.clone(),1604            token_prefix1.clone(),1605            CollectionMode::NFT1606        ), "Total collections bound exceeded");1607    });1608}16091610// Owned tokens by a single address. Positive test1611#[test]1612fn owned_tokens_bound() {1613    new_test_ext().execute_with(|| {1614        default_limits();1615        1616        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16171618        let data = default_nft_data();1619        create_test_item(collection_id, &data.clone().into());1620        create_test_item(collection_id, &data.into());1621    });1622}16231624// Owned tokens by a single address. Negotive test1625#[test]1626fn owned_tokens_bound_neg() {1627    new_test_ext().execute_with(|| {1628        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1629            collection_numbers_limit: 10,1630            account_token_ownership_limit: 1,1631            collections_admins_limit: 5,1632            custom_data_limit: 2048,1633            nft_sponsor_transfer_timeout: 15,1634            fungible_sponsor_transfer_timeout: 15,1635            refungible_sponsor_transfer_timeout: 15,          1636        }));1637        1638        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16391640        let origin1 = Origin::signed(1);1641        let data = default_nft_data();1642        create_test_item(collection_id, &data.clone().into());16431644        assert_noop!(TemplateModule::create_item(1645            origin1.clone(),1646            1,1647            1,1648            data.into()1649        ), "Owned tokens by a single address bound exceeded");1650    });1651}16521653// Number of collection admins. Positive test1654#[test]1655fn collection_admins_bound() {1656    new_test_ext().execute_with(|| {1657        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1658            collection_numbers_limit: 10,1659            account_token_ownership_limit: 10,1660            collections_admins_limit: 2,1661            custom_data_limit: 2048,1662            nft_sponsor_transfer_timeout: 15,1663            fungible_sponsor_transfer_timeout: 15,1664            refungible_sponsor_transfer_timeout: 15,          1665        }));1666        1667        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16681669        let origin1 = Origin::signed(1);1670        1671        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1672        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1673    });1674}16751676// Number of collection admins. Negotive test1677#[test]1678fn collection_admins_bound_neg() {1679    new_test_ext().execute_with(|| {1680        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1681            collection_numbers_limit: 10,1682            account_token_ownership_limit: 1,1683            collections_admins_limit: 1,1684            custom_data_limit: 2048,1685            nft_sponsor_transfer_timeout: 15,1686            fungible_sponsor_transfer_timeout: 15,1687            refungible_sponsor_transfer_timeout: 15,          1688        }));1689        1690        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16911692        let origin1 = Origin::signed(1);16931694        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1695        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), "Number of collection admins bound exceeded");1696    });1697}16981699// NFT custom data size. Negative test const_data.1700#[test]1701fn custom_data_size_nft_const_data_bound_neg() {1702    new_test_ext().execute_with(|| {1703        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1704            collection_numbers_limit: 10,1705            account_token_ownership_limit: 10,1706            collections_admins_limit: 5,1707            custom_data_limit: 2,1708            nft_sponsor_transfer_timeout: 15,1709            fungible_sponsor_transfer_timeout: 15,1710            refungible_sponsor_transfer_timeout: 15,          1711        }));1712        1713        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17141715        let origin1 = Origin::signed(1);1716        let too_big_const_data = CreateItemData::NFT(CreateNftData{1717            const_data: vec![1, 2, 3, 4],1718            variable_data: vec![]1719        });17201721        assert_noop!(TemplateModule::create_item(1722            origin1.clone(),1723            collection_id,1724            1,1725            too_big_const_data1726        ), "const_data exceeded data limit.");1727    });1728}17291730// NFT custom data size. Negative test variable_data.1731#[test]1732fn custom_data_size_nft_variable_data_bound_neg() {1733    new_test_ext().execute_with(|| {1734        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1735            collection_numbers_limit: 10,1736            account_token_ownership_limit: 10,1737            collections_admins_limit: 5,1738            custom_data_limit: 2,1739            nft_sponsor_transfer_timeout: 15,1740            fungible_sponsor_transfer_timeout: 15,1741            refungible_sponsor_transfer_timeout: 15,          1742        }));17431744        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17451746        let origin1 = Origin::signed(1);1747        let too_big_const_data = CreateItemData::NFT(CreateNftData{1748            const_data: vec![],1749            variable_data: vec![1, 2, 3, 4]1750        });17511752        assert_noop!(TemplateModule::create_item(1753            origin1.clone(),1754            collection_id,1755            1,1756            too_big_const_data1757        ), "variable_data exceeded data limit.");1758    });1759}17601761// Re fungible custom data size. Negative test const_data.1762#[test]1763fn custom_data_size_re_fungible_const_data_bound_neg() {1764    new_test_ext().execute_with(|| {1765        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1766            collection_numbers_limit: 10,1767            account_token_ownership_limit: 10,1768            collections_admins_limit: 5,1769            custom_data_limit: 2,1770            nft_sponsor_transfer_timeout: 15,1771            fungible_sponsor_transfer_timeout: 15,1772            refungible_sponsor_transfer_timeout: 15,          1773        }));17741775        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17761777        let origin1 = Origin::signed(1);1778        let too_big_const_data = CreateItemData::NFT(CreateNftData{1779            const_data: vec![1, 2, 3, 4],1780            variable_data: vec![]1781        });17821783        assert_noop!(TemplateModule::create_item(1784            origin1.clone(),1785            collection_id,1786            1,1787            too_big_const_data1788        ), "const_data exceeded data limit.");1789    });1790}17911792// Re fungible custom data size. Negative test variable_data.1793#[test]1794fn custom_data_size_re_fungible_variable_data_bound_neg() {1795    new_test_ext().execute_with(|| {1796        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1797            collection_numbers_limit: 10,1798            account_token_ownership_limit: 10,1799            collections_admins_limit: 5,1800            custom_data_limit: 2,1801            nft_sponsor_transfer_timeout: 15,1802            fungible_sponsor_transfer_timeout: 15,1803            refungible_sponsor_transfer_timeout: 15,          1804        }));18051806        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18071808        let origin1 = Origin::signed(1);1809        let too_big_const_data = CreateItemData::NFT(CreateNftData{1810            const_data: vec![],1811            variable_data: vec![1, 2, 3, 4]1812        });18131814        assert_noop!(TemplateModule::create_item(1815            origin1.clone(),1816            collection_id,1817            1,1818            too_big_const_data1819        ), "variable_data exceeded data limit.");1820    });1821}1822// #endregion18231824#[test]1825fn set_const_on_chain_schema() {1826    new_test_ext().execute_with(|| {1827        default_limits();18281829        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18301831        let origin1 = Origin::signed(1);1832        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, b"test const on chain schema".to_vec()));18331834        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"test const on chain schema".to_vec());1835        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"".to_vec());1836    });1837}18381839#[test]1840fn set_variable_on_chain_schema() {1841    new_test_ext().execute_with(|| {1842        default_limits();1843        1844        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18451846        let origin1 = Origin::signed(1);1847        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, b"test variable on chain schema".to_vec()));18481849        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"".to_vec());1850        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"test variable on chain schema".to_vec());1851    });1852}