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

difftreelog

transferFrom tests

kpozdnikin2021-01-18parent: #f8c3f30.patch.diff
in: master

3 files changed

modifiedtests/src/approve.test.tsdiffbeforeafterboth
--- a/tests/src/approve.test.ts
+++ b/tests/src/approve.test.ts
@@ -7,7 +7,7 @@
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import privateKey from './substrate/privateKey';
-import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
+import { default as usingApi } from './substrate/substrate-api';
 import {
   approveExpectFail,
   approveExpectSuccess,
@@ -29,11 +29,12 @@
       const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
       await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
       // fungible
-      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
       const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
       await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
       // reFungible
-      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
       const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
       await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
 
@@ -54,12 +55,13 @@
       await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1);
       await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 0);
       // fungible
-      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
       const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
       await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1);
       await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 0);
       // reFungible
-      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
       const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
       await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 1);
       await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 0);
@@ -81,10 +83,11 @@
       const nftCollectionId = await createCollectionExpectSuccess();
       await approveExpectFail(nftCollectionId + 1, 1, Alice, Bob);
       // fungible
-      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
       await approveExpectFail(fungibleCollectionId + 1, 1, Alice, Bob);
       // reFungible
-      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
       await approveExpectFail(reFungibleCollectionId + 1, 1, Alice, Bob);
       // garbage collection :-D
       await destroyCollectionExpectSuccess(nftCollectionId);
@@ -102,11 +105,12 @@
       await destroyCollectionExpectSuccess(nftCollectionId);
       await approveExpectFail(nftCollectionId, 1, Alice, Bob);
       // fungible
-      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
       await destroyCollectionExpectSuccess(fungibleCollectionId);
       await approveExpectFail(fungibleCollectionId, 1, Alice, Bob);
       // reFungible
-      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
       await destroyCollectionExpectSuccess(reFungibleCollectionId);
       await approveExpectFail(reFungibleCollectionId, 1, Alice, Bob);
     });
@@ -120,10 +124,11 @@
       const nftCollectionId = await createCollectionExpectSuccess();
       await approveExpectFail(nftCollectionId, 2, Alice, Bob);
       // fungible
-      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
       await approveExpectFail(fungibleCollectionId, 2, Alice, Bob);
       // reFungible
-      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
       await approveExpectFail(reFungibleCollectionId, 2, Alice, Bob);
       // garbage collection :-D
       await destroyCollectionExpectSuccess(nftCollectionId);
@@ -141,11 +146,12 @@
       const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
       await approveExpectFail(nftCollectionId, newNftTokenId, Bob, Alice);
       // fungible
-      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
       const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
       await approveExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice);
       // reFungible
-      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
       const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
       await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Bob, Alice);
modifiedtests/src/transferFrom.test.tsdiffbeforeafterboth
--- a/tests/src/transferFrom.test.ts
+++ b/tests/src/transferFrom.test.ts
@@ -3,19 +3,19 @@
 // file 'LICENSE', which is part of this source code package.
 //
 import { ApiPromise } from '@polkadot/api';
-import BN from 'bn.js';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import privateKey from './substrate/privateKey';
-import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
+import { default as usingApi } from './substrate/substrate-api';
 import {
+  approveExpectFail,
   approveExpectSuccess,
   createCollectionExpectSuccess,
   createItemExpectSuccess,
   destroyCollectionExpectSuccess,
+  transferFromExpectFail,
   transferFromExpectSuccess,
 } from './util/helpers';
-import {IKeyringPair} from "@polkadot/types/types";
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
@@ -26,29 +26,30 @@
       const Alice = privateKey('//Alice');
       const Bob = privateKey('//Bob');
       const Charlie = privateKey('//CHARLIE');
+      // nft
       const nftCollectionId = await createCollectionExpectSuccess();
