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

difftreelog

fix code style

rkv2022-09-14parent: #9844c48.patch.diff
in: master

6 files changed

modifiedtests/src/adminTransferAndBurn.test.tsdiffbeforeafterboth
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 {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import chai from 'chai';
19import chaiAsPromised from 'chai-as-promised';
20import {usingPlaygrounds} from './util/playgrounds';18import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
21
22chai.use(chaiAsPromised);
23const expect = chai.expect;
24
25let donor: IKeyringPair;
26
27before(async () => {
28  await usingPlaygrounds(async (_, privateKey) => {
29    donor = privateKey('//Alice');
30  });
31});
3219
33describe('Integration Test: ownerCanTransfer allows admins to use only transferFrom/burnFrom:', () => {20describe('Integration Test: ownerCanTransfer allows admins to use only transferFrom/burnFrom:', () => {
34  let alice: IKeyringPair;21  let alice: IKeyringPair;
35  let bob: IKeyringPair;22  let bob: IKeyringPair;
36  let charlie: IKeyringPair;23  let charlie: IKeyringPair;
3724
38  before(async () => {25  before(async () => {
39    await usingPlaygrounds(async (helper) => {26    await usingPlaygrounds(async (helper, privateKey) => {
27      const donor = privateKey('//Alice');
40      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);28      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
41    });29    });
42  });30  });
4331
44  it('admin transfers other user\'s token', async () => {32  itSub('admin transfers other user\'s token', async ({helper}) => {
45    await usingPlaygrounds(async (helper) => {
46      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});33    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
47      await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});34    await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
48      const limits = await helper.collection.getEffectiveLimits(collectionId);35    const limits = await helper.collection.getEffectiveLimits(collectionId);
55      await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});42    await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});
56      const newTokenOwner = await helper.nft.getTokenOwner(collectionId, tokenId);43    const newTokenOwner = await helper.nft.getTokenOwner(collectionId, tokenId);
57      expect(newTokenOwner.Substrate).to.be.equal(charlie.address);44    expect(newTokenOwner.Substrate).to.be.equal(charlie.address);
58    });
59  });45  });
6046
61  it('admin burns other user\'s token', async () => {47  itSub('admin burns other user\'s token', async ({helper}) => {
62    await usingPlaygrounds(async (helper) => {
63      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});48    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
6449
65      await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});50    await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
74      await helper.nft.burnToken(bob, collectionId, tokenId);59    await helper.nft.burnToken(bob, collectionId, tokenId);
75      const token = await helper.nft.getToken(collectionId, tokenId);60    const token = await helper.nft.getToken(collectionId, tokenId);
76      expect(token).to.be.null;61    expect(token).to.be.null;
77    });
78  });62  });
79});63});
8064
modifiedtests/src/change-collection-owner.test.tsdiffbeforeafterboth
--- a/tests/src/change-collection-owner.test.ts
+++ b/tests/src/change-collection-owner.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute itSub and/or modify
+// itSub under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that it will be useful,
+// Unique Network is distributed in the hope that itSub will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -15,41 +15,27 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {usingPlaygrounds} from './util/playgrounds';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
 
-let donor: IKeyringPair;
-
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
-
 describe('Integration Test changeCollectionOwner(collection_id, new_owner):', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('Changing owner changes owner address', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const beforeChanging = await helper.collection.getData(collection.collectionId);
-      expect(beforeChanging?.normalizedOwner).to.be.equal(alice.address);
+  itSub('Changing owner changes owner address', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const beforeChanging = await helper.collection.getData(collection.collectionId);
+    expect(beforeChanging?.normalizedOwner).to.be.equal(alice.address);
 
-      await collection.changeOwner(alice, bob.address);
-      const afterChanging = await helper.collection.getData(collection.collectionId);
-      expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
-    });
+    await collection.changeOwner(alice, bob.address);
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
   });
 });
 
@@ -59,64 +45,59 @@
   let charlie: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });
 
-  it('Changing the owner of the collection is not allowed for the former owner', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+  itSub('Changing the owner of the collection is not allowed for the former owner', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
 
-      await collection.changeOwner(alice, bob.address);
+    await collection.changeOwner(alice, bob.address);
 
-      const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
-      await expect(changeOwnerTx()).to.be.rejected;
+    const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const afterChanging = await helper.collection.getData(collection.collectionId);
-      expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
-    });
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
   });
 
