git.delta.rocks / unique-network / refs/commits / 464a3c1ac005

--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.test.ts
@@ -24,6 +24,7 @@
   addCollectionAdminExpectSuccess,
   createCollectionWithPropsExpectSuccess,
   createItemWithPropsExpectSuccess,
+  createItemWithPropsExpectFailure,
 } from './util/helpers';
 
 const expect = chai.expect;
@@ -128,69 +129,47 @@
       const createMode = 'NFT';
       const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode}, 
         propPerm:   [{key: 'key1', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}]});
-
-      const token = await createItemExpectSuccess(alice, newCollectionID, 'NFT');
       await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
 
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenProperties(newCollectionID, token, [{key: 'key1', value: 'v2'}]), 
-      )).to.be.rejected;
+      await createItemWithPropsExpectFailure(bob, newCollectionID, 'NFT', [{key: 'key1', value: 'v'}]);
     });
   });
 
   it('User doesnt have editing rights', async () => {
     await usingApi(async api => {
       const newCollectionID = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}]});
-      const token = await createItemExpectSuccess(alice, newCollectionID, 'NFT');
-
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setTokenProperties(newCollectionID, token, [{key: 'key1', value: 'v2'}]), 
-      )).to.be.rejected;
+      await createItemWithPropsExpectFailure(bob, newCollectionID, 'NFT', [{key: 'key1', value: 'v'}]);
     });
   });
 
   it('Adding property without access rights', async () => {
     await usingApi(async api => {
-      const createMode = 'NFT';
-      const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
-
-      const token = await createItemExpectSuccess(alice, newCollectionID, 'NFT');
+      const newCollectionID = await createCollectionWithPropsExpectSuccess();
       await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
-      
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setTokenProperties(newCollectionID, token, [{key: 'key1', value: 'v2'}]), 
-      )).to.be.rejected;
+
+      await createItemWithPropsExpectFailure(bob, newCollectionID, 'NFT', [{key: 'k', value: 'v'}]);
     });
   });
 
   it('Adding more than 64 prps', async () => {
     await usingApi(async api => {
-      const createMode = 'NFT';
-
       const prps = [];
 
       for (let i = 0; i < 65; i++) {
         prps.push({key: `key${i}`, value: `value${i}`});
       }
 
-      const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
+      const newCollectionID = await createCollectionWithPropsExpectSuccess();
       
-      await expect(executeTransaction(api, alice, api.tx.unique.setCollectionProperties(newCollectionID, prps))).to.be.rejectedWith(/common\.PropertyLimitReached/);
+      createItemWithPropsExpectFailure(alice, newCollectionID, 'NFT', prps);
     });
   });
 
   it('Trying to add bigger property than allowed', async () => {
     await usingApi(async api => {
-      const createMode = 'NFT';
-      const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
+      const newCollectionID = await createCollectionWithPropsExpectSuccess();
       
-      await expect(executeTransaction(api, alice, api.tx.unique.setCollectionProperties(newCollectionID, [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]))).to.be.rejectedWith(/common\.NoSpaceForProperty/);
+      createItemWithPropsExpectFailure(alice, newCollectionID, 'NFT', [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]);
     });
   });
 });

--- a/tests/src/createMultipleItems.test.ts
+++ b/tests/src/createMultipleItems.test.ts
@@ -34,7 +34,8 @@
   getCreatedCollectionCount,
   createCollectionWithPropsExpectSuccess,
   getCreateItemsResult,
-  createMultipleItemsWithPropsExpectSuccess
+  createMultipleItemsWithPropsExpectSuccess,
+  createMultipleItemsWithPropsExpectFailure,
 } from './util/helpers';
 
 chai.use(chaiAsPromised);
