`96cdb9b3ccba`

6 files changed

modifiedtests/src/adminTransferAndBurn.test.tsdiff before after both

--- a/tests/src/adminTransferAndBurn.test.ts
+++ b/tests/src/adminTransferAndBurn.test.ts
@@ -15,20 +15,7 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {usingPlaygrounds} from './util/playgrounds';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let donor: IKeyringPair;
-
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
 
 describe('Integration Test: ownerCanTransfer allows admins to use only transferFrom/burnFrom:', () => {
   let alice: IKeyringPair;
@@ -36,44 +23,41 @@
   let charlie: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
     });
   });
 
-  it('admin transfers other user\'s token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
-      await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
-      const limits = await helper.collection.getEffectiveLimits(collectionId);
-      expect(limits.ownerCanTransfer).to.be.true;
+  itSub('admin transfers other user\'s token', async ({helper}) => {
+    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+    await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
+    const limits = await helper.collection.getEffectiveLimits(collectionId);
+    expect(limits.ownerCanTransfer).to.be.true;
 
-      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
-      const transferResult = async () => helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
-      await expect(transferResult()).to.be.rejected;
+    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
+    const transferResult = async () => helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
+    await expect(transferResult()).to.be.rejected;
 
-      await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});
-      const newTokenOwner = await helper.nft.getTokenOwner(collectionId, tokenId);
-      expect(newTokenOwner.Substrate).to.be.equal(charlie.address);
-    });
+    await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});
+    const newTokenOwner = await helper.nft.getTokenOwner(collectionId, tokenId);
+    expect(newTokenOwner.Substrate).to.be.equal(charlie.address);
   });
 
-  it('admin burns other user\'s token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+  itSub('admin burns other user\'s token', async ({helper}) => {
+    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
 
-      await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
-      const limits = await helper.collection.getEffectiveLimits(collectionId);
-      expect(limits.ownerCanTransfer).to.be.true;
+    await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
+    const limits = await helper.collection.getEffectiveLimits(collectionId);
+    expect(limits.ownerCanTransfer).to.be.true;
 
-      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
-      const burnTxFailed = async () => helper.nft.burnToken(alice, collectionId, tokenId);
+    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
+    const burnTxFailed = async () => helper.nft.burnToken(alice, collectionId, tokenId);
 
-      await expect(burnTxFailed()).to.be.rejected;
+    await expect(burnTxFailed()).to.be.rejected;
 
-      await helper.nft.burnToken(bob, collectionId, tokenId);
-      const token = await helper.nft.getToken(collectionId, tokenId);
-      expect(token).to.be.null;
-    });
+    await helper.nft.burnToken(bob, collectionId, tokenId);
+    const token = await helper.nft.getToken(collectionId, tokenId);
+    expect(token).to.be.null;
   });
 });

modifiedtests/src/change-collection-owner.test.tsdiff before after both

--- a/tests/src/change-collection-owner.test.ts
+++ b/tests/src/change-collection-owner.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute itSub and/or modify
+// itSub under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that it will be useful,
+// Unique Network is distributed in the hope that itSub will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -15,41 +15,27 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {usingPlaygrounds} from './util/playgrounds';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
 
-let donor: IKeyringPair;
-
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
-
 describe('Integration Test changeCollectionOwner(collection_id, new_owner):', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('Changing owner changes owner address', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const beforeChanging = await helper.collection.getData(collection.collectionId);
-      expect(beforeChanging?.normalizedOwner).to.be.equal(alice.address);
+  itSub('Changing owner changes owner address', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const beforeChanging = await helper.collection.getData(collection.collectionId);
+    expect(beforeChanging?.normalizedOwner).to.be.equal(alice.address);
 
-      await collection.changeOwner(alice, bob.address);
-      const afterChanging = await helper.collection.getData(collection.collectionId);
-      expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
-    });
+    await collection.changeOwner(alice, bob.address);
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
   });
 });
 
@@ -59,64 +45,59 @@
   let charlie: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });
 
-  it('Changing the owner of the collection is not allowed for the former owner', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+  itSub('Changing the owner of the collection is not allowed for the former owner', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
 
-      await collection.changeOwner(alice, bob.address);
+    await collection.changeOwner(alice, bob.address);
 
-      const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
-      await expect(changeOwnerTx()).to.be.rejected;
+    const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const afterChanging = await helper.collection.getData(collection.collectionId);
-      expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
-    });
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
   });
 
-  it('New collectionOwner has access to sponsorship management operations in the collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.changeOwner(alice, bob.address);
+  itSub('New collectionOwner has access to sponsorship management operations in the collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.changeOwner(alice, bob.address);
 
-      const afterChanging = await helper.collection.getData(collection.collectionId);
-      expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
 
-      await collection.setSponsor(bob, charlie.address);
-      await collection.confirmSponsorship(charlie);
-      await collection.removeSponsor(bob);
-      const limits = {
-        accountTokenOwnershipLimit: 1,
-        tokenLimit: 1,
-        sponsorTransferTimeout: 1,
-        ownerCanDestroy: true,
-        ownerCanTransfer: true,
-      };
+    await collection.setSponsor(bob, charlie.address);
+    await collection.confirmSponsorship(charlie);
+    await collection.removeSponsor(bob);
+    const limits = {
+      accountTokenOwnershipLimit: 1,
+      tokenLimit: 1,
+      sponsorTransferTimeout: 1,
+      ownerCanDestroy: true,
+      ownerCanTransfer: true,
+    };
 
-      await collection.setLimits(bob, limits);
-      const gotLimits = await collection.getEffectiveLimits();
-      expect(gotLimits).to.be.deep.contains(limits);
+    await collection.setLimits(bob, limits);
+    const gotLimits = await collection.getEffectiveLimits();
+    expect(gotLimits).to.be.deep.contains(limits);
 
-      await collection.setPermissions(bob, {access: 'AllowList', mintMode: true});
+    await collection.setPermissions(bob, {access: 'AllowList', mintMode: true});
 
-      await collection.burn(bob);
-      const collectionData = await helper.collection.getData(collection.collectionId);
-      expect(collectionData).to.be.null;
-    });
+    await collection.burn(bob);
+    const collectionData = await helper.collection.getData(collection.collectionId);
+    expect(collectionData).to.be.null;
   });
 
