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

difftreelog

Merge remote-tracking branch 'origin/develop' into feature/NFTPAR-235-258

kpozdnikin2021-01-15parents: #3ed9616 #42edda1.patch.diff
in: master
# Conflicts:
#	tests/src/createCollection.test.ts
#	tests/src/util/helpers.ts

13 files changed

modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
1153            }1153            }
11541154
1155            // Reduce approval by transferred amount or remove if remaining approval drops to 01155            // Reduce approval by transferred amount or remove if remaining approval drops to 0
1156            if approval - value > 0 {1156            if approval.checked_sub(value).unwrap_or(0) > 0 {
1157                <Allowances<T>>::insert(collection_id, (item_id, &from, &recipient), approval - value);1157                <Allowances<T>>::insert(collection_id, (item_id, &from, &recipient), approval - value);
1158            }1158            }
1159            else {1159            else {
modifiedpallets/nft/src/tests.rsdiffbeforeafterboth
1// Tests to be written here1// Tests to be written here
2use super::*;2use super::*;
3use crate::mock::*;3use crate::mock::*;
4use crate::{AccessMode, ApprovePermissions, CollectionMode,4use crate::{AccessMode, CollectionMode,
5    Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData,5    Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData,
6    CollectionId, TokenId, MAX_DECIMAL_POINTS};6    CollectionId, TokenId, MAX_DECIMAL_POINTS};
7use frame_support::{assert_noop, assert_ok};7use frame_support::{assert_noop, assert_ok};
28}28}
2929
30fn default_fungible_data () -> CreateFungibleData {30fn default_fungible_data () -> CreateFungibleData {
31    CreateFungibleData { }31    CreateFungibleData { value: 5 }
32}32}
3333
34fn default_re_fungible_data () -> CreateReFungibleData {34fn default_re_fungible_data () -> CreateReFungibleData {
238        let data = default_fungible_data();238        let data = default_fungible_data();
239        create_test_item(collection_id, &data.into());239        create_test_item(collection_id, &data.into());
240240
241        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);241        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).value, 5);
242    });242    });
243}243}
244244
245#[test]245//#[test]
246fn create_multiple_fungible_items() {246// fn create_multiple_fungible_items() {
247    new_test_ext().execute_with(|| {247//     new_test_ext().execute_with(|| {
248        default_limits();248//         default_limits();
249249
250        create_test_collection(&CollectionMode::Fungible(3), 1);250//         create_test_collection(&CollectionMode::Fungible(3), 1);
251251
252        let origin1 = Origin::signed(1);252//         let origin1 = Origin::signed(1);
253253
254        let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];254//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];
255255
256        assert_ok!(TemplateModule::create_multiple_items(256//         assert_ok!(TemplateModule::create_multiple_items(
257            origin1.clone(),257//             origin1.clone(),
258            1,258//             1,
259            1,259//             1,
260            items_data.clone().into_iter().map(|d| { d.into() }).collect()260//             items_data.clone().into_iter().map(|d| { d.into() }).collect()
261        ));261//         ));
262        262        
263        for (index, _) in items_data.iter().enumerate() {263//         for (index, _) in items_data.iter().enumerate() {
264            assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).owner, 1);264//             assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).value, 5);
265        }265//         }
266        assert_eq!(TemplateModule::balance_count(1, 1), 3000);266//         assert_eq!(TemplateModule::balance_count(1, 1), 3000);
267        assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);267//         assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);
268    });268//     });
269}269// }
270270
271#[test]271#[test]
272fn transfer_fungible_item() {272fn transfer_fungible_item() {
281        let data = default_fungible_data();281        let data = default_fungible_data();
282        create_test_item(collection_id, &data.into());282        create_test_item(collection_id, &data.into());
283283
284        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);284        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 5);
285        assert_eq!(TemplateModule::balance_count(1, 1), 1000);285        assert_eq!(TemplateModule::balance_count(1, 1), 5);
286        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
287286
288        // change owner scenario287        // change owner scenario
289        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));288        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 5));
290        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);
291        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);289        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 0);
292        assert_eq!(TemplateModule::balance_count(1, 1), 0);290        assert_eq!(TemplateModule::balance_count(1, 1), 0);
293        assert_eq!(TemplateModule::balance_count(1, 2), 1000);291        assert_eq!(TemplateModule::balance_count(1, 2), 5);
294        // assert_eq!(TemplateModule::address_tokens(1, 1), []);
295        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
296292
297        // split item scenario293        // split item scenario
298        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));294        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 3));
299        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);
300        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);
301        assert_eq!(TemplateModule::balance_count(1, 2), 500);295        assert_eq!(TemplateModule::balance_count(1, 2), 2);
302        assert_eq!(TemplateModule::balance_count(1, 3), 500);296        assert_eq!(TemplateModule::balance_count(1, 3), 3);
303        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
304        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
305297
306        // split item and new owner has account scenario298        // split item and new owner has account scenario
307        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));299        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 1));
308        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);300        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 1);
309        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);301        assert_eq!(TemplateModule::fungible_item_id(1, 3).value, 4);
310        assert_eq!(TemplateModule::balance_count(1, 2), 300);302        assert_eq!(TemplateModule::balance_count(1, 2), 1);
311        assert_eq!(TemplateModule::balance_count(1, 3), 700);303        assert_eq!(TemplateModule::balance_count(1, 3), 4);
312        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
313        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
314    });304    });
315}305}
316306
451            1), Error::<Test>::NoPermission);441            1), Error::<Test>::NoPermission);
452442
453        // do approve443        // do approve
454        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));444        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
455        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);445        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
456        assert_eq!(446        assert_eq!(
457            TemplateModule::approved(1, (1, 1))[0],447            TemplateModule::approved(1, (1, 1, 2)),
458            ApprovePermissions {448            5
459                approved: 2,
460                amount: 100000000
461            }
462        );449        );
463450
464        assert_ok!(TemplateModule::transfer_from(451        assert_ok!(TemplateModule::transfer_from(
469            1,456            1,
470            1457            1
471        ));458        ));
472        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);459        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 4);
473    });460    });
474}461}
475462
505        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));492        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
506493
507        // do approve494        // do approve
508        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));495        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
509        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);496        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
510        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));497        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 5));
511        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);498        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);
512        assert_eq!(
513            TemplateModule::approved(1, (1, 1))[0],
514            ApprovePermissions {
515                approved: 2,
516                amount: 100000000
517            }
518        );
519499
520        assert_ok!(TemplateModule::transfer_from(500        assert_ok!(TemplateModule::transfer_from(
521            origin2.clone(),501            origin2.clone(),
525            1,505            1,
526            1506            1
527        ));507        ));
528        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);508        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 4);
529    });509    });
530}510}
531511
560        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));540        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
561541
562        // do approve542        // do approve
563        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));543        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
564        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);544        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
565        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));545        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 1000));
566        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);546        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 1000);
567        assert_eq!(
568            TemplateModule::approved(1, (1, 1))[0],
569            ApprovePermissions {
570                approved: 2,
571                amount: 100000000
572            }
573        );
574547
575        assert_ok!(TemplateModule::transfer_from(548        assert_ok!(TemplateModule::transfer_from(
576            origin2.clone(),549            origin2.clone(),
585        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);558        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
586        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);559        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);
587560
588        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);561        assert_eq!(
589        assert_eq!(562            TemplateModule::approved(1, (1, 1, 3)),
590            TemplateModule::approved(1, (1, 1))[0],563            900
591            ApprovePermissions {564        );
592                approved: 3,
593                amount: 100000000
594            }
595        );
596    });565    });
597}566}
598567
609        let origin1 = Origin::signed(1);578        let origin1 = Origin::signed(1);
610        let origin2 = Origin::signed(2);579        let origin2 = Origin::signed(2);
611580
612        assert_eq!(TemplateModule::balance_count(1, 1), 1000);581        assert_eq!(TemplateModule::balance_count(1, 1), 5);
613        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
614582
615        assert_ok!(TemplateModule::set_mint_permission(583        assert_ok!(TemplateModule::set_mint_permission(
616            origin1.clone(),584            origin1.clone(),
627        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));595        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
628596
629        // do approve597        // do approve
630        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));598        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
631        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);599        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
632        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));600        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 5));
633        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);601        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);
634        assert_eq!(602        assert_eq!(
635            TemplateModule::approved(1, (1, 1))[0],603            TemplateModule::approved(1, (1, 1, 2)),
636            ApprovePermissions {604            5
637                approved: 2,
638                amount: 100000000
639            }
640        );605        );
641606
642        assert_ok!(TemplateModule::transfer_from(607        assert_ok!(TemplateModule::transfer_from(
645            3,610            3,
646            1,611            1,
647            1,612            1,
648            100613            4
649        ));614        ));
650        assert_eq!(TemplateModule::balance_count(1, 1), 900);615        assert_eq!(TemplateModule::balance_count(1, 1), 1);
651        assert_eq!(TemplateModule::balance_count(1, 3), 100);616        assert_eq!(TemplateModule::balance_count(1, 3), 4);
652        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
653        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
654617
655        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);618        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
656        assert_eq!(619        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 1);
657            TemplateModule::approved(1, (1, 1))[0],
658            ApprovePermissions {
659                approved: 3,
660                amount: 100000000
661            }
662        );
663620
664        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));621        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
665        assert_ok!(TemplateModule::transfer_from(622        assert_noop!(TemplateModule::transfer_from(
666            origin2.clone(),623            origin2.clone(),
667            1,624            1,
668            3,625            3,
669            1,626            1,
670            1,627            1,
671            900628            4
672        ));629        ), Error::<Test>::TokenValueNotEnough);
673        assert_eq!(TemplateModule::balance_count(1, 1), 0);
674        assert_eq!(TemplateModule::balance_count(1, 3), 1000);
675        // assert_eq!(TemplateModule::address_tokens(1, 1), []);
676        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
677
678        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);
679    });630    });
680}631}
681632
725        assert_eq!(TemplateModule::balance_count(1, 1), 1);676        assert_eq!(TemplateModule::balance_count(1, 1), 1);
726677
727        // burn item678        // burn item
728        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));679        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));
729        assert_noop!(680        assert_noop!(
730            TemplateModule::burn_item(origin1.clone(), 1, 1),681            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),
731            Error::<Test>::TokenNotFound682            Error::<Test>::TokenNotFound
732        );683        );
733684
749        create_test_item(collection_id, &data.into());700        create_test_item(collection_id, &data.into());
750701
751        // check balance (collection with id = 1, user id = 1)702        // check balance (collection with id = 1, user id = 1)
752        assert_eq!(TemplateModule::balance_count(1, 1), 1000);703        assert_eq!(TemplateModule::balance_count(1, 1), 5);
753704
754        // burn item705        // burn item
755        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));706        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));
756        assert_noop!(707        assert_noop!(
757            TemplateModule::burn_item(origin1.clone(), 1, 1),708            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),
758            Error::<Test>::TokenNotFound709            Error::<Test>::TokenNotFound
759        );710        );
760711
791        assert_eq!(TemplateModule::balance_count(1, 1), 1000);742        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
792743
793        // burn item744        // burn item
794        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));745        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 1000));
795        assert_noop!(746        assert_noop!(
796            TemplateModule::burn_item(origin1.clone(), 1, 1),747            TemplateModule::burn_item(origin1.clone(), 1, 1, 1000),
797            Error::<Test>::TokenNotFound748            Error::<Test>::TokenNotFound
798        );749        );
799750
875826
876        // check balance (collection with id = 1, user id = 1)827        // check balance (collection with id = 1, user id = 1)
877        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);828        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);
878        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);829        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 5);
879        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);830        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);
880        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);831        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);
881        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);832        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).value, 5);
882        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);833        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);
883    });834    });
884}835}
896        let origin1 = Origin::signed(1);847        let origin1 = Origin::signed(1);
897        848        
898        // approve849        // approve
899        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));850        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 1));
900        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);851        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);
901    });852    });
902}853}
903854
914        create_test_item(collection_id, &data.into());865        create_test_item(collection_id, &data.into());
915866
916        // approve867        // approve
917        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));868        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 1));
918        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);869        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);
919870
920        assert_ok!(TemplateModule::set_mint_permission(871        assert_ok!(TemplateModule::set_mint_permission(
921            origin1.clone(),872            origin1.clone(),
1199        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));1150        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
12001151
1201        // do approve1152        // do approve
1202        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1153        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 1));
1203        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);1154        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);
12041155
1205        assert_ok!(TemplateModule::remove_from_white_list(1156        assert_ok!(TemplateModule::remove_from_white_list(
1206            origin1.clone(),1157            origin1.clone(),
1263        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1214        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
12641215
1265        // do approve1216        // do approve
1266        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1217        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 1));
1267        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);1218        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);
12681219
1269        assert_ok!(TemplateModule::remove_from_white_list(1220        assert_ok!(TemplateModule::remove_from_white_list(
1270            origin1.clone(),1221            origin1.clone(),
1298            AccessMode::WhiteList1249            AccessMode::WhiteList
1299        ));1250        ));
1300        assert_noop!(1251        assert_noop!(
1301            TemplateModule::burn_item(origin1.clone(), 1, 1),1252            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),
1302            Error::<Test>::AddresNotInWhiteList1253            Error::<Test>::AddresNotInWhiteList
1303        );1254        );
1304    });1255    });
13211272
1322        // do approve1273        // do approve
1323        assert_noop!(1274        assert_noop!(
1324            TemplateModule::approve(origin1.clone(), 1, 1, 1),1275            TemplateModule::approve(origin1.clone(), 1, 1, 1, 5),
1325            Error::<Test>::AddresNotInWhiteList1276            Error::<Test>::AddresNotInWhiteList
1326        );1277        );
1327    });1278    });
1374        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1325        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
13751326
1376        // do approve1327        // do approve
1377        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1328        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 5));
1378        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);1329        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 5);
13791330
1380        assert_ok!(TemplateModule::transfer_from(1331        assert_ok!(TemplateModule::transfer_from(
1381            origin1.clone(),1332            origin1.clone(),
modifiedtests/package.jsondiffbeforeafterboth
20    "load": "mocha --timeout 9999999 -r ts-node/register ./**/*.load.ts",20    "load": "mocha --timeout 9999999 -r ts-node/register ./**/*.load.ts",
21    "testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts",21    "testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts",
22    "testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts",22    "testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts",
23    "testRemoveCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/removeCollectionAdmin.test.ts",
23    "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",24    "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",
24    "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",25    "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
25    "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts",26    "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts",
addedtests/src/burnItem.test.tsdiffbeforeafterboth

no changes

modifiedtests/src/confirmSponsorship.test.tsdiffbeforeafterboth
89  });89  });
9090
91  it('Fungible: Transfer fees are paid by the sponsor after confirmation', async () => {91  it('Fungible: Transfer fees are paid by the sponsor after confirmation', async () => {
92    const collectionId = await createCollectionExpectSuccess({mode: 'Fungible'});92    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0 }});
93    await setCollectionSponsorExpectSuccess(collectionId, bob.address);93    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
94    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');94    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
9595
115  });115  });
116116
117  it('ReFungible: Transfer fees are paid by the sponsor after confirmation', async () => {117  it('ReFungible: Transfer fees are paid by the sponsor after confirmation', async () => {
118    const collectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});118    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0 }});
119    await setCollectionSponsorExpectSuccess(collectionId, bob.address);119    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
120    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');120    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
121121
210  });210  });
211211
212  it('Fungible: Sponsoring is rate limited', async () => {212  it('Fungible: Sponsoring is rate limited', async () => {
213    const collectionId = await createCollectionExpectSuccess({mode: 'Fungible'});213    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0 }});
214    await setCollectionSponsorExpectSuccess(collectionId, bob.address);214    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
215    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');215    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
216216
247  });247  });
248248
249  it('ReFungible: Sponsoring is rate limited', async () => {249  it('ReFungible: Sponsoring is rate limited', async () => {
250    const collectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});250    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0 }});
251    await setCollectionSponsorExpectSuccess(collectionId, bob.address);251    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
252    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');252    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
253253
modifiedtests/src/createCollection.test.tsdiffbeforeafterboth
37    await usingApi(async (api) => {
37    await usingApi(async (api) => {

38      const AcollectionCount = parseInt((await api.query.nft.collectionCount()).toString(), 10);
38      const AcollectionCount = parseInt((await api.query.nft.collectionCount()).toString(), 10);

39
39

40      const badTransaction = async () => await createCollectionExpectSuccess({mode: {type: 'Invalid'}});
40      const badTransaction = async () => {

41        await createCollectionExpectSuccess({mode: {type: 'Invalid'}});

42      };

41      // tslint:disable-next-line:no-unused-expression
43      // tslint:disable-next-line:no-unused-expression

42      expect(badTransaction()).to.be.rejected;
44      expect(badTransaction()).to.be.rejected;

43
45
modifiedtests/src/createItem.test.tsdiffbeforeafterboth
18
18

19  it('Create new item in NFT collection', async () => {
19  it('Create new item in NFT collection', async () => {

20    const createMode = 'NFT';
20    const createMode = 'NFT';

21    const newCollectionID = await createCollectionExpectSuccess({mode: createMode});
21    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});

22    await createItemExpectSuccess(alice, newCollectionID, createMode);
22    await createItemExpectSuccess(alice, newCollectionID, createMode);

23  });
23  });

24  it('Create new item in Fungible collection', async () => {
24  it('Create new item in Fungible collection', async () => {

25    const createMode = 'Fungible';
25    const createMode = 'Fungible';

26    const newCollectionID = await createCollectionExpectSuccess({mode: createMode});
26    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});

27    await createItemExpectSuccess(alice, newCollectionID, createMode);
27    await createItemExpectSuccess(alice, newCollectionID, createMode);

28  });
28  });

