git.delta.rocks / unique-network / refs/commits / 93112f6aa452

difftreelog

test(refungible-pallet) add tests for repartition events

Grigoriy Simonov2022-07-22parent: #d228734.patch.diff
in: master

3 files changed

modifiedtests/src/eth/reFungibleToken.test.tsdiffbeforeafterboth
--- a/tests/src/eth/reFungibleToken.test.ts
+++ b/tests/src/eth/reFungibleToken.test.ts
@@ -239,10 +239,69 @@
     expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(0);
     expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(200);
 
-    await contract.methods.repartition(150).send({from: receiver});
+    const result = await contract.methods.repartition(150).send({from: receiver});
+    console.log(result.events);
     await expect(contract.methods.transfer(owner, 160).send({from: receiver})).to.eventually.be.rejected;
     expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(150);
   });
+
+  itWeb3('Can repartition with increased amount', async ({web3, api, privateKeyWrapper}) => {
+    const alice = privateKeyWrapper('//Alice');
+
+    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;
+
+    const owner = createEthAccount(web3);
+    await transferBalanceToEth(api, alice, owner);
+
+    const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n, {Ethereum: owner})).itemId;
+
+    const address = tokenIdToAddress(collectionId, tokenId);
+    const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS});
+
+    const result = await contract.methods.repartition(200).send();
+    const events = normalizeEvents(result.events);
+
+    expect(events).to.include.deep.members([
+      {
+        address,
+        event: 'Transfer',
+        args: {
+          from: '0x0000000000000000000000000000000000000000',
+          to: owner,
+          value: '100',
+        },
+      },
+    ]);
+  });
+
+  itWeb3('Can repartition with decreased amount', async ({web3, api, privateKeyWrapper}) => {
+    const alice = privateKeyWrapper('//Alice');
+
+    const collectionId = (await createCollection(api, alice, {name: 'token name', mode: {type: 'ReFungible'}})).collectionId;
+
+    const owner = createEthAccount(web3);
+    await transferBalanceToEth(api, alice, owner);
+
+    const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n, {Ethereum: owner})).itemId;
+
+    const address = tokenIdToAddress(collectionId, tokenId);
+    const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS});
+
+    const result = await contract.methods.repartition(50).send();
+    const events = normalizeEvents(result.events);
+
+    expect(events).to.include.deep.members([
+      {
+        address,
+        event: 'Transfer',
+        args: {
+          from: owner,
+          to: '0x0000000000000000000000000000000000000000',
+          value: '50',
+        },
+      },
+    ]);
+  });
 });
 
 describe('Refungible: Fees', () => {
modifiedtests/src/refungible.test.tsdiffbeforeafterboth
before · tests/src/refungible.test.ts
1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {default as usingApi, executeTransaction} from './substrate/substrate-api';18import {IKeyringPair} from '@polkadot/types/types';19import {20  createCollectionExpectSuccess,21  getBalance,22  createMultipleItemsExpectSuccess,23  isTokenExists,24  getLastTokenId,25  getAllowance,26  approve,27  transferFrom,28  createCollection,29  createRefungibleToken,30  transfer,31  burnItem,32  repartitionRFT,33  createCollectionWithPropsExpectSuccess,34  getDetailedCollectionInfo,35} from './util/helpers';3637import chai from 'chai';38import chaiAsPromised from 'chai-as-promised';39chai.use(chaiAsPromised);40const expect = chai.expect;4142let alice: IKeyringPair;43let bob: IKeyringPair;4445describe('integration test: Refungible functionality:', () => {46  before(async () => {47    await usingApi(async (api, privateKeyWrapper) => {48      alice = privateKeyWrapper('//Alice');49      bob = privateKeyWrapper('//Bob');50    });51  });5253  it('Create refungible collection and token', async () => {54    await usingApi(async api => {55      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'ReFungible'}});56      expect(createCollectionResult.success).to.be.true;    57      const collectionId  = createCollectionResult.collectionId;5859      const itemCountBefore = await getLastTokenId(api, collectionId);60      const result = await createRefungibleToken(api, alice, collectionId, 100n);6162      const itemCountAfter = await getLastTokenId(api, collectionId);6364      // What to expect65      // tslint:disable-next-line:no-unused-expression66      expect(result.success).to.be.true;67      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);68      expect(collectionId).to.be.equal(result.collectionId);69      expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());70    });71  });7273  it('Transfer token pieces', async () => {74    await usingApi(async api => {75      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;76      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;7778      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);79      expect(await transfer(api, collectionId, tokenId, alice, bob, 60n)).to.be.true;8081      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(40n);82      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(60n);83      await expect(transfer(api, collectionId, tokenId, alice, bob, 41n)).to.eventually.be.rejected;84    });85  });8687  it('Create multiple tokens', async () => {88    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});89    const args = [90      {ReFungible: {pieces: 1}},91      {ReFungible: {pieces: 2}},92      {ReFungible: {pieces: 100}},93    ];94    await createMultipleItemsExpectSuccess(alice, collectionId, args);9596    await usingApi(async api => {      97      const tokenId = await getLastTokenId(api, collectionId);98      expect(tokenId).to.be.equal(3);99      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);100    });101  });102103  it('Burn some pieces', async () => {104    await usingApi(async api => {   105      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;106      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;107      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;108      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);109      expect(await burnItem(api, alice, collectionId, tokenId, 99n)).to.be.true;110      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;111      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(1n);112    });113  });114115  it('Burn all pieces', async () => {116    await usingApi(async api => {   117      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;118      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;119      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;120      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);121      expect(await burnItem(api, alice, collectionId, tokenId, 100n)).to.be.true;122      expect(await isTokenExists(api, collectionId, tokenId)).to.be.false;123    });124  });125126  it('Burn some pieces for multiple users', async () => {127    await usingApi(async api => {   128      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;129      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;130      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;131132      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);133      expect(await transfer(api, collectionId, tokenId, alice, bob, 60n)).to.be.true;134135      136      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(40n);137      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(60n);138      expect(await burnItem(api, alice, collectionId, tokenId, 40n)).to.be.true;139140      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(0n);141      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;142      expect(await burnItem(api, bob, collectionId, tokenId, 59n)).to.be.true;143144      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(1n);145      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;146      expect(await burnItem(api, bob, collectionId, tokenId, 1n)).to.be.true;147      148      expect(await isTokenExists(api, collectionId, tokenId)).to.be.false;149    });150  });151152  it('Set allowance for token', async () => {153    await usingApi(async api => {154      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;155      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;156157      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);158159      expect(await approve(api, collectionId, tokenId, alice, bob, 60n)).to.be.true;160      expect(await getAllowance(api, collectionId, alice, bob, tokenId)).to.be.equal(60n);161162      expect(await transferFrom(api, collectionId, tokenId, bob, alice, bob,  20n)).to.be.true;163      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(80n);164      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(20n);165      expect(await getAllowance(api, collectionId, alice, bob, tokenId)).to.be.equal(40n);166    });167  });168169  it('Repartition', async () => {170    await usingApi(async api => {171      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;172      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;173174      expect(await repartitionRFT(api, collectionId, alice, tokenId, 200n)).to.be.true;175      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(200n);176177      expect(await transfer(api, collectionId, tokenId, alice, bob, 110n)).to.be.true;178      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(90n);179      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(110n);180181      await expect(repartitionRFT(api, collectionId, alice, tokenId, 80n)).to.eventually.be.rejected;182183      expect(await transfer(api, collectionId, tokenId, alice, bob, 90n)).to.be.true;184      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(0n);185      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(200n);186187      expect(await repartitionRFT(api, collectionId, bob, tokenId, 150n)).to.be.true;188      await expect(transfer(api, collectionId, tokenId, bob, alice, 160n)).to.eventually.be.rejected;189    });190  });191});192193describe('Test Refungible properties:', () => {194  before(async () => {195    await usingApi(async (api, privateKeyWrapper) => {196      alice = privateKeyWrapper('//Alice');197      bob = privateKeyWrapper('//Bob');198    });199  });200  201  it('Сreate new collection with properties', async () => {202    await usingApi(async api => {203      const properties = [{key: 'key1', value: 'val1'}];204      const propertyPermissions = [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}];205      const collectionId = await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'ReFungible'},206        properties: properties,207        propPerm: propertyPermissions, 208      });209      const collection = (await getDetailedCollectionInfo(api, collectionId))!;210      expect(collection.properties.toHuman()).to.be.deep.equal(properties);211      expect(collection.tokenPropertyPermissions.toHuman()).to.be.deep.equal(propertyPermissions);212    });213  });214});
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -103,6 +103,15 @@
   collectionId: number;
   itemId: number;
   recipient?: CrossAccountId;
+  amount?: number;
+}
+
+interface DestroyItemResult {
+  success: boolean;
+  collectionId: number;
+  itemId: number;
+  owner: CrossAccountId;
+  amount: number;
 }
 
 interface TransferResult {
@@ -220,12 +229,14 @@
     const collectionId = parseInt(data[0].toString(), 10);
     const itemId = parseInt(data[1].toString(), 10);
     const recipient = normalizeAccountId(data[2].toJSON() as any);
+    const amount = parseInt(data[3].toString(), 10);
 
     const itemRes: CreateItemResult = {
       success: true,
       collectionId,
       itemId,
       recipient,
+      amount,
     };
 
     results.push(itemRes);
@@ -255,6 +266,31 @@
   return result;
 }
 
+export function getDestroyItemsResult(events: EventRecord[]): DestroyItemResult[] {
+  const results: DestroyItemResult[] = [];
+  
+  const genericResult = getGenericResult<DestroyItemResult[]>(events, 'common', 'ItemDestroyed', (data) => {
+    const collectionId = parseInt(data[0].toString(), 10);
+    const itemId = parseInt(data[1].toString(), 10);
+    const owner = normalizeAccountId(data[2].toJSON() as any);
+    const amount = parseInt(data[3].toString(), 10);
+
+    const itemRes: DestroyItemResult = {
+      success: true,
+      collectionId,
+      itemId,
+      owner,
+      amount,
+    };
+
+    results.push(itemRes);
+    return results;
+  });
+
+  if (!genericResult.success) return [];
+  return results;
+}
+
 export function getTransferResult(api: ApiPromise, events: EventRecord[]): TransferResult {
   for (const {event} of events) {
     if (api.events.common.Transfer.is(event)) {