-  it('New collectionOwner has access to changeCollectionOwner', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.changeOwner(alice, bob.address);
-      await collection.changeOwner(bob, charlie.address);
-      const collectionData = await collection.getData();
-      expect(collectionData?.normalizedOwner).to.be.equal(charlie.address);
-    });
+  itSub('New collectionOwner has access to changeCollectionOwner', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.changeOwner(alice, bob.address);
+    await collection.changeOwner(bob, charlie.address);
+    const collectionData = await collection.getData();
+    expect(collectionData?.normalizedOwner).to.be.equal(charlie.address);
   });
 });
 
@@ -126,70 +107,63 @@
   let charlie: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });
 
-  it('Not owner can\'t change owner.', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
-      await expect(changeOwnerTx()).to.be.rejected;
-    });
+  itSub('Not owner can\'t change owner.', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Collection admin can\'t change owner.', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.addAdmin(alice, {Substrate: bob.address});
-      const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
-      await expect(changeOwnerTx()).to.be.rejected;
-    });
+  itSub('Collection admin can\'t change owner.', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Can\'t change owner of a non-existing collection.', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collectionId = (1 << 32) - 1;
-      const changeOwnerTx = async () => helper.collection.changeOwner(bob, collectionId, bob.address);
-      await expect(changeOwnerTx()).to.be.rejected;
-    });
+  itSub('Can\'t change owner of a non-existing collection.', async ({helper}) => {
+    const collectionId = (1 << 32) - 1;
+    const changeOwnerTx = async () => helper.collection.changeOwner(bob, collectionId, bob.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('Former collectionOwner not allowed to sponsorship management operations in the collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.changeOwner(alice, bob.address);
+  itSub('Former collectionOwner not allowed to sponsorship management operations in the collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.changeOwner(alice, bob.address);
 
-      const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
-      await expect(changeOwnerTx()).to.be.rejected;
+    const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const afterChanging = await helper.collection.getData(collection.collectionId);
-      expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
 
-      const setSponsorTx = async () => collection.setSponsor(alice, charlie.address);
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
-      const removeSponsorTx = async () => collection.removeSponsor(alice);
-      await expect(setSponsorTx()).to.be.rejected;
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-      await expect(removeSponsorTx()).to.be.rejected;
+    const setSponsorTx = async () => collection.setSponsor(alice, charlie.address);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
+    const removeSponsorTx = async () => collection.removeSponsor(alice);
+    await expect(setSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
+    await expect(removeSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const limits = {
-        accountTokenOwnershipLimit: 1,
-        tokenLimit: 1,
-        sponsorTransferTimeout: 1,
-        ownerCanDestroy: true,
-        ownerCanTransfer: true,
-      };
+    const limits = {
+      accountTokenOwnershipLimit: 1,
+      tokenLimit: 1,
+      sponsorTransferTimeout: 1,
+      ownerCanDestroy: true,
+      ownerCanTransfer: true,
+    };
 
-      const setLimitsTx = async () => collection.setLimits(alice, limits);
-      await expect(setLimitsTx()).to.be.rejected;
+    const setLimitsTx = async () => collection.setLimits(alice, limits);
+    await expect(setLimitsTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const setPermissionTx = async () => collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
-      await expect(setPermissionTx()).to.be.rejected;
+    const setPermissionTx = async () => collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await expect(setPermissionTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const burnTx = async () => collection.burn(alice);
-      await expect(burnTx()).to.be.rejected;
-    });
+    const burnTx = async () => collection.burn(alice);
+    await expect(burnTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 });

modifiedtests/src/confirmSponsorship.test.tsdiff before after both

--- a/tests/src/confirmSponsorship.test.ts
+++ b/tests/src/confirmSponsorship.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute itSub and/or modify
+// itSub under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that it will be useful,
+// Unique Network is distributed in the hope that itSub will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -14,268 +14,218 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
 import {IKeyringPair} from '@polkadot/types/types';
-import {usingPlaygrounds} from './util/playgrounds';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let donor: IKeyringPair;
-
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
-
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-let charlie: IKeyringPair;
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
 
 describe('integration test: ext. confirmSponsorship():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
+  let zeroBalance: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
-      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie, zeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n], donor);
     });
   });
 
-  it('Confirm collection sponsorship', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-    });
+  itSub('Confirm collection sponsorship', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
   });
 
-  it('Add sponsor to a collection after the same sponsor was already added and confirmed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      await collection.setSponsor(alice, bob.address);
-    });
+  itSub('Add sponsor to a collection after the same sponsor was already added and confirmed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.setSponsor(alice, bob.address);
   });
-  it('Add new sponsor to a collection after another sponsor was already added and confirmed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      await collection.setSponsor(alice, charlie.address);
-    });
+  itSub('Add new sponsor to a collection after another sponsor was already added and confirmed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.setSponsor(alice, charlie.address);
   });
 
