git.delta.rocks / unique-network / refs/commits / 63e242dc3f1d

difftreelog

Add pieces into token data. Add negative tests.

Trubnikov Sergey2022-06-30parent: #88ef722.patch.diff
in: master

4 files changed

modifiedpallets/nonfungible/src/common.rsdiffbeforeafterboth
473		None473		None
474	}474	}
475475
476	fn total_pieces(&self, _token: TokenId) -> Option<u128> {476	fn total_pieces(&self, token: TokenId) -> Option<u128> {
477		if <TokenData<T>>::contains_key((self.id, token)) {
477		Some(1)478			Some(1)
478	}479		} else {
480			None
481		}
482	}
479}483}
480484
modifiedprimitives/data-structs/src/lib.rsdiffbeforeafterboth
--- a/primitives/data-structs/src/lib.rs
+++ b/primitives/data-structs/src/lib.rs
@@ -181,6 +181,7 @@
 pub struct TokenData<CrossAccountId> {
 	pub properties: Vec<Property>,
 	pub owner: Option<CrossAccountId>,
+	pub pieces: Option<u128>,
 }
 
 pub struct OverflowError;
modifiedruntime/common/src/runtime_apis.rsdiffbeforeafterboth
--- a/runtime/common/src/runtime_apis.rs
+++ b/runtime/common/src/runtime_apis.rs
@@ -89,7 +89,8 @@
                 ) -> Result<TokenData<CrossAccountId>, DispatchError> {
                     let token_data = TokenData {
                         properties: Self::token_properties(collection, token_id, keys)?,
-                        owner: Self::token_owner(collection, token_id)?
+                        owner: Self::token_owner(collection, token_id)?,
+                        pieces: Self::total_pieces(collection, token_id)?
                     };
 
                     Ok(token_data)
modifiedtests/src/createItem.test.tsdiffbeforeafterboth
--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.test.ts
@@ -98,47 +98,57 @@
     await createItemWithPropsExpectSuccess(alice, newCollectionID, createMode, [{key: 'key1', value: 'val1'}]);
   });
 
-  it.only('Check total pieces of Fungible token', async () => {
+  it('Check total pieces of Fungible token', async () => {
     await usingApi(async api => {
       const createMode = 'Fungible';
       const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
+      const amountPieces = 10n;
       const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
       {
         const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
         expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(10n);
+        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
       }
 
       await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);
       {
         const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
         expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(10n);
+        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
       }
+
+      const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
+      expect(totalPieces.isSome).to.be.true;
+      expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
     });
   });
 
-  it.only('Check total pieces of NFT token', async () => {
+  it('Check total pieces of NFT token', async () => {
     await usingApi(async api => {
       const createMode = 'NFT';
       const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
+      const amountPieces = 1n;
       const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
       {
         const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
         expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(1n);
+        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
       }
 
       await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);
       {
         const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
         expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(1n);
+        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
       }
+
+      const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
+      expect(totalPieces.isSome).to.be.true;
+      expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
     });
   });
 
-  it.only('Check total pieces of ReFungible token', async () => {
+  it('Check total pieces of ReFungible token', async () => {
     await usingApi(async api => {
       const createMode = 'ReFungible';
       const createCollectionResult = await createCollection(api, alice, {mode: {type: createMode}});
@@ -157,6 +167,10 @@
         expect(totalPieces.isSome).to.be.true;
         expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
       }
+
+      const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
+      expect(totalPieces.isSome).to.be.true;
+      expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
     });
   });
 });
@@ -233,4 +247,37 @@
       await createItemWithPropsExpectFailure(alice, newCollectionID, 'NFT', [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]);
     });
   });
+
+  it('Check total pieces for invalid Fungible token', async () => {
+    await usingApi(async api => {
+      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'Fungible', decimalPoints: 0}});
+      const collectionId  = createCollectionResult.collectionId;
+      const invalidTokenId = 1000_000;
+      
+      expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
+      expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.isNone).to.be.true;
+    });
+  });
+
+  it('Check total pieces for invalid NFT token', async () => {
+    await usingApi(async api => {
+      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'NFT'}});
+      const collectionId  = createCollectionResult.collectionId;
+      const invalidTokenId = 1000_000;
+      
+      expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
+      expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.isNone).to.be.true;
+    });
+  });
+
+  it('Check total pieces for invalid Refungible token', async () => {
+    await usingApi(async api => {
+      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'ReFungible'}});
+      const collectionId  = createCollectionResult.collectionId;
+      const invalidTokenId = 1000_000;
+      
+      expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
+      expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.isNone).to.be.true;
+    });
+  });
 });