git.delta.rocks / unique-network / refs/commits / f4eeb2e40d64

difftreelog

createMultipleItems test

kpozdnikin2021-01-13parent: #2c99b94.patch.diff
in: master

3 files changed

modifiedtests/package-lock.jsondiffbeforeafterboth
4824 "integrity": "sha512-1HcDas8SEj4z1Wc696tH56G8OlRaH/sqZOynNNB+HF0WOeXPaxTtbYzJY2oEfiUxjSKjhCKr+MvR7dCHcEelug==",4824 "integrity": "sha512-1HcDas8SEj4z1Wc696tH56G8OlRaH/sqZOynNNB+HF0WOeXPaxTtbYzJY2oEfiUxjSKjhCKr+MvR7dCHcEelug==",
4825 "dev": true4825 "dev": true
4826 },4826 },
4827 "@types/sprintf-js": {
4828 "version": "1.1.2",
4829 "resolved": "https://registry.npmjs.org/@types/sprintf-js/-/sprintf-js-1.1.2.tgz",
4830 "integrity": "sha512-hkgzYF+qnIl8uTO8rmUSVSfQ8BIfMXC4yJAF4n8BE758YsKBZvFC4NumnAegj7KmylP0liEZNpb9RRGFMbFejA=="
4831 },
4827 "@types/stack-utils": {4832 "@types/stack-utils": {
4828 "version": "1.0.1",4833 "version": "1.0.1",
4829 "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-1.0.1.tgz",4834 "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-1.0.1.tgz",
5867 "dev": true,5872 "dev": true,
5868 "requires": {5873 "requires": {
5869 "sprintf-js": "~1.0.2"5874 "sprintf-js": "~1.0.2"
5870 }5875 },
5876 "dependencies": {
5877 "sprintf-js": {
5878 "version": "1.0.3",
5879 "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
5880 "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=",
5881 "dev": true
5882 }
5883 }
5871 },5884 },
5872 "arr-diff": {5885 "arr-diff": {
5873 "version": "4.0.0",5886 "version": "4.0.0",
20684 }20697 }
20685 },20698 },
20686 "sprintf-js": {20699 "sprintf-js": {
20687 "version": "1.0.3",20700 "version": "1.1.2",
20688 "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",20701 "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.2.tgz",
20689 "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=",20702 "integrity": "sha512-VE0SOVEHCk7Qc8ulkWw3ntAzXuqf7S2lvwQaDLRnUeIEaKNQJzV6BwmLKhOqT61aGhfUMrXeaBk+oDGCzvhcug=="
20690 "dev": true
20691 },20703 },
20692 "sshpk": {20704 "sshpk": {
20693 "version": "1.16.1",20705 "version": "1.16.1",
modifiedtests/package.jsondiffbeforeafterboth
21 "testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts",21 "testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts",
22 "testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts",22 "testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts",
23 "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",23 "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",
24 "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts"24 "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
25 "testCreateMultipleItems": "mocha --timeout 9999999 -r ts-node/register ./**/createMultipleItems.test.ts"
25 },26 },
26 "author": "",27 "author": "",
27 "license": "Apache 2.0",28 "license": "Apache 2.0",
modifiedtests/src/createMultipleItems.test.tsdiffbeforeafterboth
3// file 'LICENSE', which is part of this source code package.3// file 'LICENSE', which is part of this source code package.
4//4//
5import { ApiPromise } from '@polkadot/api';5import { ApiPromise } from '@polkadot/api';
6import BN from 'bn.js';
6import { assert } from 'chai';7import chai from 'chai';
7import { alicesPublicKey } from './accounts';8import chaiAsPromised from 'chai-as-promised';
8import privateKey from './substrate/privateKey';9import privateKey from './substrate/privateKey';
9import usingApi from './substrate/substrate-api';10import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
10import waitNewBlocks from './substrate/wait-new-blocks';11import {createCollectionExpectSuccess, destroyCollectionExpectSuccess} from './util/helpers';
1112
13chai.use(chaiAsPromised);
12const idCollection = 12;14const expect = chai.expect;
1315
14describe('Integration Test createMultipleItems(collection_id, owner, items_data):', () => {16interface ITokenDataType {
15 it('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async () => {
16 await usingApi(async (api: ApiPromise) => {17 Owner: number[];
1718 ConstData: number[];
18 });19 VariableData: number[];
19 });
20});20}
2121
22describe('Negative Integration Test createMultipleItems(collection_id, owner, items_data):', () => {22describe('Integration Test createMultipleItems(collection_id, owner, items_data):', () => {
23 it('Create token with not existing type', async () => {23 it('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async () => {
24 await usingApi(async (api: ApiPromise) => {24 await usingApi(async (api: ApiPromise) => {
25
26 });
27 });25 const collectionId = await createCollectionExpectSuccess();
28
29 it('Create token in not existing collection', async () => {
30 await usingApi(async (api: ApiPromise) => {
31
32 });
33 });26 const itemsListIndexBefore = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
34
35 it('Create token that has reached the maximum data limit', async () => {27 expect(itemsListIndexBefore.toNumber()).to.be.equal(0);
36 await usingApi(async (api: ApiPromise) => {28 const Alice = privateKey('//Alice');
3729 const args = [{ nft: ['0x31', '0x31'] }, { nft: ['0x32', '0x32'] }, { nft: ['0x33', '0x33'] }];
38 });30 const createMultipleItemsTx = await api.tx.nft
39 });
40
41 it('Create tokens with different types', async () => {
42 await usingApi(async (api: ApiPromise) => {
43
44 });
45 });31 .createMultipleItems(collectionId, Alice.address, args);
4632 await submitTransactionAsync(Alice, createMultipleItemsTx);
47 it('Create tokens in not existing collection', async () => {33 const itemsListIndexAfter = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
34 expect(itemsListIndexAfter.toNumber()).to.be.equal(3);
35 const token1Data = await api.query.nft.nftItemList(collectionId, 1) as unknown as ITokenDataType;
36 const token2Data = await api.query.nft.nftItemList(collectionId, 2) as unknown as ITokenDataType;
37 const token3Data = await api.query.nft.nftItemList(collectionId, 3) as unknown as ITokenDataType;
38
48 await usingApi(async (api: ApiPromise) => {39 expect(token1Data.Owner.toString()).to.be.equal(Alice.address);
49
50 });
51 });
52
53 it('Create tokens with different data limits <> maximum data limit', async () => {
54 await usingApi(async (api: ApiPromise) => {40 expect(token2Data.Owner.toString()).to.be.equal(Alice.address);
5541 expect(token3Data.Owner.toString()).to.be.equal(Alice.address);
56 });42
57 });43 expect(token1Data.ConstData.toString()).to.be.equal('0x31');
44 expect(token2Data.ConstData.toString()).to.be.equal('0x32');
45 expect(token3Data.ConstData.toString()).to.be.equal('0x33');
46
47 expect(token1Data.VariableData.toString()).to.be.equal('0x31');
48 expect(token2Data.VariableData.toString()).to.be.equal('0x32');
49 expect(token3Data.VariableData.toString()).to.be.equal('0x33');
50
51 // garbage collection :-D
52 await destroyCollectionExpectSuccess(collectionId);
53 });
54 });
58});55});
5956
60describe.skip('integration test: ext. createMultipleItems():', () => {57describe('Negative Integration Test createMultipleItems(collection_id, owner, items_data):', () => {
58 it('Create token with not existing type', async () => {
59 await usingApi(async (api: ApiPromise) => {
60 const collectionId = await createCollectionExpectSuccess();
61 const Alice = privateKey('//Alice');
62 try {
63 const createMultipleItemsTx = await api.tx.nft
64 .createMultipleItems(collectionId, Alice.address, ['UNKNOWN', 'UNKNOWN', 'UNKNOWN']);
65 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
66 } catch (e) {
67 // tslint:disable-next-line:no-unused-expression
68 expect(e).to.be.exist;
69 }
70 // garbage collection :-D
71 await destroyCollectionExpectSuccess(collectionId);
72 });
73 });
74
61 it('Create two NFT tokens in active NFT collection', async () => {75 it('Create token in not existing collection', async () => {
62 await usingApi(async (api) => {76 await usingApi(async (api: ApiPromise) => {
63 const AitemListIndex = await api.query.nft.itemListIndex(idCollection);77 const collectionId = await createCollectionExpectSuccess();
64 console.log(`itemListIndex count (before): ${AitemListIndex}`);
65 const args = ['NFT', 'NFT'];
66 const alicePrivateKey = privateKey('//Alice');78 const Alice = privateKey('//Alice');
67 const createMultipleItems = await api.tx.nft79 const createMultipleItemsTx = await api.tx.nft
68 .createMultipleItems(idCollection, alicesPublicKey, args)80 .createMultipleItems(collectionId + 1, Alice.address, ['NFT', 'NFT', 'NFT']);
69 .signAndSend(alicePrivateKey);
70 // tslint:disable-next-line: no-unused-expression
71 assert.exists(createMultipleItems, 'createMultipleItems is neither `null` or `undefined`');
72 console.log(`Ext. createMultipleItems submitted with hash: ${createMultipleItems}`);
73 await waitNewBlocks(api);
74 const BitemListIndex = await api.query.nft.itemListIndex(idCollection);81 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
75 console.log(`itemListIndex count (after): ${BitemListIndex}`);82 // garbage collection :-D
76 if (BitemListIndex === AitemListIndex) { assert.fail('Corret token not added in collection!'); }83 await destroyCollectionExpectSuccess(collectionId);
77 });84 });
78 });85 });
86
79 it('(!negative test!) Create two Fungible tokens in active NFT collection', async () => {87 it('Create NFT and Re-fungible tokens that has reached the maximum data limit', async () => {
80 await usingApi(async (api) => {88 await usingApi(async (api: ApiPromise) => {
89 // NFT
81 const AitemListIndex = await api.query.nft.itemListIndex(idCollection);90 const collectionId = await createCollectionExpectSuccess();
82 console.log(`itemListIndex count (before): ${AitemListIndex}`);
83 const args = ['Fungible', 'Fungible'];91 const Alice = privateKey('//Alice');
84 const alicePrivateKey = privateKey('//Alice');92 const args = [
93 { nft: ['A'.repeat(2049), 'A'.repeat(2049)] },
94 { nft: ['B'.repeat(2049), 'B'.repeat(2049)] },
95 { nft: ['C'.repeat(2049), 'C'.repeat(2049)] },
96 ];
85 const createMultipleItems = await api.tx.nft97 const createMultipleItemsTx = await api.tx.nft
86 .createMultipleItems(idCollection, alicesPublicKey, args)98 .createMultipleItems(collectionId, Alice.address, args);
87 .signAndSend(alicePrivateKey);
88 // tslint:disable-next-line: no-unused-expression
89 assert.exists(createMultipleItems, 'createMultipleItems is neither `null` or `undefined`');99 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
100 // garbage collection :-D
90 console.log(`Ext. createMultipleItems submitted with hash: ${createMultipleItems}`);101 await destroyCollectionExpectSuccess(collectionId);
102
103 // Fungible
91 await waitNewBlocks(api);104 const collectionIdFungible = await createCollectionExpectSuccess();
105 const argsFungible = [
106 { fungible: parseInt('1'.repeat(2049), 10) },
107 { fungible: parseInt('2'.repeat(2049), 10) },
108 { fungible: parseInt('3'.repeat(2049), 10) },
109 ];
92 const BitemListIndex = await api.query.nft.itemListIndex(idCollection);110 const createMultipleItemsTxFungible = await api.tx.nft
111 .createMultipleItems(collectionIdFungible, Alice.address, argsFungible);
93 console.log(`itemListIndex count (after): ${BitemListIndex}`);112 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTxFungible)).to.be.rejected;
113 // garbage collection :-D
94 if (BitemListIndex > AitemListIndex) { assert.fail('Incorrect token added in collection!'); }114 await destroyCollectionExpectSuccess(collectionId);
95 });115 });
96 });116 });
117
118 it('Create tokens with different types', async () => {
119 await usingApi(async (api: ApiPromise) => {
120 const collectionId = await createCollectionExpectSuccess();
121 const Alice = privateKey('//Alice');
122 const createMultipleItemsTx = await api.tx.nft
123 .createMultipleItems(collectionId, Alice.address, ['NFT', 'Fungible', 'ReFungible']);
124 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
125 // garbage collection :-D
126 await destroyCollectionExpectSuccess(collectionId);
127 });
128 });
129
97 it('(!negative test!) Create two ReFungible tokens in active NFT collection', async () => {130 it('Create tokens with different data limits <> maximum data limit', async () => {
98 await usingApi(async (api) => {131 await usingApi(async (api: ApiPromise) => {
99 const AitemListIndex = await api.query.nft.itemListIndex(idCollection);132 const collectionId = await createCollectionExpectSuccess();
100 console.log(`itemListIndex count (before): ${AitemListIndex}`);
101 const args = ['ReFungible', 'ReFungible'];133 const Alice = privateKey('//Alice');
102 const alicePrivateKey = privateKey('//Alice');134 const args = [
135 { nft: ['A', 'A'] },
136 { nft: ['B', 'B'.repeat(2049)] },
137 { nft: ['C'.repeat(2049), 'C'] },
138 ];
103 const createMultipleItems = await api.tx.nft139 const createMultipleItemsTx = await api.tx.nft
104 .createMultipleItems(idCollection, alicesPublicKey, args)140 .createMultipleItems(collectionId, Alice.address, args);
105 .signAndSend(alicePrivateKey);
106 // tslint:disable-next-line: no-unused-expression
107 assert.exists(createMultipleItems, 'createMultipleItems is neither `null` or `undefined`');
108 console.log(`Ext. createMultipleItems submitted with hash: ${createMultipleItems}`);
109 await waitNewBlocks(api);
110 const BitemListIndex = await api.query.nft.itemListIndex(idCollection);141 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
111 console.log(`itemListIndex count (after): ${BitemListIndex}`);142 // garbage collection :-D
112 if (BitemListIndex > AitemListIndex) { assert.fail('Incorrect token added in collection!'); }143 await destroyCollectionExpectSuccess(collectionId);
113 });144 });
114 });145 });
115});146});