-  it('NFT: Transfer fees are paid by the sponsor after confirmation', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const token = await collection.mintToken(alice, {Substrate: zeroBalance.address});
-      await token.transfer(zeroBalance, {Substrate: alice.address});
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
-      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
-    });
+  itSub('NFT: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const token = await collection.mintToken(alice, {Substrate: zeroBalance.address});
+    await token.transfer(zeroBalance, {Substrate: alice.address});
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('Fungible: Transfer fees are paid by the sponsor after confirmation', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      await collection.mint(alice, {Substrate: zeroBalance.address}, 100n);
-      await collection.transfer(zeroBalance, {Substrate: alice.address}, 1n);
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
-      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
-    });
+  itSub('Fungible: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
+    await collection.transfer(zeroBalance, {Substrate: alice.address}, 1n);
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('ReFungible: Transfer fees are paid by the sponsor after confirmation', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const token = await collection.mintToken(alice, {Substrate: zeroBalance.address}, 100n);
-      await token.transfer(zeroBalance, {Substrate: alice.address}, 1n);
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
-      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
-    });
+  itSub.ifWithPallets('ReFungible: Transfer fees are paid by the sponsor after confirmation', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
+    await token.transfer(zeroBalance, {Substrate: alice.address}, 1n);
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('CreateItem fees are paid by the sponsor after confirmation', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
-      await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
+  itSub('CreateItem fees are paid by the sponsor after confirmation', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
 
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('NFT: Sponsoring of transfers is rate limited', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
+  itSub('NFT: Sponsoring of transfers is rate limited', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
 
-      const token = await collection.mintToken(alice, {Substrate: alice.address});
-      await token.transfer(alice, {Substrate: zeroBalance.address});
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const token = await collection.mintToken(alice, {Substrate: alice.address});
+    await token.transfer(alice, {Substrate: zeroBalance.address});
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
 
-      const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
-      await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 
-  it('Fungible: Sponsoring is rate limited', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
+  itSub('Fungible: Sponsoring is rate limited', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
 
-      await collection.mint(alice, {Substrate: zeroBalance.address}, 100n);
-      await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
+    await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
 
-      const transferTx = async () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});
-      await expect(transferTx()).to.be.rejected;
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});
+    await expect(transferTx()).to.be.rejected;
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 
-  it('ReFungible: Sponsoring is rate limited', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
+  itSub.ifWithPallets('ReFungible: Sponsoring is rate limited', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
 
-      const token = await collection.mintToken(alice, {Substrate: zeroBalance.address}, 100n);
-      await token.transfer(zeroBalance, {Substrate: alice.address});
+    const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
+    await token.transfer(zeroBalance, {Substrate: alice.address});
 
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
-      await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 
-  it('NFT: Sponsoring of createItem is rate limited', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      await collection.setPermissions(alice, {mintMode: true, access: 'AllowList'});
-      await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
+  itSub('NFT: Sponsoring of createItem is rate limited', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.setPermissions(alice, {mintMode: true, access: 'AllowList'});
+    await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
 
-      await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+    await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
 
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const mintTx = async () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
-      await expect(mintTx()).to.be.rejectedWith('Inability to pay some fees');
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const mintTx = async () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+    await expect(mintTx()).to.be.rejectedWith('Inability to pay some fees');
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 });
 
 describe('(!negative test!) integration test: ext. confirmSponsorship():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
+  let ownerZeroBalance: IKeyringPair;
+  let senderZeroBalance: IKeyringPair;
+
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
-      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie, ownerZeroBalance, senderZeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n, 0n], donor);
     });
   });
 
-  it('(!negative test!) Confirm sponsorship for a collection that never existed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collectionId = 1 << 32 - 1;
-      const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship for a collection that never existed', async ({helper}) => {
+    const collectionId = 1_000_000;
+    const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('(!negative test!) Confirm sponsorship using a non-sponsor address', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship using a non-sponsor address', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship using owner address', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship using owner address', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship by collection admin', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.addAdmin(alice, {Substrate: charlie.address});
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship by collection admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.addAdmin(alice, {Substrate: charlie.address});
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship in a collection that was destroyed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.burn(alice);
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship in a collection that was destroyed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.burn(alice);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      const [ownerZeroBalance, senderZeroBalance] = await helper.arrange.createAccounts([0n, 0n], donor);
-      const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});
-      const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const transferTx = async () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});
-      await expect(transferTx()).to.be.rejected;
-      const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
-      expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);
-    });
+  itSub('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});
+    const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});
+    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+    const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);
   });
 });

modifiedtests/src/createCollection.test.tsdiff before after both

--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute itSub and/or modify
+// itSub under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that it will be useful,
+// Unique Network is distributed in the hope that itSub will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -14,145 +14,125 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {usingPlaygrounds} from './util/playgrounds';
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
 import {IKeyringPair} from '@polkadot/types/types';
 import {IProperty} from './util/playgrounds/types';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let donor: IKeyringPair;
-
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
-
-let alice: IKeyringPair;
 
 describe('integration test: ext. createCollection():', () => {
+  let alice: IKeyringPair;
+
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice] = await helper.arrange.createAccounts([100n], donor);
     });
   });
-  it('Create new NFT collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    });
+  itSub('Create new NFT collection', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
   });
-  it('Create new NFT collection whith collection_name of maximum length (64 bytes)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'});
-    });
+  itSub('Create new NFT collection whith collection_name of maximum length (64 bytes)', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'});
   });
-  it('Create new NFT collection whith collection_description of maximum length (256 bytes)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'});
-    });
+  itSub('Create new NFT collection whith collection_description of maximum length (256 bytes)', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'});
   });
-  it('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)});
-    });
+  itSub('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)});
   });
-  it('Create new Fungible collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 0);
-    });
+  itSub('Create new Fungible collection', async ({helper}) => {
+
+    await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 0);
   });
-  it('Create new ReFungible collection', async function() {
-    await usingPlaygrounds(async (helper) => {
-      await helper.rft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
-    });
+  itSub.ifWithPallets('Create new ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+
+    await helper.rft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
   });
 
-  it('create new collection with properties', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
-        properties: [{key: 'key1', value: 'val1'}],
-        tokenPropertyPermissions: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}],
-      });
+  itSub('create new collection with properties', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {
+      name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'key1', value: 'val1'}],
+      tokenPropertyPermissions: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}],
     });
   });
 