-  it('New collectionOwner has access to sponsorship management operations in the collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.changeOwner(alice, bob.address);
+  itSub('New collectionOwner has access to sponsorship management operations in the collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.changeOwner(alice, bob.address);
 
-      const afterChanging = await helper.collection.getData(collection.collectionId);
-      expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
 
-      await collection.setSponsor(bob, charlie.address);
-      await collection.confirmSponsorship(charlie);
-      await collection.removeSponsor(bob);
-      const limits = {
-        accountTokenOwnershipLimit: 1,
-        tokenLimit: 1,
-        sponsorTransferTimeout: 1,
-        ownerCanDestroy: true,
-        ownerCanTransfer: true,
-      };
+    await collection.setSponsor(bob, charlie.address);
+    await collection.confirmSponsorship(charlie);
+    await collection.removeSponsor(bob);
+    const limits = {
+      accountTokenOwnershipLimit: 1,
+      tokenLimit: 1,
+      sponsorTransferTimeout: 1,
+      ownerCanDestroy: true,
+      ownerCanTransfer: true,
+    };
 
-      await collection.setLimits(bob, limits);
-      const gotLimits = await collection.getEffectiveLimits();
-      expect(gotLimits).to.be.deep.contains(limits);
+    await collection.setLimits(bob, limits);
+    const gotLimits = await collection.getEffectiveLimits();
+    expect(gotLimits).to.be.deep.contains(limits);
 
-      await collection.setPermissions(bob, {access: 'AllowList', mintMode: true});
+    await collection.setPermissions(bob, {access: 'AllowList', mintMode: true});
 
-      await collection.burn(bob);
-      const collectionData = await helper.collection.getData(collection.collectionId);
-      expect(collectionData).to.be.null;
-    });
+    await collection.burn(bob);
+    const collectionData = await helper.collection.getData(collection.collectionId);
+    expect(collectionData).to.be.null;
   });
 
-  it('New collectionOwner has access to changeCollectionOwner', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.changeOwner(alice, bob.address);
-      await collection.changeOwner(bob, charlie.address);
-      const collectionData = await collection.getData();
-      expect(collectionData?.normalizedOwner).to.be.equal(charlie.address);
-    });
+  itSub('New collectionOwner has access to changeCollectionOwner', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.changeOwner(alice, bob.address);
+    await collection.changeOwner(bob, charlie.address);
+    const collectionData = await collection.getData();
+    expect(collectionData?.normalizedOwner).to.be.equal(charlie.address);
   });
 });
 
@@ -126,70 +107,63 @@
   let charlie: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });
 
