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

1// Tests to be written here2use super::*;3use crate::mock::*;4use crate::{AccessMode, 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            const_on_chain_schema_limit: 1024,24            offchain_schema_limit: 1024,25            variable_on_chain_schema_limit: 1024,26        }));27}2829fn default_nft_data() -> CreateNftData {30    CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }31}3233fn default_fungible_data () -> CreateFungibleData {34    CreateFungibleData { value: 5 }35}3637fn default_re_fungible_data () -> CreateReFungibleData {38    CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }39}4041fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64, id: CollectionId) -> CollectionId {42    let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();43    let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();44    let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();4546    let origin1 = Origin::signed(owner);47    assert_ok!(TemplateModule::create_collection(48            origin1.clone(),49            col_name1.clone(),50            col_desc1.clone(),51            token_prefix1.clone(),52            mode.clone()53        ));5455    let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();56    let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();57    let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();58    assert_eq!(TemplateModule::collection(id).owner, owner);59    assert_eq!(TemplateModule::collection(id).name, saved_col_name);60    assert_eq!(TemplateModule::collection(id).mode, *mode);61    assert_eq!(TemplateModule::collection(id).description, saved_description);62    assert_eq!(TemplateModule::collection(id).token_prefix, saved_prefix);63    id64}6566fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {67    create_test_collection_for_owner(&mode, 1, id)68}6970fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {71    let origin1 = Origin::signed(1);72    assert_ok!(TemplateModule::create_item(73            origin1.clone(),74            collection_id,75            1,76            data.clone()77        ));7879}8081// Use cases tests region82// #region8384#[test]85fn set_version_schema() {86    new_test_ext().execute_with(|| {87        default_limits();88        let origin1 = Origin::signed(1);89        let collection_id = create_test_collection(&CollectionMode::NFT, 1);90        91        assert_ok!(TemplateModule::set_schema_version(origin1, collection_id, SchemaVersion::Unique));92        assert_eq!(TemplateModule::collection(collection_id).schema_version, SchemaVersion::Unique);93    });94}9596#[test]97fn create_fungible_collection_fails_with_large_decimal_numbers() {98    new_test_ext().execute_with(|| {99        default_limits();100101        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();102        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();103        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();104105        let origin1 = Origin::signed(1);106        assert_noop!(TemplateModule::create_collection(107            origin1,108            col_name1,109            col_desc1,110            token_prefix1,111            CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1)112        ), Error::<Test>::CollectionDecimalPointLimitExceeded);113    });    114}115116#[test]117fn create_re_fungible_collection_fails_with_large_decimal_numbers() {118    new_test_ext().execute_with(|| {119        default_limits();120121        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();122        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();123        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();124125        let origin1 = Origin::signed(1);126        assert_noop!(TemplateModule::create_collection(127            origin1,128            col_name1,129            col_desc1,130            token_prefix1,131            CollectionMode::ReFungible(MAX_DECIMAL_POINTS + 1)132        ), Error::<Test>::CollectionDecimalPointLimitExceeded);133    });134}135136#[test]137fn create_nft_item() {138    new_test_ext().execute_with(|| {139        default_limits();140        let collection_id = create_test_collection(&CollectionMode::NFT, 1);141        142        let data = default_nft_data();143        create_test_item(collection_id, &data.clone().into());144        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);145        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);146    });147}148149// Use cases tests region150// #region151#[test]152fn create_nft_multiple_items() {153    new_test_ext().execute_with(|| {154        default_limits();155        156        create_test_collection(&CollectionMode::NFT, 1);157158        let origin1 = Origin::signed(1);159160        let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];161162        assert_ok!(TemplateModule::create_multiple_items(163            origin1.clone(),164            1,165            1,166            items_data.clone().into_iter().map(|d| { d.into() }).collect()167        ));168        for (index, data) in items_data.iter().enumerate() {169            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as TokenId).const_data.to_vec(), data.const_data);170            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as TokenId).variable_data.to_vec(), data.variable_data);171        }172    });173}174175#[test]176fn create_refungible_item() {177    new_test_ext().execute_with(|| {178        default_limits();179        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);180181        let data = default_re_fungible_data();182        create_test_item(collection_id, &data.clone().into());183        assert_eq!(184            TemplateModule::refungible_item_id(collection_id, 1).const_data,185            data.const_data186        );187        assert_eq!(188            TemplateModule::refungible_item_id(collection_id, 1).variable_data,189            data.variable_data190        );191        assert_eq!(192            TemplateModule::refungible_item_id(collection_id, 1).owner[0],193            Ownership {194                owner: 1,195                fraction: 1000196            }197        );198    });199}200201#[test]202fn create_multiple_refungible_items() {203    new_test_ext().execute_with(|| {204        default_limits();205        206        create_test_collection(&CollectionMode::ReFungible(3), 1);207208        let origin1 = Origin::signed(1);209210        let items_data = vec![default_re_fungible_data(), default_re_fungible_data(), default_re_fungible_data()];211212        assert_ok!(TemplateModule::create_multiple_items(213            origin1.clone(),214            1,215            1,216            items_data.clone().into_iter().map(|d| { d.into() }).collect()217        ));218        for (index, data) in items_data.iter().enumerate() {219220            let item = TemplateModule::refungible_item_id(1, (index + 1) as TokenId);221            assert_eq!(item.const_data.to_vec(), data.const_data);222            assert_eq!(item.variable_data.to_vec(), data.variable_data);223            assert_eq!(224                item.owner[0],225                Ownership {226                    owner: 1,227                    fraction: 1000228                }229            );230        }231    });232}233234#[test]235fn create_fungible_item() {236    new_test_ext().execute_with(|| {237        default_limits();238        239        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);240241        let data = default_fungible_data();242        create_test_item(collection_id, &data.into());243244        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).value, 5);245    });246}247248//#[test]249// fn create_multiple_fungible_items() {250//     new_test_ext().execute_with(|| {251//         default_limits();252253//         create_test_collection(&CollectionMode::Fungible(3), 1);254255//         let origin1 = Origin::signed(1);256257//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];258259//         assert_ok!(TemplateModule::create_multiple_items(260//             origin1.clone(),261//             1,262//             1,263//             items_data.clone().into_iter().map(|d| { d.into() }).collect()264//         ));265        266//         for (index, _) in items_data.iter().enumerate() {267//             assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).value, 5);268//         }269//         assert_eq!(TemplateModule::balance_count(1, 1), 3000);270//         assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);271//     });272// }273274#[test]275fn transfer_fungible_item() {276    new_test_ext().execute_with(|| {277        default_limits();278        279        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);280281        let origin1 = Origin::signed(1);282        let origin2 = Origin::signed(2);283284        let data = default_fungible_data();285        create_test_item(collection_id, &data.into());286287        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 5);288        assert_eq!(TemplateModule::balance_count(1, 1), 5);289290        // change owner scenario291        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 5));292        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 0);293        assert_eq!(TemplateModule::balance_count(1, 1), 0);294        assert_eq!(TemplateModule::balance_count(1, 2), 5);295296        // split item scenario297        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 3));298        assert_eq!(TemplateModule::balance_count(1, 2), 2);299        assert_eq!(TemplateModule::balance_count(1, 3), 3);300301        // split item and new owner has account scenario302        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 1));303        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 1);304        assert_eq!(TemplateModule::fungible_item_id(1, 3).value, 4);305        assert_eq!(TemplateModule::balance_count(1, 2), 1);306        assert_eq!(TemplateModule::balance_count(1, 3), 4);307    });308}309310#[test]311fn transfer_refungible_item() {312    new_test_ext().execute_with(|| {313        default_limits();314        315        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);316317        let data = default_re_fungible_data();318        create_test_item(collection_id, &data.clone().into());319320        let origin1 = Origin::signed(1);321        let origin2 = Origin::signed(2);322        assert_eq!(323            TemplateModule::refungible_item_id(collection_id, 1).const_data,324            data.const_data325        );326        assert_eq!(327            TemplateModule::refungible_item_id(collection_id, 1).variable_data,328            data.variable_data329        );330        assert_eq!(331            TemplateModule::refungible_item_id(collection_id, 1).owner[0],332            Ownership {333                owner: 1,334                fraction: 1000335            }336        );337        assert_eq!(TemplateModule::balance_count(1, 1), 1000);338        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);339340        // change owner scenario341        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));342        assert_eq!(343            TemplateModule::refungible_item_id(1, 1).owner[0],344            Ownership {345                owner: 2,346                fraction: 1000347            }348        );349        assert_eq!(TemplateModule::balance_count(1, 1), 0);350        assert_eq!(TemplateModule::balance_count(1, 2), 1000);351        // assert_eq!(TemplateModule::address_tokens(1, 1), []);352        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);353354        // split item scenario355        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));356        assert_eq!(357            TemplateModule::refungible_item_id(1, 1).owner[0],358            Ownership {359                owner: 2,360                fraction: 500361            }362        );363        assert_eq!(364            TemplateModule::refungible_item_id(1, 1).owner[1],365            Ownership {366                owner: 3,367                fraction: 500368            }369        );370        assert_eq!(TemplateModule::balance_count(1, 2), 500);371        assert_eq!(TemplateModule::balance_count(1, 3), 500);372        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);373        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);374375        // split item and new owner has account scenario376        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));377        assert_eq!(378            TemplateModule::refungible_item_id(1, 1).owner[0],379            Ownership {380                owner: 2,381                fraction: 300382            }383        );384        assert_eq!(385            TemplateModule::refungible_item_id(1, 1).owner[1],386            Ownership {387                owner: 3,388                fraction: 700389            }390        );391        assert_eq!(TemplateModule::balance_count(1, 2), 300);392        assert_eq!(TemplateModule::balance_count(1, 3), 700);393        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);394        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);395    });396}397398#[test]399fn transfer_nft_item() {400    new_test_ext().execute_with(|| {401        default_limits();402        403        let collection_id = create_test_collection(&CollectionMode::NFT, 1);404405        let data = default_nft_data();406        create_test_item(collection_id, &data.into());407        assert_eq!(TemplateModule::balance_count(1, 1), 1);408        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);409410        let origin1 = Origin::signed(1);411        // default scenario412        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));413        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);414        assert_eq!(TemplateModule::balance_count(1, 1), 0);415        assert_eq!(TemplateModule::balance_count(1, 2), 1);416        // assert_eq!(TemplateModule::address_tokens(1, 1), []);417        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);418    });419}420421#[test]422fn nft_approve_and_transfer_from() {423    new_test_ext().execute_with(|| {424        default_limits();425        426        let collection_id = create_test_collection(&CollectionMode::NFT, 1);427428        let data = default_nft_data();429        create_test_item(collection_id, &data.into());430431        let origin1 = Origin::signed(1);432        let origin2 = Origin::signed(2);433434        assert_eq!(TemplateModule::balance_count(1, 1), 1);435        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);436437        // neg transfer438        assert_noop!(TemplateModule::transfer_from(439            origin2.clone(),440            1,441            2,442            1,443            1,444            1), Error::<Test>::NoPermission);445446        // do approve447        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));448        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);449        assert_eq!(450            TemplateModule::approved(1, (1, 1, 2)),451            5452        );453454        assert_ok!(TemplateModule::transfer_from(455            origin2.clone(),456            1,457            2,458            1,459            1,460            1461        ));462        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 4);463    });464}465466#[test]467fn nft_approve_and_transfer_from_white_list() {468    new_test_ext().execute_with(|| {469        default_limits();470        471        let collection_id = create_test_collection(&CollectionMode::NFT, 1);472473        let origin1 = Origin::signed(1);474        let origin2 = Origin::signed(2);475476        let data = default_nft_data();477        create_test_item(collection_id, &data.clone().into());478479        assert_eq!(TemplateModule::nft_item_id(1, 1).const_data, data.const_data);480        assert_eq!(TemplateModule::balance_count(1, 1), 1);481        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);482483        assert_ok!(TemplateModule::set_mint_permission(484            origin1.clone(),485            1,486            true487        ));488        assert_ok!(TemplateModule::set_public_access_mode(489            origin1.clone(),490            1,491            AccessMode::WhiteList492        ));493        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));494        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));495        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));496497        // do approve498        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));499        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);500        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 5));501        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);502503        assert_ok!(TemplateModule::transfer_from(504            origin2.clone(),505            1,506            3,507            1,508            1,509            1510        ));511        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 4);512    });513}514515#[test]516fn refungible_approve_and_transfer_from() {517    new_test_ext().execute_with(|| {518        default_limits();519        520        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);521        522        let origin1 = Origin::signed(1);523        let origin2 = Origin::signed(2);524525        let data = default_re_fungible_data();526        create_test_item(collection_id, &data.into());527528        assert_eq!(TemplateModule::balance_count(1, 1), 1000);529        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);530531        assert_ok!(TemplateModule::set_mint_permission(532            origin1.clone(),533            1,534            true535        ));536        assert_ok!(TemplateModule::set_public_access_mode(537            origin1.clone(),538            1,539            AccessMode::WhiteList540        ));541        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));542        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));543        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));544545        // do approve546        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));547        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);548        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 1000));549        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 1000);550551        assert_ok!(TemplateModule::transfer_from(552            origin2.clone(),553            1,554            3,555            1,556            1,557            100558        ));559        assert_eq!(TemplateModule::balance_count(1, 1), 900);560        assert_eq!(TemplateModule::balance_count(1, 3), 100);561        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);562        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);563564        assert_eq!(565            TemplateModule::approved(1, (1, 1, 3)),566            900567        );568    });569}570571#[test]572fn fungible_approve_and_transfer_from() {573    new_test_ext().execute_with(|| {574        default_limits();575        576        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);577        578        let data = default_fungible_data();579        create_test_item(collection_id, &data.into());580581        let origin1 = Origin::signed(1);582        let origin2 = Origin::signed(2);583584        assert_eq!(TemplateModule::balance_count(1, 1), 5);585586        assert_ok!(TemplateModule::set_mint_permission(587            origin1.clone(),588            1,589            true590        ));591        assert_ok!(TemplateModule::set_public_access_mode(592            origin1.clone(),593            1,594            AccessMode::WhiteList595        ));596        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));597        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));598        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));599600        // do approve601        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));602        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);603        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 5));604        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);605        assert_eq!(606            TemplateModule::approved(1, (1, 1, 2)),607            5608        );609610        assert_ok!(TemplateModule::transfer_from(611            origin2.clone(),612            1,613            3,614            1,615            1,616            4617        ));618        assert_eq!(TemplateModule::balance_count(1, 1), 1);619        assert_eq!(TemplateModule::balance_count(1, 3), 4);620621        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);622623        assert_noop!(TemplateModule::transfer_from(624            origin2.clone(),625            1,626            3,627            1,628            1,629            4630        ), Error::<Test>::TokenValueNotEnough);631    });632}633634#[test]635fn change_collection_owner() {636    new_test_ext().execute_with(|| {637        default_limits();638        639        let collection_id = create_test_collection(&CollectionMode::NFT, 1);640        641        let origin1 = Origin::signed(1);642        assert_ok!(TemplateModule::change_collection_owner(643            origin1.clone(),644            collection_id,645            2646        ));647        assert_eq!(TemplateModule::collection(collection_id).owner, 2);648    });649}650651#[test]652fn destroy_collection() {653    new_test_ext().execute_with(|| {654        default_limits();655        656        let collection_id = create_test_collection(&CollectionMode::NFT, 1);657        658        let origin1 = Origin::signed(1);659        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));660    });661}662663#[test]664fn burn_nft_item() {665    new_test_ext().execute_with(|| {666        default_limits();667        668        let collection_id = create_test_collection(&CollectionMode::NFT, 1);669670        let origin1 = Origin::signed(1);671        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));672        673        let data = default_nft_data();674        create_test_item(collection_id, &data.into());675676        // check balance (collection with id = 1, user id = 1)677        assert_eq!(TemplateModule::balance_count(1, 1), 1);678679        // burn item680        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));681        assert_noop!(682            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),683            Error::<Test>::TokenNotFound684        );685686        assert_eq!(TemplateModule::balance_count(1, 1), 0);687    });688}689690#[test]691fn burn_fungible_item() {692    new_test_ext().execute_with(|| {693        default_limits();694        695        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);696        697        let origin1 = Origin::signed(1);698        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));699        700        let data = default_fungible_data();701        create_test_item(collection_id, &data.into());702703        // check balance (collection with id = 1, user id = 1)704        assert_eq!(TemplateModule::balance_count(1, 1), 5);705706        // burn item707        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));708        assert_noop!(709            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),710            Error::<Test>::TokenNotFound711        );712713        assert_eq!(TemplateModule::balance_count(1, 1), 0);714    });715}716717#[test]718fn burn_refungible_item() {719    new_test_ext().execute_with(|| {720        default_limits();721        722        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);723        let origin1 = Origin::signed(1);724725        assert_ok!(TemplateModule::set_mint_permission(726            origin1.clone(),727            collection_id,728            true729        ));730        assert_ok!(TemplateModule::set_public_access_mode(731            origin1.clone(),732            collection_id,733            AccessMode::WhiteList734        ));735        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));736737        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));738        739        let data = default_re_fungible_data();740        create_test_item(collection_id, &data.into());741742        // check balance (collection with id = 1, user id = 2)743        assert_eq!(TemplateModule::balance_count(1, 1), 1000);744745        // burn item746        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 1000));747        assert_noop!(748            TemplateModule::burn_item(origin1.clone(), 1, 1, 1000),749            Error::<Test>::TokenNotFound750        );751752        assert_eq!(TemplateModule::balance_count(1, 1), 0);753    });754}755756#[test]757fn add_collection_admin() {758    new_test_ext().execute_with(|| {759        default_limits();760        761        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);762        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);763        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);764        765        let origin1 = Origin::signed(1);766767        // collection admin768        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));769        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));770771        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);772        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);773    });774}775776#[test]777fn remove_collection_admin() {778    new_test_ext().execute_with(|| {779        default_limits();780        781        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);782        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);783        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);784785        let origin1 = Origin::signed(1);786        let origin2 = Origin::signed(2);787788        // collection admin789        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));790        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));791792        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);793        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);794795        // remove admin796        assert_ok!(TemplateModule::remove_collection_admin(797            origin2.clone(),798            1,799            3800        ));801        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);802    });803}804805#[test]806fn balance_of() {807    new_test_ext().execute_with(|| {808        default_limits();809        810        let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);811        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);812        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3), 3);813        814        // check balance before815        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);816        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);817        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);818819        let nft_data = default_nft_data();820        create_test_item(nft_collection_id, &nft_data.into());821        822        let fungible_data = default_fungible_data();823        create_test_item(fungible_collection_id, &fungible_data.into());824        825        let re_fungible_data = default_re_fungible_data();826        create_test_item(re_fungible_collection_id, &re_fungible_data.into());827828        // check balance (collection with id = 1, user id = 1)829        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);830        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 5);831        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);832        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);833        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).value, 5);834        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);835    });836}837838#[test]839fn approve() {840    new_test_ext().execute_with(|| {841        default_limits();842        843        let collection_id = create_test_collection(&CollectionMode::NFT, 1);844        845        let data = default_nft_data();846        create_test_item(collection_id, &data.into());847848        let origin1 = Origin::signed(1);849        850        // approve851        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 1));852        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);853    });854}855856#[test]857fn transfer_from() {858    new_test_ext().execute_with(|| {859        default_limits();860        861        let collection_id = create_test_collection(&CollectionMode::NFT, 1);862        let origin1 = Origin::signed(1);863        let origin2 = Origin::signed(2);864865        let data = default_nft_data();866        create_test_item(collection_id, &data.into());867868        // approve869        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 1));870        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);871872        assert_ok!(TemplateModule::set_mint_permission(873            origin1.clone(),874            1,875            true876        ));877        assert_ok!(TemplateModule::set_public_access_mode(878            origin1.clone(),879            1,880            AccessMode::WhiteList881        ));882        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));883        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));884        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));885886        assert_ok!(TemplateModule::transfer_from(887            origin2.clone(),888            1,889            2,890            1,891            1,892            1893        ));894895        // after transfer896        assert_eq!(TemplateModule::balance_count(1, 1), 0);897        assert_eq!(TemplateModule::balance_count(1, 2), 1);898    });899}900901// #endregion902903// Coverage tests region904// #region905906#[test]907fn owner_can_add_address_to_white_list() {908    new_test_ext().execute_with(|| {909        default_limits();910        911        let collection_id = create_test_collection(&CollectionMode::NFT, 1);912913        let origin1 = Origin::signed(1);914        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));915        assert_eq!(TemplateModule::white_list(collection_id, 2), true);916    });917}918919#[test]920fn admin_can_add_address_to_white_list() {921    new_test_ext().execute_with(|| {922        default_limits();923        924        let collection_id = create_test_collection(&CollectionMode::NFT, 1);925        let origin1 = Origin::signed(1);926        let origin2 = Origin::signed(2);927928        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));929        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));930        assert_eq!(TemplateModule::white_list(collection_id, 3), true);931    });932}933934#[test]935fn nonprivileged_user_cannot_add_address_to_white_list() {936    new_test_ext().execute_with(|| {937        default_limits();938        939        let collection_id = create_test_collection(&CollectionMode::NFT, 1);940941        let origin2 = Origin::signed(2);942        assert_noop!(943            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),944            Error::<Test>::NoPermission945        );946    });947}948949#[test]950fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {951    new_test_ext().execute_with(|| {952        default_limits();953954        let origin1 = Origin::signed(1);955956        assert_noop!(957            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),958            Error::<Test>::CollectionNotFound959        );960    });961}962963#[test]964fn nobody_can_add_address_to_white_list_of_deleted_collection() {965    new_test_ext().execute_with(|| {966        default_limits();967        968        let collection_id = create_test_collection(&CollectionMode::NFT, 1);969970        let origin1 = Origin::signed(1);971        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));972        assert_noop!(973            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),974            Error::<Test>::CollectionNotFound975        );976    });977}978979// If address is already added to white list, nothing happens980#[test]981fn address_is_already_added_to_white_list() {982    new_test_ext().execute_with(|| {983        default_limits();984        985        let collection_id = create_test_collection(&CollectionMode::NFT, 1);986        let origin1 = Origin::signed(1);987        988        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));989        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));990        assert_eq!(TemplateModule::white_list(collection_id, 2), true);991    });992}993994#[test]995fn owner_can_remove_address_from_white_list() {996    new_test_ext().execute_with(|| {997        default_limits();998        999        let collection_id = create_test_collection(&CollectionMode::NFT, 1);10001001        let origin1 = Origin::signed(1);1002        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1003        assert_ok!(TemplateModule::remove_from_white_list(1004            origin1.clone(),1005            collection_id,1006            21007        ));1008        assert_eq!(TemplateModule::white_list(collection_id, 2), false);1009    });1010}10111012#[test]1013fn admin_can_remove_address_from_white_list() {1014    new_test_ext().execute_with(|| {1015        default_limits();1016        1017        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1018        let origin1 = Origin::signed(1);1019        let origin2 = Origin::signed(2);10201021        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));10221023        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));1024        assert_ok!(TemplateModule::remove_from_white_list(1025            origin2.clone(),1026            collection_id,1027            31028        ));1029        assert_eq!(TemplateModule::white_list(collection_id, 3), false);1030    });1031}10321033#[test]1034fn nonprivileged_user_cannot_remove_address_from_white_list() {1035    new_test_ext().execute_with(|| {1036        default_limits();1037        1038        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1039        let origin1 = Origin::signed(1);1040        let origin2 = Origin::signed(2);10411042        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1043        assert_noop!(1044            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1045            Error::<Test>::NoPermission1046        );1047        assert_eq!(TemplateModule::white_list(collection_id, 2), true);1048    });1049}10501051#[test]1052fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1053    new_test_ext().execute_with(|| {1054        default_limits();1055        let origin1 = Origin::signed(1);10561057        assert_noop!(1058            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),1059            Error::<Test>::CollectionNotFound1060        );1061    });1062}10631064#[test]1065fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1066    new_test_ext().execute_with(|| {1067        default_limits();1068        1069        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1070        let origin1 = Origin::signed(1);1071        let origin2 = Origin::signed(2);10721073        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1074        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));1075        assert_noop!(1076            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1077            Error::<Test>::CollectionNotFound1078        );1079        assert_eq!(TemplateModule::white_list(collection_id, 2), false);1080    });1081}10821083// If address is already removed from white list, nothing happens1084#[test]1085fn address_is_already_removed_from_white_list() {1086    new_test_ext().execute_with(|| {1087        default_limits();1088        1089        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1090        let origin1 = Origin::signed(1);10911092        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1093        assert_ok!(TemplateModule::remove_from_white_list(1094            origin1.clone(),1095            collection_id,1096            21097        ));1098        assert_ok!(TemplateModule::remove_from_white_list(1099            origin1.clone(),1100            collection_id,1101            21102        ));1103        assert_eq!(TemplateModule::white_list(collection_id, 2), false);1104    });1105}11061107// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1108#[test]1109fn white_list_test_1() {1110    new_test_ext().execute_with(|| {1111        default_limits();1112        1113        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11141115        let origin1 = Origin::signed(1);1116        1117        let data = default_nft_data();1118        create_test_item(collection_id, &data.into());11191120        assert_ok!(TemplateModule::set_public_access_mode(1121            origin1.clone(),1122            collection_id,1123            AccessMode::WhiteList1124        ));1125        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11261127        assert_noop!(1128            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1129            Error::<Test>::AddresNotInWhiteList1130        );1131    });1132}11331134#[test]1135fn white_list_test_2() {1136    new_test_ext().execute_with(|| {1137        default_limits();1138        1139        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1140        let origin1 = Origin::signed(1);1141        1142        let data = default_nft_data();1143        create_test_item(collection_id, &data.into());11441145        assert_ok!(TemplateModule::set_public_access_mode(1146            origin1.clone(),1147            collection_id,1148            AccessMode::WhiteList1149        ));1150        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1151        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));11521153        // do approve1154        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 1));1155        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);11561157        assert_ok!(TemplateModule::remove_from_white_list(1158            origin1.clone(),1159            1,1160            11161        ));11621163        assert_noop!(1164            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1165            Error::<Test>::AddresNotInWhiteList1166        );1167    });1168}11691170// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1171#[test]1172fn white_list_test_3() {1173    new_test_ext().execute_with(|| {1174        default_limits();1175        1176        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11771178        let origin1 = Origin::signed(1);1179        1180        let data = default_nft_data();1181        create_test_item(collection_id, &data.into());11821183        assert_ok!(TemplateModule::set_public_access_mode(1184            origin1.clone(),1185            collection_id,1186            AccessMode::WhiteList1187        ));1188        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));11891190        assert_noop!(1191            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1192            Error::<Test>::AddresNotInWhiteList1193        );1194    });1195}11961197#[test]1198fn white_list_test_4() {1199    new_test_ext().execute_with(|| {1200        default_limits();1201        1202        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12031204        let origin1 = Origin::signed(1);12051206        let data = default_nft_data();1207        create_test_item(collection_id, &data.into());12081209        assert_ok!(TemplateModule::set_public_access_mode(1210            origin1.clone(),1211            collection_id,1212            AccessMode::WhiteList1213        ));1214        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1215        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12161217        // do approve1218        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 1));1219        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);12201221        assert_ok!(TemplateModule::remove_from_white_list(1222            origin1.clone(),1223            collection_id,1224            21225        ));12261227        assert_noop!(1228            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1229            Error::<Test>::AddresNotInWhiteList1230        );1231    });1232}12331234// 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)1235#[test]1236fn white_list_test_5() {1237    new_test_ext().execute_with(|| {1238        default_limits();1239        1240        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12411242        let origin1 = Origin::signed(1);12431244        let data = default_nft_data();1245        create_test_item(collection_id, &data.into());12461247        assert_ok!(TemplateModule::set_public_access_mode(1248            origin1.clone(),1249            collection_id,1250            AccessMode::WhiteList1251        ));1252        assert_noop!(1253            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),1254            Error::<Test>::AddresNotInWhiteList1255        );1256    });1257}12581259// If Public Access mode is set to WhiteList, token transfers can’t be Approved by a non-whitelisted address (see Approve method).1260#[test]1261fn white_list_test_6() {1262    new_test_ext().execute_with(|| {1263        default_limits();1264        1265        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12661267        let origin1 = Origin::signed(1);12681269        let data = default_nft_data();1270        create_test_item(collection_id, &data.into());12711272        assert_ok!(TemplateModule::set_public_access_mode(1273            origin1.clone(),1274            collection_id,1275            AccessMode::WhiteList1276        ));12771278        // do approve1279        assert_noop!(1280            TemplateModule::approve(origin1.clone(), 1, 1, 1, 5),1281            Error::<Test>::AddresNotInWhiteList1282        );1283    });1284}12851286// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1287//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1288#[test]1289fn white_list_test_7() {1290    new_test_ext().execute_with(|| {1291        default_limits();1292        1293        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12941295        let data = default_nft_data();1296        create_test_item(collection_id, &data.into());1297        1298        let origin1 = Origin::signed(1);12991300        assert_ok!(TemplateModule::set_public_access_mode(1301            origin1.clone(),1302            collection_id,1303            AccessMode::WhiteList1304        ));1305        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1306        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13071308        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1309    });1310}13111312#[test]1313fn white_list_test_8() {1314    new_test_ext().execute_with(|| {1315        default_limits();1316        1317        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13181319        let data = default_nft_data();1320        create_test_item(collection_id, &data.into());1321        1322        let origin1 = Origin::signed(1);13231324        assert_ok!(TemplateModule::set_public_access_mode(1325            origin1.clone(),1326            collection_id,1327            AccessMode::WhiteList1328        ));1329        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1330        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13311332        // do approve1333        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 5));1334        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 5);13351336        assert_ok!(TemplateModule::transfer_from(1337            origin1.clone(),1338            1,1339            2,1340            1,1341            1,1342            11343        ));1344    });1345}13461347// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1348#[test]1349fn white_list_test_9() {1350    new_test_ext().execute_with(|| {1351        default_limits();1352        1353        let collection_id = create_test_collection(&CollectionMode::NFT, 1);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::set_mint_permission(1362            origin1.clone(),1363            collection_id,1364            false1365        ));13661367        let data = default_nft_data();1368        create_test_item(collection_id, &data.into());1369    });1370}13711372// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1373#[test]1374fn white_list_test_10() {1375    new_test_ext().execute_with(|| {1376        default_limits();1377        1378        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13791380        let origin1 = Origin::signed(1);1381        let origin2 = Origin::signed(2);13821383        assert_ok!(TemplateModule::set_public_access_mode(1384            origin1.clone(),1385            collection_id,1386            AccessMode::WhiteList1387        ));1388        assert_ok!(TemplateModule::set_mint_permission(1389            origin1.clone(),1390            collection_id,1391            false1392        ));13931394        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));13951396        assert_ok!(TemplateModule::create_item(1397            origin2.clone(),1398            collection_id,1399            2,1400            default_nft_data().into()1401        ));1402    });1403}14041405// 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.1406#[test]1407fn white_list_test_11() {1408    new_test_ext().execute_with(|| {1409        default_limits();1410        1411        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14121413        let origin1 = Origin::signed(1);1414        let origin2 = Origin::signed(2);14151416        assert_ok!(TemplateModule::set_public_access_mode(1417            origin1.clone(),1418            collection_id,1419            AccessMode::WhiteList1420        ));1421        assert_ok!(TemplateModule::set_mint_permission(1422            origin1.clone(),1423            collection_id,1424            false1425        ));1426        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14271428        assert_noop!(1429            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1430            Error::<Test>::PublicMintingNotAllowed1431        );1432    });1433}14341435// 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.1436#[test]1437fn white_list_test_12() {1438    new_test_ext().execute_with(|| {1439        default_limits();1440        1441        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14421443        let origin1 = Origin::signed(1);1444        let origin2 = Origin::signed(2);14451446        assert_ok!(TemplateModule::set_public_access_mode(1447            origin1.clone(),1448            collection_id,1449            AccessMode::WhiteList1450        ));1451        assert_ok!(TemplateModule::set_mint_permission(1452            origin1.clone(),1453            collection_id,1454            false1455        ));14561457        assert_noop!(1458            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1459            Error::<Test>::PublicMintingNotAllowed1460        );1461    });1462}14631464// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1465#[test]1466fn white_list_test_13() {1467    new_test_ext().execute_with(|| {1468        default_limits();1469        1470        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14711472        let origin1 = Origin::signed(1);14731474        assert_ok!(TemplateModule::set_public_access_mode(1475            origin1.clone(),1476            collection_id,1477            AccessMode::WhiteList1478        ));1479        assert_ok!(TemplateModule::set_mint_permission(1480            origin1.clone(),1481            collection_id,1482            true1483        ));14841485        let data = default_nft_data();1486        create_test_item(collection_id, &data.into());1487    });1488}14891490// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1491#[test]1492fn white_list_test_14() {1493    new_test_ext().execute_with(|| {1494        default_limits();1495        1496        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14971498        let origin1 = Origin::signed(1);1499        let origin2 = Origin::signed(2);15001501        assert_ok!(TemplateModule::set_public_access_mode(1502            origin1.clone(),1503            collection_id,1504            AccessMode::WhiteList1505        ));1506        assert_ok!(TemplateModule::set_mint_permission(1507            origin1.clone(),1508            collection_id,1509            true1510        ));15111512        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));15131514        assert_ok!(TemplateModule::create_item(1515            origin2.clone(),1516            1,1517            2,1518            default_nft_data().into()1519        ));1520    });1521}15221523// 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.1524#[test]1525fn white_list_test_15() {1526    new_test_ext().execute_with(|| {1527        default_limits();1528        1529        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15301531        let origin1 = Origin::signed(1);1532        let origin2 = Origin::signed(2);15331534        assert_ok!(TemplateModule::set_public_access_mode(1535            origin1.clone(),1536            collection_id,1537            AccessMode::WhiteList1538        ));1539        assert_ok!(TemplateModule::set_mint_permission(1540            origin1.clone(),1541            collection_id,1542            true1543        ));15441545        assert_noop!(1546            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1547            Error::<Test>::AddresNotInWhiteList1548        );1549    });1550}15511552// 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.1553#[test]1554fn white_list_test_16() {1555    new_test_ext().execute_with(|| {1556        default_limits();1557        1558        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15591560        let origin1 = Origin::signed(1);1561        let origin2 = Origin::signed(2);15621563        assert_ok!(TemplateModule::set_public_access_mode(1564            origin1.clone(),1565            collection_id,1566            AccessMode::WhiteList1567        ));1568        assert_ok!(TemplateModule::set_mint_permission(1569            origin1.clone(),1570            collection_id,1571            true1572        ));1573        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));15741575        assert_ok!(TemplateModule::create_item(1576            origin2.clone(),1577            1,1578            2,1579            default_nft_data().into()1580        ));1581    });1582}15831584// Total number of collections. Positive test1585#[test]1586fn total_number_collections_bound() {1587    new_test_ext().execute_with(|| {1588        default_limits();1589        1590        create_test_collection(&CollectionMode::NFT, 1);1591    });1592}15931594// Total number of collections. Negotive test1595#[test]1596fn total_number_collections_bound_neg() {1597    new_test_ext().execute_with(|| {1598        default_limits();15991600        let origin1 = Origin::signed(1);16011602        for i in 0..default_collection_numbers_limit() {1603            create_test_collection(&CollectionMode::NFT, i + 1);1604        }16051606        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1607        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1608        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();16091610        // 11-th collection in chain. Expects error1611        assert_noop!(TemplateModule::create_collection(1612            origin1.clone(),1613            col_name1.clone(),1614            col_desc1.clone(),1615            token_prefix1.clone(),1616            CollectionMode::NFT1617        ), Error::<Test>::TotalCollectionsLimitExceeded);1618    });1619}16201621// Owned tokens by a single address. Positive test1622#[test]1623fn owned_tokens_bound() {1624    new_test_ext().execute_with(|| {1625        default_limits();1626        1627        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16281629        let data = default_nft_data();1630        create_test_item(collection_id, &data.clone().into());1631        create_test_item(collection_id, &data.into());1632    });1633}16341635// Owned tokens by a single address. Negotive test1636#[test]1637fn owned_tokens_bound_neg() {1638    new_test_ext().execute_with(|| {1639        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1640            collection_numbers_limit: 10,1641            account_token_ownership_limit: 1,1642            collections_admins_limit: 5,1643            custom_data_limit: 2048,1644            nft_sponsor_transfer_timeout: 15,1645            fungible_sponsor_transfer_timeout: 15,1646            refungible_sponsor_transfer_timeout: 15,1647            const_on_chain_schema_limit: 1024,1648            offchain_schema_limit: 1024,1649            variable_on_chain_schema_limit: 1024,1650        }));1651        1652        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16531654        let origin1 = Origin::signed(1);1655        let data = default_nft_data();1656        create_test_item(collection_id, &data.clone().into());16571658        assert_noop!(TemplateModule::create_item(1659            origin1.clone(),1660            1,1661            1,1662            data.into()1663        ),  Error::<Test>::AddressOwnershipLimitExceeded);1664    });1665}16661667// Number of collection admins. Positive test1668#[test]1669fn collection_admins_bound() {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: 10,1674            collections_admins_limit: 2,1675            custom_data_limit: 2048,1676            nft_sponsor_transfer_timeout: 15,1677            fungible_sponsor_transfer_timeout: 15,1678            refungible_sponsor_transfer_timeout: 15,1679            const_on_chain_schema_limit: 1024,1680            offchain_schema_limit: 1024,1681            variable_on_chain_schema_limit: 1024,1682        }));1683        1684        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16851686        let origin1 = Origin::signed(1);1687        1688        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1689        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1690    });1691}16921693// Number of collection admins. Negotive test1694#[test]1695fn collection_admins_bound_neg() {1696    new_test_ext().execute_with(|| {1697        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1698            collection_numbers_limit: 10,1699            account_token_ownership_limit: 1,1700            collections_admins_limit: 1,1701            custom_data_limit: 2048,1702            nft_sponsor_transfer_timeout: 15,1703            fungible_sponsor_transfer_timeout: 15,1704            refungible_sponsor_transfer_timeout: 15,1705            const_on_chain_schema_limit: 1024,1706            offchain_schema_limit: 1024,1707            variable_on_chain_schema_limit: 1024,1708        }));1709        1710        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17111712        let origin1 = Origin::signed(1);17131714        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1715        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), Error::<Test>::CollectionAdminsLimitExceeded);1716    });1717}17181719// NFT custom data size. Negative test const_data.1720#[test]1721fn custom_data_size_nft_const_data_bound_neg() {1722    new_test_ext().execute_with(|| {1723        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1724            collection_numbers_limit: 10,1725            account_token_ownership_limit: 10,1726            collections_admins_limit: 5,1727            custom_data_limit: 2,1728            nft_sponsor_transfer_timeout: 15,1729            fungible_sponsor_transfer_timeout: 15,1730            refungible_sponsor_transfer_timeout: 15,1731            const_on_chain_schema_limit: 1024,1732            offchain_schema_limit: 1024,1733            variable_on_chain_schema_limit: 1024,1734        }));1735        1736        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17371738        let origin1 = Origin::signed(1);1739        let too_big_const_data = CreateItemData::NFT(CreateNftData{1740            const_data: vec![1, 2, 3, 4],1741            variable_data: vec![]1742        });17431744        assert_noop!(TemplateModule::create_item(1745            origin1.clone(),1746            collection_id,1747            1,1748            too_big_const_data1749        ), Error::<Test>::TokenConstDataLimitExceeded);1750    });1751}17521753// NFT custom data size. Negative test variable_data.1754#[test]1755fn custom_data_size_nft_variable_data_bound_neg() {1756    new_test_ext().execute_with(|| {1757        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1758            collection_numbers_limit: 10,1759            account_token_ownership_limit: 10,1760            collections_admins_limit: 5,1761            custom_data_limit: 2,1762            nft_sponsor_transfer_timeout: 15,1763            fungible_sponsor_transfer_timeout: 15,1764            refungible_sponsor_transfer_timeout: 15,1765            const_on_chain_schema_limit: 1024,1766            offchain_schema_limit: 1024,1767            variable_on_chain_schema_limit: 1024,1768        }));17691770        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17711772        let origin1 = Origin::signed(1);1773        let too_big_const_data = CreateItemData::NFT(CreateNftData{1774            const_data: vec![],1775            variable_data: vec![1, 2, 3, 4]1776        });17771778        assert_noop!(TemplateModule::create_item(1779            origin1.clone(),1780            collection_id,1781            1,1782            too_big_const_data1783        ), Error::<Test>::TokenVariableDataLimitExceeded);1784    });1785}17861787// Re fungible custom data size. Negative test const_data.1788#[test]1789fn custom_data_size_re_fungible_const_data_bound_neg() {1790    new_test_ext().execute_with(|| {1791        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1792            collection_numbers_limit: 10,1793            account_token_ownership_limit: 10,1794            collections_admins_limit: 5,1795            custom_data_limit: 2,1796            nft_sponsor_transfer_timeout: 15,1797            fungible_sponsor_transfer_timeout: 15,1798            refungible_sponsor_transfer_timeout: 15,1799            const_on_chain_schema_limit: 1024,1800            offchain_schema_limit: 1024,1801            variable_on_chain_schema_limit: 1024,1802        }));18031804        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18051806        let origin1 = Origin::signed(1);1807        let too_big_const_data = CreateItemData::NFT(CreateNftData{1808            const_data: vec![1, 2, 3, 4],1809            variable_data: vec![]1810        });18111812        assert_noop!(TemplateModule::create_item(1813            origin1.clone(),1814            collection_id,1815            1,1816            too_big_const_data1817        ), Error::<Test>::TokenConstDataLimitExceeded);1818    });1819}18201821// Re fungible custom data size. Negative test variable_data.1822#[test]1823fn custom_data_size_re_fungible_variable_data_bound_neg() {1824    new_test_ext().execute_with(|| {1825        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1826            collection_numbers_limit: 10,1827            account_token_ownership_limit: 10,1828            collections_admins_limit: 5,1829            custom_data_limit: 2,1830            nft_sponsor_transfer_timeout: 15,1831            fungible_sponsor_transfer_timeout: 15,1832            refungible_sponsor_transfer_timeout: 15,1833            const_on_chain_schema_limit: 1024,1834            offchain_schema_limit: 1024,1835            variable_on_chain_schema_limit: 1024,1836        }));18371838        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18391840        let origin1 = Origin::signed(1);1841        let too_big_const_data = CreateItemData::NFT(CreateNftData{1842            const_data: vec![],1843            variable_data: vec![1, 2, 3, 4]1844        });18451846        assert_noop!(TemplateModule::create_item(1847            origin1.clone(),1848            collection_id,1849            1,1850            too_big_const_data1851        ), Error::<Test>::TokenVariableDataLimitExceeded);1852    });1853}1854// #endregion18551856#[test]1857fn set_const_on_chain_schema() {1858    new_test_ext().execute_with(|| {1859        default_limits();18601861        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18621863        let origin1 = Origin::signed(1);1864        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, b"test const on chain schema".to_vec()));18651866        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"test const on chain schema".to_vec());1867        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"".to_vec());1868    });1869}18701871#[test]1872fn set_variable_on_chain_schema() {1873    new_test_ext().execute_with(|| {1874        default_limits();1875        1876        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18771878        let origin1 = Origin::signed(1);1879        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, b"test variable on chain schema".to_vec()));18801881        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"".to_vec());1882        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"test variable on chain schema".to_vec());1883    });1884}18851886#[test]1887fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1888    new_test_ext().execute_with(|| {1889        default_limits();18901891        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18921893        let origin1 = Origin::signed(1);1894        1895        let data = default_nft_data();1896        create_test_item(1, &data.into());1897        1898        let variable_data = b"test set_variable_meta_data method.".to_vec();1899        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));19001901        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, variable_data);1902    });1903}19041905#[test]1906fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1907    new_test_ext().execute_with(|| {1908        default_limits();19091910        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);19111912        let origin1 = Origin::signed(1);19131914        let data = default_re_fungible_data();1915        create_test_item(1, &data.into());19161917        let variable_data = b"test set_variable_meta_data method.".to_vec();1918        assert_ok!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()));19191920        assert_eq!(TemplateModule::refungible_item_id(collection_id, 1).variable_data, variable_data);1921    });1922}192319241925#[test]1926fn set_variable_meta_data_on_fungible_token_fails() {1927    new_test_ext().execute_with(|| {1928        default_limits();19291930        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);19311932        let origin1 = Origin::signed(1);19331934        let data = default_fungible_data();1935        create_test_item(1, &data.into());19361937        let variable_data = b"test set_variable_meta_data method.".to_vec();1938        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data.clone()), Error::<Test>::CantStoreMetadataInFungibleTokens);1939    });1940}19411942#[test]1943fn set_variable_meta_data_on_nft_token_fails_for_big_data() {1944    new_test_ext().execute_with(|| {1945        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1946            collection_numbers_limit: default_collection_numbers_limit(),1947            account_token_ownership_limit: 10,1948            collections_admins_limit: 5,1949            custom_data_limit: 10,1950            nft_sponsor_transfer_timeout: 15,1951            fungible_sponsor_transfer_timeout: 15,1952            refungible_sponsor_transfer_timeout: 15,1953            const_on_chain_schema_limit: 1024,1954            offchain_schema_limit: 1024,1955            variable_on_chain_schema_limit: 1024,1956        }));19571958        let collection_id = create_test_collection(&CollectionMode::NFT, 1);19591960        let origin1 = Origin::signed(1);19611962        let data = default_nft_data();1963        create_test_item(1, &data.into());19641965        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1966        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);1967    });1968}19691970#[test]1971fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {1972    new_test_ext().execute_with(|| {1973        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1974            collection_numbers_limit: default_collection_numbers_limit(),1975            account_token_ownership_limit: 10,1976            collections_admins_limit: 5,1977            custom_data_limit: 10,1978            nft_sponsor_transfer_timeout: 15,1979            fungible_sponsor_transfer_timeout: 15,1980            refungible_sponsor_transfer_timeout: 15,1981            const_on_chain_schema_limit: 1024,1982            offchain_schema_limit: 1024,1983            variable_on_chain_schema_limit: 1024,1984        }));198519861987        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);19881989        let origin1 = Origin::signed(1);19901991        let data = default_re_fungible_data();1992        create_test_item(1, &data.into());19931994        let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1995        assert_noop!(TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data), Error::<Test>::TokenVariableDataLimitExceeded);1996    });1997}