-  it('Create new collection with extra fields', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 8);
-      await collection.setPermissions(alice, {access: 'AllowList'});
-      await collection.setLimits(alice, {accountTokenOwnershipLimit: 3});
-      const data = await collection.getData();
-      const limits = await collection.getEffectiveLimits();
-      const raw = data?.raw;
+  itSub('Create new collection with extra fields', async ({helper}) => {
+
+    const collection = await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 8);
+    await collection.setPermissions(alice, {access: 'AllowList'});
+    await collection.setLimits(alice, {accountTokenOwnershipLimit: 3});
+    const data = await collection.getData();
+    const limits = await collection.getEffectiveLimits();
+    const raw = data?.raw;
 
-      expect(data?.normalizedOwner).to.be.equal(alice.address);
-      expect(data?.name).to.be.equal('name');
-      expect(data?.description).to.be.equal('descr');
-      expect(raw.permissions.access).to.be.equal('AllowList');
-      expect(raw.mode).to.be.deep.equal({Fungible: '8'});
-      expect(limits.accountTokenOwnershipLimit).to.be.equal(3);
-    });
+    expect(data?.normalizedOwner).to.be.equal(alice.address);
+    expect(data?.name).to.be.equal('name');
+    expect(data?.description).to.be.equal('descr');
+    expect(raw.permissions.access).to.be.equal('AllowList');
+    expect(raw.mode).to.be.deep.equal({Fungible: '8'});
+    expect(limits.accountTokenOwnershipLimit).to.be.equal(3);
   });
 
-  it('New collection is not external', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
-      const data = await collection.getData();
-      expect(data?.raw.readOnly).to.be.false;
-    });
+  itSub('New collection is not external', async ({helper}) => {
+
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+    const data = await collection.getData();
+    expect(data?.raw.readOnly).to.be.false;
   });
 });
 
 describe('(!negative test!) integration test: ext. createCollection():', () => {
-  it('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});
-      await expect(mintCollectionTx()).to.be.rejected;
+  let alice: IKeyringPair;
+
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([100n], donor);
     });
   });
