git.delta.rocks / unique-network / refs/commits / 944d507c1d0c

1// Tests to be written here2use super::*;3use crate::mock::*;4use crate::{AccessMode, ApprovePermissions, CollectionMode,5    Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData,6    CollectionId, TokenId, MAX_DECIMAL_POINTS};7use frame_support::{assert_noop, assert_ok};8use frame_system::{ RawOrigin };910fn default_collection_numbers_limit() -> u32 {11    1012}1314fn default_limits() {15    assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 16            collection_numbers_limit: default_collection_numbers_limit(),17            account_token_ownership_limit: 10,18            collections_admins_limit: 5,19            custom_data_limit: 2048,20            nft_sponsor_transfer_timeout: 15,21            fungible_sponsor_transfer_timeout: 15,22            refungible_sponsor_transfer_timeout: 15,          23        }));24}2526fn default_nft_data() -> CreateNftData {27    CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }28}2930fn default_fungible_data () -> CreateFungibleData {31    CreateFungibleData { }32}3334fn default_re_fungible_data () -> CreateReFungibleData {35    CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }36}3738fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64, id: CollectionId) -> CollectionId {39    let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();40    let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();41    let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();4243    let origin1 = Origin::signed(owner);44    assert_ok!(TemplateModule::create_collection(45            origin1.clone(),46            col_name1.clone(),47            col_desc1.clone(),48            token_prefix1.clone(),49            mode.clone()50        ));5152    let saved_col_name: Vec<u16> = "Test1\0\0".encode_utf16().collect::<Vec<u16>>();53    let saved_description: Vec<u16> = "TestDescription1\0\0".encode_utf16().collect::<Vec<u16>>();54    let saved_prefix: Vec<u8> = b"token_prefix1\0\0".to_vec();55    assert_eq!(TemplateModule::collection(id).owner, owner);56    assert_eq!(TemplateModule::collection(id).name, saved_col_name);57    assert_eq!(TemplateModule::collection(id).mode, *mode);58    assert_eq!(TemplateModule::collection(id).description, saved_description);59    assert_eq!(TemplateModule::collection(id).token_prefix, saved_prefix);60    id61}6263fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {64    create_test_collection_for_owner(&mode, 1, id)65}6667fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {68    let origin1 = Origin::signed(1);69    assert_ok!(TemplateModule::create_item(70            origin1.clone(),71            collection_id,72            1,73            data.clone()74        ));7576}7778// Use cases tests region79// #region80#[test]81fn create_fungible_collection_fails_with_large_decimal_numbers() {82    new_test_ext().execute_with(|| {83        default_limits();8485        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();86        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();87        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();8889        let origin1 = Origin::signed(1);90        assert_noop!(TemplateModule::create_collection(91            origin1,92            col_name1,93            col_desc1,94            token_prefix1,95            CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1)96        ), Error::<Test>::CollectionDecimalPointLimitExceeded);97    });    98}99100#[test]101fn create_re_fungible_collection_fails_with_large_decimal_numbers() {102    new_test_ext().execute_with(|| {103        default_limits();104105        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();106        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();107        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();108109        let origin1 = Origin::signed(1);110        assert_noop!(TemplateModule::create_collection(111            origin1,112            col_name1,113            col_desc1,114            token_prefix1,115            CollectionMode::ReFungible(MAX_DECIMAL_POINTS + 1)116        ), Error::<Test>::CollectionDecimalPointLimitExceeded);117    });118}119120#[test]121fn create_nft_item() {122    new_test_ext().execute_with(|| {123        default_limits();124        let collection_id = create_test_collection(&CollectionMode::NFT, 1);125        126        let data = default_nft_data();127        create_test_item(collection_id, &data.clone().into());128        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);129        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);130    });131}132133// Use cases tests region134// #region135#[test]136fn create_nft_multiple_items() {137    new_test_ext().execute_with(|| {138        default_limits();139        140        create_test_collection(&CollectionMode::NFT, 1);141142        let origin1 = Origin::signed(1);143144        let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];145146        assert_ok!(TemplateModule::create_multiple_items(147            origin1.clone(),148            1,149            1,150            items_data.clone().into_iter().map(|d| { d.into() }).collect()151        ));152        for (index, data) in items_data.iter().enumerate() {153            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as TokenId).const_data.to_vec(), data.const_data);154            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as TokenId).variable_data.to_vec(), data.variable_data);155        }156    });157}158159#[test]160fn create_refungible_item() {161    new_test_ext().execute_with(|| {162        default_limits();163        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);164165        let data = default_re_fungible_data();166        create_test_item(collection_id, &data.clone().into());167        assert_eq!(168            TemplateModule::refungible_item_id(collection_id, 1).const_data,169            data.const_data170        );171        assert_eq!(172            TemplateModule::refungible_item_id(collection_id, 1).variable_data,173            data.variable_data174        );175        assert_eq!(176            TemplateModule::refungible_item_id(collection_id, 1).owner[0],177            Ownership {178                owner: 1,179                fraction: 1000180            }181        );182    });183}184185#[test]186fn create_multiple_refungible_items() {187    new_test_ext().execute_with(|| {188        default_limits();189        190        create_test_collection(&CollectionMode::ReFungible(3), 1);191192        let origin1 = Origin::signed(1);193194        let items_data = vec![default_re_fungible_data(), default_re_fungible_data(), default_re_fungible_data()];195196        assert_ok!(TemplateModule::create_multiple_items(197            origin1.clone(),198            1,199            1,200            items_data.clone().into_iter().map(|d| { d.into() }).collect()201        ));202        for (index, data) in items_data.iter().enumerate() {203204            let item = TemplateModule::refungible_item_id(1, (index + 1) as TokenId);205            assert_eq!(item.const_data.to_vec(), data.const_data);206            assert_eq!(item.variable_data.to_vec(), data.variable_data);207            assert_eq!(208                item.owner[0],209                Ownership {210                    owner: 1,211                    fraction: 1000212                }213            );214        }215    });216}217218#[test]219fn create_fungible_item() {220    new_test_ext().execute_with(|| {221        default_limits();222        223        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);224225        let data = default_fungible_data();226        create_test_item(collection_id, &data.into());227228        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);229    });230}231232#[test]233fn create_multiple_fungible_items() {234    new_test_ext().execute_with(|| {235        default_limits();236237        create_test_collection(&CollectionMode::Fungible(3), 1);238239        let origin1 = Origin::signed(1);240241        let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];242243        assert_ok!(TemplateModule::create_multiple_items(244            origin1.clone(),245            1,246            1,247            items_data.clone().into_iter().map(|d| { d.into() }).collect()248        ));249        250        for (index, _) in items_data.iter().enumerate() {251            assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).owner, 1);252        }253        assert_eq!(TemplateModule::balance_count(1, 1), 3000);254        assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);255    });256}257258#[test]259fn transfer_fungible_item() {260    new_test_ext().execute_with(|| {261        default_limits();262        263        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);264265        let origin1 = Origin::signed(1);266        let origin2 = Origin::signed(2);267268        let data = default_fungible_data();269        create_test_item(collection_id, &data.into());270271        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);272        assert_eq!(TemplateModule::balance_count(1, 1), 1000);273        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);274275        // change owner scenario276        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));277        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);278        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);279        assert_eq!(TemplateModule::balance_count(1, 1), 0);280        assert_eq!(TemplateModule::balance_count(1, 2), 1000);281        // assert_eq!(TemplateModule::address_tokens(1, 1), []);282        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);283284        // split item scenario285        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));286        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);287        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);288        assert_eq!(TemplateModule::balance_count(1, 2), 500);289        assert_eq!(TemplateModule::balance_count(1, 3), 500);290        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);291        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);292293        // split item and new owner has account scenario294        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));295        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);296        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);297        assert_eq!(TemplateModule::balance_count(1, 2), 300);298        assert_eq!(TemplateModule::balance_count(1, 3), 700);299        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);300        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);301    });302}303304#[test]305fn transfer_refungible_item() {306    new_test_ext().execute_with(|| {307        default_limits();308        309        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);310311        let data = default_re_fungible_data();312        create_test_item(collection_id, &data.clone().into());313314        let origin1 = Origin::signed(1);315        let origin2 = Origin::signed(2);316        assert_eq!(317            TemplateModule::refungible_item_id(collection_id, 1).const_data,318            data.const_data319        );320        assert_eq!(321            TemplateModule::refungible_item_id(collection_id, 1).variable_data,322            data.variable_data323        );324        assert_eq!(325            TemplateModule::refungible_item_id(collection_id, 1).owner[0],326            Ownership {327                owner: 1,328                fraction: 1000329            }330        );331        assert_eq!(TemplateModule::balance_count(1, 1), 1000);332        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);333334        // change owner scenario335        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));336        assert_eq!(337            TemplateModule::refungible_item_id(1, 1).owner[0],338            Ownership {339                owner: 2,340                fraction: 1000341            }342        );343        assert_eq!(TemplateModule::balance_count(1, 1), 0);344        assert_eq!(TemplateModule::balance_count(1, 2), 1000);345        // assert_eq!(TemplateModule::address_tokens(1, 1), []);346        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);347348        // split item scenario349        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));350        assert_eq!(351            TemplateModule::refungible_item_id(1, 1).owner[0],352            Ownership {353                owner: 2,354                fraction: 500355            }356        );357        assert_eq!(358            TemplateModule::refungible_item_id(1, 1).owner[1],359            Ownership {360                owner: 3,361                fraction: 500362            }363        );364        assert_eq!(TemplateModule::balance_count(1, 2), 500);365        assert_eq!(TemplateModule::balance_count(1, 3), 500);366        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);367        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);368369        // split item and new owner has account scenario370        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));371        assert_eq!(372            TemplateModule::refungible_item_id(1, 1).owner[0],373            Ownership {374                owner: 2,375                fraction: 300376            }377        );378        assert_eq!(379            TemplateModule::refungible_item_id(1, 1).owner[1],380            Ownership {381                owner: 3,382                fraction: 700383            }384        );385        assert_eq!(TemplateModule::balance_count(1, 2), 300);386        assert_eq!(TemplateModule::balance_count(1, 3), 700);387        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);388        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);389    });390}391392#[test]393fn transfer_nft_item() {394    new_test_ext().execute_with(|| {395        default_limits();396        397        let collection_id = create_test_collection(&CollectionMode::NFT, 1);398399        let data = default_nft_data();400        create_test_item(collection_id, &data.into());401        assert_eq!(TemplateModule::balance_count(1, 1), 1);402        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);403404        let origin1 = Origin::signed(1);405        // default scenario406        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));407        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);408        assert_eq!(TemplateModule::balance_count(1, 1), 0);409        assert_eq!(TemplateModule::balance_count(1, 2), 1);410        // assert_eq!(TemplateModule::address_tokens(1, 1), []);411        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);412    });413}414415#[test]416fn nft_approve_and_transfer_from() {417    new_test_ext().execute_with(|| {418        default_limits();419        420        let collection_id = create_test_collection(&CollectionMode::NFT, 1);421422        let data = default_nft_data();423        create_test_item(collection_id, &data.into());424425        let origin1 = Origin::signed(1);426        let origin2 = Origin::signed(2);427428        assert_eq!(TemplateModule::balance_count(1, 1), 1);429        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);430431        // neg transfer432        assert_noop!(TemplateModule::transfer_from(433            origin2.clone(),434            1,435            2,436            1,437            1,438            1), Error::<Test>::NoPermission);439440        // do approve441        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));442        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);443        assert_eq!(444            TemplateModule::approved(1, (1, 1))[0],445            ApprovePermissions {446                approved: 2,447                amount: 100000000448            }449        );450451        assert_ok!(TemplateModule::transfer_from(452            origin2.clone(),453            1,454            2,455            1,456            1,457            1458        ));459        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);460    });461}462463#[test]464fn nft_approve_and_transfer_from_white_list() {465    new_test_ext().execute_with(|| {466        default_limits();467        468        let collection_id = create_test_collection(&CollectionMode::NFT, 1);469470        let origin1 = Origin::signed(1);471        let origin2 = Origin::signed(2);472473        let data = default_nft_data();474        create_test_item(collection_id, &data.clone().into());475476        assert_eq!(TemplateModule::nft_item_id(1, 1).const_data, data.const_data);477        assert_eq!(TemplateModule::balance_count(1, 1), 1);478        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);479480        assert_ok!(TemplateModule::set_mint_permission(481            origin1.clone(),482            1,483            true484        ));485        assert_ok!(TemplateModule::set_public_access_mode(486            origin1.clone(),487            1,488            AccessMode::WhiteList489        ));490        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));491        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));492        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));493494        // do approve495        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));496        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);497        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));498        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);499        assert_eq!(500            TemplateModule::approved(1, (1, 1))[0],501            ApprovePermissions {502                approved: 2,503                amount: 100000000504            }505        );506507        assert_ok!(TemplateModule::transfer_from(508            origin2.clone(),509            1,510            3,511            1,512            1,513            1514        ));515        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);516    });517}518519#[test]520fn refungible_approve_and_transfer_from() {521    new_test_ext().execute_with(|| {522        default_limits();523        524        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);525        526        let origin1 = Origin::signed(1);527        let origin2 = Origin::signed(2);528529        let data = default_re_fungible_data();530        create_test_item(collection_id, &data.into());531532        assert_eq!(TemplateModule::balance_count(1, 1), 1000);533        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);534535        assert_ok!(TemplateModule::set_mint_permission(536            origin1.clone(),537            1,538            true539        ));540        assert_ok!(TemplateModule::set_public_access_mode(541            origin1.clone(),542            1,543            AccessMode::WhiteList544        ));545        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));546        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));547        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));548549        // do approve550        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));551        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);552        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));553        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);554        assert_eq!(555            TemplateModule::approved(1, (1, 1))[0],556            ApprovePermissions {557                approved: 2,558                amount: 100000000559            }560        );561562        assert_ok!(TemplateModule::transfer_from(563            origin2.clone(),564            1,565            3,566            1,567            1,568            100569        ));570        assert_eq!(TemplateModule::balance_count(1, 1), 900);571        assert_eq!(TemplateModule::balance_count(1, 3), 100);572        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);573        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);574575        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);576        assert_eq!(577            TemplateModule::approved(1, (1, 1))[0],578            ApprovePermissions {579                approved: 3,580                amount: 100000000581            }582        );583    });584}585586#[test]587fn fungible_approve_and_transfer_from() {588    new_test_ext().execute_with(|| {589        default_limits();590        591        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);592        593        let data = default_fungible_data();594        create_test_item(collection_id, &data.into());595596        let origin1 = Origin::signed(1);597        let origin2 = Origin::signed(2);598599        assert_eq!(TemplateModule::balance_count(1, 1), 1000);600        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);601602        assert_ok!(TemplateModule::set_mint_permission(603            origin1.clone(),604            1,605            true606        ));607        assert_ok!(TemplateModule::set_public_access_mode(608            origin1.clone(),609            1,610            AccessMode::WhiteList611        ));612        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));613        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));614        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));615616        // do approve617        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));618        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);619        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));620        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);621        assert_eq!(622            TemplateModule::approved(1, (1, 1))[0],623            ApprovePermissions {624                approved: 2,625                amount: 100000000626            }627        );628629        assert_ok!(TemplateModule::transfer_from(630            origin2.clone(),631            1,632            3,633            1,634            1,635            100636        ));637        assert_eq!(TemplateModule::balance_count(1, 1), 900);638        assert_eq!(TemplateModule::balance_count(1, 3), 100);639        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);640        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);641642        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);643        assert_eq!(644            TemplateModule::approved(1, (1, 1))[0],645            ApprovePermissions {646                approved: 3,647                amount: 100000000648            }649        );650651        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));652        assert_ok!(TemplateModule::transfer_from(653            origin2.clone(),654            1,655            3,656            1,657            1,658            900659        ));660        assert_eq!(TemplateModule::balance_count(1, 1), 0);661        assert_eq!(TemplateModule::balance_count(1, 3), 1000);662        // assert_eq!(TemplateModule::address_tokens(1, 1), []);663        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);664665        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);666    });667}668669#[test]670fn change_collection_owner() {671    new_test_ext().execute_with(|| {672        default_limits();673        674        let collection_id = create_test_collection(&CollectionMode::NFT, 1);675        676        let origin1 = Origin::signed(1);677        assert_ok!(TemplateModule::change_collection_owner(678            origin1.clone(),679            collection_id,680            2681        ));682        assert_eq!(TemplateModule::collection(collection_id).owner, 2);683    });684}685686#[test]687fn destroy_collection() {688    new_test_ext().execute_with(|| {689        default_limits();690        691        let collection_id = create_test_collection(&CollectionMode::NFT, 1);692        693        let origin1 = Origin::signed(1);694        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));695    });696}697698#[test]699fn burn_nft_item() {700    new_test_ext().execute_with(|| {701        default_limits();702        703        let collection_id = create_test_collection(&CollectionMode::NFT, 1);704705        let origin1 = Origin::signed(1);706        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));707        708        let data = default_nft_data();709        create_test_item(collection_id, &data.into());710711        // check balance (collection with id = 1, user id = 1)712        assert_eq!(TemplateModule::balance_count(1, 1), 1);713714        // burn item715        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));716        assert_noop!(717            TemplateModule::burn_item(origin1.clone(), 1, 1),718            Error::<Test>::TokenNotFound719        );720721        assert_eq!(TemplateModule::balance_count(1, 1), 0);722    });723}724725#[test]726fn burn_fungible_item() {727    new_test_ext().execute_with(|| {728        default_limits();729        730        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);731        732        let origin1 = Origin::signed(1);733        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));734        735        let data = default_fungible_data();736        create_test_item(collection_id, &data.into());737738        // check balance (collection with id = 1, user id = 1)739        assert_eq!(TemplateModule::balance_count(1, 1), 1000);740741        // burn item742        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));743        assert_noop!(744            TemplateModule::burn_item(origin1.clone(), 1, 1),745            Error::<Test>::TokenNotFound746        );747748        assert_eq!(TemplateModule::balance_count(1, 1), 0);749    });750}751752#[test]753fn burn_refungible_item() {754    new_test_ext().execute_with(|| {755        default_limits();756        757        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);758        let origin1 = Origin::signed(1);759760        assert_ok!(TemplateModule::set_mint_permission(761            origin1.clone(),762            collection_id,763            true764        ));765        assert_ok!(TemplateModule::set_public_access_mode(766            origin1.clone(),767            collection_id,768            AccessMode::WhiteList769        ));770        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));771772        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));773        774        let data = default_re_fungible_data();775        create_test_item(collection_id, &data.into());776777        // check balance (collection with id = 1, user id = 2)778        assert_eq!(TemplateModule::balance_count(1, 1), 1000);779780        // burn item781        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));782        assert_noop!(783            TemplateModule::burn_item(origin1.clone(), 1, 1),784            Error::<Test>::TokenNotFound785        );786787        assert_eq!(TemplateModule::balance_count(1, 1), 0);788    });789}790791#[test]792fn add_collection_admin() {793    new_test_ext().execute_with(|| {794        default_limits();795        796        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);797        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);798        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);799        800        let origin1 = Origin::signed(1);801802        // collection admin803        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));804        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));805806        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);807        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);808    });809}810811#[test]812fn remove_collection_admin() {813    new_test_ext().execute_with(|| {814        default_limits();815        816        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);817        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);818        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);819820        let origin1 = Origin::signed(1);821        let origin2 = Origin::signed(2);822823        // collection admin824        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));825        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));826827        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);828        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);829830        // remove admin831        assert_ok!(TemplateModule::remove_collection_admin(832            origin2.clone(),833            1,834            3835        ));836        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);837    });838}839840#[test]841fn balance_of() {842    new_test_ext().execute_with(|| {843        default_limits();844        845        let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);846        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);847        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3), 3);848        849        // check balance before850        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);851        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);852        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);853854        let nft_data = default_nft_data();855        create_test_item(nft_collection_id, &nft_data.into());856        857        let fungible_data = default_fungible_data();858        create_test_item(fungible_collection_id, &fungible_data.into());859        860        let re_fungible_data = default_re_fungible_data();861        create_test_item(re_fungible_collection_id, &re_fungible_data.into());862863        // check balance (collection with id = 1, user id = 1)864        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);865        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);866        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);867        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);868        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);869        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);870    });871}872873#[test]874fn approve() {875    new_test_ext().execute_with(|| {876        default_limits();877        878        let collection_id = create_test_collection(&CollectionMode::NFT, 1);879        880        let data = default_nft_data();881        create_test_item(collection_id, &data.into());882883        let origin1 = Origin::signed(1);884        885        // approve886        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));887        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);888    });889}890891#[test]892fn transfer_from() {893    new_test_ext().execute_with(|| {894        default_limits();895        896        let collection_id = create_test_collection(&CollectionMode::NFT, 1);897        let origin1 = Origin::signed(1);898        let origin2 = Origin::signed(2);899900        let data = default_nft_data();901        create_test_item(collection_id, &data.into());902903        // approve904        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));905        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);906907        assert_ok!(TemplateModule::set_mint_permission(908            origin1.clone(),909            1,910            true911        ));912        assert_ok!(TemplateModule::set_public_access_mode(913            origin1.clone(),914            1,915            AccessMode::WhiteList916        ));917        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));918        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));919        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));920921        assert_ok!(TemplateModule::transfer_from(922            origin2.clone(),923            1,924            2,925            1,926            1,927            1928        ));929930        // after transfer931        assert_eq!(TemplateModule::balance_count(1, 1), 0);932        assert_eq!(TemplateModule::balance_count(1, 2), 1);933    });934}935936// #endregion937938// Coverage tests region939// #region940941#[test]942fn owner_can_add_address_to_white_list() {943    new_test_ext().execute_with(|| {944        default_limits();945        946        let collection_id = create_test_collection(&CollectionMode::NFT, 1);947948        let origin1 = Origin::signed(1);949        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));950        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);951    });952}953954#[test]955fn admin_can_add_address_to_white_list() {956    new_test_ext().execute_with(|| {957        default_limits();958        959        let collection_id = create_test_collection(&CollectionMode::NFT, 1);960        let origin1 = Origin::signed(1);961        let origin2 = Origin::signed(2);962963        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));964        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));965        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);966    });967}968969#[test]970fn nonprivileged_user_cannot_add_address_to_white_list() {971    new_test_ext().execute_with(|| {972        default_limits();973        974        let collection_id = create_test_collection(&CollectionMode::NFT, 1);975976        let origin2 = Origin::signed(2);977        assert_noop!(978            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),979            Error::<Test>::NoPermission980        );981    });982}983984#[test]985fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {986    new_test_ext().execute_with(|| {987        default_limits();988989        let origin1 = Origin::signed(1);990991        assert_noop!(992            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),993            Error::<Test>::CollectionNotFound994        );995    });996}997998#[test]999fn nobody_can_add_address_to_white_list_of_deleted_collection() {1000    new_test_ext().execute_with(|| {1001        default_limits();1002        1003        let collection_id = create_test_collection(&CollectionMode::NFT, 1);10041005        let origin1 = Origin::signed(1);1006        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));1007        assert_noop!(1008            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),1009            Error::<Test>::CollectionNotFound1010        );1011    });1012}10131014// If address is already added to white list, nothing happens1015#[test]1016fn address_is_already_added_to_white_list() {1017    new_test_ext().execute_with(|| {1018        default_limits();1019        1020        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1021        let origin1 = Origin::signed(1);1022        1023        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1024        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1025        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);1026        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);1027    });1028}10291030#[test]1031fn owner_can_remove_address_from_white_list() {1032    new_test_ext().execute_with(|| {1033        default_limits();1034        1035        let collection_id = create_test_collection(&CollectionMode::NFT, 1);10361037        let origin1 = Origin::signed(1);1038        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1039        assert_ok!(TemplateModule::remove_from_white_list(1040            origin1.clone(),1041            collection_id,1042            21043        ));1044        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1045    });1046}10471048#[test]1049fn admin_can_remove_address_from_white_list() {1050    new_test_ext().execute_with(|| {1051        default_limits();1052        1053        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1054        let origin1 = Origin::signed(1);1055        let origin2 = Origin::signed(2);10561057        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));10581059        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));1060        assert_ok!(TemplateModule::remove_from_white_list(1061            origin2.clone(),1062            collection_id,1063            31064        ));1065        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1066    });1067}10681069#[test]1070fn nonprivileged_user_cannot_remove_address_from_white_list() {1071    new_test_ext().execute_with(|| {1072        default_limits();1073        1074        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1075        let origin1 = Origin::signed(1);1076        let origin2 = Origin::signed(2);10771078        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1079        assert_noop!(1080            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1081            Error::<Test>::NoPermission1082        );1083        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);1084    });1085}10861087#[test]1088fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1089    new_test_ext().execute_with(|| {1090        default_limits();1091        let origin1 = Origin::signed(1);10921093        assert_noop!(1094            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),1095            Error::<Test>::CollectionNotFound1096        );1097    });1098}10991100#[test]1101fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1102    new_test_ext().execute_with(|| {1103        default_limits();1104        1105        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1106        let origin1 = Origin::signed(1);1107        let origin2 = Origin::signed(2);11081109        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1110        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));1111        assert_noop!(1112            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1113            Error::<Test>::CollectionNotFound1114        );1115        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1116    });1117}11181119// If address is already removed from white list, nothing happens1120#[test]1121fn address_is_already_removed_from_white_list() {1122    new_test_ext().execute_with(|| {1123        default_limits();1124        1125        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1126        let origin1 = Origin::signed(1);11271128        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1129        assert_ok!(TemplateModule::remove_from_white_list(1130            origin1.clone(),1131            collection_id,1132            21133        ));1134        assert_ok!(TemplateModule::remove_from_white_list(1135            origin1.clone(),1136            collection_id,1137            21138        ));1139        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1140    });1141}11421143// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1144#[test]1145fn white_list_test_1() {1146    new_test_ext().execute_with(|| {1147        default_limits();1148        1149        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11501151        let origin1 = Origin::signed(1);1152        1153        let data = default_nft_data();1154        create_test_item(collection_id, &data.into());11551156        assert_ok!(TemplateModule::set_public_access_mode(1157            origin1.clone(),1158            collection_id,1159            AccessMode::WhiteList1160        ));1161        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11621163        assert_noop!(1164            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1165            Error::<Test>::AddresNotInWhiteList1166        );1167    });1168}11691170#[test]1171fn white_list_test_2() {1172    new_test_ext().execute_with(|| {1173        default_limits();1174        1175        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1176        let origin1 = Origin::signed(1);1177        1178        let data = default_nft_data();1179        create_test_item(collection_id, &data.into());11801181        assert_ok!(TemplateModule::set_public_access_mode(1182            origin1.clone(),1183            collection_id,1184            AccessMode::WhiteList1185        ));1186        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1187        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));11881189        // do approve1190        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1191        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);11921193        assert_ok!(TemplateModule::remove_from_white_list(1194            origin1.clone(),1195            1,1196            11197        ));11981199        assert_noop!(1200            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1201            Error::<Test>::AddresNotInWhiteList1202        );1203    });1204}12051206// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1207#[test]1208fn white_list_test_3() {1209    new_test_ext().execute_with(|| {1210        default_limits();1211        1212        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12131214        let origin1 = Origin::signed(1);1215        1216        let data = default_nft_data();1217        create_test_item(collection_id, &data.into());12181219        assert_ok!(TemplateModule::set_public_access_mode(1220            origin1.clone(),1221            collection_id,1222            AccessMode::WhiteList1223        ));1224        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));12251226        assert_noop!(1227            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1228            Error::<Test>::AddresNotInWhiteList1229        );1230    });1231}12321233#[test]1234fn white_list_test_4() {1235    new_test_ext().execute_with(|| {1236        default_limits();1237        1238        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12391240        let origin1 = Origin::signed(1);12411242        let data = default_nft_data();1243        create_test_item(collection_id, &data.into());12441245        assert_ok!(TemplateModule::set_public_access_mode(1246            origin1.clone(),1247            collection_id,1248            AccessMode::WhiteList1249        ));1250        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1251        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12521253        // do approve1254        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1255        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);12561257        assert_ok!(TemplateModule::remove_from_white_list(1258            origin1.clone(),1259            collection_id,1260            21261        ));12621263        assert_noop!(1264            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1265            Error::<Test>::AddresNotInWhiteList1266        );1267    });1268}12691270// 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)1271#[test]1272fn white_list_test_5() {1273    new_test_ext().execute_with(|| {1274        default_limits();1275        1276        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12771278        let origin1 = Origin::signed(1);12791280        let data = default_nft_data();1281        create_test_item(collection_id, &data.into());12821283        assert_ok!(TemplateModule::set_public_access_mode(1284            origin1.clone(),1285            collection_id,1286            AccessMode::WhiteList1287        ));1288        assert_noop!(1289            TemplateModule::burn_item(origin1.clone(), 1, 1),1290            Error::<Test>::AddresNotInWhiteList1291        );1292    });1293}12941295// If Public Access mode is set to WhiteList, oken transfers can’t be Approved by a non-whitelisted address (see Approve method).1296#[test]1297fn white_list_test_6() {1298    new_test_ext().execute_with(|| {1299        default_limits();1300        1301        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13021303        let origin1 = Origin::signed(1);1304        assert_ok!(TemplateModule::set_public_access_mode(1305            origin1.clone(),1306            collection_id,1307            AccessMode::WhiteList1308        ));13091310        // do approve1311        assert_noop!(1312            TemplateModule::approve(origin1.clone(), 1, 1, 1),1313            Error::<Test>::AddresNotInWhiteList1314        );1315    });1316}13171318// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1319//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1320#[test]1321fn white_list_test_7() {1322    new_test_ext().execute_with(|| {1323        default_limits();1324        1325        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13261327        let data = default_nft_data();1328        create_test_item(collection_id, &data.into());1329        1330        let origin1 = Origin::signed(1);13311332        assert_ok!(TemplateModule::set_public_access_mode(1333            origin1.clone(),1334            collection_id,1335            AccessMode::WhiteList1336        ));1337        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1338        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13391340        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1341    });1342}13431344#[test]1345fn white_list_test_8() {1346    new_test_ext().execute_with(|| {1347        default_limits();1348        1349        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13501351        let data = default_nft_data();1352        create_test_item(collection_id, &data.into());1353        1354        let origin1 = Origin::signed(1);13551356        assert_ok!(TemplateModule::set_public_access_mode(1357            origin1.clone(),1358            collection_id,1359            AccessMode::WhiteList1360        ));1361        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1362        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13631364        // do approve1365        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1366        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);13671368        assert_ok!(TemplateModule::transfer_from(1369            origin1.clone(),1370            1,1371            2,1372            1,1373            1,1374            11375        ));1376    });1377}13781379// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1380#[test]1381fn white_list_test_9() {1382    new_test_ext().execute_with(|| {1383        default_limits();1384        1385        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1386        let origin1 = Origin::signed(1);13871388        assert_ok!(TemplateModule::set_public_access_mode(1389            origin1.clone(),1390            collection_id,1391            AccessMode::WhiteList1392        ));1393        assert_ok!(TemplateModule::set_mint_permission(1394            origin1.clone(),1395            collection_id,1396            false1397        ));13981399        let data = default_nft_data();1400        create_test_item(collection_id, &data.into());1401    });1402}14031404// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1405#[test]1406fn white_list_test_10() {1407    new_test_ext().execute_with(|| {1408        default_limits();1409        1410        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14111412        let origin1 = Origin::signed(1);1413        let origin2 = Origin::signed(2);14141415        assert_ok!(TemplateModule::set_public_access_mode(1416            origin1.clone(),1417            collection_id,1418            AccessMode::WhiteList1419        ));1420        assert_ok!(TemplateModule::set_mint_permission(1421            origin1.clone(),1422            collection_id,1423            false1424        ));14251426        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));14271428        assert_ok!(TemplateModule::create_item(1429            origin2.clone(),1430            collection_id,1431            2,1432            default_nft_data().into()1433        ));1434    });1435}14361437// 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.1438#[test]1439fn white_list_test_11() {1440    new_test_ext().execute_with(|| {1441        default_limits();1442        1443        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14441445        let origin1 = Origin::signed(1);1446        let origin2 = Origin::signed(2);14471448        assert_ok!(TemplateModule::set_public_access_mode(1449            origin1.clone(),1450            collection_id,1451            AccessMode::WhiteList1452        ));1453        assert_ok!(TemplateModule::set_mint_permission(1454            origin1.clone(),1455            collection_id,1456            false1457        ));1458        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14591460        assert_noop!(1461            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1462            Error::<Test>::PublicMintingNotAllowed1463        );1464    });1465}14661467// 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.1468#[test]1469fn white_list_test_12() {1470    new_test_ext().execute_with(|| {1471        default_limits();1472        1473        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14741475        let origin1 = Origin::signed(1);1476        let origin2 = Origin::signed(2);14771478        assert_ok!(TemplateModule::set_public_access_mode(1479            origin1.clone(),1480            collection_id,1481            AccessMode::WhiteList1482        ));1483        assert_ok!(TemplateModule::set_mint_permission(1484            origin1.clone(),1485            collection_id,1486            false1487        ));14881489        assert_noop!(1490            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1491            Error::<Test>::PublicMintingNotAllowed1492        );1493    });1494}14951496// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1497#[test]1498fn white_list_test_13() {1499    new_test_ext().execute_with(|| {1500        default_limits();1501        1502        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15031504        let origin1 = Origin::signed(1);15051506        assert_ok!(TemplateModule::set_public_access_mode(1507            origin1.clone(),1508            collection_id,1509            AccessMode::WhiteList1510        ));1511        assert_ok!(TemplateModule::set_mint_permission(1512            origin1.clone(),1513            collection_id,1514            true1515        ));15161517        let data = default_nft_data();1518        create_test_item(collection_id, &data.into());1519    });1520}15211522// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1523#[test]1524fn white_list_test_14() {1525    new_test_ext().execute_with(|| {1526        default_limits();1527        1528        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15291530        let origin1 = Origin::signed(1);1531        let origin2 = Origin::signed(2);15321533        assert_ok!(TemplateModule::set_public_access_mode(1534            origin1.clone(),1535            collection_id,1536            AccessMode::WhiteList1537        ));1538        assert_ok!(TemplateModule::set_mint_permission(1539            origin1.clone(),1540            collection_id,1541            true1542        ));15431544        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));15451546        assert_ok!(TemplateModule::create_item(1547            origin2.clone(),1548            1,1549            2,1550            default_nft_data().into()1551        ));1552    });1553}15541555// 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.1556#[test]1557fn white_list_test_15() {1558    new_test_ext().execute_with(|| {1559        default_limits();1560        1561        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15621563        let origin1 = Origin::signed(1);1564        let origin2 = Origin::signed(2);15651566        assert_ok!(TemplateModule::set_public_access_mode(1567            origin1.clone(),1568            collection_id,1569            AccessMode::WhiteList1570        ));1571        assert_ok!(TemplateModule::set_mint_permission(1572            origin1.clone(),1573            collection_id,1574            true1575        ));15761577        assert_noop!(1578            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1579            Error::<Test>::AddresNotInWhiteList1580        );1581    });1582}15831584// 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.1585#[test]1586fn white_list_test_16() {1587    new_test_ext().execute_with(|| {1588        default_limits();1589        1590        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15911592        let origin1 = Origin::signed(1);1593        let origin2 = Origin::signed(2);15941595        assert_ok!(TemplateModule::set_public_access_mode(1596            origin1.clone(),1597            collection_id,1598            AccessMode::WhiteList1599        ));1600        assert_ok!(TemplateModule::set_mint_permission(1601            origin1.clone(),1602            collection_id,1603            true1604        ));1605        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));16061607        assert_ok!(TemplateModule::create_item(1608            origin2.clone(),1609            1,1610            2,1611            default_nft_data().into()1612        ));1613    });1614}16151616// Total number of collections. Positive test1617#[test]1618fn total_number_collections_bound() {1619    new_test_ext().execute_with(|| {1620        default_limits();1621        1622        create_test_collection(&CollectionMode::NFT, 1);1623    });1624}16251626// Total number of collections. Negotive test1627#[test]1628fn total_number_collections_bound_neg() {1629    new_test_ext().execute_with(|| {1630        default_limits();16311632        let origin1 = Origin::signed(1);16331634        for i in 0..default_collection_numbers_limit() {1635            create_test_collection(&CollectionMode::NFT, i + 1);1636        }16371638        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1639        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1640        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();16411642        // 11-th collection in chain. Expects error1643        assert_noop!(TemplateModule::create_collection(1644            origin1.clone(),1645            col_name1.clone(),1646            col_desc1.clone(),1647            token_prefix1.clone(),1648            CollectionMode::NFT1649        ), Error::<Test>::TotalCollectionsLimitExceeded);1650    });1651}16521653// Owned tokens by a single address. Positive test1654#[test]1655fn owned_tokens_bound() {1656    new_test_ext().execute_with(|| {1657        default_limits();1658        1659        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16601661        let data = default_nft_data();1662        create_test_item(collection_id, &data.clone().into());1663        create_test_item(collection_id, &data.into());1664    });1665}16661667// Owned tokens by a single address. Negotive test1668#[test]1669fn owned_tokens_bound_neg() {1670    new_test_ext().execute_with(|| {1671        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1672            collection_numbers_limit: 10,1673            account_token_ownership_limit: 1,1674            collections_admins_limit: 5,1675            custom_data_limit: 2048,1676            nft_sponsor_transfer_timeout: 15,1677            fungible_sponsor_transfer_timeout: 15,1678            refungible_sponsor_transfer_timeout: 15,          1679        }));1680        1681        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16821683        let origin1 = Origin::signed(1);1684        let data = default_nft_data();1685        create_test_item(collection_id, &data.clone().into());16861687        assert_noop!(TemplateModule::create_item(1688            origin1.clone(),1689            1,1690            1,1691            data.into()1692        ),  Error::<Test>::AddressOwnershipLimitExceeded);1693    });1694}16951696// Number of collection admins. Positive test1697#[test]1698fn collection_admins_bound() {1699    new_test_ext().execute_with(|| {1700        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1701            collection_numbers_limit: 10,1702            account_token_ownership_limit: 10,1703            collections_admins_limit: 2,1704            custom_data_limit: 2048,1705            nft_sponsor_transfer_timeout: 15,1706            fungible_sponsor_transfer_timeout: 15,1707            refungible_sponsor_transfer_timeout: 15,          1708        }));1709        1710        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17111712        let origin1 = Origin::signed(1);1713        1714        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1715        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1716    });1717}17181719// Number of collection admins. Negotive test1720#[test]1721fn collection_admins_bound_neg() {1722    new_test_ext().execute_with(|| {1723        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1724            collection_numbers_limit: 10,1725            account_token_ownership_limit: 1,1726            collections_admins_limit: 1,1727            custom_data_limit: 2048,1728            nft_sponsor_transfer_timeout: 15,1729            fungible_sponsor_transfer_timeout: 15,1730            refungible_sponsor_transfer_timeout: 15,          1731        }));1732        1733        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17341735        let origin1 = Origin::signed(1);17361737        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1738        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), Error::<Test>::CollectionAdminsLimitExceeded);1739    });1740}17411742// NFT custom data size. Negative test const_data.1743#[test]1744fn custom_data_size_nft_const_data_bound_neg() {1745    new_test_ext().execute_with(|| {1746        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1747            collection_numbers_limit: 10,1748            account_token_ownership_limit: 10,1749            collections_admins_limit: 5,1750            custom_data_limit: 2,1751            nft_sponsor_transfer_timeout: 15,1752            fungible_sponsor_transfer_timeout: 15,1753            refungible_sponsor_transfer_timeout: 15,          1754        }));1755        1756        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17571758        let origin1 = Origin::signed(1);1759        let too_big_const_data = CreateItemData::NFT(CreateNftData{1760            const_data: vec![1, 2, 3, 4],1761            variable_data: vec![]1762        });17631764        assert_noop!(TemplateModule::create_item(1765            origin1.clone(),1766            collection_id,1767            1,1768            too_big_const_data1769        ), Error::<Test>::TokenConstDataLimitExceeded);1770    });1771}17721773// NFT custom data size. Negative test variable_data.1774#[test]1775fn custom_data_size_nft_variable_data_bound_neg() {1776    new_test_ext().execute_with(|| {1777        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1778            collection_numbers_limit: 10,1779            account_token_ownership_limit: 10,1780            collections_admins_limit: 5,1781            custom_data_limit: 2,1782            nft_sponsor_transfer_timeout: 15,1783            fungible_sponsor_transfer_timeout: 15,1784            refungible_sponsor_transfer_timeout: 15,          1785        }));17861787        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17881789        let origin1 = Origin::signed(1);1790        let too_big_const_data = CreateItemData::NFT(CreateNftData{1791            const_data: vec![],1792            variable_data: vec![1, 2, 3, 4]1793        });17941795        assert_noop!(TemplateModule::create_item(1796            origin1.clone(),1797            collection_id,1798            1,1799            too_big_const_data1800        ), Error::<Test>::TokenVariableDataLimitExceeded);1801    });1802}18031804// Re fungible custom data size. Negative test const_data.1805#[test]1806fn custom_data_size_re_fungible_const_data_bound_neg() {1807    new_test_ext().execute_with(|| {1808        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1809            collection_numbers_limit: 10,1810            account_token_ownership_limit: 10,1811            collections_admins_limit: 5,1812            custom_data_limit: 2,1813            nft_sponsor_transfer_timeout: 15,1814            fungible_sponsor_transfer_timeout: 15,1815            refungible_sponsor_transfer_timeout: 15,          1816        }));18171818        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18191820        let origin1 = Origin::signed(1);1821        let too_big_const_data = CreateItemData::NFT(CreateNftData{1822            const_data: vec![1, 2, 3, 4],1823            variable_data: vec![]1824        });18251826        assert_noop!(TemplateModule::create_item(1827            origin1.clone(),1828            collection_id,1829            1,1830            too_big_const_data1831        ), Error::<Test>::TokenConstDataLimitExceeded);1832    });1833}18341835// Re fungible custom data size. Negative test variable_data.1836#[test]1837fn custom_data_size_re_fungible_variable_data_bound_neg() {1838    new_test_ext().execute_with(|| {1839        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1840            collection_numbers_limit: 10,1841            account_token_ownership_limit: 10,1842            collections_admins_limit: 5,1843            custom_data_limit: 2,1844            nft_sponsor_transfer_timeout: 15,1845            fungible_sponsor_transfer_timeout: 15,1846            refungible_sponsor_transfer_timeout: 15,          1847        }));18481849        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18501851        let origin1 = Origin::signed(1);1852        let too_big_const_data = CreateItemData::NFT(CreateNftData{1853            const_data: vec![],1854            variable_data: vec![1, 2, 3, 4]1855        });18561857        assert_noop!(TemplateModule::create_item(1858            origin1.clone(),1859            collection_id,1860            1,1861            too_big_const_data1862        ), Error::<Test>::TokenVariableDataLimitExceeded);1863    });1864}1865// #endregion18661867#[test]1868fn set_const_on_chain_schema() {1869    new_test_ext().execute_with(|| {1870        default_limits();18711872        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18731874        let origin1 = Origin::signed(1);1875        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, b"test const on chain schema".to_vec()));18761877        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"test const on chain schema".to_vec());1878        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"".to_vec());1879    });1880}18811882#[test]1883fn set_variable_on_chain_schema() {1884    new_test_ext().execute_with(|| {1885        default_limits();1886        1887        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18881889        let origin1 = Origin::signed(1);1890        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, b"test variable on chain schema".to_vec()));18911892        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"".to_vec());1893        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"test variable on chain schema".to_vec());1894    });1895}18961897#[test]1898fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1899    new_test_ext().execute_with(|| {1900        default_limits();19011902        let collection_id = create_test_collection(&CollectionMode::NFT, 1);19031904        let origin1 = Origin::signed(1);1905        1906        let data = default_nft_data();1907        create_test_item(1, &data.into());1908        1909        let variable_data = b"test set_variable_meta_data method.".to_vec();1910        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));19111912        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, variable_data);1913    });1914}19151916#[test]1917fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1918    new_test_ext().execute_with(|| {1919        default_limits();19201921        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);19221923        let origin1 = Origin::signed(1);19241925        let data = default_re_fungible_data();1926        create_test_item(1, &data.into());19271928        let variable_data = b"test set_variable_meta_data method.".to_vec();1929        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));19301931        assert_eq!(TemplateModule::refungible_item_id(collection_id, 1).variable_data, variable_data);1932    });1933}193419351936#[test]1937fn set_variable_meta_data_on_fungible_token_fails() {1938    new_test_ext().execute_with(|| {1939        default_limits();19401941        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);19421943        let origin1 = Origin::signed(1);19441945        let data = default_fungible_data();1946        create_test_item(1, &data.into());19471948        let variable_data = b"test set_variable_meta_data method.".to_vec();1949        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()), Error::<Test>::CantStoreMetadataInFungibleTokens);1950    });1951}19521953#[test]1954fn set_variable_meta_data_on_nft_token_fails_for_big_data() {1955    new_test_ext().execute_with(|| {1956        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1957            collection_numbers_limit: default_collection_numbers_limit(),1958            account_token_ownership_limit: 10,1959            collections_admins_limit: 5,1960            custom_data_limit: 10,1961            nft_sponsor_transfer_timeout: 15,1962            fungible_sponsor_transfer_timeout: 15,1963            refungible_sponsor_transfer_timeout: 15,          1964        }));19651966        let collection_id = create_test_collection(&CollectionMode::NFT, 1);19671968        let origin1 = Origin::signed(1);19691970        let data = default_nft_data();1971        create_test_item(1, &data.into());19721973        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1974        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);1975    });1976}19771978#[test]1979fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {1980    new_test_ext().execute_with(|| {1981        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1982            collection_numbers_limit: default_collection_numbers_limit(),1983            account_token_ownership_limit: 10,1984            collections_admins_limit: 5,1985            custom_data_limit: 10,1986            nft_sponsor_transfer_timeout: 15,1987            fungible_sponsor_transfer_timeout: 15,1988            refungible_sponsor_transfer_timeout: 15,          1989        }));199019911992        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);19931994        let origin1 = Origin::signed(1);19951996        let data = default_re_fungible_data();1997        create_test_item(1, &data.into());19981999        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();2000        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);2001    });2002}