29  it('Create new item in ReFungible collection', async () => {
29  it('Create new item in ReFungible collection', async () => {

30    const createMode = 'ReFungible';
30    const createMode = 'ReFungible';

31    const newCollectionID = await createCollectionExpectSuccess({mode: createMode});
31    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});

32    await createItemExpectSuccess(alice, newCollectionID, createMode);
32    await createItemExpectSuccess(alice, newCollectionID, createMode);

33  });
33  });

34});
34});
modifiedtests/src/destroyCollection.test.tsdiffbeforeafterboth
14    await destroyCollectionExpectSuccess(collectionId);14    await destroyCollectionExpectSuccess(collectionId);
15  });15  });
16  it('Fungible collection can be destroyed', async () => {16  it('Fungible collection can be destroyed', async () => {
17    const collectionId = await createCollectionExpectSuccess({ mode: 'Fungible' });17    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
18    await destroyCollectionExpectSuccess(collectionId);18    await destroyCollectionExpectSuccess(collectionId);
19  });19  });
20  it('ReFungible collection can be destroyed', async () => {20  it('ReFungible collection can be destroyed', async () => {
21    const collectionId = await createCollectionExpectSuccess({ mode: 'ReFungible' });21    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
22    await destroyCollectionExpectSuccess(collectionId);22    await destroyCollectionExpectSuccess(collectionId);
23  });23  });
24});24});
addedtests/src/removeCollectionAdmin.test.tsdiffbeforeafterboth