-  it('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+
+  itSub('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async ({helper}) => {
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
+  });
+  itSub('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async ({helper}) => {
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
-  it('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async ({helper}) => {
+
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
-  it('(!negative test!) fails when bad limits are set', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) fails when bad limits are set', async ({helper}) => {
+
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
+    await expect(mintCollectionTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
   });
 
-  it('(!negative test!) create collection with incorrect property limit (64 elements)', async () => {
+  itSub('(!negative test!) create collection with incorrect property limit (64 elements)', async ({helper}) => {
     const props: IProperty[] = [];
 
     for (let i = 0; i < 65; i++) {
       props.push({key: `key${i}`, value: `value${i}`});
     }
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('(!negative test!) create collection with incorrect property limit (40 kb)', async () => {
+  itSub('(!negative test!) create collection with incorrect property limit (40 kb)', async ({helper}) => {
     const props: IProperty[] = [];
 
     for (let i = 0; i < 32; i++) {
       props.push({key: `key${i}`.repeat(80), value: `value${i}`.repeat(80)});
     }
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
 });

modifiedtests/src/createItem.test.tsdiff before after both

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
2// This file is part of Unique Network.2// This file is part of Unique Network.
33
4// Unique Network is free software: you can redistribute it and/or modify4// Unique Network is free software: you can redistribute itSub and/or modify
5// it under the terms of the GNU General Public License as published by5// itSub under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.7// (at your option) any later version.
88
9// Unique Network is distributed in the hope that it will be useful,9// Unique Network is distributed in the hope that itSub will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12// GNU General Public License for more details.12// GNU General Public License for more details.
1313
14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import chai from 'chai';
18import chaiAsPromised from 'chai-as-promised';
19import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18
20import {19import {
21  createCollection,20  createCollection,
22  itApi,21  itApi,
23  normalizeAccountId,22  normalizeAccountId,
24  getCreateItemResult,23  getCreateItemResult,
25} from './util/helpers';24} from './util/helpers';
25
26import {usingPlaygrounds} from './util/playgrounds';26import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
27import {IProperty} from './util/playgrounds/types';27import {IProperty} from './util/playgrounds/types';
28import {executeTransaction} from './substrate/substrate-api';28import {executeTransaction} from './substrate/substrate-api';
2929
30chai.use(chaiAsPromised);
31const expect = chai.expect;
32
33let donor: IKeyringPair;
34
35before(async () => {
36  await usingPlaygrounds(async (_, privateKey) => {
37    donor = privateKey('//Alice');
38  });
39});
40
41let alice: IKeyringPair;
42let bob: IKeyringPair;
4330
44describe('integration test: ext. ():', () => {31describe('integration test: ext. ():', () => {
32  let alice: IKeyringPair;
33  let bob: IKeyringPair;
34
45  before(async () => {35  before(async () => {
46    await usingPlaygrounds(async (helper) => {36    await usingPlaygrounds(async (helper, privateKey) => {
37      const donor = privateKey('//Alice');
47      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);38      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
48    });39    });
49  });40  });
5041
51  it('Create new item in NFT collection', async () => {42  itSub('Create new item in NFT collection', async ({helper}) => {
52    await usingPlaygrounds(async (helper) => {
53      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});43    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
54      await collection.mintToken(alice, {Substrate: alice.address});44    await collection.mintToken(alice, {Substrate: alice.address});
55    });
56  });45  });
57  it('Create new item in Fungible collection', async () => {46  itSub('Create new item in Fungible collection', async ({helper}) => {
58    await usingPlaygrounds(async (helper) => {
59      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);47    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
60      await collection.mint(alice, {Substrate: alice.address}, 10n);48    await collection.mint(alice, 10n, {Substrate: alice.address});
61    });
62  });49  });
63  itApi.skip('Check events on create new item in Fungible collection', async ({api}) => {50  itApi.skip('Check events on create new item in Fungible collection', async ({api}) => {
64    const createMode = 'Fungible';51    const createMode = 'Fungible';
86    }73    }
87
88  });74  });
89  it('Create new item in ReFungible collection', async function() {75  itSub.ifWithPallets('Create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) =>  {
90    await usingPlaygrounds(async (helper) => {
91      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});76    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
92      await collection.mintToken(alice, {Substrate: alice.address}, 100n);77    await collection.mintToken(alice, 100n, {Substrate: alice.address});
93    });78  });
94  });
95  it('Create new item in NFT collection with collection admin permissions', async () => {79  itSub('Create new item in NFT collection with collection admin permissions', async ({helper}) => {
96    await usingPlaygrounds(async (helper) => {
97      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});80    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
98      await collection.addAdmin(alice, {Substrate: bob.address});81    await collection.addAdmin(alice, {Substrate: bob.address});
99      await collection.mintToken(bob, {Substrate: alice.address});82    await collection.mintToken(bob, {Substrate: alice.address});
100    });
101  });83  });
102  it('Create new item in Fungible collection with collection admin permissions', async () => {84  itSub('Create new item in Fungible collection with collection admin permissions', async ({helper}) => {
103    await usingPlaygrounds(async (helper) => {
104      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);85    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
105      await collection.addAdmin(alice, {Substrate: bob.address});86    await collection.addAdmin(alice, {Substrate: bob.address});
106      await collection.mint(bob, {Substrate: alice.address}, 10n);87    await collection.mint(bob, 10n, {Substrate: alice.address});
107    });
108  });88  });
109  it('Create new item in ReFungible collection with collection admin permissions', async function() {89  itSub.ifWithPallets('Create new item in ReFungible collection with collection admin permissions', [Pallets.ReFungible], async ({helper}) =>  {
110    await usingPlaygrounds(async (helper) => {
111      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});90    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
112      await collection.addAdmin(alice, {Substrate: bob.address});91    await collection.addAdmin(alice, {Substrate: bob.address});
113      await collection.mintToken(bob, {Substrate: alice.address}, 100n);92    await collection.mintToken(bob, 100n, {Substrate: alice.address});
114    });93  });
115  });
11694
117  it('Set property Admin', async () => {95  itSub('Set property Admin', async ({helper}) => {
118    await usingPlaygrounds(async (helper) => {
119      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',96    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
120        properties: [{key: 'k', value: 'v'}],97      properties: [{key: 'k', value: 'v'}],
121        tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],98      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],
122      });99    });
123      await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);100    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
124    });
125  });101  });
126102
127  it('Set property AdminConst', async () => {103  itSub('Set property AdminConst', async ({helper}) => {
128    await usingPlaygrounds(async (helper) => {
129      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',104    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
130        properties: [{key: 'k', value: 'v'}],105      properties: [{key: 'k', value: 'v'}],
131        tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],106      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],
132      });107    });
133      await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);108    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
134    });
135  });109  });
136110
137  it('Set property itemOwnerOrAdmin', async () => {111  itSub('Set property itemOwnerOrAdmin', async ({helper}) => {
138    await usingPlaygrounds(async (helper) => {
139      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',112    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
140        properties: [{key: 'k', value: 'v'}],113      properties: [{key: 'k', value: 'v'}],
141        tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],114      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],
142      });115    });
143      await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);116    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
144    });
145  });117  });
146118
147  it('Check total pieces of Fungible token', async () => {119  itSub('Check total pieces of Fungible token', async ({helper}) => {
148    await usingPlaygrounds(async (helper) => {
149      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);120    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
150      const amount = 10n;121    const amount = 10n;
151      await collection.mint(alice, {Substrate: bob.address}, amount);122    await collection.mint(alice, amount, {Substrate: bob.address});
152      {123    {
153        const totalPieces = await collection.getTotalPieces();124      const totalPieces = await collection.getTotalPieces();
154        expect(totalPieces).to.be.equal(amount);125      expect(totalPieces).to.be.equal(amount);
158        const totalPieces = await collection.getTotalPieces();129      const totalPieces = await collection.getTotalPieces();
159        expect(totalPieces).to.be.equal(amount);130      expect(totalPieces).to.be.equal(amount);
160      }131    }
161    });
162  });132  });
163133
164  it('Check total pieces of NFT token', async () => {134  itSub('Check total pieces of NFT token', async ({helper}) => {
165    await usingPlaygrounds(async (helper) => {
166      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});135    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
167      const amount = 1n;136    const amount = 1n;
168      const token = await collection.mintToken(alice, {Substrate: bob.address});137    const token = await collection.mintToken(alice, {Substrate: bob.address});
175        const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);144      const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
176        expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);145      expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
177      }146    }
178    });
179  });147  });
180148
181  it('Check total pieces of ReFungible token', async function() {149  itSub.ifWithPallets('Check total pieces of ReFungible token', [Pallets.ReFungible], async ({helper}) => {
182    await usingPlaygrounds(async (helper) => {
183      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});150    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
184      const amount = 100n;151    const amount = 100n;
185      const token = await collection.mintToken(alice, {Substrate: bob.address}, amount);152    const token = await collection.mintToken(alice, amount, {Substrate: bob.address});
186      {153    {
187        const totalPieces = await token.getTotalPieces();154      const totalPieces = await token.getTotalPieces();
188        expect(totalPieces).to.be.equal(amount);155      expect(totalPieces).to.be.equal(amount);
192        const totalPieces = await token.getTotalPieces();159      const totalPieces = await token.getTotalPieces();
193        expect(totalPieces).to.be.equal(amount);160      expect(totalPieces).to.be.equal(amount);
194      }161    }
195    });162  });
196  });
197});163});
198164
199describe('Negative integration test: ext. createItem():', () => {165describe('Negative integration test: ext. createItem():', () => {
166  let alice: IKeyringPair;
167  let bob: IKeyringPair;
168
200  before(async () => {169  before(async () => {
201    await usingPlaygrounds(async (helper) => {170    await usingPlaygrounds(async (helper, privateKey) => {
171      const donor = privateKey('//Alice');
202      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);172      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
203    });173    });
204  });174  });
205175
206  it('Regular user cannot create new item in NFT collection', async () => {176  itSub('Regular user cannot create new item in NFT collection', async ({helper}) => {
207    await usingPlaygrounds(async (helper) => {
208      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});177    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
209      const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});178    const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
210      await expect(mintTx()).to.be.rejected;179    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
211    });
212  });180  });
213  it('Regular user cannot create new item in Fungible collection', async () => {181  itSub('Regular user cannot create new item in Fungible collection', async ({helper}) => {
214    await usingPlaygrounds(async (helper) => {
215      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);182    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
216      const mintTx = async () => collection.mint(bob, {Substrate: bob.address}, 10n);183    const mintTx = async () => collection.mint(bob, 10n, {Substrate: bob.address});
217      await expect(mintTx()).to.be.rejected;184    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
218    });
219  });185  });
220  it('Regular user cannot create new item in ReFungible collection', async () => {186  itSub('Regular user cannot create new item in ReFungible collection', async ({helper}) => {
221    await usingPlaygrounds(async (helper) => {
222      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});187    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
223      const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});188    const mintTx = async () => collection.mintToken(bob, 100n, {Substrate: bob.address});
224      await expect(mintTx()).to.be.rejected;189    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
225    });
226  });190  });
227191
228  it('No editing rights', async () => {192  itSub('No editing rights', async ({helper}) => {
229    await usingPlaygrounds(async (helper) => {
230      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',193    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
231        tokenPropertyPermissions: [{key: 'k', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}],194      tokenPropertyPermissions: [{key: 'k', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}],
232      });195    });
233      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);196    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
234      await expect(mintTx()).to.be.rejected;197    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
235    });
236  });198  });
237199
238  it('User doesnt have editing rights', async () => {200  itSub('User doesnt have editing rights', async ({helper}) => {
239    await usingPlaygrounds(async (helper) => {
240      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',201    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
241        tokenPropertyPermissions: [{key: 'k', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],202      tokenPropertyPermissions: [{key: 'k', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],
242      });203    });
243      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);204    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
244      await expect(mintTx()).to.be.rejected;205    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
245    });
246  });206  });
247207
248  it('Adding property without access rights', async () => {208  itSub('Adding property without access rights', async ({helper}) => {
249    await usingPlaygrounds(async (helper) => {
250      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});209    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
251      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);210    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
252      await expect(mintTx()).to.be.rejected;211    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
253    });
254  });212  });
255213
256  it('Adding more than 64 prps', async () => {214  itSub('Adding more than 64 prps', async ({helper}) => {
257    const props: IProperty[] = [];215    const props: IProperty[] = [];
258216
259    for (let i = 0; i < 65; i++) {217    for (let i = 0; i < 65; i++) {
260      props.push({key: `key${i}`, value: `value${i}`});218      props.push({key: `key${i}`, value: `value${i}`});
261    }219    }
262220
263    await usingPlaygrounds(async (helper) => {221
264      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});222    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
265      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, props);223    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, props);
266      await expect(mintTx()).to.be.rejected;224    await expect(mintTx()).to.be.rejectedWith('Verification Error');
267    });
268  });225  });
269226
270  it('Trying to add bigger property than allowed', async () => {227  itSub('Trying to add bigger property than allowed', async ({helper}) => {
271    await usingPlaygrounds(async (helper) => {
272      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',228    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
273        tokenPropertyPermissions: [229      tokenPropertyPermissions: [
274          {key: 'k1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},230        {key: 'k1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
279        {key: 'k1', value: 'vvvvvv'.repeat(5000)},235      {key: 'k1', value: 'vvvvvv'.repeat(5000)},
280        {key: 'k2', value: 'vvv'.repeat(5000)},236      {key: 'k2', value: 'vvv'.repeat(5000)},
281      ]);237    ]);
282      await expect(mintTx()).to.be.rejected;238    await expect(mintTx()).to.be.rejectedWith(/common\.NoSpaceForProperty/);
283    });
284  });239  });
285240
286  it('Check total pieces for invalid Fungible token', async () => {241  itSub('Check total pieces for invalid Fungible token', async ({helper}) => {
287    await usingPlaygrounds(async (helper) => {
288      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);242    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
289      const invalidTokenId = 1_000_000;243    const invalidTokenId = 1_000_000;
290      expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;244    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
291      expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);245    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
292    });
293  });246  });
294247
295  it('Check total pieces for invalid NFT token', async () => {248  itSub('Check total pieces for invalid NFT token', async ({helper}) => {
296    await usingPlaygrounds(async (helper) => {
297      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});249    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
298      const invalidTokenId = 1_000_000;250    const invalidTokenId = 1_000_000;
299      expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;251    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
300      expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);252    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
301    });
302  });253  });
303254
304  it('Check total pieces for invalid Refungible token', async function() {255  itSub.ifWithPallets('Check total pieces for invalid Refungible token', [Pallets.ReFungible], async ({helper}) => {
305    await usingPlaygrounds(async (helper) => {
306      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});256    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
307      const invalidTokenId = 1_000_000;257    const invalidTokenId = 1_000_000;
308      expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;258    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
309      expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);259    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
310    });260  });
311  });
312});261});
313262