-  it('Not owner can\'t change owner.', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
-      await expect(changeOwnerTx()).to.be.rejected;
-    });
+  itSub('Not owner can\'t change owner.', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Collection admin can\'t change owner.', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.addAdmin(alice, {Substrate: bob.address});
-      const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
-      await expect(changeOwnerTx()).to.be.rejected;
-    });
+  itSub('Collection admin can\'t change owner.', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Can\'t change owner of a non-existing collection.', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collectionId = (1 << 32) - 1;
-      const changeOwnerTx = async () => helper.collection.changeOwner(bob, collectionId, bob.address);
-      await expect(changeOwnerTx()).to.be.rejected;
-    });
+  itSub('Can\'t change owner of a non-existing collection.', async ({helper}) => {
+    const collectionId = (1 << 32) - 1;
+    const changeOwnerTx = async () => helper.collection.changeOwner(bob, collectionId, bob.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('Former collectionOwner not allowed to sponsorship management operations in the collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.changeOwner(alice, bob.address);
+  itSub('Former collectionOwner not allowed to sponsorship management operations in the collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.changeOwner(alice, bob.address);
 
-      const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
-      await expect(changeOwnerTx()).to.be.rejected;
+    const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const afterChanging = await helper.collection.getData(collection.collectionId);
-      expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(bob.address);
 
-      const setSponsorTx = async () => collection.setSponsor(alice, charlie.address);
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
-      const removeSponsorTx = async () => collection.removeSponsor(alice);
-      await expect(setSponsorTx()).to.be.rejected;
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-      await expect(removeSponsorTx()).to.be.rejected;
+    const setSponsorTx = async () => collection.setSponsor(alice, charlie.address);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
+    const removeSponsorTx = async () => collection.removeSponsor(alice);
+    await expect(setSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
+    await expect(removeSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const limits = {
-        accountTokenOwnershipLimit: 1,
-        tokenLimit: 1,
-        sponsorTransferTimeout: 1,
-        ownerCanDestroy: true,
-        ownerCanTransfer: true,
-      };
+    const limits = {
+      accountTokenOwnershipLimit: 1,
+      tokenLimit: 1,
+      sponsorTransferTimeout: 1,
+      ownerCanDestroy: true,
+      ownerCanTransfer: true,
+    };
 
-      const setLimitsTx = async () => collection.setLimits(alice, limits);
-      await expect(setLimitsTx()).to.be.rejected;
+    const setLimitsTx = async () => collection.setLimits(alice, limits);
+    await expect(setLimitsTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const setPermissionTx = async () => collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
-      await expect(setPermissionTx()).to.be.rejected;
+    const setPermissionTx = async () => collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await expect(setPermissionTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const burnTx = async () => collection.burn(alice);
-      await expect(burnTx()).to.be.rejected;
-    });
+    const burnTx = async () => collection.burn(alice);
+    await expect(burnTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 });
modifiedtests/src/confirmSponsorship.test.tsdiffbeforeafterboth
--- a/tests/src/confirmSponsorship.test.ts
+++ b/tests/src/confirmSponsorship.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute itSub and/or modify
+// itSub under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that it will be useful,
+// Unique Network is distributed in the hope that itSub will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -14,268 +14,218 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
 import {IKeyringPair} from '@polkadot/types/types';
-import {usingPlaygrounds} from './util/playgrounds';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let donor: IKeyringPair;
-
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
-
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-let charlie: IKeyringPair;
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
 
 describe('integration test: ext. confirmSponsorship():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
+  let zeroBalance: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
-      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie, zeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n], donor);
     });
   });
 
-  it('Confirm collection sponsorship', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-    });
+  itSub('Confirm collection sponsorship', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
   });
 
-  it('Add sponsor to a collection after the same sponsor was already added and confirmed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      await collection.setSponsor(alice, bob.address);
-    });
+  itSub('Add sponsor to a collection after the same sponsor was already added and confirmed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.setSponsor(alice, bob.address);
   });
-  it('Add new sponsor to a collection after another sponsor was already added and confirmed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      await collection.setSponsor(alice, charlie.address);
-    });
+  itSub('Add new sponsor to a collection after another sponsor was already added and confirmed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.setSponsor(alice, charlie.address);
   });
 