@@ -432,79 +433,44 @@
   it('No editing rights', async () => {
     await usingApi(async (api: ApiPromise) => {
       const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}],
-        propPerm:   [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}]});
+        propPerm:   [{key: 'key1', permission: {mutable: false, collectionAdmin: false, tokenOwner: true}}]});
       const itemsListIndexBefore = await getLastTokenId(api, collectionId);
       expect(itemsListIndexBefore).to.be.equal(0);
       await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      const args = [{Nft: {const_data: '0x31'}},
+      const args = [{Nft: {const_data: '0x31', properties: [{key: 'key1', value: 'v2'}]}},
         {Nft: {const_data: '0x32'}},
         {Nft: {const_data: '0x33'}}];
 
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-
-      const events = await submitTransactionAsync(alice, createMultipleItemsTx);
-      const result = getCreateItemsResult(events);
-
-      for (const elem of result) {
-        await expect(executeTransaction(
-          api,
-          bob,
-          api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'key1', value: 'v2'}]),
-        )).to.be.rejected;
-      }
-
-      // await expect(submitTransactionAsync(bob, createMultipleItemsTx)).to.be.rejected;
+      await createMultipleItemsWithPropsExpectFailure(bob, collectionId, args);
     });
   });
 
   it('User doesnt have editing rights', async () => {
     await usingApi(async (api: ApiPromise) => {
       const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}],
-        propPerm:   [{key: 'key1', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}]});
+        propPerm:   [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}]});
       const itemsListIndexBefore = await getLastTokenId(api, collectionId);
       expect(itemsListIndexBefore).to.be.equal(0);
       await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      const args = [{Nft: {const_data: '0x31'}},
+      const args = [{Nft: {const_data: '0x31', properties: [{key: 'key1', value: 'v2'}]}},
         {Nft: {const_data: '0x32'}},
         {Nft: {const_data: '0x33'}}];
 
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-
-      const events = await submitTransactionAsync(alice, createMultipleItemsTx);
-      const result = getCreateItemsResult(events);
-
-      for (const elem of result) {
-        await expect(executeTransaction(
-          api,
-          bob,
-          api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'key1', value: 'v2'}]),
-        )).to.be.rejected;
-      }
+      await createMultipleItemsWithPropsExpectFailure(bob, collectionId, args);
     });
   });
 
   it('Adding property without access rights', async () => {
     await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}]});
+      const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'k', value: 'v1'}]});
       const itemsListIndexBefore = await getLastTokenId(api, collectionId);
       await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
       expect(itemsListIndexBefore).to.be.equal(0);
-      const args = [{Nft: {const_data: '0x31'}},
+      const args = [{Nft: {const_data: '0x31', properties: [{key: 'k', value: 'v'}]}},
         {Nft: {const_data: '0x32'}},
         {Nft: {const_data: '0x33'}}];
 
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-
-      const events = await submitTransactionAsync(alice, createMultipleItemsTx);
-      const result = getCreateItemsResult(events);
-
-      for (const elem of result) {
-        await expect(executeTransaction(
-          api,
-          bob,
-          api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'key1', value: 'v2'}]),
-        )).to.be.rejected;
-      }
+      await createMultipleItemsWithPropsExpectFailure(bob, collectionId, args);
     });
   });
 
@@ -515,15 +481,6 @@
       const itemsListIndexBefore = await getLastTokenId(api, collectionId);
       expect(itemsListIndexBefore).to.be.equal(0);
       await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-
-      const args = [{Nft: {const_data: '0x31'}},
-        {Nft: {const_data: '0x32'}},
-        {Nft: {const_data: '0x33'}}];
-
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      const events = await submitTransactionAsync(alice, createMultipleItemsTx);
-
-      const result = getCreateItemsResult(events);
 
       const prps = [];
 
@@ -531,43 +488,24 @@
         prps.push({key: `key${i}`, value: `value${i}`});
       }
 
-      await expect(executeTransaction(api, bob, api.tx.unique.setCollectionProperties(collectionId, prps))).to.be.rejectedWith(/common\.PropertyLimitReached/);
+      const args = [{Nft: {const_data: '0x31', properties: prps}},
+        {Nft: {const_data: '0x32', properties: prps}},
+        {Nft: {const_data: '0x33', properties: prps}}];
 
-      for (const elem of result) {
-        await expect(executeTransaction(
-          api,
-          bob,
-          api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, prps),
-        )).to.be.rejected;
-      }
+      createMultipleItemsWithPropsExpectFailure(alice, collectionId, args);
     });
   });
 
   it('Trying to add bigger property than allowed', async () => {
     await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}],
-        propPerm:   [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}]});
+      const collectionId = await createCollectionWithPropsExpectSuccess({propPerm:   [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]});
       const itemsListIndexBefore = await getLastTokenId(api, collectionId);
       expect(itemsListIndexBefore).to.be.equal(0);
