git.delta.rocks / unique-network / refs/commits / 8154d7d843bf

difftreelog

transferSuccess

kpozdnikin2021-01-19parent: #567e35d.patch.diff
in: master

5 files changed

modifiedtests/package.jsondiffbeforeafterboth
--- a/tests/package.json
+++ b/tests/package.json
@@ -28,7 +28,8 @@
     "testTransferFrom": "mocha --timeout 9999999 -r ts-node/register ./**/transferFrom.test.ts",
     "testCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
     "testToggleContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/toggleContractWhiteList.test.ts",
-    "testAddToContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/addToContractWhiteList.test.ts"
+    "testAddToContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/addToContractWhiteList.test.ts",
+    "testTransfer": "mocha --timeout 9999999 -r ts-node/register ./**/transfer.test.ts"
   },
   "author": "",
   "license": "Apache 2.0",
modifiedtests/src/substrate/get-balance.tsdiffbeforeafterboth
--- a/tests/src/substrate/get-balance.ts
+++ b/tests/src/substrate/get-balance.ts
@@ -3,12 +3,12 @@
 // file 'LICENSE', which is part of this source code package.
 //
 
-import { ApiPromise } from "@polkadot/api";
-import promisifySubstrate from "./promisify-substrate";
-import {AccountInfo} from "@polkadot/types/interfaces/system";
+import { ApiPromise } from '@polkadot/api';
+import {AccountInfo} from '@polkadot/types/interfaces/system';
+import promisifySubstrate from './promisify-substrate';
 
-export default async function getBalance(api: ApiPromise, accounts: string[]): Promise<bigint[]> {
-  const balance = promisifySubstrate(api, (accounts: string[]) => api.query.system.account.multi(accounts));
+export default async function getBalance(api: ApiPromise, accounts: string[]): Promise<Array<bigint>> {
+  const balance = promisifySubstrate(api, (acc: string[]) => api.query.system.account.multi(acc));
   const responce = await balance(accounts) as unknown as AccountInfo[];
-  return responce.map(r => r.data.free.toBigInt().valueOf());
+  return responce.map((r) => r.data.free.toBigInt().valueOf());
 }
modifiedtests/src/substrate/substrate-api.tsdiffbeforeafterboth
--- a/tests/src/substrate/substrate-api.ts
+++ b/tests/src/substrate/substrate-api.ts
@@ -58,21 +58,22 @@
   return TransactionStatus.Fail;
 }
 