-  it('NFT: Transfer fees are paid by the sponsor after confirmation', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const token = await collection.mintToken(alice, {Substrate: zeroBalance.address});
-      await token.transfer(zeroBalance, {Substrate: alice.address});
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
-      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
-    });
+  itSub('NFT: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const token = await collection.mintToken(alice, {Substrate: zeroBalance.address});
+    await token.transfer(zeroBalance, {Substrate: alice.address});
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('Fungible: Transfer fees are paid by the sponsor after confirmation', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      await collection.mint(alice, {Substrate: zeroBalance.address}, 100n);
-      await collection.transfer(zeroBalance, {Substrate: alice.address}, 1n);
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
-      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
-    });
+  itSub('Fungible: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
+    await collection.transfer(zeroBalance, {Substrate: alice.address}, 1n);
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('ReFungible: Transfer fees are paid by the sponsor after confirmation', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const token = await collection.mintToken(alice, {Substrate: zeroBalance.address}, 100n);
-      await token.transfer(zeroBalance, {Substrate: alice.address}, 1n);
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
-      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
-    });
+  itSub.ifWithPallets('ReFungible: Transfer fees are paid by the sponsor after confirmation', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
+    await token.transfer(zeroBalance, {Substrate: alice.address}, 1n);
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('CreateItem fees are paid by the sponsor after confirmation', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
-      await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
+  itSub('CreateItem fees are paid by the sponsor after confirmation', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
 
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('NFT: Sponsoring of transfers is rate limited', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
+  itSub('NFT: Sponsoring of transfers is rate limited', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
 
-      const token = await collection.mintToken(alice, {Substrate: alice.address});
-      await token.transfer(alice, {Substrate: zeroBalance.address});
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const token = await collection.mintToken(alice, {Substrate: alice.address});
+    await token.transfer(alice, {Substrate: zeroBalance.address});
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
 
-      const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
-      await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 
-  it('Fungible: Sponsoring is rate limited', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
+  itSub('Fungible: Sponsoring is rate limited', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
 
-      await collection.mint(alice, {Substrate: zeroBalance.address}, 100n);
-      await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
+    await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
 
-      const transferTx = async () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});
-      await expect(transferTx()).to.be.rejected;
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});
+    await expect(transferTx()).to.be.rejected;
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 
-  it('ReFungible: Sponsoring is rate limited', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
+  itSub.ifWithPallets('ReFungible: Sponsoring is rate limited', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
 
-      const token = await collection.mintToken(alice, {Substrate: zeroBalance.address}, 100n);
-      await token.transfer(zeroBalance, {Substrate: alice.address});
+    const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
+    await token.transfer(zeroBalance, {Substrate: alice.address});
 
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
-      await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 
-  it('NFT: Sponsoring of createItem is rate limited', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      await collection.setPermissions(alice, {mintMode: true, access: 'AllowList'});
-      await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
+  itSub('NFT: Sponsoring of createItem is rate limited', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.setPermissions(alice, {mintMode: true, access: 'AllowList'});
+    await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
 
-      await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+    await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
 
-      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const mintTx = async () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
-      await expect(mintTx()).to.be.rejectedWith('Inability to pay some fees');
-      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const mintTx = async () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+    await expect(mintTx()).to.be.rejectedWith('Inability to pay some fees');
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 });
 
 describe('(!negative test!) integration test: ext. confirmSponsorship():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
+  let ownerZeroBalance: IKeyringPair;
+  let senderZeroBalance: IKeyringPair;
+
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
-      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie, ownerZeroBalance, senderZeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n, 0n], donor);
     });
   });
 
-  it('(!negative test!) Confirm sponsorship for a collection that never existed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collectionId = 1 << 32 - 1;
-      const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship for a collection that never existed', async ({helper}) => {
+    const collectionId = 1_000_000;
+    const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('(!negative test!) Confirm sponsorship using a non-sponsor address', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship using a non-sponsor address', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship using owner address', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship using owner address', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship by collection admin', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.addAdmin(alice, {Substrate: charlie.address});
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship by collection admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.addAdmin(alice, {Substrate: charlie.address});
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship in a collection that was destroyed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.burn(alice);
-      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
-      await expect(confirmSponsorshipTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) Confirm sponsorship in a collection that was destroyed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.burn(alice);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.setSponsor(alice, bob.address);
-      await collection.confirmSponsorship(bob);
-      const [ownerZeroBalance, senderZeroBalance] = await helper.arrange.createAccounts([0n, 0n], donor);
-      const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});
-      const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
-      const transferTx = async () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});
-      await expect(transferTx()).to.be.rejected;
-      const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
-      expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);
-    });
+  itSub('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});
+    const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});
+    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+    const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);
   });
 });
modifiedtests/src/createCollection.test.tsdiffbeforeafterboth
--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute itSub and/or modify
+// itSub under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that it will be useful,
+// Unique Network is distributed in the hope that itSub will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -14,145 +14,125 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {usingPlaygrounds} from './util/playgrounds';
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
 import {IKeyringPair} from '@polkadot/types/types';
 import {IProperty} from './util/playgrounds/types';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let donor: IKeyringPair;
-
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
-
-let alice: IKeyringPair;
 
 describe('integration test: ext. createCollection():', () => {
+  let alice: IKeyringPair;
+
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice] = await helper.arrange.createAccounts([100n], donor);
     });
   });
-  it('Create new NFT collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    });
+  itSub('Create new NFT collection', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
   });
-  it('Create new NFT collection whith collection_name of maximum length (64 bytes)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'});
-    });
+  itSub('Create new NFT collection whith collection_name of maximum length (64 bytes)', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'});
   });
-  it('Create new NFT collection whith collection_description of maximum length (256 bytes)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'});
-    });
+  itSub('Create new NFT collection whith collection_description of maximum length (256 bytes)', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'});
   });
-  it('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)});
-    });
+  itSub('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)});
   });
