git.delta.rocks / unique-network / refs/commits / 424f9cb7a9fa

1// Tests to be written here2use crate::mock::*;3use crate::{AccessMode, ApprovePermissions, CollectionMode, Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData};4use frame_support::{assert_noop, assert_ok};5use frame_system::{ RawOrigin };67fn default_collection_numbers_limit() -> u64 {8    109}1011fn default_limits() {12    assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 13            collection_numbers_limit: default_collection_numbers_limit(),14            account_token_ownership_limit: 10,15            collections_admins_limit: 5,16            custom_data_limit: 2048,17            nft_sponsor_transfer_timeout: 15,18            fungible_sponsor_transfer_timeout: 15,19            refungible_sponsor_transfer_timeout: 15,          20        }));21}2223fn default_nft_data() -> CreateNftData {24    CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }25}2627fn default_fungible_data () -> CreateFungibleData {28    CreateFungibleData { }29}3031fn default_re_fungible_data () -> CreateReFungibleData {32    CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] }33}3435fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64, id: u64) -> u64 {36    let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();37    let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();38    let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();3940    let origin1 = Origin::signed(owner);41    assert_ok!(TemplateModule::create_collection(42            origin1.clone(),43            col_name1.clone(),44            col_desc1.clone(),45            token_prefix1.clone(),46            mode.clone()47        ));4849    let saved_col_name: Vec<u16> = "Test1\0\0".encode_utf16().collect::<Vec<u16>>();50    let saved_description: Vec<u16> = "TestDescription1\0\0".encode_utf16().collect::<Vec<u16>>();51    let saved_prefix: Vec<u8> = b"token_prefix1\0\0".to_vec();52    assert_eq!(TemplateModule::collection(id).owner, owner);53    assert_eq!(TemplateModule::collection(id).name, saved_col_name);54    assert_eq!(TemplateModule::collection(id).mode, *mode);55    assert_eq!(TemplateModule::collection(id).description, saved_description);56    assert_eq!(TemplateModule::collection(id).token_prefix, saved_prefix);57    id58}5960fn create_test_collection(mode: &CollectionMode, id: u64) -> u64 {61    create_test_collection_for_owner(&mode, 1, id)62}6364fn create_test_item(collection_id: u64, data: &CreateItemData) {65    let origin1 = Origin::signed(1);66    assert_ok!(TemplateModule::create_item(67            origin1.clone(),68            collection_id,69            1,70            data.clone()71        ));7273}7475// Use cases tests region76// #region77#[test]78fn create_nft_item() {79    new_test_ext().execute_with(|| {80        default_limits();81        let collection_id = create_test_collection(&CollectionMode::NFT, 1);82        83        let data = default_nft_data();84        create_test_item(collection_id, &data.clone().into());85        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);86        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);87    });88}8990// Use cases tests region91// #region92#[test]93fn create_nft_multiple_items() {94    new_test_ext().execute_with(|| {95        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();96        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();97        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();98        let mode: CollectionMode = CollectionMode::NFT(2000);99100        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 101            collection_numbers_limit: 10,102            account_token_ownership_limit: 10,103            collections_admins_limit: 5,104            custom_data_limit: 2048,105            nft_sponsor_transfer_timeout: 15,106            fungible_sponsor_transfer_timeout: 15,107            refungible_sponsor_transfer_timeout: 15,          108        }));109110        let origin1 = Origin::signed(1);111        assert_ok!(TemplateModule::create_collection(112            origin1.clone(),113            col_name1.clone(),114            col_desc1.clone(),115            token_prefix1.clone(),116            mode117        ));118        assert_eq!(TemplateModule::collection(1).owner, 1);119120        let properties = [[1, 2, 3].to_vec(), [3, 2, 1].to_vec(), [3, 3, 3].to_vec()].to_vec();121122        assert_ok!(TemplateModule::create_multiple_items(123            origin1.clone(),124            1,125            properties.clone(),126            1127        ));128        for (index, data) in properties.iter().enumerate() {129            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as u64).data, *data);130        }131    });132}133134#[test]135fn create_refungible_item() {136    new_test_ext().execute_with(|| {137        default_limits();138        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);139140        let data = default_re_fungible_data();141        create_test_item(collection_id, &data.clone().into());142        assert_eq!(143            TemplateModule::refungible_item_id(collection_id, 1).const_data,144            data.const_data145        );146        assert_eq!(147            TemplateModule::refungible_item_id(collection_id, 1).variable_data,148            data.variable_data149        );150        assert_eq!(151            TemplateModule::refungible_item_id(collection_id, 1).owner[0],152            Ownership {153                owner: 1,154                fraction: 1000155            }156        );157    });158}159160#[test]161fn create_multiple_refungible_items() {162    new_test_ext().execute_with(|| {163        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();164        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();165        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();166        let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);167168        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 169            collection_numbers_limit: 10,170            account_token_ownership_limit: 10,171            collections_admins_limit: 5,172            custom_data_limit: 2048,173            nft_sponsor_transfer_timeout: 15,174            fungible_sponsor_transfer_timeout: 15,175            refungible_sponsor_transfer_timeout: 15,          176        }));177178        let origin1 = Origin::signed(1);179        assert_ok!(TemplateModule::create_collection(180            origin1.clone(),181            col_name1.clone(),182            col_desc1.clone(),183            token_prefix1.clone(),184            mode185        ));186        assert_eq!(TemplateModule::collection(1).owner, 1);187188        let properties = [[1, 2, 3].to_vec(), [3, 2, 1].to_vec(), [3, 3, 3].to_vec()].to_vec();189190        assert_ok!(TemplateModule::create_multiple_items(191            origin1.clone(),192            1,193            properties.clone(),194            1195        ));196        for (index, data) in properties.iter().enumerate() {197198            let item = TemplateModule::refungible_item_id(1, (index + 1) as u64);199            assert_eq!(item.data, *data);200            assert_eq!(201                item.owner[0],202                Ownership {203                    owner: 1,204                    fraction: 1000205                }206            );207        }208    });209}210211#[test]212fn create_fungible_item() {213    new_test_ext().execute_with(|| {214        default_limits();215        216        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);217218        let data = default_fungible_data();219        create_test_item(collection_id, &data.into());220221        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);222    });223}224225#[test]226fn create_multiple_fungible_items() {227    new_test_ext().execute_with(|| {228        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();229        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();230        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();231        let mode: CollectionMode = CollectionMode::Fungible(3);232233        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 234            collection_numbers_limit: 10,235            account_token_ownership_limit: 10,236            collections_admins_limit: 5,237            custom_data_limit: 2048,238            nft_sponsor_transfer_timeout: 15,239            fungible_sponsor_transfer_timeout: 15,240            refungible_sponsor_transfer_timeout: 15,          241        }));242243        let origin1 = Origin::signed(1);244        assert_ok!(TemplateModule::create_collection(245            origin1.clone(),246            col_name1.clone(),247            col_desc1.clone(),248            token_prefix1.clone(),249            mode250        ));251        assert_eq!(TemplateModule::collection(1).owner, 1);252253        let properties = [[].to_vec(), [].to_vec(), [].to_vec()].to_vec();254255        assert_ok!(TemplateModule::create_multiple_items(256            origin1.clone(),257            1,258            properties.clone(),259            1260        ));261        262        for (index, _) in properties.iter().enumerate() {263            assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as u64).owner, 1);264        }265        assert_eq!(TemplateModule::balance_count(1, 1), 3000);266        assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);267    });268}269270#[test]271fn transfer_fungible_item() {272    new_test_ext().execute_with(|| {273        default_limits();274        275        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);276277        let origin1 = Origin::signed(1);278        let origin2 = Origin::signed(2);279280        let data = default_fungible_data();281        create_test_item(collection_id, &data.into());282283        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);284        assert_eq!(TemplateModule::balance_count(1, 1), 1000);285        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);286287        // change owner scenario288        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));289        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);290        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);291        assert_eq!(TemplateModule::balance_count(1, 1), 0);292        assert_eq!(TemplateModule::balance_count(1, 2), 1000);293        // assert_eq!(TemplateModule::address_tokens(1, 1), []);294        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);295296        // split item scenario297        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));298        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);299        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);300        assert_eq!(TemplateModule::balance_count(1, 2), 500);301        assert_eq!(TemplateModule::balance_count(1, 3), 500);302        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);303        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);304305        // split item and new owner has account scenario306        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));307        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);308        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);309        assert_eq!(TemplateModule::balance_count(1, 2), 300);310        assert_eq!(TemplateModule::balance_count(1, 3), 700);311        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);312        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);313    });314}315316#[test]317fn transfer_refungible_item() {318    new_test_ext().execute_with(|| {319        default_limits();320        321        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);322323        let data = default_re_fungible_data();324        create_test_item(collection_id, &data.clone().into());325326        let origin1 = Origin::signed(1);327        let origin2 = Origin::signed(2);328        assert_eq!(329            TemplateModule::refungible_item_id(collection_id, 1).const_data,330            data.const_data331        );332        assert_eq!(333            TemplateModule::refungible_item_id(collection_id, 1).variable_data,334            data.variable_data335        );336        assert_eq!(337            TemplateModule::refungible_item_id(collection_id, 1).owner[0],338            Ownership {339                owner: 1,340                fraction: 1000341            }342        );343        assert_eq!(TemplateModule::balance_count(1, 1), 1000);344        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);345346        // change owner scenario347        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));348        assert_eq!(349            TemplateModule::refungible_item_id(1, 1).owner[0],350            Ownership {351                owner: 2,352                fraction: 1000353            }354        );355        assert_eq!(TemplateModule::balance_count(1, 1), 0);356        assert_eq!(TemplateModule::balance_count(1, 2), 1000);357        // assert_eq!(TemplateModule::address_tokens(1, 1), []);358        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);359360        // split item scenario361        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));362        assert_eq!(363            TemplateModule::refungible_item_id(1, 1).owner[0],364            Ownership {365                owner: 2,366                fraction: 500367            }368        );369        assert_eq!(370            TemplateModule::refungible_item_id(1, 1).owner[1],371            Ownership {372                owner: 3,373                fraction: 500374            }375        );376        assert_eq!(TemplateModule::balance_count(1, 2), 500);377        assert_eq!(TemplateModule::balance_count(1, 3), 500);378        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);379        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);380381        // split item and new owner has account scenario382        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));383        assert_eq!(384            TemplateModule::refungible_item_id(1, 1).owner[0],385            Ownership {386                owner: 2,387                fraction: 300388            }389        );390        assert_eq!(391            TemplateModule::refungible_item_id(1, 1).owner[1],392            Ownership {393                owner: 3,394                fraction: 700395            }396        );397        assert_eq!(TemplateModule::balance_count(1, 2), 300);398        assert_eq!(TemplateModule::balance_count(1, 3), 700);399        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);400        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);401    });402}403404#[test]405fn transfer_nft_item() {406    new_test_ext().execute_with(|| {407        default_limits();408        409        let collection_id = create_test_collection(&CollectionMode::NFT, 1);410411        let data = default_nft_data();412        create_test_item(collection_id, &data.into());413        assert_eq!(TemplateModule::balance_count(1, 1), 1);414        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);415416        let origin1 = Origin::signed(1);417        // default scenario418        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));419        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);420        assert_eq!(TemplateModule::balance_count(1, 1), 0);421        assert_eq!(TemplateModule::balance_count(1, 2), 1);422        // assert_eq!(TemplateModule::address_tokens(1, 1), []);423        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);424    });425}426427#[test]428fn nft_approve_and_transfer_from() {429    new_test_ext().execute_with(|| {430        default_limits();431        432        let collection_id = create_test_collection(&CollectionMode::NFT, 1);433434        let data = default_nft_data();435        create_test_item(collection_id, &data.into());436437        let origin1 = Origin::signed(1);438        let origin2 = Origin::signed(2);439440        assert_eq!(TemplateModule::balance_count(1, 1), 1);441        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);442443        // neg transfer444        assert_noop!(TemplateModule::transfer_from(445            origin2.clone(),446            1,447            2,448            1,449            1,450            1), "Only item owner, collection owner and admins can modify items");451452        // do approve453        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));454        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);455        assert_eq!(456            TemplateModule::approved(1, (1, 1))[0],457            ApprovePermissions {458                approved: 2,459                amount: 100000000460            }461        );462463        assert_ok!(TemplateModule::transfer_from(464            origin2.clone(),465            1,466            2,467            1,468            1,469            1470        ));471        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);472    });473}474475#[test]476fn nft_approve_and_transfer_from_white_list() {477    new_test_ext().execute_with(|| {478        default_limits();479        480        let collection_id = create_test_collection(&CollectionMode::NFT, 1);481482        let origin1 = Origin::signed(1);483        let origin2 = Origin::signed(2);484485        let data = default_nft_data();486        create_test_item(collection_id, &data.clone().into());487488        assert_eq!(TemplateModule::nft_item_id(1, 1).const_data, data.const_data);489        assert_eq!(TemplateModule::balance_count(1, 1), 1);490        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);491492        assert_ok!(TemplateModule::set_mint_permission(493            origin1.clone(),494            1,495            true496        ));497        assert_ok!(TemplateModule::set_public_access_mode(498            origin1.clone(),499            1,500            AccessMode::WhiteList501        ));502        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));503        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));504        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));505506        // do approve507        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));508        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);509        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));510        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);511        assert_eq!(512            TemplateModule::approved(1, (1, 1))[0],513            ApprovePermissions {514                approved: 2,515                amount: 100000000516            }517        );518519        assert_ok!(TemplateModule::transfer_from(520            origin2.clone(),521            1,522            3,523            1,524            1,525            1526        ));527        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);528    });529}530531#[test]532fn refungible_approve_and_transfer_from() {533    new_test_ext().execute_with(|| {534        default_limits();535        536        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);537        538        let origin1 = Origin::signed(1);539        let origin2 = Origin::signed(2);540541        let data = default_re_fungible_data();542        create_test_item(collection_id, &data.into());543544        assert_eq!(TemplateModule::balance_count(1, 1), 1000);545        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);546547        assert_ok!(TemplateModule::set_mint_permission(548            origin1.clone(),549            1,550            true551        ));552        assert_ok!(TemplateModule::set_public_access_mode(553            origin1.clone(),554            1,555            AccessMode::WhiteList556        ));557        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));558        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));559        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));560561        // do approve562        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));563        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);564        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));565        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);566        assert_eq!(567            TemplateModule::approved(1, (1, 1))[0],568            ApprovePermissions {569                approved: 2,570                amount: 100000000571            }572        );573574        assert_ok!(TemplateModule::transfer_from(575            origin2.clone(),576            1,577            3,578            1,579            1,580            100581        ));582        assert_eq!(TemplateModule::balance_count(1, 1), 900);583        assert_eq!(TemplateModule::balance_count(1, 3), 100);584        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);585        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);586587        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);588        assert_eq!(589            TemplateModule::approved(1, (1, 1))[0],590            ApprovePermissions {591                approved: 3,592                amount: 100000000593            }594        );595    });596}597598#[test]599fn fungible_approve_and_transfer_from() {600    new_test_ext().execute_with(|| {601        default_limits();602        603        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);604        605        let data = default_fungible_data();606        create_test_item(collection_id, &data.into());607608        let origin1 = Origin::signed(1);609        let origin2 = Origin::signed(2);610611        assert_eq!(TemplateModule::balance_count(1, 1), 1000);612        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);613614        assert_ok!(TemplateModule::set_mint_permission(615            origin1.clone(),616            1,617            true618        ));619        assert_ok!(TemplateModule::set_public_access_mode(620            origin1.clone(),621            1,622            AccessMode::WhiteList623        ));624        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));625        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));626        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));627628        // do approve629        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));630        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);631        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));632        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);633        assert_eq!(634            TemplateModule::approved(1, (1, 1))[0],635            ApprovePermissions {636                approved: 2,637                amount: 100000000638            }639        );640641        assert_ok!(TemplateModule::transfer_from(642            origin2.clone(),643            1,644            3,645            1,646            1,647            100648        ));649        assert_eq!(TemplateModule::balance_count(1, 1), 900);650        assert_eq!(TemplateModule::balance_count(1, 3), 100);651        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);652        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);653654        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);655        assert_eq!(656            TemplateModule::approved(1, (1, 1))[0],657            ApprovePermissions {658                approved: 3,659                amount: 100000000660            }661        );662663        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));664        assert_ok!(TemplateModule::transfer_from(665            origin2.clone(),666            1,667            3,668            1,669            1,670            900671        ));672        assert_eq!(TemplateModule::balance_count(1, 1), 0);673        assert_eq!(TemplateModule::balance_count(1, 3), 1000);674        // assert_eq!(TemplateModule::address_tokens(1, 1), []);675        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);676677        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);678    });679}680681#[test]682fn change_collection_owner() {683    new_test_ext().execute_with(|| {684        default_limits();685        686        let collection_id = create_test_collection(&CollectionMode::NFT, 1);687        688        let origin1 = Origin::signed(1);689        assert_ok!(TemplateModule::change_collection_owner(690            origin1.clone(),691            collection_id,692            2693        ));694        assert_eq!(TemplateModule::collection(collection_id).owner, 2);695    });696}697698#[test]699fn destroy_collection() {700    new_test_ext().execute_with(|| {701        default_limits();702        703        let collection_id = create_test_collection(&CollectionMode::NFT, 1);704        705        let origin1 = Origin::signed(1);706        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));707    });708}709710#[test]711fn burn_nft_item() {712    new_test_ext().execute_with(|| {713        default_limits();714        715        let collection_id = create_test_collection(&CollectionMode::NFT, 1);716717        let origin1 = Origin::signed(1);718        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));719        720        let data = default_nft_data();721        create_test_item(collection_id, &data.into());722723        // check balance (collection with id = 1, user id = 1)724        assert_eq!(TemplateModule::balance_count(1, 1), 1);725726        // burn item727        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));728        assert_noop!(729            TemplateModule::burn_item(origin1.clone(), 1, 1),730            "Item does not exists"731        );732733        assert_eq!(TemplateModule::balance_count(1, 1), 0);734    });735}736737#[test]738fn burn_fungible_item() {739    new_test_ext().execute_with(|| {740        default_limits();741        742        let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);743        744        let origin1 = Origin::signed(1);745        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));746        747        let data = default_fungible_data();748        create_test_item(collection_id, &data.into());749750        // check balance (collection with id = 1, user id = 1)751        assert_eq!(TemplateModule::balance_count(1, 1), 1000);752753        // burn item754        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));755        assert_noop!(756            TemplateModule::burn_item(origin1.clone(), 1, 1),757            "Item does not exists"758        );759760        assert_eq!(TemplateModule::balance_count(1, 1), 0);761    });762}763764#[test]765fn burn_refungible_item() {766    new_test_ext().execute_with(|| {767        default_limits();768        769        let collection_id = create_test_collection(&CollectionMode::ReFungible(3), 1);770        let origin1 = Origin::signed(1);771772        assert_ok!(TemplateModule::set_mint_permission(773            origin1.clone(),774            collection_id,775            true776        ));777        assert_ok!(TemplateModule::set_public_access_mode(778            origin1.clone(),779            collection_id,780            AccessMode::WhiteList781        ));782        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));783784        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));785        786        let data = default_re_fungible_data();787        create_test_item(collection_id, &data.into());788789        // check balance (collection with id = 1, user id = 2)790        assert_eq!(TemplateModule::balance_count(1, 1), 1000);791792        // burn item793        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));794        assert_noop!(795            TemplateModule::burn_item(origin1.clone(), 1, 1),796            "Item does not exists"797        );798799        assert_eq!(TemplateModule::balance_count(1, 1), 0);800    });801}802803#[test]804fn add_collection_admin() {805    new_test_ext().execute_with(|| {806        default_limits();807        808        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);809        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);810        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);811        812        let origin1 = Origin::signed(1);813814        // collection admin815        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));816        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));817818        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);819        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);820    });821}822823#[test]824fn remove_collection_admin() {825    new_test_ext().execute_with(|| {826        default_limits();827        828        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);829        create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);830        create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);831832        let origin1 = Origin::signed(1);833        let origin2 = Origin::signed(2);834835        // collection admin836        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));837        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));838839        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);840        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);841842        // remove admin843        assert_ok!(TemplateModule::remove_collection_admin(844            origin2.clone(),845            1,846            3847        ));848        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);849    });850}851852#[test]853fn balance_of() {854    new_test_ext().execute_with(|| {855        default_limits();856        857        let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);858        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);859        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3), 3);860        861        // check balance before862        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);863        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);864        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);865866        let nft_data = default_nft_data();867        create_test_item(nft_collection_id, &nft_data.into());868        869        let fungible_data = default_fungible_data();870        create_test_item(fungible_collection_id, &fungible_data.into());871        872        let re_fungible_data = default_re_fungible_data();873        create_test_item(re_fungible_collection_id, &re_fungible_data.into());874875        // check balance (collection with id = 1, user id = 1)876        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);877        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);878        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);879        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);880        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);881        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);882    });883}884885#[test]886fn approve() {887    new_test_ext().execute_with(|| {888        default_limits();889        890        let collection_id = create_test_collection(&CollectionMode::NFT, 1);891        892        let data = default_nft_data();893        create_test_item(collection_id, &data.into());894895        let origin1 = Origin::signed(1);896        897        // approve898        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));899        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);900    });901}902903#[test]904fn transfer_from() {905    new_test_ext().execute_with(|| {906        default_limits();907        908        let collection_id = create_test_collection(&CollectionMode::NFT, 1);909        let origin1 = Origin::signed(1);910        let origin2 = Origin::signed(2);911912        let data = default_nft_data();913        create_test_item(collection_id, &data.into());914915        // approve916        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));917        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);918919        assert_ok!(TemplateModule::set_mint_permission(920            origin1.clone(),921            1,922            true923        ));924        assert_ok!(TemplateModule::set_public_access_mode(925            origin1.clone(),926            1,927            AccessMode::WhiteList928        ));929        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));930        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));931        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));932933        assert_ok!(TemplateModule::transfer_from(934            origin2.clone(),935            1,936            2,937            1,938            1,939            1940        ));941942        // after transfer943        assert_eq!(TemplateModule::balance_count(1, 1), 0);944        assert_eq!(TemplateModule::balance_count(1, 2), 1);945    });946}947948// #endregion949950// Coverage tests region951// #region952953#[test]954fn owner_can_add_address_to_white_list() {955    new_test_ext().execute_with(|| {956        default_limits();957        958        let collection_id = create_test_collection(&CollectionMode::NFT, 1);959960        let origin1 = Origin::signed(1);961        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));962        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);963    });964}965966#[test]967fn admin_can_add_address_to_white_list() {968    new_test_ext().execute_with(|| {969        default_limits();970        971        let collection_id = create_test_collection(&CollectionMode::NFT, 1);972        let origin1 = Origin::signed(1);973        let origin2 = Origin::signed(2);974975        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));976        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));977        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);978    });979}980981#[test]982fn nonprivileged_user_cannot_add_address_to_white_list() {983    new_test_ext().execute_with(|| {984        default_limits();985        986        let collection_id = create_test_collection(&CollectionMode::NFT, 1);987988        let origin2 = Origin::signed(2);989        assert_noop!(990            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),991            "You do not have permissions to modify this collection"992        );993    });994}995996#[test]997fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {998    new_test_ext().execute_with(|| {999        default_limits();10001001        let origin1 = Origin::signed(1);10021003        assert_noop!(1004            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),1005            "This collection does not exist"1006        );1007    });1008}10091010#[test]1011fn nobody_can_add_address_to_white_list_of_deleted_collection() {1012    new_test_ext().execute_with(|| {1013        default_limits();1014        1015        let collection_id = create_test_collection(&CollectionMode::NFT, 1);10161017        let origin1 = Origin::signed(1);1018        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));1019        assert_noop!(1020            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),1021            "This collection does not exist"1022        );1023    });1024}10251026// If address is already added to white list, nothing happens1027#[test]1028fn address_is_already_added_to_white_list() {1029    new_test_ext().execute_with(|| {1030        default_limits();1031        1032        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1033        let origin1 = Origin::signed(1);1034        1035        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1036        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1037        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);1038        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);1039    });1040}10411042#[test]1043fn owner_can_remove_address_from_white_list() {1044    new_test_ext().execute_with(|| {1045        default_limits();1046        1047        let collection_id = create_test_collection(&CollectionMode::NFT, 1);10481049        let origin1 = Origin::signed(1);1050        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1051        assert_ok!(TemplateModule::remove_from_white_list(1052            origin1.clone(),1053            collection_id,1054            21055        ));1056        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1057    });1058}10591060#[test]1061fn admin_can_remove_address_from_white_list() {1062    new_test_ext().execute_with(|| {1063        default_limits();1064        1065        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1066        let origin1 = Origin::signed(1);1067        let origin2 = Origin::signed(2);10681069        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));10701071        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));1072        assert_ok!(TemplateModule::remove_from_white_list(1073            origin2.clone(),1074            collection_id,1075            31076        ));1077        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1078    });1079}10801081#[test]1082fn nonprivileged_user_cannot_remove_address_from_white_list() {1083    new_test_ext().execute_with(|| {1084        default_limits();1085        1086        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1087        let origin1 = Origin::signed(1);1088        let origin2 = Origin::signed(2);10891090        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1091        assert_noop!(1092            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1093            "You do not have permissions to modify this collection"1094        );1095        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);1096    });1097}10981099#[test]1100fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1101    new_test_ext().execute_with(|| {1102        default_limits();1103        let origin1 = Origin::signed(1);11041105        assert_noop!(1106            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),1107            "This collection does not exist"1108        );1109    });1110}11111112#[test]1113fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1114    new_test_ext().execute_with(|| {1115        default_limits();1116        1117        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1118        let origin1 = Origin::signed(1);1119        let origin2 = Origin::signed(2);11201121        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1122        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));1123        assert_noop!(1124            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),1125            "This collection does not exist"1126        );1127        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1128    });1129}11301131// If address is already removed from white list, nothing happens1132#[test]1133fn address_is_already_removed_from_white_list() {1134    new_test_ext().execute_with(|| {1135        default_limits();1136        1137        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1138        let origin1 = Origin::signed(1);11391140        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1141        assert_ok!(TemplateModule::remove_from_white_list(1142            origin1.clone(),1143            collection_id,1144            21145        ));1146        assert_ok!(TemplateModule::remove_from_white_list(1147            origin1.clone(),1148            collection_id,1149            21150        ));1151        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);1152    });1153}11541155// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1156#[test]1157fn white_list_test_1() {1158    new_test_ext().execute_with(|| {1159        default_limits();1160        1161        let collection_id = create_test_collection(&CollectionMode::NFT, 1);11621163        let origin1 = Origin::signed(1);1164        1165        let data = default_nft_data();1166        create_test_item(collection_id, &data.into());11671168        assert_ok!(TemplateModule::set_public_access_mode(1169            origin1.clone(),1170            collection_id,1171            AccessMode::WhiteList1172        ));1173        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));11741175        assert_noop!(1176            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1177            "Address is not in white list"1178        );1179    });1180}11811182#[test]1183fn white_list_test_2() {1184    new_test_ext().execute_with(|| {1185        default_limits();1186        1187        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1188        let origin1 = Origin::signed(1);1189        1190        let data = default_nft_data();1191        create_test_item(collection_id, &data.into());11921193        assert_ok!(TemplateModule::set_public_access_mode(1194            origin1.clone(),1195            collection_id,1196            AccessMode::WhiteList1197        ));1198        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1199        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));12001201        // do approve1202        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1203        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);12041205        assert_ok!(TemplateModule::remove_from_white_list(1206            origin1.clone(),1207            1,1208            11209        ));12101211        assert_noop!(1212            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1213            "Address is not in white list"1214        );1215    });1216}12171218// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1219#[test]1220fn white_list_test_3() {1221    new_test_ext().execute_with(|| {1222        default_limits();1223        1224        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12251226        let origin1 = Origin::signed(1);1227        1228        let data = default_nft_data();1229        create_test_item(collection_id, &data.into());12301231        assert_ok!(TemplateModule::set_public_access_mode(1232            origin1.clone(),1233            collection_id,1234            AccessMode::WhiteList1235        ));1236        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));12371238        assert_noop!(1239            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),1240            "Address is not in white list"1241        );1242    });1243}12441245#[test]1246fn white_list_test_4() {1247    new_test_ext().execute_with(|| {1248        default_limits();1249        1250        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12511252        let origin1 = Origin::signed(1);12531254        let data = default_nft_data();1255        create_test_item(collection_id, &data.into());12561257        assert_ok!(TemplateModule::set_public_access_mode(1258            origin1.clone(),1259            collection_id,1260            AccessMode::WhiteList1261        ));1262        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1263        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));12641265        // do approve1266        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1267        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);12681269        assert_ok!(TemplateModule::remove_from_white_list(1270            origin1.clone(),1271            collection_id,1272            21273        ));12741275        assert_noop!(1276            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),1277            "Address is not in white list"1278        );1279    });1280}12811282// 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)1283#[test]1284fn white_list_test_5() {1285    new_test_ext().execute_with(|| {1286        default_limits();1287        1288        let collection_id = create_test_collection(&CollectionMode::NFT, 1);12891290        let origin1 = Origin::signed(1);12911292        let data = default_nft_data();1293        create_test_item(collection_id, &data.into());12941295        assert_ok!(TemplateModule::set_public_access_mode(1296            origin1.clone(),1297            collection_id,1298            AccessMode::WhiteList1299        ));1300        assert_noop!(1301            TemplateModule::burn_item(origin1.clone(), 1, 1),1302            "Address is not in white list"1303        );1304    });1305}13061307// If Public Access mode is set to WhiteList, oken transfers can’t be Approved by a non-whitelisted address (see Approve method).1308#[test]1309fn white_list_test_6() {1310    new_test_ext().execute_with(|| {1311        default_limits();1312        1313        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13141315        let origin1 = Origin::signed(1);1316        assert_ok!(TemplateModule::set_public_access_mode(1317            origin1.clone(),1318            collection_id,1319            AccessMode::WhiteList1320        ));13211322        // do approve1323        assert_noop!(1324            TemplateModule::approve(origin1.clone(), 1, 1, 1),1325            "Address is not in white list"1326        );1327    });1328}13291330// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1331//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1332#[test]1333fn white_list_test_7() {1334    new_test_ext().execute_with(|| {1335        default_limits();1336        1337        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13381339        let data = default_nft_data();1340        create_test_item(collection_id, &data.into());1341        1342        let origin1 = Origin::signed(1);13431344        assert_ok!(TemplateModule::set_public_access_mode(1345            origin1.clone(),1346            collection_id,1347            AccessMode::WhiteList1348        ));1349        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1350        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13511352        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1353    });1354}13551356#[test]1357fn white_list_test_8() {1358    new_test_ext().execute_with(|| {1359        default_limits();1360        1361        let collection_id = create_test_collection(&CollectionMode::NFT, 1);13621363        let data = default_nft_data();1364        create_test_item(collection_id, &data.into());1365        1366        let origin1 = Origin::signed(1);13671368        assert_ok!(TemplateModule::set_public_access_mode(1369            origin1.clone(),1370            collection_id,1371            AccessMode::WhiteList1372        ));1373        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));1374        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));13751376        // do approve1377        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1378        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);13791380        assert_ok!(TemplateModule::transfer_from(1381            origin1.clone(),1382            1,1383            2,1384            1,1385            1,1386            11387        ));1388    });1389}13901391// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1392#[test]1393fn white_list_test_9() {1394    new_test_ext().execute_with(|| {1395        default_limits();1396        1397        let collection_id = create_test_collection(&CollectionMode::NFT, 1);1398        let origin1 = Origin::signed(1);13991400        assert_ok!(TemplateModule::set_public_access_mode(1401            origin1.clone(),1402            collection_id,1403            AccessMode::WhiteList1404        ));1405        assert_ok!(TemplateModule::set_mint_permission(1406            origin1.clone(),1407            collection_id,1408            false1409        ));14101411        let data = default_nft_data();1412        create_test_item(collection_id, &data.into());1413    });1414}14151416// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1417#[test]1418fn white_list_test_10() {1419    new_test_ext().execute_with(|| {1420        default_limits();1421        1422        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14231424        let origin1 = Origin::signed(1);1425        let origin2 = Origin::signed(2);14261427        assert_ok!(TemplateModule::set_public_access_mode(1428            origin1.clone(),1429            collection_id,1430            AccessMode::WhiteList1431        ));1432        assert_ok!(TemplateModule::set_mint_permission(1433            origin1.clone(),1434            collection_id,1435            false1436        ));14371438        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));14391440        assert_ok!(TemplateModule::create_item(1441            origin2.clone(),1442            collection_id,1443            2,1444            default_nft_data().into()1445        ));1446    });1447}14481449// 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.1450#[test]1451fn white_list_test_11() {1452    new_test_ext().execute_with(|| {1453        default_limits();1454        1455        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14561457        let origin1 = Origin::signed(1);1458        let origin2 = Origin::signed(2);14591460        assert_ok!(TemplateModule::set_public_access_mode(1461            origin1.clone(),1462            collection_id,1463            AccessMode::WhiteList1464        ));1465        assert_ok!(TemplateModule::set_mint_permission(1466            origin1.clone(),1467            collection_id,1468            false1469        ));1470        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));14711472        assert_noop!(1473            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1474            "Public minting is not allowed for this collection."1475        );1476    });1477}14781479// 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.1480#[test]1481fn white_list_test_12() {1482    new_test_ext().execute_with(|| {1483        default_limits();1484        1485        let collection_id = create_test_collection(&CollectionMode::NFT, 1);14861487        let origin1 = Origin::signed(1);1488        let origin2 = Origin::signed(2);14891490        assert_ok!(TemplateModule::set_public_access_mode(1491            origin1.clone(),1492            collection_id,1493            AccessMode::WhiteList1494        ));1495        assert_ok!(TemplateModule::set_mint_permission(1496            origin1.clone(),1497            collection_id,1498            false1499        ));15001501        assert_noop!(1502            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1503            "Public minting is not allowed for this collection."1504        );1505    });1506}15071508// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1509#[test]1510fn white_list_test_13() {1511    new_test_ext().execute_with(|| {1512        default_limits();1513        1514        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15151516        let origin1 = Origin::signed(1);15171518        assert_ok!(TemplateModule::set_public_access_mode(1519            origin1.clone(),1520            collection_id,1521            AccessMode::WhiteList1522        ));1523        assert_ok!(TemplateModule::set_mint_permission(1524            origin1.clone(),1525            collection_id,1526            true1527        ));15281529        let data = default_nft_data();1530        create_test_item(collection_id, &data.into());1531    });1532}15331534// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1535#[test]1536fn white_list_test_14() {1537    new_test_ext().execute_with(|| {1538        default_limits();1539        1540        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15411542        let origin1 = Origin::signed(1);1543        let origin2 = Origin::signed(2);15441545        assert_ok!(TemplateModule::set_public_access_mode(1546            origin1.clone(),1547            collection_id,1548            AccessMode::WhiteList1549        ));1550        assert_ok!(TemplateModule::set_mint_permission(1551            origin1.clone(),1552            collection_id,1553            true1554        ));15551556        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));15571558        assert_ok!(TemplateModule::create_item(1559            origin2.clone(),1560            1,1561            2,1562            default_nft_data().into()1563        ));1564    });1565}15661567// 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.1568#[test]1569fn white_list_test_15() {1570    new_test_ext().execute_with(|| {1571        default_limits();1572        1573        let collection_id = create_test_collection(&CollectionMode::NFT, 1);15741575        let origin1 = Origin::signed(1);1576        let origin2 = Origin::signed(2);15771578        assert_ok!(TemplateModule::set_public_access_mode(1579            origin1.clone(),1580            collection_id,1581            AccessMode::WhiteList1582        ));1583        assert_ok!(TemplateModule::set_mint_permission(1584            origin1.clone(),1585            collection_id,1586            true1587        ));15881589        assert_noop!(1590            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1591            "Address is not in white list"1592        );1593    });1594}15951596// 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.1597#[test]1598fn white_list_test_16() {1599    new_test_ext().execute_with(|| {1600        default_limits();1601        1602        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16031604        let origin1 = Origin::signed(1);1605        let origin2 = Origin::signed(2);16061607        assert_ok!(TemplateModule::set_public_access_mode(1608            origin1.clone(),1609            collection_id,1610            AccessMode::WhiteList1611        ));1612        assert_ok!(TemplateModule::set_mint_permission(1613            origin1.clone(),1614            collection_id,1615            true1616        ));1617        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));16181619        assert_ok!(TemplateModule::create_item(1620            origin2.clone(),1621            1,1622            2,1623            default_nft_data().into()1624        ));1625    });1626}16271628// Total number of collections. Positive test1629#[test]1630fn total_number_collections_bound() {1631    new_test_ext().execute_with(|| {1632        default_limits();1633        1634        create_test_collection(&CollectionMode::NFT, 1);1635    });1636}16371638// Total number of collections. Negotive test1639#[test]1640fn total_number_collections_bound_neg() {1641    new_test_ext().execute_with(|| {1642        default_limits();16431644        let origin1 = Origin::signed(1);16451646        for i in 0..default_collection_numbers_limit() {1647            create_test_collection(&CollectionMode::NFT, i + 1);1648        }16491650        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1651        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1652        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();16531654        // 11-th collection in chain. Expects error1655        assert_noop!(TemplateModule::create_collection(1656            origin1.clone(),1657            col_name1.clone(),1658            col_desc1.clone(),1659            token_prefix1.clone(),1660            CollectionMode::NFT1661        ), "Total collections bound exceeded");1662    });1663}16641665// Owned tokens by a single address. Positive test1666#[test]1667fn owned_tokens_bound() {1668    new_test_ext().execute_with(|| {1669        default_limits();1670        1671        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16721673        let data = default_nft_data();1674        create_test_item(collection_id, &data.clone().into());1675        create_test_item(collection_id, &data.into());1676    });1677}16781679// Owned tokens by a single address. Negotive test1680#[test]1681fn owned_tokens_bound_neg() {1682    new_test_ext().execute_with(|| {1683        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1684            collection_numbers_limit: 10,1685            account_token_ownership_limit: 1,1686            collections_admins_limit: 5,1687            custom_data_limit: 2048,1688            nft_sponsor_transfer_timeout: 15,1689            fungible_sponsor_transfer_timeout: 15,1690            refungible_sponsor_transfer_timeout: 15,          1691        }));1692        1693        let collection_id = create_test_collection(&CollectionMode::NFT, 1);16941695        let origin1 = Origin::signed(1);1696        let data = default_nft_data();1697        create_test_item(collection_id, &data.clone().into());16981699        assert_noop!(TemplateModule::create_item(1700            origin1.clone(),1701            1,1702            1,1703            data.into()1704        ), "Owned tokens by a single address bound exceeded");1705    });1706}17071708// Number of collection admins. Positive test1709#[test]1710fn collection_admins_bound() {1711    new_test_ext().execute_with(|| {1712        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1713            collection_numbers_limit: 10,1714            account_token_ownership_limit: 10,1715            collections_admins_limit: 2,1716            custom_data_limit: 2048,1717            nft_sponsor_transfer_timeout: 15,1718            fungible_sponsor_transfer_timeout: 15,1719            refungible_sponsor_transfer_timeout: 15,          1720        }));1721        1722        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17231724        let origin1 = Origin::signed(1);1725        1726        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1727        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));1728    });1729}17301731// Number of collection admins. Negotive test1732#[test]1733fn collection_admins_bound_neg() {1734    new_test_ext().execute_with(|| {1735        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1736            collection_numbers_limit: 10,1737            account_token_ownership_limit: 1,1738            collections_admins_limit: 1,1739            custom_data_limit: 2048,1740            nft_sponsor_transfer_timeout: 15,1741            fungible_sponsor_transfer_timeout: 15,1742            refungible_sponsor_transfer_timeout: 15,          1743        }));1744        1745        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17461747        let origin1 = Origin::signed(1);17481749        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));1750        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), "Number of collection admins bound exceeded");1751    });1752}17531754// NFT custom data size. Negative test const_data.1755#[test]1756fn custom_data_size_nft_const_data_bound_neg() {1757    new_test_ext().execute_with(|| {1758        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1759            collection_numbers_limit: 10,1760            account_token_ownership_limit: 10,1761            collections_admins_limit: 5,1762            custom_data_limit: 2,1763            nft_sponsor_transfer_timeout: 15,1764            fungible_sponsor_transfer_timeout: 15,1765            refungible_sponsor_transfer_timeout: 15,          1766        }));1767        1768        let collection_id = create_test_collection(&CollectionMode::NFT, 1);17691770        let origin1 = Origin::signed(1);1771        let too_big_const_data = CreateItemData::NFT(CreateNftData{1772            const_data: vec![1, 2, 3, 4],1773            variable_data: vec![]1774        });17751776        assert_noop!(TemplateModule::create_item(1777            origin1.clone(),1778            collection_id,1779            1,1780            too_big_const_data1781        ), "const_data exceeded data limit.");1782    });1783}17841785// NFT custom data size. Negative test variable_data.1786#[test]1787fn custom_data_size_nft_variable_data_bound_neg() {1788    new_test_ext().execute_with(|| {1789        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1790            collection_numbers_limit: 10,1791            account_token_ownership_limit: 10,1792            collections_admins_limit: 5,1793            custom_data_limit: 2,1794            nft_sponsor_transfer_timeout: 15,1795            fungible_sponsor_transfer_timeout: 15,1796            refungible_sponsor_transfer_timeout: 15,          1797        }));17981799        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18001801        let origin1 = Origin::signed(1);1802        let too_big_const_data = CreateItemData::NFT(CreateNftData{1803            const_data: vec![],1804            variable_data: vec![1, 2, 3, 4]1805        });18061807        assert_noop!(TemplateModule::create_item(1808            origin1.clone(),1809            collection_id,1810            1,1811            too_big_const_data1812        ), "variable_data exceeded data limit.");1813    });1814}18151816// Re fungible custom data size. Negative test const_data.1817#[test]1818fn custom_data_size_re_fungible_const_data_bound_neg() {1819    new_test_ext().execute_with(|| {1820        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1821            collection_numbers_limit: 10,1822            account_token_ownership_limit: 10,1823            collections_admins_limit: 5,1824            custom_data_limit: 2,1825            nft_sponsor_transfer_timeout: 15,1826            fungible_sponsor_transfer_timeout: 15,1827            refungible_sponsor_transfer_timeout: 15,          1828        }));18291830        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18311832        let origin1 = Origin::signed(1);1833        let too_big_const_data = CreateItemData::NFT(CreateNftData{1834            const_data: vec![1, 2, 3, 4],1835            variable_data: vec![]1836        });18371838        assert_noop!(TemplateModule::create_item(1839            origin1.clone(),1840            collection_id,1841            1,1842            too_big_const_data1843        ), "const_data exceeded data limit.");1844    });1845}18461847// Re fungible custom data size. Negative test variable_data.1848#[test]1849fn custom_data_size_re_fungible_variable_data_bound_neg() {1850    new_test_ext().execute_with(|| {1851        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1852            collection_numbers_limit: 10,1853            account_token_ownership_limit: 10,1854            collections_admins_limit: 5,1855            custom_data_limit: 2,1856            nft_sponsor_transfer_timeout: 15,1857            fungible_sponsor_transfer_timeout: 15,1858            refungible_sponsor_transfer_timeout: 15,          1859        }));18601861        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18621863        let origin1 = Origin::signed(1);1864        let too_big_const_data = CreateItemData::NFT(CreateNftData{1865            const_data: vec![],1866            variable_data: vec![1, 2, 3, 4]1867        });18681869        assert_noop!(TemplateModule::create_item(1870            origin1.clone(),1871            collection_id,1872            1,1873            too_big_const_data1874        ), "variable_data exceeded data limit.");1875    });1876}1877// #endregion18781879#[test]1880fn set_const_on_chain_schema() {1881    new_test_ext().execute_with(|| {1882        default_limits();18831884        let collection_id = create_test_collection(&CollectionMode::NFT, 1);18851886        let origin1 = Origin::signed(1);1887        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, b"test const on chain schema".to_vec()));18881889        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"test const on chain schema".to_vec());1890        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"".to_vec());1891    });1892}18931894#[test]1895fn set_variable_on_chain_schema() {1896    new_test_ext().execute_with(|| {1897        default_limits();1898        1899        let collection_id = create_test_collection(&CollectionMode::NFT, 1);19001901        let origin1 = Origin::signed(1);1902        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, b"test variable on chain schema".to_vec()));19031904        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, b"".to_vec());1905        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, b"test variable on chain schema".to_vec());1906    });1907}