git.delta.rocks / unique-network / refs/commits / 96cdb9b3ccba

--- 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;
   });
 });

--- 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/);
   });
 });

--- 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);
   });
 });

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 {usingPlaygrounds} from './util/playgrounds';17import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
20import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
21import {IProperty} from './util/playgrounds/types';19import {IProperty} from './util/playgrounds/types';
22
23chai.use(chaiAsPromised);
24const expect = chai.expect;
25
26let donor: IKeyringPair;
27
28before(async () => {
29  await usingPlaygrounds(async (_, privateKey) => {
30    donor = privateKey('//Alice');
31  });
32});
33
34let alice: IKeyringPair;
3520
36describe('integration test: ext. createCollection():', () => {21describe('integration test: ext. createCollection():', () => {
22  let alice: IKeyringPair;
23
37  before(async () => {24  before(async () => {
38    await usingPlaygrounds(async (helper) => {25    await usingPlaygrounds(async (helper, privateKey) => {
26      const donor = privateKey('//Alice');
39      [alice] = await helper.arrange.createAccounts([100n], donor);27      [alice] = await helper.arrange.createAccounts([100n], donor);
40    });28    });
41  });29  });
42  it('Create new NFT collection', async () => {30  itSub('Create new NFT collection', async ({helper}) => {
43    await usingPlaygrounds(async (helper) => {31
44      await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});32    await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
45    });
46  });33  });
47  it('Create new NFT collection whith collection_name of maximum length (64 bytes)', async () => {34  itSub('Create new NFT collection whith collection_name of maximum length (64 bytes)', async ({helper}) => {
48    await usingPlaygrounds(async (helper) => {35
49      await helper.nft.mintCollection(alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'});36    await helper.nft.mintCollection(alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'});
50    });
51  });37  });
52  it('Create new NFT collection whith collection_description of maximum length (256 bytes)', async () => {38  itSub('Create new NFT collection whith collection_description of maximum length (256 bytes)', async ({helper}) => {
53    await usingPlaygrounds(async (helper) => {39
54      await helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'});40    await helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'});
55    });
56  });41  });
57  it('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async () => {42  itSub('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async ({helper}) => {
58    await usingPlaygrounds(async (helper) => {43
59      await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)});44    await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)});
60    });
61  });45  });
62  it('Create new Fungible collection', async () => {46  itSub('Create new Fungible collection', async ({helper}) => {
63    await usingPlaygrounds(async (helper) => {47
64      await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 0);48    await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 0);
65    });
66  });49  });
67  it('Create new ReFungible collection', async function() {50  itSub.ifWithPallets('Create new ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
68    await usingPlaygrounds(async (helper) => {51
69      await helper.rft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});52    await helper.rft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
70    });53  });
71  });
7254
73  it('create new collection with properties', async () => {55  itSub('create new collection with properties', async ({helper}) => {
74    await usingPlaygrounds(async (helper) => {56
75      await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',57    await helper.nft.mintCollection(alice, {
58      name: 'name', description: 'descr', tokenPrefix: 'COL',
76        properties: [{key: 'key1', value: 'val1'}],59      properties: [{key: 'key1', value: 'val1'}],
77        tokenPropertyPermissions: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}],60      tokenPropertyPermissions: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}],
78      });61    });
79    });
80  });62  });
8163
82  it('Create new collection with extra fields', async () => {64  itSub('Create new collection with extra fields', async ({helper}) => {
83    await usingPlaygrounds(async (helper) => {65
84      const collection = await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 8);66    const collection = await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 8);
85      await collection.setPermissions(alice, {access: 'AllowList'});67    await collection.setPermissions(alice, {access: 'AllowList'});
86      await collection.setLimits(alice, {accountTokenOwnershipLimit: 3});68    await collection.setLimits(alice, {accountTokenOwnershipLimit: 3});
94      expect(raw.permissions.access).to.be.equal('AllowList');76    expect(raw.permissions.access).to.be.equal('AllowList');
95      expect(raw.mode).to.be.deep.equal({Fungible: '8'});77    expect(raw.mode).to.be.deep.equal({Fungible: '8'});
96      expect(limits.accountTokenOwnershipLimit).to.be.equal(3);78    expect(limits.accountTokenOwnershipLimit).to.be.equal(3);
97    });
98  });79  });
9980
100  it('New collection is not external', async () => {81  itSub('New collection is not external', async ({helper}) => {
101    await usingPlaygrounds(async (helper) => {82
102      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});83    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
103      const data = await collection.getData();84    const data = await collection.getData();
104      expect(data?.raw.readOnly).to.be.false;85    expect(data?.raw.readOnly).to.be.false;
105    });
106  });86  });
107});87});
10888
109describe('(!negative test!) integration test: ext. createCollection():', () => {89describe('(!negative test!) integration test: ext. createCollection():', () => {
90  let alice: IKeyringPair;
91
92  before(async () => {
93    await usingPlaygrounds(async (helper, privateKey) => {
94      const donor = privateKey('//Alice');
95      [alice] = await helper.arrange.createAccounts([100n], donor);
96    });
97  });
98
110  it('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async () => {99  itSub('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async ({helper}) => {
111    await usingPlaygrounds(async (helper) => {
112      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});100    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});
113      await expect(mintCollectionTx()).to.be.rejected;101    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
114    });
115  });102  });
116  it('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async () => {103  itSub('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async ({helper}) => {
117    await usingPlaygrounds(async (helper) => {
118      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});104    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});
119      await expect(mintCollectionTx()).to.be.rejected;105    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
120    });
121  });106  });
122  it('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async () => {107  itSub('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async ({helper}) => {
123    await usingPlaygrounds(async (helper) => {108
124      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});109    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
125      await expect(mintCollectionTx()).to.be.rejected;110    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
126    });
127  });111  });
128  it('(!negative test!) fails when bad limits are set', async () => {112  itSub('(!negative test!) fails when bad limits are set', async ({helper}) => {
129    await usingPlaygrounds(async (helper) => {113
130      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});114    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
131      await expect(mintCollectionTx()).to.be.rejected;115    await expect(mintCollectionTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
132    });
133  });116  });
134117
135  it('(!negative test!) create collection with incorrect property limit (64 elements)', async () => {118  itSub('(!negative test!) create collection with incorrect property limit (64 elements)', async ({helper}) => {
136    const props: IProperty[] = [];119    const props: IProperty[] = [];
137120
138    for (let i = 0; i < 65; i++) {121    for (let i = 0; i < 65; i++) {
139      props.push({key: `key${i}`, value: `value${i}`});122      props.push({key: `key${i}`, value: `value${i}`});
140    }123    }
141    await usingPlaygrounds(async (helper) => {
142      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});124    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
143      await expect(mintCollectionTx()).to.be.rejected;125    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
144    });
145  });126  });
146127
147  it('(!negative test!) create collection with incorrect property limit (40 kb)', async () => {128  itSub('(!negative test!) create collection with incorrect property limit (40 kb)', async ({helper}) => {
148    const props: IProperty[] = [];129    const props: IProperty[] = [];
149130
150    for (let i = 0; i < 32; i++) {131    for (let i = 0; i < 32; i++) {
151      props.push({key: `key${i}`.repeat(80), value: `value${i}`.repeat(80)});132      props.push({key: `key${i}`.repeat(80), value: `value${i}`.repeat(80)});
152    }133    }
153    await usingPlaygrounds(async (helper) => {134
154      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});135    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
155      await expect(mintCollectionTx()).to.be.rejected;136    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
156    });
157  });137  });
158});138});
159139

