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

difftreelog

Unit tests added

str-mv2020-09-08parent: #aa92af0.patch.diff
in: master

3 files changed

modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -129,6 +129,18 @@
     pub amount: u64
 }
 
+#[derive(Encode, Decode, Default, Clone, PartialEq)]
+#[cfg_attr(feature = "std", derive(Debug))]
+pub struct VestingItem<AccountId, Moment>
+{
+    pub sender: AccountId,
+    pub recipient: AccountId,
+    pub collection_id: u64,
+    pub item_id: u64,
+    pub amount: u64,
+    pub vesting_date: Moment
+}
+
 pub trait Trait: system::Trait {
     type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
 
@@ -156,6 +168,10 @@
         pub FungibleItemList get(fn fungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;
         pub ReFungibleItemList get(fn refungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;
 
+        // Active vesting list
+        // pub VestingList get(fn vesting): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => VestingItem<T::AccountId, T::Moment>;
+
+        /// Index list
         pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;
 
         // Sponsorship
@@ -636,6 +652,7 @@
 
     fn burn_refungible_item(collection_id: u64, item_id: u64, owner: T::AccountId) -> DispatchResult {
   
+        ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), "Item does not exists");
         let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);
         let item = collection.owner.iter().filter(|&i| i.owner == owner).next().unwrap();
         Self::remove_token_index(collection_id, item_id, owner.clone())?;
@@ -655,6 +672,7 @@
 
     fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {
   
+        ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), "Item does not exists");
         let item = <NftItemList<T>>::get(collection_id, item_id);
         Self::remove_token_index(collection_id, item_id, item.owner.clone())?;
 
@@ -671,6 +689,7 @@
 
     fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {
   
+        ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), "Item does not exists");
         let item = <FungibleItemList<T>>::get(collection_id, item_id);
         Self::remove_token_index(collection_id, item_id, item.owner.clone())?;
 
