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

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

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

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
2// This file is part of Unique Network.2// This file is part of Unique Network.
33
4// Unique Network is free software: you can redistribute it and/or modify4// Unique Network is free software: you can redistribute itSub and/or modify
5// it under the terms of the GNU General Public License as published by5// itSub under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.7// (at your option) any later version.
88
9// Unique Network is distributed in the hope that it will be useful,9// Unique Network is distributed in the hope that itSub will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12// GNU General Public License for more details.12// GNU General Public License for more details.
1313
14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import chai from 'chai';
18import chaiAsPromised from 'chai-as-promised';
19import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
20import {usingPlaygrounds} from './util/playgrounds';18import {usingPlaygrounds, expect, itSub, Pallets} 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});
32
33let alice: IKeyringPair;
34let bob: IKeyringPair;
35let charlie: IKeyringPair;
3619
37describe('integration test: ext. confirmSponsorship():', () => {20describe('integration test: ext. confirmSponsorship():', () => {
21  let alice: IKeyringPair;
22  let bob: IKeyringPair;
23  let charlie: IKeyringPair;
24  let zeroBalance: IKeyringPair;
3825
39  before(async () => {26  before(async () => {
40    await usingPlaygrounds(async (helper) => {27    await usingPlaygrounds(async (helper, privateKey) => {
28      const donor = privateKey('//Alice');
41      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);29      [alice, bob, charlie, zeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n], donor);
42    });30    });
43  });31  });
4432
45  it('Confirm collection sponsorship', async () => {33  itSub('Confirm collection sponsorship', async ({helper}) => {
46    await usingPlaygrounds(async (helper) => {
47      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});34    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
48      await collection.setSponsor(alice, bob.address);35    await collection.setSponsor(alice, bob.address);
49      await collection.confirmSponsorship(bob);36    await collection.confirmSponsorship(bob);
50    });
51  });37  });
5238
53  it('Add sponsor to a collection after the same sponsor was already added and confirmed', async () => {39  itSub('Add sponsor to a collection after the same sponsor was already added and confirmed', async ({helper}) => {
54    await usingPlaygrounds(async (helper) => {
55      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});40    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
56      await collection.setSponsor(alice, bob.address);41    await collection.setSponsor(alice, bob.address);
57      await collection.confirmSponsorship(bob);42    await collection.confirmSponsorship(bob);
58      await collection.setSponsor(alice, bob.address);43    await collection.setSponsor(alice, bob.address);
59    });
60  });44  });
61  it('Add new sponsor to a collection after another sponsor was already added and confirmed', async () => {45  itSub('Add new sponsor to a collection after another sponsor was already added and confirmed', async ({helper}) => {
62    await usingPlaygrounds(async (helper) => {
63      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});46    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
64      await collection.setSponsor(alice, bob.address);47    await collection.setSponsor(alice, bob.address);
65      await collection.confirmSponsorship(bob);48    await collection.confirmSponsorship(bob);
66      await collection.setSponsor(alice, charlie.address);49    await collection.setSponsor(alice, charlie.address);
67    });
68  });50  });
6951
70  it('NFT: Transfer fees are paid by the sponsor after confirmation', async () => {52  itSub('NFT: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {
71    await usingPlaygrounds(async (helper) => {
72      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
73      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});53    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
74      await collection.setSponsor(alice, bob.address);54    await collection.setSponsor(alice, bob.address);
75      await collection.confirmSponsorship(bob);55    await collection.confirmSponsorship(bob);
78      await token.transfer(zeroBalance, {Substrate: alice.address});58    await token.transfer(zeroBalance, {Substrate: alice.address});
79      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);59    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
80      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;60    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
81    });
82  });61  });
8362
84  it('Fungible: Transfer fees are paid by the sponsor after confirmation', async () => {63  itSub('Fungible: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {
85    await usingPlaygrounds(async (helper) => {
86      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
87      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);64    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
88      await collection.setSponsor(alice, bob.address);65    await collection.setSponsor(alice, bob.address);
89      await collection.confirmSponsorship(bob);66    await collection.confirmSponsorship(bob);
90      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);67    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
91      await collection.mint(alice, {Substrate: zeroBalance.address}, 100n);68    await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
92      await collection.transfer(zeroBalance, {Substrate: alice.address}, 1n);69    await collection.transfer(zeroBalance, {Substrate: alice.address}, 1n);
93      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);70    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
94      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;71    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
95    });
96  });72  });
9773
98  it('ReFungible: Transfer fees are paid by the sponsor after confirmation', async function() {74  itSub.ifWithPallets('ReFungible: Transfer fees are paid by the sponsor after confirmation', [Pallets.ReFungible], async ({helper}) => {
99    await usingPlaygrounds(async (helper) => {
100      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
101      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});75    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
102      await collection.setSponsor(alice, bob.address);76    await collection.setSponsor(alice, bob.address);
103      await collection.confirmSponsorship(bob);77    await collection.confirmSponsorship(bob);
104      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);78    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
105      const token = await collection.mintToken(alice, {Substrate: zeroBalance.address}, 100n);79    const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
106      await token.transfer(zeroBalance, {Substrate: alice.address}, 1n);80    await token.transfer(zeroBalance, {Substrate: alice.address}, 1n);
107      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);81    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
108      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;82    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
109    });83  });
110  });
11184
112  it('CreateItem fees are paid by the sponsor after confirmation', async () => {85  itSub('CreateItem fees are paid by the sponsor after confirmation', async ({helper}) => {
113    await usingPlaygrounds(async (helper) => {
114      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
115      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});86    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
116      await collection.setSponsor(alice, bob.address);87    await collection.setSponsor(alice, bob.address);
117      await collection.confirmSponsorship(bob);88    await collection.confirmSponsorship(bob);
123      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);94    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
12495
125      expect(bobBalanceAfter < bobBalanceBefore).to.be.true;96    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
126    });
127  });97  });
12898
129  it('NFT: Sponsoring of transfers is rate limited', async () => {99  itSub('NFT: Sponsoring of transfers is rate limited', async ({helper}) => {
130    await usingPlaygrounds(async (helper) => {
131      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
132      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});100    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
133      await collection.setSponsor(alice, bob.address);101    await collection.setSponsor(alice, bob.address);
134      await collection.confirmSponsorship(bob);102    await collection.confirmSponsorship(bob);
142      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);110    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
143111
144      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;112    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
145    });
146  });113  });
147114
148  it('Fungible: Sponsoring is rate limited', async () => {115  itSub('Fungible: Sponsoring is rate limited', async ({helper}) => {
149    await usingPlaygrounds(async (helper) => {
150      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
151      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});116    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
152      await collection.setSponsor(alice, bob.address);117    await collection.setSponsor(alice, bob.address);
153      await collection.confirmSponsorship(bob);118    await collection.confirmSponsorship(bob);
154119
155      await collection.mint(alice, {Substrate: zeroBalance.address}, 100n);120    await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
156      await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);121    await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);
157      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);122    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
158123
161      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);126    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
162127
163      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;128    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
164    });
165  });129  });
166130
167  it('ReFungible: Sponsoring is rate limited', async function() {131  itSub.ifWithPallets('ReFungible: Sponsoring is rate limited', [Pallets.ReFungible], async ({helper}) => {
168    await usingPlaygrounds(async (helper) => {
169      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
170      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});132    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
171      await collection.setSponsor(alice, bob.address);133    await collection.setSponsor(alice, bob.address);
172      await collection.confirmSponsorship(bob);134    await collection.confirmSponsorship(bob);
173135
174      const token = await collection.mintToken(alice, {Substrate: zeroBalance.address}, 100n);136    const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
175      await token.transfer(zeroBalance, {Substrate: alice.address});137    await token.transfer(zeroBalance, {Substrate: alice.address});
176138
177      const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);139    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
180      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);142    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
181143
182      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;144    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
183    });145  });
184  });
185146
186  it('NFT: Sponsoring of createItem is rate limited', async () => {147  itSub('NFT: Sponsoring of createItem is rate limited', async ({helper}) => {
187    await usingPlaygrounds(async (helper) => {
188      const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
189      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});148    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
190      await collection.setSponsor(alice, bob.address);149    await collection.setSponsor(alice, bob.address);
191      await collection.confirmSponsorship(bob);150    await collection.confirmSponsorship(bob);
200      const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);159    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
201160
202      expect(bobBalanceAfter === bobBalanceBefore).to.be.true;161    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
203    });
204  });162  });
205});163});
206164
207describe('(!negative test!) integration test: ext. confirmSponsorship():', () => {165describe('(!negative test!) integration test: ext. confirmSponsorship():', () => {
166  let alice: IKeyringPair;
167  let bob: IKeyringPair;
168  let charlie: IKeyringPair;
169  let ownerZeroBalance: IKeyringPair;
170  let senderZeroBalance: IKeyringPair;
171
208  before(async () => {172  before(async () => {
209    await usingPlaygrounds(async (helper) => {173    await usingPlaygrounds(async (helper, privateKey) => {
174      const donor = privateKey('//Alice');
210      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);175      [alice, bob, charlie, ownerZeroBalance, senderZeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n, 0n], donor);
211    });176    });
212  });177  });
213178
214  it('(!negative test!) Confirm sponsorship for a collection that never existed', async () => {179  itSub('(!negative test!) Confirm sponsorship for a collection that never existed', async ({helper}) => {
215    await usingPlaygrounds(async (helper) => {180    const collectionId = 1_000_000;
216      const collectionId = 1 << 32 - 1;
217      const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);181    const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);
218      await expect(confirmSponsorshipTx()).to.be.rejected;182    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
219    });
220  });183  });
221184
222  it('(!negative test!) Confirm sponsorship using a non-sponsor address', async () => {185  itSub('(!negative test!) Confirm sponsorship using a non-sponsor address', async ({helper}) => {
223    await usingPlaygrounds(async (helper) => {
224      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});186    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
225      await collection.setSponsor(alice, bob.address);187    await collection.setSponsor(alice, bob.address);
226      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);188    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
227      await expect(confirmSponsorshipTx()).to.be.rejected;189    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
228    });
229  });190  });
230191
231  it('(!negative test!) Confirm sponsorship using owner address', async () => {192  itSub('(!negative test!) Confirm sponsorship using owner address', async ({helper}) => {
232    await usingPlaygrounds(async (helper) => {
233      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});193    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
234      await collection.setSponsor(alice, bob.address);194    await collection.setSponsor(alice, bob.address);
235      const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);195    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
236      await expect(confirmSponsorshipTx()).to.be.rejected;196    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
237    });
238  });197  });
239198
240  it('(!negative test!) Confirm sponsorship by collection admin', async () => {199  itSub('(!negative test!) Confirm sponsorship by collection admin', async ({helper}) => {
241    await usingPlaygrounds(async (helper) => {
242      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});200    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
243      await collection.setSponsor(alice, bob.address);201    await collection.setSponsor(alice, bob.address);
244      await collection.addAdmin(alice, {Substrate: charlie.address});202    await collection.addAdmin(alice, {Substrate: charlie.address});
245      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);203    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
246      await expect(confirmSponsorshipTx()).to.be.rejected;204    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
247    });
248  });205  });
249206
250  it('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async () => {207  itSub('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async ({helper}) => {
251    await usingPlaygrounds(async (helper) => {
252      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});208    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
253      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);209    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
254      await expect(confirmSponsorshipTx()).to.be.rejected;210    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
255    });
256  });211  });
257212
258  it('(!negative test!) Confirm sponsorship in a collection that was destroyed', async () => {213  itSub('(!negative test!) Confirm sponsorship in a collection that was destroyed', async ({helper}) => {
259    await usingPlaygrounds(async (helper) => {
260      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});214    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
261      await collection.burn(alice);215    await collection.burn(alice);
262      const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);216    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
263      await expect(confirmSponsorshipTx()).to.be.rejected;217    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
264    });
265  });218  });
266219
267  it('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', async () => {220  itSub('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', async ({helper}) => {
268    await usingPlaygrounds(async (helper) => {
269      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});221    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
270      await collection.setSponsor(alice, bob.address);222    await collection.setSponsor(alice, bob.address);
271      await collection.confirmSponsorship(bob);223    await collection.confirmSponsorship(bob);
272      const [ownerZeroBalance, senderZeroBalance] = await helper.arrange.createAccounts([0n, 0n], donor);
273      const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});224    const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});
274      const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);225    const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
275      const transferTx = async () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});226    const transferTx = async () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});
276      await expect(transferTx()).to.be.rejected;227    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
277      const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);228    const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
278      expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);229    expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);
279    });
280  });230  });
281});231});
282232

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