modifiedtests/src/createMultipleItems.test.tsdiff before after both

--- a/tests/src/createMultipleItems.test.ts
+++ b/tests/src/createMultipleItems.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute itSub and/or modify
+// itSub under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that it will be useful,
+// Unique Network is distributed in the hope that itSub will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -15,179 +15,154 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
 import {
   normalizeAccountId,
 } from './util/helpers';
-import {usingPlaygrounds} from './util/playgrounds';
+import {usingPlaygrounds, expect, Pallets, itSub} from './util/playgrounds';
 
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let donor: IKeyringPair;
-
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
 
 describe('Integration Test createMultipleItems(collection_id, owner, items_data):', () => {
   let alice: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice] = await helper.arrange.createAccounts([100n], donor);
     });
   });
 
-  it('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'data', permission: {tokenOwner: true, mutable: false, collectionAdmin: false}},
-        ],
-      });
-      const args = [
-        {properties: [{key: 'data', value: '1'}]},
-        {properties: [{key: 'data', value: '2'}]},
-        {properties: [{key: 'data', value: '3'}]},
-      ];
-      const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      for (const [i, token] of tokens.entries()) {
-        const tokenData = await token.getData();
-        expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: alice.address});
-        expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
-      }
+  itSub('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: false, collectionAdmin: false}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: '1'}]},
+      {properties: [{key: 'data', value: '2'}]},
+      {properties: [{key: 'data', value: '3'}]},
+    ];
+    const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    for (const [i, token] of tokens.entries()) {
+      const tokenData = await token.getData();
+      expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: alice.address});
+      expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
+    }
   });
 