-      console.log('nftCollectionId', nftCollectionId);
-      const collectionInfo = await api.query.nft.collection(nftCollectionId);
-      console.log('collectionInfo', collectionInfo);
-      // nft
       const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
       await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
 
-      await transferFromExpectSuccess(nftCollectionId, newNftTokenId, Alice, Charlie, 1, 'NFT');
+      await transferFromExpectSuccess(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1, 'NFT');
 
       // fungible
-      /*const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
       const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
       await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
+      await transferFromExpectSuccess(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1, 'Fungible');
       // reFungible
-      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
       const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
-      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);*/
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
+      await transferFromExpectSuccess(reFungibleCollectionId,
+        newReFungibleTokenId, Bob, Alice, Charlie, 1, 'ReFungible');
 
       // garbage collection :-D
       await destroyCollectionExpectSuccess(nftCollectionId);
-      // await destroyCollectionExpectSuccess(fungibleCollectionId);
-      // await destroyCollectionExpectSuccess(reFungibleCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
 });
@@ -56,43 +57,157 @@
 describe('Negative Integration Test transferFrom(from, recipient, collection_id, item_id, value):', () => {
   it('transferFrom for a collection that does not exist', async () => {
     await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      await approveExpectFail(nftCollectionId + 1, 1, Alice, Bob);
+
+      await transferFromExpectFail(nftCollectionId + 1, 1, Bob, Alice, Charlie, 1);
+
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      await approveExpectFail(fungibleCollectionId + 1, 1, Alice, Bob);
+
+      await transferFromExpectFail(fungibleCollectionId + 1, 1, Bob, Alice, Charlie, 1);
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      await approveExpectFail(reFungibleCollectionId + 1, 1, Alice, Bob);
 
+      await transferFromExpectFail(reFungibleCollectionId + 1, 1, Bob, Alice, Charlie, 1);
+
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
 
-  it('transferFrom for a collection that was destroyed', async () => {
+  /* it('transferFrom for a collection that was destroyed', async () => {
     await usingApi(async (api: ApiPromise) => {
-
+      this test copies approve negative test
     });
-  });
+  }); */
 
-  it('transferFrom a token that does not exist', async () => {
+  /* it('transferFrom a token that does not exist', async () => {
     await usingApi(async (api: ApiPromise) => {
-
+      this test copies approve negative test
     });
-  });
+  }); */
 
-  it('transferFrom a token that was deleted', async () => {
+  /* it('transferFrom a token that was deleted', async () => {
     await usingApi(async (api: ApiPromise) => {
-
+      this test copies approve negative test
     });
-  });
+  }); */
 
   it('transferFrom for not approved address', 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 transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);
+
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1);
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await transferFromExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Bob, Alice, Charlie, 1);
+
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
 
   it('transferFrom incorrect token count', 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 approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
+
+      await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 2);
+
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
+      await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 2);
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
+      await transferFromExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Bob, Alice, Charlie, 2);
 
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
 
   it('execute transferFrom from account that is not owner of collection', async () => {
     await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      const Dave = privateKey('//DAVE');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      try {
+        await approveExpectFail(nftCollectionId, newNftTokenId, Dave, Bob);
+        await transferFromExpectFail(nftCollectionId, newNftTokenId, Dave, Alice, Charlie, 1);
+      } catch (e) {
+        // tslint:disable-next-line:no-unused-expression
+        expect(e).to.be.exist;
+      }
 
+      // await transferFromExpectFail(nftCollectionId, newNftTokenId, Dave, Alice, Charlie, 1);
+
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      try {
+        await approveExpectFail(fungibleCollectionId, newFungibleTokenId, Dave, Bob);
+        await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Dave, Alice, Charlie, 1);
+      } catch (e) {
+        // tslint:disable-next-line:no-unused-expression
+        expect(e).to.be.exist;
+      }
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      try {
+        await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Dave, Bob);
+        await transferFromExpectFail(reFungibleCollectionId, newReFungibleTokenId, Dave, Alice, Charlie, 1);
+      } catch (e) {
+        // tslint:disable-next-line:no-unused-expression
+        expect(e).to.be.exist;
+      }
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
 });
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
36  itemId: number;36  itemId: number;
37}37}
38
39interface IReFungibleOwner {
40  Fraction: BN;
41  Owner: number[];
42}
3843
39interface ITokenDataType {44interface ITokenDataType {
40  Owner: number[];45  Owner: number[];
41  ConstData: number[];46  ConstData: number[];
42  VariableData: number[];47  VariableData: number[];
43}48}
49
50interface IFungibleTokenDataType {
51  Value: BN;
52}
53
54interface IReFungibleTokenDataType {
55  Owner: IReFungibleOwner[];
56  ConstData: number[];
57  VariableData: number[];
58}
4459
45export function getGenericResult(events: EventRecord[]): GenericResult {60export function getGenericResult(events: EventRecord[]): GenericResult {
46  const result: GenericResult = {61  const result: GenericResult = {
396export async function411export async function
397transferFromExpectSuccess(collectionId: number, tokenId: number, accountFrom: IKeyringPair,412transferFromExpectSuccess(collectionId: number,
413                          tokenId: number,
414                          accountApproved: IKeyringPair,
415                          accountFrom: IKeyringPair,
398                          accountTo: IKeyringPair, value: number = 1, type: string = 'NFT') {416                          accountTo: IKeyringPair,
417                          value: number = 1,
418                          type: string = 'NFT') {
399  await usingApi(async (api: ApiPromise) => {419  await usingApi(async (api: ApiPromise) => {
420    let balanceBefore = new BN(0);
421    if (type === 'Fungible') {
422      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;
423    }
400    const transferFromTx = await api.tx.nft.transferFrom(424    const transferFromTx = await api.tx.nft.transferFrom(
401      accountFrom.address, accountTo.address, collectionId, tokenId, value);425      accountFrom.address, accountTo.address, collectionId, tokenId, value);
402    const events = await submitTransactionAsync(accountFrom, transferFromTx);426    const events = await submitTransactionAsync(accountFrom, transferFromTx);
403    const result = getCreateItemResult(events);427    const result = getCreateItemResult(events);
404    // tslint:disable-next-line:no-unused-expression428    // tslint:disable-next-line:no-unused-expression
405    expect(result.success).to.be.true;429    expect(result.success).to.be.true;
406    if (type === 'NFT') {430    if (type === 'NFT') {
407      const nftItemData = api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;431      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;
408      console.log('NFT data', nftItemData);432      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);
409    }433    }
410    if (type === 'Fungible') {434    if (type === 'Fungible') {
411      const nftItemData = api.query.nft.fungibleItemList(collectionId, tokenId) as unknown as ITokenDataType;435      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;
412      console.log('Fungible data', nftItemData);436      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);
413    }437    }
414    if (type === 'ReFungible') {438    if (type === 'ReFungible') {
415      const nftItemData = api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as ITokenDataType;439      const nftItemData =
440        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;
416      console.log('reFungibleItemList data', nftItemData);441      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);
442      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);
417    }443    }
418  });444  });
419}445}
446
447export async function
448transferFromExpectFail(collectionId: number,
449                       tokenId: number,
450                       accountApproved: IKeyringPair,
451                       accountFrom: IKeyringPair,
452                       accountTo: IKeyringPair,
453                       value: number = 1) {
454  await usingApi(async (api: ApiPromise) => {
455    const transferFromTx = await api.tx.nft.transferFrom(
456      accountFrom.address, accountTo.address, collectionId, tokenId, value);
457    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;
458    const result = getCreateCollectionResult(events);
459    // tslint:disable-next-line:no-unused-expression
460    expect(result.success).to.be.false;
461  });
462}
420463
421export async function464export async function
422approveExpectFail(collectionId: number,465approveExpectFail(collectionId: number,