--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute itSub and/or modify
+// itSub under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that it will be useful,
+// Unique Network is distributed in the hope that itSub will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -14,51 +14,38 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
 import {IKeyringPair} from '@polkadot/types/types';
+
 import {
   createCollection,
   itApi,
   normalizeAccountId,
   getCreateItemResult,
 } from './util/helpers';
-import {usingPlaygrounds} from './util/playgrounds';
+
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
 import {IProperty} from './util/playgrounds/types';
 import {executeTransaction} from './substrate/substrate-api';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
 
-let donor: IKeyringPair;
 
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
-
-let alice: IKeyringPair;
-let bob: IKeyringPair;
+describe('integration test: ext. ():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
 
-describe('integration test: ext. ():', () => {
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('Create new item in NFT collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.mintToken(alice, {Substrate: alice.address});
-    });
+  itSub('Create new item in NFT collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.mintToken(alice, {Substrate: alice.address});
   });
-  it('Create new item in Fungible collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      await collection.mint(alice, {Substrate: alice.address}, 10n);
-    });
+  itSub('Create new item in Fungible collection', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await collection.mint(alice, 10n, {Substrate: alice.address});
   });
   itApi.skip('Check events on create new item in Fungible collection', async ({api}) => {
     const createMode = 'Fungible';
@@ -84,229 +71,191 @@
       expect(result.collectionId).to.be.equal(newCollectionID);
       expect(result.recipient).to.be.deep.equal(to);
     }
-
   });