--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.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,51 +14,38 @@
 // 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 {
   createCollection,
   itApi,
   normalizeAccountId,
   getCreateItemResult,
 } from './util/helpers';
-import {usingPlaygrounds} from './util/playgrounds';
+
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
 import {IProperty} from './util/playgrounds/types';
 import {executeTransaction} from './substrate/substrate-api';
-
-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;
+describe('integration test: ext. ():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
 
-describe('integration test: ext. ():', () => {
   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('Create new item in NFT collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.mintToken(alice, {Substrate: alice.address});
-    });
+  itSub('Create new item in NFT collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.mintToken(alice, {Substrate: alice.address});
   });
-  it('Create new item in Fungible collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      await collection.mint(alice, {Substrate: alice.address}, 10n);
-    });
+  itSub('Create new item in Fungible collection', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await collection.mint(alice, 10n, {Substrate: alice.address});
   });
   itApi.skip('Check events on create new item in Fungible collection', async ({api}) => {
     const createMode = 'Fungible';
@@ -84,229 +71,191 @@
       expect(result.collectionId).to.be.equal(newCollectionID);
       expect(result.recipient).to.be.deep.equal(to);
     }
-
   });
-  it('Create new item in ReFungible collection', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.mintToken(alice, {Substrate: alice.address}, 100n);
-    });
+  itSub.ifWithPallets('Create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) =>  {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.mintToken(alice, 100n, {Substrate: alice.address});
   });
