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

difftreelog

transferSuccess

kpozdnikin2021-01-19parent: #8154d7d.patch.diff
in: master

3 files changed

modifiedtests/src/burnItem.test.tsdiffbeforeafterboth
--- a/tests/src/burnItem.test.ts
+++ b/tests/src/burnItem.test.ts
@@ -35,16 +35,16 @@
       const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
       const events = await submitTransactionAsync(alice, tx);
       const result = getGenericResult(events);
-  
-      // Get the item 
+      // Get the item
       const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();
- 
       // What to expect
+      // tslint:disable-next-line:no-unused-expression
       expect(result.success).to.be.true;
+      // tslint:disable-next-line:no-unused-expression
       expect(item).to.be.not.null;
       expect(item.Owner).to.be.equal(nullPublicKey);
     });
-  
+
   });
   it('Burn item in Fungible collection', async () => {
     const createMode = 'Fungible';
modifiedtests/src/transfer.test.tsdiffbeforeafterboth
--- a/tests/src/transfer.test.ts
+++ b/tests/src/transfer.test.ts
@@ -8,17 +8,18 @@
 import { alicesPublicKey, bobsPublicKey } from './accounts';
 import getBalance from './substrate/get-balance';
 import privateKey from './substrate/privateKey';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
+import { default as usingApi, submitTransactionAsync } from './substrate/substrate-api';
 import {
-  approveExpectSuccess,
-  createCollectionExpectSuccess, createItemExpectSuccess,
+  burnItemExpectSuccess, createCollectionExpectSuccess, createItemExpectSuccess,
+  destroyCollectionExpectSuccess,
   findUnusedAddress,
   getCreateCollectionResult,
   getCreateItemResult,
+  transferExpectFail,
   transferExpectSuccess,
 } from './util/helpers';
 
-describe('Integration Test Transfer(recipient, collection_id, item_id, value)', () => {
+/*describe('Integration Test Transfer(recipient, collection_id, item_id, value)', () => {
   it('Balance transfers and check balance', async () => {
     await usingApi(async (api: ApiPromise) => {
       const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);
@@ -58,44 +59,125 @@
   });
 
   it('Create collection, balance transfers and check balance', async () => {
-    const Alice = privateKey('//Alice');
-    const Bob = privateKey('//Bob');
-    const Charlie = privateKey('//CHARLIE');
-    // nft
-    const nftCollectionId = await createCollectionExpectSuccess();
-    const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
-
-    await transferExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
-
-    // fungible
-    const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
-    await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
-    await transferExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');
-    // reFungible
-    const reFungibleCollectionId = await
-      createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
-    const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
-    await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
-    await transferExpectSuccess(reFungibleCollectionId,
-      newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');
+    await usingApi(async (api) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await transferExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await transferExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await transferExpectSuccess(reFungibleCollectionId,
+        newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');
+    });
   });
-});
+});*/
 
 describe('Negative Integration Test Transfer(recipient, collection_id, item_id, value)', () => {
-  it('Transfer with not existed collection_id', async () => {
-
+  /*it('Transfer with not existed collection_id', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await transferExpectFail(nftCollectionCount + 1, 1, Alice, Bob, 1);
+      // fungible
+      const fungibleCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await transferExpectFail(fungibleCollectionCount + 1, 1, Alice, Bob, 1);
+      // reFungible
+      const reFungibleCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await transferExpectFail(reFungibleCollectionCount + 1, 1, Alice, Bob, 1);
+    });
   });
   it('Transfer with deleted collection_id', async () => {
-
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await transferExpectFail(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await transferExpectFail(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
+      await transferExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');
+    });
   });
   it('Transfer with not existed item_id', async () => {
-
+   await usingApi(async (api: ApiPromise) => {
+     const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      await transferExpectFail(nftCollectionId, 2, Alice, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      await transferExpectFail(fungibleCollectionId, 2, Alice, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      await transferExpectFail(reFungibleCollectionId,
+        2, Alice, Bob, 1, 'ReFungible');
+   });
   });
   it('Transfer with deleted item_id', async () => {
-
-  });
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await burnItemExpectSuccess(Alice, nftCollectionId, newNftTokenId, 1);
+      await transferExpectFail(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await burnItemExpectSuccess(Alice, fungibleCollectionId, newFungibleTokenId, 1);
+      await transferExpectFail(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 1);
+      await transferExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');
+    });
+  });*/
   it('Transfer with recipient that is not owner', async () => {
-
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await transferExpectFail(nftCollectionId, newNftTokenId, Charlie, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await transferExpectFail(fungibleCollectionId, newFungibleTokenId, Charlie, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await transferExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Charlie, Bob, 1, 'ReFungible');
+    });
   });
 });
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
391  ReFungible: CreateReFungibleData;391  ReFungible: CreateReFungibleData;
392}392}
393
394export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {
395  await usingApi(async (api) => {
396    const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
397    const events = await submitTransactionAsync(owner, tx);
398    const result = getGenericResult(events);
399    // Get the item
400    const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();
401    // What to expect
402    // tslint:disable-next-line:no-unused-expression
403    expect(result.success).to.be.true;
404    // tslint:disable-next-line:no-unused-expression
405    expect(item).to.be.not.null;
406    expect(item.Owner).to.be.equal(nullPublicKey);
407  });
408}
393409
394export async function410export async function
395approveExpectSuccess(collectionId: number,411approveExpectSuccess(collectionId: number,
495  });511  });
496}512}
513
514export async function
515transferExpectFail(collectionId: number,
516                   tokenId: number,
517                   sender: IKeyringPair,
518                   recipient: IKeyringPair,
519                   value: number = 1,
520                   type: string = 'NFT') {
521  await usingApi(async (api: ApiPromise) => {
522    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);
523    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;
524    const result = getCreateCollectionResult(events);
525    // tslint:disable-next-line:no-unused-expression
526    expect(result.success).to.be.false;
527  });
528}
497529
498export async function530export async function
499approveExpectFail(collectionId: number,531approveExpectFail(collectionId: number,
559    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();592    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
560593
561    // What to expect594    // What to expect
595    // tslint:disable-next-line:no-unused-expression
562    expect(result.success).to.be.true;596    expect(result.success).to.be.true;
563    expect(collection.Access).to.be.equal('WhiteList');597    expect(collection.Access).to.be.equal('WhiteList');
564  });598  });