modifiedpallets/nft/src/tests.rsdiffbeforeafterboth
364 });363 });
365}364}
366365
367366#[test]
368367fn change_collection_owner() {
369368 new_test_ext().execute_with(|| {
370369 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
371370 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
372371 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
373372 let mode: CollectionMode = CollectionMode::NFT(2000);
374373
375374 let origin1 = Origin::signed(1);
376375 assert_ok!(TemplateModule::create_collection(
377376 origin1.clone(),
378377 col_name1.clone(),
379378 col_desc1.clone(),
380379 token_prefix1.clone(),
381380 mode
382// #[test]381 ));
383// fn create_collection_test() {382 assert_ok!(TemplateModule::change_collection_owner(
384// new_test_ext().execute_with(|| {383 origin1.clone(),
385// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();384 1,
386// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();385 2
387// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();386 ));
388387 assert_eq!(TemplateModule::collection(1).owner, 2);
389// let size = 1024;388 });
390// let origin1 = Origin::signed(1);389}
391// assert_ok!(TemplateModule::create_collection(390
392// origin1.clone(),391#[test]
393// col_name1.clone(),392fn destroy_collection() {
394// col_desc1.clone(),393 new_test_ext().execute_with(|| {
395// token_prefix1.clone(),394 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
396// size395 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
397// ));396 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
398// assert_eq!(TemplateModule::collection(1).owner, 1);397 let mode: CollectionMode = CollectionMode::NFT(2000);
399// });398
400// }399 let origin1 = Origin::signed(1);
401400 assert_ok!(TemplateModule::create_collection(
402// #[test]401 origin1.clone(),
403// fn change_collection_owner() {402 col_name1.clone(),
404// new_test_ext().execute_with(|| {403 col_desc1.clone(),
405// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();404 token_prefix1.clone(),
406// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();405 mode
407// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();406 ));
408407 assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
409// let size = 1024;408 });
410// let origin1 = Origin::signed(1);409}
411410
412// assert_ok!(TemplateModule::create_collection(411#[test]
413// origin1.clone(),412fn burn_nft_item() {
414// col_name1.clone(),413 new_test_ext().execute_with(|| {
415// col_desc1.clone(),414 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
416// token_prefix1.clone(),415 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
417// size416 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
418// ));417 let mode: CollectionMode = CollectionMode::NFT(2000);
419// assert_ok!(TemplateModule::change_collection_owner(418
420// origin1.clone(),419 let origin1 = Origin::signed(1);
421// 1,420 let origin2 = Origin::signed(2);
422// 2421 assert_ok!(TemplateModule::create_collection(
423// ));422 origin1.clone(),
424// assert_eq!(TemplateModule::collection(1).owner, 2);423 col_name1.clone(),
425// });424 col_desc1.clone(),
426// }425 token_prefix1.clone(),
427426 mode
428// #[test]427 ));
429// fn destroy_collection() {428 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
430// new_test_ext().execute_with(|| {429 assert_ok!(TemplateModule::create_item(
431// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();430 origin2.clone(),
432// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();431 1,
433// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();432 [1, 2, 3].to_vec(),
434433 1
435// let size = 1024;434 ));
436// let origin1 = Origin::signed(1);435
437436 assert_eq!(TemplateModule::nft_item_id(1,1).data, [1,2,3].to_vec());
438// assert_ok!(TemplateModule::create_collection(437
439// origin1.clone(),438 // check balance (collection with id = 1, user id = 1)
440// col_name1.clone(),439 assert_eq!(TemplateModule::balance_count(1, 1), 1);
441// col_desc1.clone(),440
442// token_prefix1.clone(),441 // burn item
443// size442 assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
444// ));443 assert_noop!(
445// assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));444 TemplateModule::burn_item(origin1.clone(), 1, 1),
446// });445 "Item does not exists"
447// }446 );
448447
449// #[test]448 assert_eq!(TemplateModule::balance_count(1, 1), 0);
450// fn create_item() {449 });
451// new_test_ext().execute_with(|| {450}
452// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();451
453// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();452#[test]
454// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();453fn burn_fungible_item() {
455454 new_test_ext().execute_with(|| {
456// let size = 1024;455 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
457// let origin1 = Origin::signed(1);456 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
458// let origin2 = Origin::signed(2);457 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
459458 let mode: CollectionMode = CollectionMode::Fungible(3);
460// assert_ok!(TemplateModule::create_collection(459
461// origin1.clone(),460 let origin1 = Origin::signed(1);
462// col_name1.clone(),461 let origin2 = Origin::signed(2);
463// col_desc1.clone(),462 assert_ok!(TemplateModule::create_collection(
464// token_prefix1.clone(),463 origin1.clone(),
465// size464 col_name1.clone(),
466// ));465 col_desc1.clone(),
467// assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));466 token_prefix1.clone(),
468// assert_ok!(TemplateModule::create_item(467 mode
469// origin2.clone(),468 ));
470// 1,469 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
471// [1, 1, 1].to_vec()470 assert_ok!(TemplateModule::create_item(
472// ));471 origin2.clone(),
472 1,
473 [].to_vec(),
474 1
475 ));
473476
474// // check balance (collection with id = 1, user id = 2)477 // check balance (collection with id = 1, user id = 1)
475// assert_eq!(TemplateModule::balance_count((1, 2)), 1);478 assert_eq!(TemplateModule::balance_count(1, 1), 1000);
476// });479
477// }480 // burn item
478481 assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
479// #[test]482 assert_noop!(
480// fn burn_item() {483 TemplateModule::burn_item(origin1.clone(), 1, 1),
481// new_test_ext().execute_with(|| {484 "Item does not exists"
482// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();485 );
483// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();486
484// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();487 assert_eq!(TemplateModule::balance_count(1, 1), 0);
485488 });
486// let size = 1024;489}
487// let origin1 = Origin::signed(1);490
488// let origin2 = Origin::signed(2);491#[test]
489492fn burn_refungible_item() {
490// assert_ok!(TemplateModule::create_collection(493 new_test_ext().execute_with(|| {
491// origin1.clone(),494 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
492// col_name1.clone(),495 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
493// col_desc1.clone(),496 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
494// token_prefix1.clone(),497 let mode: CollectionMode = CollectionMode::ReFungible(200, 3);
495// size498
496// ));499 let origin1 = Origin::signed(1);
497// assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));500 let origin2 = Origin::signed(2);
498// assert_ok!(TemplateModule::create_item(501 assert_ok!(TemplateModule::create_collection(
499// origin2.clone(),502 origin1.clone(),
500// 1,503 col_name1.clone(),
501// [1, 1, 1].to_vec()504 col_desc1.clone(),
502// ));505 token_prefix1.clone(),
506 mode
507 ));
508 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
509 assert_ok!(TemplateModule::create_item(
510 origin2.clone(),
511 1,
512 [1,2,3].to_vec(),
513 1
514 ));
515
516 assert_eq!(TemplateModule::refungible_item_id(1,1).data, [1,2,3].to_vec());
503517
504// // check balance (collection with id = 1, user id = 2)518 // check balance (collection with id = 1, user id = 2)
505// assert_eq!(TemplateModule::balance_count((1, 2)), 1);519 assert_eq!(TemplateModule::balance_count(1, 1), 1000);
506520
507// // burn item521 // burn item
508// assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));522 assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
509// assert_noop!(523 assert_noop!(
510// TemplateModule::burn_item(origin1.clone(), 1, 1),524 TemplateModule::burn_item(origin1.clone(), 1, 1),
511// "Item does not exists"525 "Item does not exists"
512// );526 );
513527
514// assert_eq!(TemplateModule::balance_count((1, 1)), 0);528 assert_eq!(TemplateModule::balance_count(1, 1), 0);
515// });529 });
516// }530}
517531
518// #[test]532#[test]
519// fn add_collection_admin() {533fn add_collection_admin() {
520// new_test_ext().execute_with(|| {534 new_test_ext().execute_with(|| {
521// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();535 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
522// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();536 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
523// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();537 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
524538 let mode: CollectionMode = CollectionMode::NFT(2000);
525// let size = 1024;539
526// let origin1 = Origin::signed(1);540 let origin1 = Origin::signed(1);
527// let origin2 = Origin::signed(2);541 let origin2 = Origin::signed(2);
528// let origin3 = Origin::signed(3);542 let origin3 = Origin::signed(3);
529543 assert_ok!(TemplateModule::create_collection(
530// assert_ok!(TemplateModule::create_collection(544 origin1.clone(),
531// origin1.clone(),545 col_name1.clone(),
532// col_name1.clone(),546 col_desc1.clone(),
533// col_desc1.clone(),547 token_prefix1.clone(),
534// token_prefix1.clone(),548 mode.clone()
535// size549 ));
536// ));550 assert_ok!(TemplateModule::create_collection(
537// assert_ok!(TemplateModule::create_collection(551 origin2.clone(),
538// origin2.clone(),552 col_name1.clone(),
539// col_name1.clone(),553 col_desc1.clone(),
540// col_desc1.clone(),554 token_prefix1.clone(),
541// token_prefix1.clone(),555 mode.clone()
542// size556 ));
543// ));557 assert_ok!(TemplateModule::create_collection(
544// assert_ok!(TemplateModule::create_collection(558 origin3.clone(),
545// origin3.clone(),559 col_name1.clone(),
546// col_name1.clone(),560 col_desc1.clone(),
547// col_desc1.clone(),561 token_prefix1.clone(),
548// token_prefix1.clone(),562 mode.clone()
549// size563 ));
550// ));564
551565 assert_eq!(TemplateModule::collection(1).owner, 1);
552// assert_eq!(TemplateModule::collection(1).owner, 1);566 assert_eq!(TemplateModule::collection(2).owner, 2);
553// assert_eq!(TemplateModule::collection(2).owner, 2);567 assert_eq!(TemplateModule::collection(3).owner, 3);
554// assert_eq!(TemplateModule::collection(3).owner, 3);568
555569 // collection admin
556// // collection admin570 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
557// assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));571 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
558// assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));572
559573 assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
560// assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);574 assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
561// assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);575 });
562// });576}
563// }577
564578#[test]
565// #[test]579fn remove_collection_admin() {
566// fn remove_collection_admin() {580 new_test_ext().execute_with(|| {
567// new_test_ext().execute_with(|| {581 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
568// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();582 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
569// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();583 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
570// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();584 let mode: CollectionMode = CollectionMode::NFT(2000);
571585
572// let size = 1024;586 let origin1 = Origin::signed(1);
573// let origin1 = Origin::signed(1);587 let origin2 = Origin::signed(2);
574// let origin2 = Origin::signed(2);588 let origin3 = Origin::signed(3);
575// let origin3 = Origin::signed(3);589
576590 assert_ok!(TemplateModule::create_collection(
577// assert_ok!(TemplateModule::create_collection(591 origin1.clone(),
578// origin1.clone(),592 col_name1.clone(),
579// col_name1.clone(),593 col_desc1.clone(),
580// col_desc1.clone(),594 token_prefix1.clone(),
581// token_prefix1.clone(),595 mode.clone()
582// size596 ));
583// ));597 assert_ok!(TemplateModule::create_collection(
584// assert_ok!(TemplateModule::create_collection(598 origin2.clone(),
585// origin2.clone(),599 col_name1.clone(),
586// col_name1.clone(),600 col_desc1.clone(),
587// col_desc1.clone(),601 token_prefix1.clone(),
588// token_prefix1.clone(),602 mode.clone()
589// size603 ));
590// ));604 assert_ok!(TemplateModule::create_collection(
591// assert_ok!(TemplateModule::create_collection(605 origin3.clone(),
592// origin3.clone(),606 col_name1.clone(),
593// col_name1.clone(),607 col_desc1.clone(),
594// col_desc1.clone(),608 token_prefix1.clone(),
595// token_prefix1.clone(),609 mode.clone()
596// size610 ));
597// ));611
598612 assert_eq!(TemplateModule::collection(1).owner, 1);
599// assert_eq!(TemplateModule::collection(1).owner, 1);613 assert_eq!(TemplateModule::collection(2).owner, 2);
600// assert_eq!(TemplateModule::collection(2).owner, 2);614 assert_eq!(TemplateModule::collection(3).owner, 3);
601// assert_eq!(TemplateModule::collection(3).owner, 3);615
602616 // collection admin
603// // collection admin617 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
604// assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));618 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
605// assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));619
606620 assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
607// assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);621 assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
608// assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);622
609623 // remove admin
610// // remove admin624 assert_ok!(TemplateModule::remove_collection_admin(
611// assert_ok!(TemplateModule::remove_collection_admin(625 origin2.clone(),
612// origin2.clone(),626 1,
613// 1,627 3
614// 3628 ));
615// ));629 assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);
616// assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);630 });
617// });631}
618// }632
619633#[test]
620// #[test]634fn balance_of() {
621// fn balance_of() {635 new_test_ext().execute_with(|| {
622// new_test_ext().execute_with(|| {636 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
623// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();637 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
624// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();638 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
625// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();639 let nft_mode: CollectionMode = CollectionMode::NFT(2000);
626640 let furg_mode: CollectionMode = CollectionMode::Fungible(3);
627// let size = 1024;641 let refung_mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
628// let origin1 = Origin::signed(1);642
629// let origin2 = Origin::signed(2);643 let origin1 = Origin::signed(1);
630// let origin3 = Origin::signed(3);644
631645 assert_ok!(TemplateModule::create_collection(
632// assert_ok!(TemplateModule::create_collection(646 origin1.clone(),
633// origin1.clone(),647 col_name1.clone(),
634// col_name1.clone(),648 col_desc1.clone(),
635// col_desc1.clone(),649 token_prefix1.clone(),
636// token_prefix1.clone(),650 nft_mode.clone()
637// size651 ));
638// ));652 assert_ok!(TemplateModule::create_collection(
639// assert_ok!(TemplateModule::create_collection(653 origin1.clone(),
640// origin2.clone(),654 col_name1.clone(),
641// col_name1.clone(),655 col_desc1.clone(),
642// col_desc1.clone(),656 token_prefix1.clone(),
643// token_prefix1.clone(),657 furg_mode.clone()
644// size658 ));
645// ));659 assert_ok!(TemplateModule::create_collection(
646// assert_ok!(TemplateModule::create_collection(660 origin1.clone(),
647// origin3.clone(),661 col_name1.clone(),
648// col_name1.clone(),662 col_desc1.clone(),
649// col_desc1.clone(),663 token_prefix1.clone(),
650// token_prefix1.clone(),664 refung_mode.clone()
651// size665 ));
652// ));666
653667 assert_eq!(TemplateModule::collection(1).owner, 1);
654// assert_eq!(TemplateModule::collection(1).owner, 1);668 assert_eq!(TemplateModule::collection(2).owner, 1);
655// assert_eq!(TemplateModule::collection(2).owner, 2);669 assert_eq!(TemplateModule::collection(3).owner, 1);
656// assert_eq!(TemplateModule::collection(3).owner, 3);670
657671 // check balance before
658// // check balance before672 assert_eq!(TemplateModule::balance_count(1, 1), 0);
659// assert_eq!(TemplateModule::balance_count((1, 1)), 0);673 assert_eq!(TemplateModule::balance_count(2, 1), 0);
660674 assert_eq!(TemplateModule::balance_count(3, 1), 0);
661// // create item675
662// assert_ok!(TemplateModule::create_item(676 // create item
663// origin1.clone(),677 assert_ok!(TemplateModule::create_item(
664// 1,678 origin1.clone(),
665// [1, 1, 1].to_vec()679 1,
666// ));680 [1, 1, 1].to_vec(),
681 1
682 ));
683
684 assert_ok!(TemplateModule::create_item(
685 origin1.clone(),
686 2,
687 [].to_vec(),
688 1
689 ));
690
691 assert_ok!(TemplateModule::create_item(
692 origin1.clone(),
693 3,
694 [1, 1, 1].to_vec(),
695 1
696 ));
667697
668// // check balance (collection with id = 1, user id = 2)698 // check balance (collection with id = 1, user id = 1)
669// assert_eq!(TemplateModule::balance_count((1, 1)), 1);699 assert_eq!(TemplateModule::balance_count(1, 1), 1);
670// assert_eq!(TemplateModule::item_id((1, 1)).owner, 1);700 assert_eq!(TemplateModule::balance_count(2, 1), 1000);
671// });701 assert_eq!(TemplateModule::balance_count(3, 1), 1000);
672// }702 assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 1);
673703 assert_eq!(TemplateModule::fungible_item_id(2, 1).owner, 1);
674// #[test]704 assert_eq!(TemplateModule::refungible_item_id(3, 1).owner[0].owner, 1);
675// fn transfer() {705 });
676// new_test_ext().execute_with(|| {706}
677// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();707
678// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();708#[test]
679// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();709fn approve() {
680710 new_test_ext().execute_with(|| {
681// let size = 1024;711 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
682// let origin1 = Origin::signed(1);712 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
683// let origin2 = Origin::signed(2);713 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
684// let origin3 = Origin::signed(3);714 let nft_mode: CollectionMode = CollectionMode::NFT(2000);
685715 let origin1 = Origin::signed(1);
686// assert_ok!(TemplateModule::create_collection(716
687// origin1.clone(),717 assert_ok!(TemplateModule::create_collection(
688// col_name1.clone(),718 origin1.clone(),
689// col_desc1.clone(),719 col_name1.clone(),
690// token_prefix1.clone(),720 col_desc1.clone(),
691// size721 token_prefix1.clone(),
692// ));722 nft_mode.clone()
693// assert_ok!(TemplateModule::create_collection(723 ));
694// origin2.clone(),724
695// col_name1.clone(),725 assert_eq!(TemplateModule::collection(1).owner, 1);
696// col_desc1.clone(),726
697// token_prefix1.clone(),727 // create item
698// size728 assert_ok!(TemplateModule::create_item(
699// ));729 origin1.clone(),
700// assert_ok!(TemplateModule::create_collection(730 1,
701// origin3.clone(),731 [1, 1, 1].to_vec(),
702// col_name1.clone(),732 1
703// col_desc1.clone(),733 ));
704// token_prefix1.clone(),734
705// size
706// ));
707
708// assert_eq!(TemplateModule::collection(1).owner, 1);
709// assert_eq!(TemplateModule::collection(2).owner, 2);
710// assert_eq!(TemplateModule::collection(3).owner, 3);
711
712// // create item
713// assert_ok!(TemplateModule::create_item(
714// origin1.clone(),
715// 1,
716// [1, 1, 1].to_vec()
717// ));
718
719// // transfer
720// assert_ok!(TemplateModule::transfer(origin1.clone(), 1, 1, 2));
721// assert_eq!(TemplateModule::item_id((1, 1)).owner, 2);
722
723// // balance_of check
724// assert_eq!(TemplateModule::balance_count((1, 1)), 0);
725// assert_eq!(TemplateModule::balance_count((1, 2)), 1);
726// });
727// }
728
729// #[test]
730// fn approve() {735 // approve
731// new_test_ext().execute_with(|| {736 assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
732// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();737 assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);
733// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();738 });
734// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();739}
735740
736// let size = 1024;741#[test]
737// let origin1 = Origin::signed(1);742fn transfer_from() {
738// let origin2 = Origin::signed(2);743 new_test_ext().execute_with(|| {
739// let origin3 = Origin::signed(3);744 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
740745 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
741// assert_ok!(TemplateModule::create_collection(746 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
742// origin1.clone(),747 let mode: CollectionMode = CollectionMode::NFT(2000);
743// col_name1.clone(),748 let origin1 = Origin::signed(1);
744// col_desc1.clone(),749 let origin2 = Origin::signed(2);
745// token_prefix1.clone(),750
746// size751 assert_ok!(TemplateModule::create_collection(
747// ));752 origin1.clone(),
748// assert_ok!(TemplateModule::create_collection(753 col_name1.clone(),
749// origin2.clone(),754 col_desc1.clone(),
750// col_name1.clone(),755 token_prefix1.clone(),
751// col_desc1.clone(),756 mode
752// token_prefix1.clone(),757 ));
753// size758
754// ));759 assert_eq!(TemplateModule::collection(1).owner, 1);
755// assert_ok!(TemplateModule::create_collection(760
756// origin3.clone(),761 // create item
757// col_name1.clone(),762 assert_ok!(TemplateModule::create_item(
758// col_desc1.clone(),763 origin1.clone(),
759// token_prefix1.clone(),764 1,
760// size765 [1, 1, 1].to_vec(),
761// ));766 1
762767 ));
763// assert_eq!(TemplateModule::collection(1).owner, 1);768
764// assert_eq!(TemplateModule::collection(2).owner, 2);769 // approve
765// assert_eq!(TemplateModule::collection(3).owner, 3);770 assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
766771 assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);
767// // create item772 assert_ok!(TemplateModule::transfer_from(origin2.clone(), 1, 2, 1, 1, 1));
768// assert_ok!(TemplateModule::create_item(773
769// origin1.clone(),774 // after transfer
770// 1,775 assert_eq!(TemplateModule::balance_count(1, 1), 0);
771// [1, 1, 1].to_vec()776 assert_eq!(TemplateModule::balance_count(1, 2), 1);
772// ));777 });
773778}
774// // approve
775// assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
776// assert_eq!(TemplateModule::approved((1, 1)).contains(&2), true);
777// });
778// }
779
780// #[test]
781// fn get_approved() {
782// new_test_ext().execute_with(|| {
783// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
784// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
785// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
786
787// let size = 1024;
788// let origin1 = Origin::signed(1);
789// let origin2 = Origin::signed(2);
790// let origin3 = Origin::signed(3);
791
792// assert_ok!(TemplateModule::create_collection(
793// origin1.clone(),
794// col_name1.clone(),
795// col_desc1.clone(),
796// token_prefix1.clone(),
797// size
798// ));
799// assert_ok!(TemplateModule::create_collection(
800// origin2.clone(),
801// col_name1.clone(),
802// col_desc1.clone(),
803// token_prefix1.clone(),
804// size
805// ));
806// assert_ok!(TemplateModule::create_collection(
807// origin3.clone(),
808// col_name1.clone(),
809// col_desc1.clone(),
810// token_prefix1.clone(),
811// size
812// ));
813
814// assert_eq!(TemplateModule::collection(1).owner, 1);
815// assert_eq!(TemplateModule::collection(2).owner, 2);
816// assert_eq!(TemplateModule::collection(3).owner, 3);
817
818// // create item
819// assert_ok!(TemplateModule::create_item(
820// origin1.clone(),
821// 1,
822// [1, 1, 1].to_vec()
823// ));
824
825// // approve
826// assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
827// assert_eq!(TemplateModule::approved((1, 1)).contains(&2), true);
828// });
829// }
830
831// #[test]
832// fn transfer_from() {
833// new_test_ext().execute_with(|| {
834// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
835// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
836// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
837
838// let size = 1024;
839// let origin1 = Origin::signed(1);
840// let origin2 = Origin::signed(2);
841// let origin3 = Origin::signed(3);
842
843// assert_ok!(TemplateModule::create_collection(
844// origin1.clone(),
845// col_name1.clone(),
846// col_desc1.clone(),
847// token_prefix1.clone(),
848// size
849// ));
850// assert_ok!(TemplateModule::create_collection(
851// origin2.clone(),
852// col_name1.clone(),
853// col_desc1.clone(),
854// token_prefix1.clone(),
855// size
856// ));
857// assert_ok!(TemplateModule::create_collection(
858// origin3.clone(),
859// col_name1.clone(),
860// col_desc1.clone(),
861// token_prefix1.clone(),
862// size
863// ));
864
865// assert_eq!(TemplateModule::collection(1).owner, 1);
866// assert_eq!(TemplateModule::collection(2).owner, 2);
867// assert_eq!(TemplateModule::collection(3).owner, 3);
868
869// // create item
870// assert_ok!(TemplateModule::create_item(
871// origin1.clone(),
872// 1,
873// [1, 1, 1].to_vec()
874// ));
875
876// // approve
877// assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
878// assert_ok!(TemplateModule::transfer_from(origin1.clone(), 1, 1, 2));
879// });
880// }
881
882// #[test]
883// fn index_list() {
884// new_test_ext().execute_with(|| {
885// let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
886// let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
887// let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
888
889// let size = 1024;
890// let origin1 = Origin::signed(1);
891// let origin2 = Origin::signed(2);
892// let origin3 = Origin::signed(3);
893
894// assert_ok!(TemplateModule::create_collection(
895// origin1.clone(),
896// col_name1.clone(),
897// col_desc1.clone(),
898// token_prefix1.clone(),
899// size
900// ));
901// assert_ok!(TemplateModule::create_collection(
902// origin2.clone(),
903// col_name1.clone(),
904// col_desc1.clone(),
905// token_prefix1.clone(),
906// size
907// ));
908// assert_ok!(TemplateModule::create_collection(
909// origin3.clone(),
910// col_name1.clone(),
911// col_desc1.clone(),
912// token_prefix1.clone(),
913// size
914// ));
915
916// assert_eq!(TemplateModule::collection(1).owner, 1);
917// assert_eq!(TemplateModule::collection(2).owner, 2);
918// assert_eq!(TemplateModule::collection(3).owner, 3);
919// // create items
920// assert_ok!(TemplateModule::create_item(
921// origin1.clone(),
922// 1,
923// [1, 1, 1].to_vec()
924// ));
925// assert_ok!(TemplateModule::create_item(
926// origin1.clone(),
927// 1,
928// [1, 1, 2].to_vec()
929// ));
930// assert_ok!(TemplateModule::create_item(
931// origin1.clone(),
932// 1,
933// [1, 2, 3].to_vec()
934// ));
935// assert_eq!(TemplateModule::address_tokens((1, 1)).len(), 3);
936// // burn one
937// assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 2));
938// assert_eq!(TemplateModule::address_tokens((1, 1)).len(), 2);
939// // burn another one
940// assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 3));
941// assert_eq!(TemplateModule::address_tokens((1, 1))[0], 1);
942// });
943// }
944779
modifiedruntime/src/lib.rsdiffbeforeafterboth
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -190,7 +190,6 @@
     /// Version of the runtime.
     type Version = Version;
     /// Converts a module to the index of the module in `construct_runtime!`.
-    ///
     /// This type is being generated by `construct_runtime!`.
     type ModuleToIndex = ModuleToIndex;
     /// What to do if a new account is created.