-  it('Create new item in NFT collection with collection admin permissions', 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});
-      await collection.mintToken(bob, {Substrate: alice.address});
-    });
+  itSub('Create new item in NFT collection with collection admin permissions', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.mintToken(bob, {Substrate: alice.address});
   });
-  it('Create new item in Fungible collection with collection admin permissions', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      await collection.addAdmin(alice, {Substrate: bob.address});
-      await collection.mint(bob, {Substrate: alice.address}, 10n);
-    });
+  itSub('Create new item in Fungible collection with collection admin permissions', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.mint(bob, 10n, {Substrate: alice.address});
   });
-  it('Create new item in ReFungible collection with collection admin permissions', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.addAdmin(alice, {Substrate: bob.address});
-      await collection.mintToken(bob, {Substrate: alice.address}, 100n);
-    });
+  itSub.ifWithPallets('Create new item in ReFungible collection with collection admin permissions', [Pallets.ReFungible], async ({helper}) =>  {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.mintToken(bob, 100n, {Substrate: alice.address});
   });
 
-  it('Set property Admin', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
-        properties: [{key: 'k', value: 'v'}],
-        tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],
-      });
-      await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+  itSub('Set property Admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'k', value: 'v'}],
+      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],
     });
+    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
   });
 
-  it('Set property AdminConst', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
-        properties: [{key: 'k', value: 'v'}],
-        tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],
-      });
-      await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+  itSub('Set property AdminConst', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'k', value: 'v'}],
+      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],
     });
+    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
   });
 
-  it('Set property itemOwnerOrAdmin', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
-        properties: [{key: 'k', value: 'v'}],
-        tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],
-      });
-      await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+  itSub('Set property itemOwnerOrAdmin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'k', value: 'v'}],
+      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],
     });
+    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
   });
 
-  it('Check total pieces of Fungible token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      const amount = 10n;
-      await collection.mint(alice, {Substrate: bob.address}, amount);
-      {
-        const totalPieces = await collection.getTotalPieces();
-        expect(totalPieces).to.be.equal(amount);
-      }
-      await collection.transfer(bob, {Substrate: alice.address}, 1n);
-      {
-        const totalPieces = await collection.getTotalPieces();
-        expect(totalPieces).to.be.equal(amount);
-      }
-    });
+  itSub('Check total pieces of Fungible token', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    const amount = 10n;
+    await collection.mint(alice, amount, {Substrate: bob.address});
+    {
+      const totalPieces = await collection.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
+    await collection.transfer(bob, {Substrate: alice.address}, 1n);
+    {
+      const totalPieces = await collection.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
   });
 
-  it('Check total pieces of NFT token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const amount = 1n;
-      const token = await collection.mintToken(alice, {Substrate: bob.address});
-      {
-        const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
-        expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
-      }
-      await token.transfer(bob, {Substrate: alice.address});
-      {
-        const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
-        expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
-      }
-    });
+  itSub('Check total pieces of NFT token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const amount = 1n;
+    const token = await collection.mintToken(alice, {Substrate: bob.address});
+    {
+      const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
+      expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
+    }
+    await token.transfer(bob, {Substrate: alice.address});
+    {
+      const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
+      expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
+    }
   });
 