-      const args = [{Nft: {const_data: '0x31'}},
-        {Nft: {const_data: '0x32'}},
-        {Nft: {const_data: '0x33'}}];
-
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-
-      const events = await submitTransactionAsync(alice, createMultipleItemsTx);
-      const result = getCreateItemsResult(events);
-
-
-      await expect(executeTransaction(api, alice, api.tx.unique.setCollectionProperties(collectionId, [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]))).to.be.rejectedWith(/common\.NoSpaceForProperty/);
+      const args = [{Nft: {const_data: '0x31', properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]}},
+        {Nft: {const_data: '0x32', properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]}},
+        {Nft: {const_data: '0x33', properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]}}];
 
-      for (const elem of result) {
-        await expect(executeTransaction(
-          api,
-          bob,
-          api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]),
-        )).to.be.rejected;
-      }
+      createMultipleItemsWithPropsExpectFailure(alice, collectionId, args);
     });
   });
 });

--- a/tests/src/interfaces/rmrk/definitions.ts
+++ b/tests/src/interfaces/rmrk/definitions.ts
@@ -24,92 +24,92 @@
 
 const atParam = {name: 'at', type: 'Hash', isOptional: true};
 const fn = (description: string, params: RpcParam[], type: string) => ({
-    description,
-    params: [...params, atParam],
-    type,
+  description,
+  params: [...params, atParam],
+  type,
 });
 
 export default {
-    types,
-    rpc: {
-        lastCollectionIdx: fn('Get the latest created collection id', [], 'u32'),
-        collectionById: fn('Get collection by id', [{name: 'id', type: 'u32'}], 'Option<RmrkTypesCollectionInfo>'),
-        nftById: fn(
-            'Get NFT by collection id and NFT id',
-            [
-                {name: 'collectionId', type: 'u32'},
-                {name: 'nftId', type: 'u32'},
-            ],
-            'Option<RmrkTypesNftInfo>'
-        ),
-        accountTokens: fn(
-            'Get tokens owned by an account in a collection',
-            [
-                {name: 'accountId', type: 'AccountId32'},
-                {name: 'collectionId', type: 'u32'}
-            ],
-            'Vec<u32>'
-        ),
-        nftChildren: fn(
-            'Get NFT children',
-            [
-                {name: 'collectionId', type: 'u32'},
-                {name: 'nftId', type: 'u32'},
-            ],
-            'Vec<RmrkTypesNftChild>'
-        ),
-        collectionProperties: fn(
-            'Get collection properties',
-            [{name: 'collectionId', type: 'u32'}],
-            'Vec<RmrkTypesPropertyInfo>'
-        ),
-        nftProperties: fn(
-            'Get NFT properties',
-            [
-                {name: 'collectionId', type: 'u32'},
-                {name: 'nftId', type: 'u32'}
-            ],
-            'Vec<RmrkTypesPropertyInfo>'
-        ),
-        nftResources: fn(
-            'Get NFT resources',
-            [
-                {name: 'collectionId', type: 'u32'},
-                {name: 'nftId', type: 'u32'}
-            ],
-            'Vec<RmrkTypesResourceInfo>'
-        ),
-        nftResourcePriorities: fn(
-            'Get NFT resource priorities',
-            [
-                {name: 'collectionId', type: 'u32'},
-                {name: 'nftId', type: 'u32'}
-            ],
-            'Vec<Bytes>'
-        ),
-        base: fn(
-            'Get base info',
-            [{name: 'baseId', type: 'u32'}],
-            'Option<RmrkTypesBaseInfo>'
-        ),
-        baseParts: fn(
-            'Get all Base\'s parts',
-            [{name: 'baseId', type: 'u32'}],
-            'Vec<RmrkTypesPartType>'
-        ),
-        themeNames: fn(
-            'Get Base\'s theme names',
-            [{name: 'baseId', type: 'u32'}],
-            'Vec<Bytes>'
-        ),
-        themes: fn(
-            'Get Theme\'s keys values',
-            [
-                {name: 'baseId', type: 'u32'},
-                {name: 'themeName', type: 'String'},
-                {name: 'keys', type: 'Option<Vec<String>>'}
-            ],
-            'Option<RmrkTypesTheme>'
-        )
-    }
+  types,
+  rpc: {
+    lastCollectionIdx: fn('Get the latest created collection id', [], 'u32'),
+    collectionById: fn('Get collection by id', [{name: 'id', type: 'u32'}], 'Option<RmrkTypesCollectionInfo>'),
+    nftById: fn(
+      'Get NFT by collection id and NFT id',
+      [
+        {name: 'collectionId', type: 'u32'},
+        {name: 'nftId', type: 'u32'},
+      ],
+      'Option<RmrkTypesNftInfo>',
+    ),
+    accountTokens: fn(
+      'Get tokens owned by an account in a collection',
+      [
+        {name: 'accountId', type: 'AccountId32'},
+        {name: 'collectionId', type: 'u32'},
+      ],
+      'Vec<u32>',
+    ),
+    nftChildren: fn(
+      'Get NFT children',
+      [
+        {name: 'collectionId', type: 'u32'},
+        {name: 'nftId', type: 'u32'},
+      ],
+      'Vec<RmrkTypesNftChild>',
+    ),
+    collectionProperties: fn(
+      'Get collection properties',
+      [{name: 'collectionId', type: 'u32'}],
+      'Vec<RmrkTypesPropertyInfo>',
+    ),
+    nftProperties: fn(
+      'Get NFT properties',
+      [
+        {name: 'collectionId', type: 'u32'},
+        {name: 'nftId', type: 'u32'},
+      ],
+      'Vec<RmrkTypesPropertyInfo>',
+    ),
+    nftResources: fn(
+      'Get NFT resources',
+      [
+        {name: 'collectionId', type: 'u32'},
+        {name: 'nftId', type: 'u32'},
+      ],
+      'Vec<RmrkTypesResourceInfo>',
+    ),
+    nftResourcePriorities: fn(
+      'Get NFT resource priorities',
+      [
+        {name: 'collectionId', type: 'u32'},
+        {name: 'nftId', type: 'u32'},
+      ],
+      'Vec<Bytes>',
+    ),
+    base: fn(
+      'Get base info',
+      [{name: 'baseId', type: 'u32'}],
+      'Option<RmrkTypesBaseInfo>',
+    ),
+    baseParts: fn(
+      'Get all Base\'s parts',
+      [{name: 'baseId', type: 'u32'}],
+      'Vec<RmrkTypesPartType>',
+    ),
+    themeNames: fn(
+      'Get Base\'s theme names',
+      [{name: 'baseId', type: 'u32'}],
+      'Vec<Bytes>',
+    ),
+    themes: fn(
+      'Get Theme\'s keys values',
+      [
+        {name: 'baseId', type: 'u32'},
+        {name: 'themeName', type: 'String'},
+        {name: 'keys', type: 'Option<Vec<String>>'},
+      ],
+      'Option<RmrkTypesTheme>',
+    ),
+  },
 };