-  it('Create 0x01, 0x02, 0x03 items in active Fungible collection and verify tokens data in chain', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-      });
-      const args = [
-        {value: 1n},
-        {value: 2n},
-        {value: 3n},
-      ];
-      await helper.ft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(6n);
+  itSub('Create 0x01, 0x02, 0x03 items in active Fungible collection and verify tokens data in chain', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+    const args = [
+      {value: 1n},
+      {value: 2n},
+      {value: 3n},
+    ];
+    await helper.ft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, args, {Substrate: alice.address});
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(6n);
   });
 
-  it('Create 0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-      });
-      const args = [
-        {pieces: 1n},
-        {pieces: 2n},
-        {pieces: 3n},
-      ];
-      const tokens = await helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+  itSub.ifWithPallets('Create 0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+    });
+    const args = [
+      {pieces: 1n},
+      {pieces: 2n},
+      {pieces: 3n},
+    ];
+    const tokens = await helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
 
-      for (const [i, token] of tokens.entries()) {
-        expect(await token.getBalance({Substrate: alice.address})).to.be.equal(BigInt(i + 1));
-      }
-    });
+    for (const [i, token] of tokens.entries()) {
+      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(BigInt(i + 1));
+    }
   });
 
-  it('Can mint amount of items equals to collection limits', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        limits: {
-          tokenLimit: 2,
-        },
-      });
-      const args = [{}, {}];
-      await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+  itSub('Can mint amount of items equals to collection limits', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      limits: {
+        tokenLimit: 2,
+      },
     });
+    const args = [{}, {}];
+    await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
   });
 
-  it('Create 0x31, 0x32, 0x33 items in active NFT with property Admin', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'data', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}},
-        ],
-      });
-      const args = [
-        {properties: [{key: 'data', value: '1'}]},
-        {properties: [{key: 'data', value: '2'}]},
-        {properties: [{key: 'data', value: '3'}]},
-      ];
-      const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      for (const [i, token] of tokens.entries()) {
-        const tokenData = await token.getData();
-        expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: alice.address});
-        expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
-      }
+  itSub('Create 0x31, 0x32, 0x33 items in active NFT with property Admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: '1'}]},
+      {properties: [{key: 'data', value: '2'}]},
+      {properties: [{key: 'data', value: '3'}]},
+    ];
+    const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    for (const [i, token] of tokens.entries()) {
+      const tokenData = await token.getData();
+      expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: alice.address});
+      expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
+    }
   });
 
-  it('Create 0x31, 0x32, 0x33 items in active NFT with property AdminConst', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'data', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}},
-        ],
-      });
-      const args = [
-        {properties: [{key: 'data', value: '1'}]},
-        {properties: [{key: 'data', value: '2'}]},
-        {properties: [{key: 'data', value: '3'}]},
-      ];
-      const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      for (const [i, token] of tokens.entries()) {
-        const tokenData = await token.getData();
-        expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: alice.address});
-        expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
-      }
+  itSub('Create 0x31, 0x32, 0x33 items in active NFT with property AdminConst', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: '1'}]},
+      {properties: [{key: 'data', value: '2'}]},
+      {properties: [{key: 'data', value: '3'}]},
+    ];
+    const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    for (const [i, token] of tokens.entries()) {
+      const tokenData = await token.getData();
+      expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: alice.address});
+      expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
+    }
   });
 
-  it('Create 0x31, 0x32, 0x33 items in active NFT with property itemOwnerOrAdmin', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
-        ],
-      });
-      const args = [
-        {properties: [{key: 'data', value: '1'}]},
-        {properties: [{key: 'data', value: '2'}]},
-        {properties: [{key: 'data', value: '3'}]},
-      ];
-      const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      for (const [i, token] of tokens.entries()) {
-        const tokenData = await token.getData();
-        expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: alice.address});
-        expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
-      }
+  itSub('Create 0x31, 0x32, 0x33 items in active NFT with property itemOwnerOrAdmin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: '1'}]},
+      {properties: [{key: 'data', value: '2'}]},
+      {properties: [{key: 'data', value: '3'}]},
+    ];
+    const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    for (const [i, token] of tokens.entries()) {
+      const tokenData = await token.getData();
+      expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: alice.address});
+      expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
+    }
   });
 });
 