-  it('Check total pieces of ReFungible token', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const amount = 100n;
-      const token = await collection.mintToken(alice, {Substrate: bob.address}, amount);
-      {
-        const totalPieces = await token.getTotalPieces();
-        expect(totalPieces).to.be.equal(amount);
-      }
-      await token.transfer(bob, {Substrate: alice.address}, 60n);
-      {
-        const totalPieces = await token.getTotalPieces();
-        expect(totalPieces).to.be.equal(amount);
-      }
-    });
+  itSub.ifWithPallets('Check total pieces of ReFungible token', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const amount = 100n;
+    const token = await collection.mintToken(alice, amount, {Substrate: bob.address});
+    {
+      const totalPieces = await token.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
+    await token.transfer(bob, {Substrate: alice.address}, 60n);
+    {
+      const totalPieces = await token.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
   });
 });
 
 describe('Negative integration test: ext. createItem():', () => {
+  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('Regular user cannot create new item in NFT collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
-      await expect(mintTx()).to.be.rejected;
-    });
+  itSub('Regular user cannot create new item in NFT collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
-  it('Regular user cannot create new item in Fungible collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      const mintTx = async () => collection.mint(bob, {Substrate: bob.address}, 10n);
-      await expect(mintTx()).to.be.rejected;
-    });
+  itSub('Regular user cannot create new item in Fungible collection', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    const mintTx = async () => collection.mint(bob, 10n, {Substrate: bob.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
-  it('Regular user cannot create new item in ReFungible collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
-      await expect(mintTx()).to.be.rejected;
-    });
+  itSub('Regular user cannot create new item in ReFungible collection', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(bob, 100n, {Substrate: bob.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
-  it('No editing rights', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
-        tokenPropertyPermissions: [{key: 'k', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}],
-      });
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
-      await expect(mintTx()).to.be.rejected;
+  itSub('No editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+      tokenPropertyPermissions: [{key: 'k', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}],
     });
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('User doesnt have editing rights', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
-        tokenPropertyPermissions: [{key: 'k', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],
-      });
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
-      await expect(mintTx()).to.be.rejected;
+  itSub('User doesnt have editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+      tokenPropertyPermissions: [{key: 'k', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],
     });
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    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: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
-      await expect(mintTx()).to.be.rejected;
-    });
+  itSub('Adding property without access rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding more than 64 prps', async () => {
+  itSub('Adding more than 64 prps', 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 collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, props);
-      await expect(mintTx()).to.be.rejected;
-    });
+
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, props);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('Trying to add bigger property than allowed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'k1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
-          {key: 'k2', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
-        ],
-      });
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [
-        {key: 'k1', value: 'vvvvvv'.repeat(5000)},
-        {key: 'k2', value: 'vvv'.repeat(5000)},
-      ]);
-      await expect(mintTx()).to.be.rejected;
+  itSub('Trying to add bigger property than allowed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'k1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
+        {key: 'k2', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
+      ],
     });
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [
+      {key: 'k1', value: 'vvvvvv'.repeat(5000)},
+      {key: 'k2', value: 'vvv'.repeat(5000)},
+    ]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoSpaceForProperty/);
   });
 
-  it('Check total pieces for invalid Fungible token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      const invalidTokenId = 1_000_000;
-      expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
-      expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
-    });
+  itSub('Check total pieces for invalid Fungible token', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    const invalidTokenId = 1_000_000;
+    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
+    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
   });
 
-  it('Check total pieces for invalid NFT token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const invalidTokenId = 1_000_000;
-      expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
-      expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
-    });
+  itSub('Check total pieces for invalid NFT token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const invalidTokenId = 1_000_000;
+    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
+    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
   });
 
-  it('Check total pieces for invalid Refungible token', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const invalidTokenId = 1_000_000;
-      expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
-      expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
-    });
+  itSub.ifWithPallets('Check total pieces for invalid Refungible token', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const invalidTokenId = 1_000_000;
+    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
+    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
   });
 });

--- 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');
   });
 });