-  it('Create new item in ReFungible collection', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.mintToken(alice, {Substrate: alice.address}, 100n);
-    });
+  itSub.ifWithPallets('Create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) =>  {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.mintToken(alice, 100n, {Substrate: alice.address});
   });
-  it('Create new item in NFT collection with collection admin permissions', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.addAdmin(alice, {Substrate: bob.address});
-      await collection.mintToken(bob, {Substrate: alice.address});
-    });
+  itSub('Create new item in NFT collection with collection admin permissions', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.mintToken(bob, {Substrate: alice.address});
   });
-  it('Create new item in Fungible collection with collection admin permissions', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      await collection.addAdmin(alice, {Substrate: bob.address});
-      await collection.mint(bob, {Substrate: alice.address}, 10n);
-    });
+  itSub('Create new item in Fungible collection with collection admin permissions', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.mint(bob, 10n, {Substrate: alice.address});
   });
-  it('Create new item in ReFungible collection with collection admin permissions', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      await collection.addAdmin(alice, {Substrate: bob.address});
-      await collection.mintToken(bob, {Substrate: alice.address}, 100n);
-    });
+  itSub.ifWithPallets('Create new item in ReFungible collection with collection admin permissions', [Pallets.ReFungible], async ({helper}) =>  {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.mintToken(bob, 100n, {Substrate: alice.address});
   });
 