no changes

modifiedtests/src/setCollectionLimits.test.tsdiffbeforeafterboth
32  });32  });
33  it('choose or create collection for testing', async () => {33  it('choose or create collection for testing', async () => {
34    await usingApi(async () => {34    await usingApi(async () => {
35      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: 'NFT'});35      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
36    });36    });
37  });37  });
38});38});
modifiedtests/src/setCollectionSponsor.test.tsdiffbeforeafterboth
30    await setCollectionSponsorExpectSuccess(collectionId, bob.address);30    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
31  });31  });
32  it('Set Fungible collection sponsor', async () => {32  it('Set Fungible collection sponsor', async () => {
33    const collectionId = await createCollectionExpectSuccess({ mode: 'Fungible' });33    const collectionId = await createCollectionExpectSuccess({ mode: {type: 'Fungible', decimalPoints: 0} });
34    await setCollectionSponsorExpectSuccess(collectionId, bob.address);34    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
35  });35  });
36  it('Set ReFungible collection sponsor', async () => {36  it('Set ReFungible collection sponsor', async () => {
37    const collectionId = await createCollectionExpectSuccess({ mode: 'ReFungible' });37    const collectionId = await createCollectionExpectSuccess({ mode: {type: 'ReFungible', decimalPoints: 0} });
38    await setCollectionSponsorExpectSuccess(collectionId, bob.address);38    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
39  });39  });
4040
modifiedtests/src/setSchemaVersion.test.tsdiffbeforeafterboth
35  });35  });
36  it('choose or create collection for testing', async () => {36  it('choose or create collection for testing', async () => {
37    await usingApi(async () => {37    await usingApi(async () => {
38      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: 'NFT'});38      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
39    });39    });
40  });40  });
41});41});
93      const nonExistedCollectionId = collectionCount + 1;93      const nonExistedCollectionId = collectionCount + 1;
94      tx = api.tx.nft.setSchemaVersion(nonExistedCollectionId, 'ImageURL');94      tx = api.tx.nft.setSchemaVersion(nonExistedCollectionId, 'ImageURL');
95      await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;95      await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;
96      /*try {
97        await submitTransactionAsync(alice, tx);
98      } catch (e) {
99        // tslint:disable-next-line:no-unused-expression
100        expect(e).to.be.exist;
101      }*/
102    });96    });
103  });97  });
10498
119      await destroyCollectionExpectSuccess(collectionIdForTesting);113      await destroyCollectionExpectSuccess(collectionIdForTesting);
120      tx = api.tx.nft.setSchemaVersion(collectionIdForTesting, 'ImageURL');114      tx = api.tx.nft.setSchemaVersion(collectionIdForTesting, 'ImageURL');
121      await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;115      await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;
122      /*try {
123        tx = api.tx.nft.setSchemaVersion(collectionIdForTesting, 'ImageURL');
124        await submitTransactionAsync(alice, tx);
125      } catch (e) {
126        // tslint:disable-next-line:no-unused-expression
127        expect(e).to.be.exist;
128      }*/
129    });116    });
130  });117  });
131});118});
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
112  decimalPoints: number;112  decimalPoints: number;
113}113}
114
115interface Nft {
116  type: 'NFT'
117}
118
119interface Fungible {
120  type: 'Fungible',
121  decimalPoints: number
122}
123
124interface ReFungible {
125  type: 'ReFungible',
126  decimalPoints: number
127}
114128
115type CollectionMode = Nft | Fungible | ReFungible | Invalid;129type CollectionMode = Nft | Fungible | ReFungible | Invalid;
116130