-  it('Create new Fungible collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 0);
-    });
+  itSub('Create new Fungible collection', async ({helper}) => {
+
+    await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 0);
   });
-  it('Create new ReFungible collection', async function() {
-    await usingPlaygrounds(async (helper) => {
-      await helper.rft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
-    });
+  itSub.ifWithPallets('Create new ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+
+    await helper.rft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
   });
 
-  it('create new collection with properties', async () => {
-    await usingPlaygrounds(async (helper) => {
-      await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
-        properties: [{key: 'key1', value: 'val1'}],
-        tokenPropertyPermissions: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}],
-      });
+  itSub('create new collection with properties', async ({helper}) => {
+
+    await helper.nft.mintCollection(alice, {
+      name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'key1', value: 'val1'}],
+      tokenPropertyPermissions: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}],
     });
   });
 
-  it('Create new collection with extra fields', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 8);
-      await collection.setPermissions(alice, {access: 'AllowList'});
-      await collection.setLimits(alice, {accountTokenOwnershipLimit: 3});
-      const data = await collection.getData();
-      const limits = await collection.getEffectiveLimits();
-      const raw = data?.raw;
+  itSub('Create new collection with extra fields', async ({helper}) => {
+
+    const collection = await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 8);
+    await collection.setPermissions(alice, {access: 'AllowList'});
+    await collection.setLimits(alice, {accountTokenOwnershipLimit: 3});
+    const data = await collection.getData();
+    const limits = await collection.getEffectiveLimits();
+    const raw = data?.raw;
 
-      expect(data?.normalizedOwner).to.be.equal(alice.address);
-      expect(data?.name).to.be.equal('name');
-      expect(data?.description).to.be.equal('descr');
-      expect(raw.permissions.access).to.be.equal('AllowList');
-      expect(raw.mode).to.be.deep.equal({Fungible: '8'});
-      expect(limits.accountTokenOwnershipLimit).to.be.equal(3);
-    });
+    expect(data?.normalizedOwner).to.be.equal(alice.address);
+    expect(data?.name).to.be.equal('name');
+    expect(data?.description).to.be.equal('descr');
+    expect(raw.permissions.access).to.be.equal('AllowList');
+    expect(raw.mode).to.be.deep.equal({Fungible: '8'});
+    expect(limits.accountTokenOwnershipLimit).to.be.equal(3);
   });
 
-  it('New collection is not external', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
-      const data = await collection.getData();
-      expect(data?.raw.readOnly).to.be.false;
-    });
+  itSub('New collection is not external', async ({helper}) => {
+
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+    const data = await collection.getData();
+    expect(data?.raw.readOnly).to.be.false;
   });
 });
 
 describe('(!negative test!) integration test: ext. createCollection():', () => {
-  it('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});
-      await expect(mintCollectionTx()).to.be.rejected;
+  let alice: IKeyringPair;
+
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([100n], donor);
     });
   });
-  it('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+
+  itSub('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async ({helper}) => {
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
+  });
+  itSub('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async ({helper}) => {
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
-  it('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async ({helper}) => {
+
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
-  it('(!negative test!) fails when bad limits are set', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+  itSub('(!negative test!) fails when bad limits are set', async ({helper}) => {
+
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
+    await expect(mintCollectionTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
   });
 
-  it('(!negative test!) create collection with incorrect property limit (64 elements)', async () => {
+  itSub('(!negative test!) create collection with incorrect property limit (64 elements)', async ({helper}) => {
     const props: IProperty[] = [];
 
     for (let i = 0; i < 65; i++) {
       props.push({key: `key${i}`, value: `value${i}`});
     }
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('(!negative test!) create collection with incorrect property limit (40 kb)', async () => {
+  itSub('(!negative test!) create collection with incorrect property limit (40 kb)', async ({helper}) => {
     const props: IProperty[] = [];
 
     for (let i = 0; i < 32; i++) {
       props.push({key: `key${i}`.repeat(80), value: `value${i}`.repeat(80)});
     }
-    await usingPlaygrounds(async (helper) => {
-      const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
-      await expect(mintCollectionTx()).to.be.rejected;
-    });
+
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
 });
modifiedtests/src/createItem.test.tsdiffbeforeafterboth
--- 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);
   });
 });
modifiedtests/src/createMultipleItems.test.tsdiffbeforeafterboth
--- 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');
   });
 });