-  it('Set property Admin', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
-        properties: [{key: 'k', value: 'v'}],
-        tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],
-      });
-      await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+  itSub('Set property Admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'k', value: 'v'}],
+      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],
     });
+    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
   });
 
-  it('Set property AdminConst', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
-        properties: [{key: 'k', value: 'v'}],
-        tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],
-      });
-      await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+  itSub('Set property AdminConst', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'k', value: 'v'}],
+      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],
     });
+    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
   });
 
-  it('Set property itemOwnerOrAdmin', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
-        properties: [{key: 'k', value: 'v'}],
-        tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],
-      });
-      await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+  itSub('Set property itemOwnerOrAdmin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'k', value: 'v'}],
+      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],
     });
+    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
   });
 
-  it('Check total pieces of Fungible token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      const amount = 10n;
-      await collection.mint(alice, {Substrate: bob.address}, amount);
-      {
-        const totalPieces = await collection.getTotalPieces();
-        expect(totalPieces).to.be.equal(amount);
-      }
-      await collection.transfer(bob, {Substrate: alice.address}, 1n);
-      {
-        const totalPieces = await collection.getTotalPieces();
-        expect(totalPieces).to.be.equal(amount);
-      }
-    });
+  itSub('Check total pieces of Fungible token', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    const amount = 10n;
+    await collection.mint(alice, amount, {Substrate: bob.address});
+    {
+      const totalPieces = await collection.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
+    await collection.transfer(bob, {Substrate: alice.address}, 1n);
+    {
+      const totalPieces = await collection.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
   });
 
-  it('Check total pieces of NFT token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const amount = 1n;
-      const token = await collection.mintToken(alice, {Substrate: bob.address});
-      {
-        const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
-        expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
-      }
-      await token.transfer(bob, {Substrate: alice.address});
-      {
-        const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
-        expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
-      }
-    });
+  itSub('Check total pieces of NFT token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const amount = 1n;
+    const token = await collection.mintToken(alice, {Substrate: bob.address});
+    {
+      const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
+      expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
+    }
+    await token.transfer(bob, {Substrate: alice.address});
+    {
+      const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
+      expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
+    }
   });
 