-export function submitTransactionAsync(sender: IKeyringPair, transaction: SubmittableExtrinsic<ApiTypes>): Promise<EventRecord[]> {
-  return new Promise(async function(resolve, reject) {
+export function
+submitTransactionAsync(sender: IKeyringPair, transaction: SubmittableExtrinsic<ApiTypes>): Promise<EventRecord[]> {
+  return new Promise(async (resolve, reject) => {
     try {
       await transaction.signAndSend(sender, ({ events = [], status }) => {
         const transactionStatus = getTransactionStatus(events, status);
 
-        if (transactionStatus == TransactionStatus.Success) {
+        if (transactionStatus === TransactionStatus.Success) {
           resolve(events);
-        } else if (transactionStatus == TransactionStatus.Fail) {
+        } else if (transactionStatus === TransactionStatus.Fail) {
           console.log(`Something went wrong with transaction. Status: ${status}`);
           reject(events);
         }
       });
     } catch (e) {
-      console.log("Error: ", e);
+      console.log('Error: ', e);
       reject(e);
     }
   });
modifiedtests/src/transfer.test.tsdiffbeforeafterboth
before · tests/src/transfer.test.ts
1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56import { expect, assert } from "chai";7import { default as usingApi, submitTransactionAsync } from "./substrate/substrate-api";8import { alicesPublicKey, bobsPublicKey, ferdiesPublicKey } from "./accounts";9import privateKey from "./substrate/privateKey";10import getBalance from "./substrate/get-balance";11import { BigNumber } from 'bignumber.js';12import { findUnusedAddress } from './util/helpers'1314describe('Transfer', () => {15  it('Balance transfers', async () => {16    await usingApi(async api => {17      const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);1819      const alicePrivateKey = privateKey('//Alice');20      21      const transfer = api.tx.balances.transfer(bobsPublicKey, 1n);22      const result = await submitTransactionAsync(alicePrivateKey, transfer);2324      const [alicesBalanceAfter, bobsBalanceAfter] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);2526      expect(alicesBalanceAfter < alicesBalanceBefore).to.be.true;27      expect(bobsBalanceAfter > bobsBalanceBefore).to.be.true;28    });29  });3031  it('Inability to pay fees error message is correct', async () => {32    await usingApi(async api => {33      // Find unused address34      const pk = await findUnusedAddress(api);3536      const error = console.error;37      const log = console.log;38      console.log = function () {};39      console.error = function () {};40  41      const badTransfer = api.tx.balances.transfer(bobsPublicKey, 1n);42      const badTransaction = async function () { 43        const result = await submitTransactionAsync(pk, badTransfer);44      };45      await expect(badTransaction()).to.be.rejectedWith("Inability to pay some fees");4647      console.log = log;48      console.error = error;49    });50  });51});
after · tests/src/transfer.test.ts
1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56import { ApiPromise } from '@polkadot/api';7import { expect } from 'chai';8import { alicesPublicKey, bobsPublicKey } from './accounts';9import getBalance from './substrate/get-balance';10import privateKey from './substrate/privateKey';11import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';12import {13  approveExpectSuccess,14  createCollectionExpectSuccess, createItemExpectSuccess,15  findUnusedAddress,16  getCreateCollectionResult,17  getCreateItemResult,18  transferExpectSuccess,19} from './util/helpers';2021describe('Integration Test Transfer(recipient, collection_id, item_id, value)', () => {22  it('Balance transfers and check balance', async () => {23    await usingApi(async (api: ApiPromise) => {24      const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);2526      const alicePrivateKey = privateKey('//Alice');2728      const transfer = api.tx.balances.transfer(bobsPublicKey, 1n);29      const events = await submitTransactionAsync(alicePrivateKey, transfer);30      const result = getCreateItemResult(events);31      // tslint:disable-next-line:no-unused-expression32      expect(result.success).to.be.true;3334      const [alicesBalanceAfter, bobsBalanceAfter] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);3536      // tslint:disable-next-line:no-unused-expression37      expect(alicesBalanceAfter < alicesBalanceBefore).to.be.true;38      // tslint:disable-next-line:no-unused-expression39      expect(bobsBalanceAfter > bobsBalanceBefore).to.be.true;40    });41  });4243  it('Inability to pay fees error message is correct', async () => {44    await usingApi(async (api) => {45      // Find unused address46      const pk = await findUnusedAddress(api);4748      const badTransfer = api.tx.balances.transfer(bobsPublicKey, 1n);49      // const events = await submitTransactionAsync(pk, badTransfer);50      const badTransaction = async () => {51        const events = await submitTransactionAsync(pk, badTransfer);52        const result = getCreateCollectionResult(events);53        // tslint:disable-next-line:no-unused-expression54        expect(result.success).to.be.false;55      };56      expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees , e.g. account balance too low');57    });58  });5960  it('Create collection, balance transfers and check balance', async () => {61    const Alice = privateKey('//Alice');62    const Bob = privateKey('//Bob');63    const Charlie = privateKey('//CHARLIE');64    // nft65    const nftCollectionId = await createCollectionExpectSuccess();66    const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');6768    await transferExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');6970    // fungible71    const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});72    const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');73    await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);74    await transferExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');75    // reFungible76    const reFungibleCollectionId = await77      createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});78    const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');79    await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);80    await transferExpectSuccess(reFungibleCollectionId,81      newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');82  });83});8485describe('Negative Integration Test Transfer(recipient, collection_id, item_id, value)', () => {86  it('Transfer with not existed collection_id', async () => {8788  });89  it('Transfer with deleted collection_id', async () => {9091  });92  it('Transfer with not existed item_id', async () => {9394  });95  it('Transfer with deleted item_id', async () => {9697  });98  it('Transfer with recipient that is not owner', async () => {99100  });101});
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -462,6 +462,40 @@
 }
 
 export async function
+transferExpectSuccess(collectionId: number,
+                      tokenId: number,
+                      sender: IKeyringPair,
+                      recipient: IKeyringPair,
+                      value: number = 1,
+                      type: string = 'NFT') {
+  await usingApi(async (api: ApiPromise) => {
+    let balanceBefore = new BN(0);
+    if (type === 'Fungible') {
+      balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;
+    }
+    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);
+    const events = await submitTransactionAsync(sender, transferTx);
+    const result = getCreateItemResult(events);
+    // tslint:disable-next-line:no-unused-expression
+    expect(result.success).to.be.true;
+    if (type === 'NFT') {
+      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;
+      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);
+    }
+    if (type === 'Fungible') {
+      const balanceAfter = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;
+      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);
+    }
+    if (type === 'ReFungible') {
+      const nftItemData =
+        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;
+      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);
+      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);
+    }
+  });
+}
+
+export async function
 approveExpectFail(collectionId: number,
                   tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {
   await usingApi(async (api: ApiPromise) => {