@@ -196,229 +171,205 @@
   let bob: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('Regular user cannot create items in active NFT collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-      });
-      const args = [
-        {},
-        {},
-      ];
-      const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
+  itSub('Regular user cannot create items in active NFT collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+    const args = [
+      {},
+      {},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
-  it('Regular user cannot create items in active Fungible collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-      });
-      const args = [
-        {value: 1n},
-        {value: 2n},
-        {value: 3n},
-      ];
-      const mintTx = async () => helper.ft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
+  itSub('Regular user cannot create items in active Fungible collection', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+    const args = [
+      {value: 1n},
+      {value: 2n},
+      {value: 3n},
+    ];
+    const mintTx = async () => helper.ft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, args, {Substrate: alice.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
-  it('Regular user cannot create items in active ReFungible collection', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-      });
-      const args = [
-        {pieces: 1n},
-        {pieces: 1n},
-        {pieces: 1n},
-      ];
-      const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
+  itSub.ifWithPallets('Regular user cannot create items in active ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+    const args = [
+      {pieces: 1n},
+      {pieces: 1n},
+      {pieces: 1n},
+    ];
+    const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
-  it('Create token in not existing collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collectionId = 1_000_000;
-      const args = [
-        {},
-        {},
-      ];
-      const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
-    });
+  itSub('Create token in not existing collection', async ({helper}) => {
+    const collectionId = 1_000_000;
+    const args = [
+      {},
+      {},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('Create NFTs that has reached the maximum data limit', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
-        ],
-      });
-      const args = [
-        {properties: [{key: 'data', value: 'A'.repeat(32769)}]},
-        {properties: [{key: 'data', value: 'B'.repeat(32769)}]},
-        {properties: [{key: 'data', value: 'C'.repeat(32769)}]},
-      ];
-      const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejected;
+  itSub('Create NFTs that has reached the maximum data limit', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: 'A'.repeat(32769)}]},
+      {properties: [{key: 'data', value: 'B'.repeat(32769)}]},
+      {properties: [{key: 'data', value: 'C'.repeat(32769)}]},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('Create Refungible tokens that has reached the maximum data limit', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
-        ],
-      });
-      const args = [
-        {pieces: 10n, properties: [{key: 'data', value: 'A'.repeat(32769)}]},
-        {pieces: 10n, properties: [{key: 'data', value: 'B'.repeat(32769)}]},
-        {pieces: 10n, properties: [{key: 'data', value: 'C'.repeat(32769)}]},
-      ];
-      const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejected;
+  itSub.ifWithPallets('Create Refungible tokens that has reached the maximum data limit', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {pieces: 10n, properties: [{key: 'data', value: 'A'.repeat(32769)}]},
+      {pieces: 10n, properties: [{key: 'data', value: 'B'.repeat(32769)}]},
+      {pieces: 10n, properties: [{key: 'data', value: 'C'.repeat(32769)}]},
+    ];
+    const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('Create tokens with different types', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const {collectionId} = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-      });
+  itSub.ifWithPallets('Create tokens with different types', [Pallets.ReFungible], async ({helper}) => {
+    const {collectionId} = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+    });
 
-      //FIXME:
-      const types = ['NFT', 'Fungible', 'ReFungible'];
-      const mintTx = helper.api?.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), types);
-      await expect(helper.signTransaction(alice, mintTx)).to.be.rejected;
-    });
+    const types = ['NFT', 'Fungible', 'ReFungible'];
+    const mintTx = helper.api?.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), types);
+    await expect(helper.signTransaction(alice, mintTx)).to.be.rejected;
   });
 
-  it('Create tokens with different data limits <> maximum data limit', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
-        ],
-      });
-      const args = [
-        {properties: [{key: 'data', value: 'A'}]},
-        {properties: [{key: 'data', value: 'B'.repeat(32769)}]},
-      ];
-      const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejected;
+  itSub('Create tokens with different data limits <> maximum data limit', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: 'A'}]},
+      {properties: [{key: 'data', value: 'B'.repeat(32769)}]},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('Fails when minting tokens exceeds collectionLimits amount', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
-        ],
-        limits: {
-          tokenLimit: 1,
-        },
-      });
-      const args = [
-        {},
-        {},
-      ];
-      const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejected;
+  itSub('Fails when minting tokens exceeds collectionLimits amount', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
+      limits: {
+        tokenLimit: 1,
+      },
     });
+    const args = [
+      {},
+      {},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
   });
 
-  it('User doesnt have editing rights', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'data', permission: {tokenOwner: false, mutable: true, collectionAdmin: false}},
-        ],
-      });
-      const args = [
-        {properties: [{key: 'data', value: 'A'}]},
-      ];
-      const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejected;
+  itSub('User doesnt have editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: false, mutable: true, collectionAdmin: false}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: 'A'}]},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding property without access rights', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-        properties: [
-          {
-            key: 'data',
-            value: 'v',
-          },
-        ],
-      });
-      const args = [
-        {properties: [{key: 'data', value: 'A'}]},
-      ];
-      const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejected;
+  itSub('Adding property without access rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      properties: [
+        {
+          key: 'data',
+          value: 'v',
+        },
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: 'A'}]},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding more than 64 prps', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {
-        name: 'name',
-        description: 'descr',
-        tokenPrefix: 'COL',
-      });
-      const prps = [];
+  itSub('Adding more than 64 prps', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+    });
+    const prps = [];
 
-      for (let i = 0; i < 65; i++) {
-        prps.push({key: `key${i}`, value: `value${i}`});
-      }
+    for (let i = 0; i < 65; i++) {
+      prps.push({key: `key${i}`, value: `value${i}`});
+    }
 
-      const args = [
-        {properties: prps},
-        {properties: prps},
-        {properties: prps},
-      ];
+    const args = [
+      {properties: prps},
+      {properties: prps},
+      {properties: prps},
+    ];
 
-      const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
-      await expect(mintTx()).to.be.rejected;
-    });
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 });