-  it('Check total pieces of ReFungible token', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const amount = 100n;
-      const token = await collection.mintToken(alice, {Substrate: bob.address}, amount);
-      {
-        const totalPieces = await token.getTotalPieces();
-        expect(totalPieces).to.be.equal(amount);
-      }
-      await token.transfer(bob, {Substrate: alice.address}, 60n);
-      {
-        const totalPieces = await token.getTotalPieces();
-        expect(totalPieces).to.be.equal(amount);
-      }
-    });
+  itSub.ifWithPallets('Check total pieces of ReFungible token', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const amount = 100n;
+    const token = await collection.mintToken(alice, amount, {Substrate: bob.address});
+    {
+      const totalPieces = await token.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
+    await token.transfer(bob, {Substrate: alice.address}, 60n);
+    {
+      const totalPieces = await token.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
   });
 });
 
 describe('Negative integration test: ext. createItem():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
       [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('Regular user cannot create new item in NFT collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
-      await expect(mintTx()).to.be.rejected;
-    });
+  itSub('Regular user cannot create new item in NFT collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
-  it('Regular user cannot create new item in Fungible collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      const mintTx = async () => collection.mint(bob, {Substrate: bob.address}, 10n);
-      await expect(mintTx()).to.be.rejected;
-    });
+  itSub('Regular user cannot create new item in Fungible collection', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    const mintTx = async () => collection.mint(bob, 10n, {Substrate: bob.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
-  it('Regular user cannot create new item in ReFungible collection', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
-      await expect(mintTx()).to.be.rejected;
-    });
+  itSub('Regular user cannot create new item in ReFungible collection', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(bob, 100n, {Substrate: bob.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
-  it('No editing rights', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
-        tokenPropertyPermissions: [{key: 'k', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}],
-      });
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
-      await expect(mintTx()).to.be.rejected;
+  itSub('No editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+      tokenPropertyPermissions: [{key: 'k', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}],
     });
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('User doesnt have editing rights', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
-        tokenPropertyPermissions: [{key: 'k', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],
-      });
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
-      await expect(mintTx()).to.be.rejected;
+  itSub('User doesnt have editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+      tokenPropertyPermissions: [{key: 'k', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],
     });
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding property without access rights', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
-      await expect(mintTx()).to.be.rejected;
-    });
+  itSub('Adding property without access rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding more than 64 prps', async () => {
+  itSub('Adding more than 64 prps', async ({helper}) => {
     const props: IProperty[] = [];
 
     for (let i = 0; i < 65; i++) {
       props.push({key: `key${i}`, value: `value${i}`});
     }
 
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, props);
-      await expect(mintTx()).to.be.rejected;
-    });
+
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, props);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('Trying to add bigger property than allowed', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
-        tokenPropertyPermissions: [
-          {key: 'k1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
-          {key: 'k2', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
-        ],
-      });
-      const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [
-        {key: 'k1', value: 'vvvvvv'.repeat(5000)},
-        {key: 'k2', value: 'vvv'.repeat(5000)},
-      ]);
-      await expect(mintTx()).to.be.rejected;
+  itSub('Trying to add bigger property than allowed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'k1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
+        {key: 'k2', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
+      ],
     });
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [
+      {key: 'k1', value: 'vvvvvv'.repeat(5000)},
+      {key: 'k2', value: 'vvv'.repeat(5000)},
+    ]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoSpaceForProperty/);
   });
 
-  it('Check total pieces for invalid Fungible token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-      const invalidTokenId = 1_000_000;
-      expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
-      expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
-    });
+  itSub('Check total pieces for invalid Fungible token', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    const invalidTokenId = 1_000_000;
+    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
+    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
   });
 
-  it('Check total pieces for invalid NFT token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const invalidTokenId = 1_000_000;
-      expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
-      expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
-    });
+  itSub('Check total pieces for invalid NFT token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const invalidTokenId = 1_000_000;
+    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
+    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
   });
 
-  it('Check total pieces for invalid Refungible token', async function() {
-    await usingPlaygrounds(async (helper) => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-      const invalidTokenId = 1_000_000;
-      expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
-      expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
-    });
+  itSub.ifWithPallets('Check total pieces for invalid Refungible token', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const invalidTokenId = 1_000_000;
+    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
+    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
   });
 });

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