--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -1135,7 +1135,32 @@
     const events = await submitTransactionAsync(sender, tx);
     const result = getCreateItemsResult(events);
 
-    for (let res of result) {
+    for (const res of result) {
+      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;
+    }
+  });
+}
+
+export async function createMultipleItemsWithPropsExpectFailure(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {
+  await usingApi(async (api) => {
+    const to = normalizeAccountId(owner);
+    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);
+
+    const events = await expect(await submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;
+    const result = getCreateItemsResult(events);
+
+    expect(result).to.be.equal(false);
+  });
+}
+
+export async function createMultipleItemsExWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any) {
+  await usingApi(async (api) => {
+    const tx = api.tx.unique.createMultipleItemsEx(collectionId, itemsData);
+
+    const events = await submitTransactionAsync(sender, tx);
+    const result = getCreateItemsResult(events);
+
+    for (const res of result) {
       expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;
     }
   });
@@ -1156,7 +1181,7 @@
       const createData = {refungible: {const_data: [], pieces: 100}};
       tx = api.tx.unique.createItem(collectionId, to, createData as any);
     } else {
-      const data = api.createType('UpDataStructsCreateItemData', { NFT: { constData: 'test', properties: props}});
+      const data = api.createType('UpDataStructsCreateItemData', {NFT: {constData: 'test', properties: props}});
       tx = api.tx.unique.createItem(collectionId, to, data as UpDataStructsCreateItemData);
     }
 
@@ -1186,6 +1211,25 @@
   return newItemId;
 }
 
+export async function createItemWithPropsExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, props: Array<Property>, owner: CrossAccountId | string = sender.address) {
+  await usingApi(async (api) => {
+
+    let tx;
+    if (createMode === 'NFT') {
+      const data = api.createType('UpDataStructsCreateItemData', {NFT: {constData: 'test', properties: props}});
+      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), data);
+    } else {
+      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);
+    }
+
+
+    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;
+    const result = getCreateItemResult(events);
+
+    expect(result.success).to.be.false;
+  });
+}
+
 export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {
   let newItemId = 0;
   await usingApi(async (api) => {