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

difftreelog

Merge pull request #60 from usetech-llc/feature/NFTPAR-241

Greg Zaitsev2021-02-03parents: #3f6d973 #b21f673.patch.diff
in: master
Feature/nftpar 241

4 files changed

modifiedtests/package.jsondiffbeforeafterboth
27 "testRemoveCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/removeCollectionAdmin.test.ts",27 "testRemoveCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/removeCollectionAdmin.test.ts",
28 "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",28 "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",
29 "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",29 "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
30 "testCreateMultipleItems": "mocha --timeout 9999999 -r ts-node/register ./**/createMultipleItems.test.ts",
30 "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts",31 "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts",
31 "testTransferFrom": "mocha --timeout 9999999 -r ts-node/register ./**/transferFrom.test.ts",32 "testTransferFrom": "mocha --timeout 9999999 -r ts-node/register ./**/transferFrom.test.ts",
32 "testCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",33 "testCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
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//
5
6import { assert } from 'chai';5import { ApiPromise } from '@polkadot/api';
6import BN from 'bn.js';
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 {
1112 createCollectionExpectSuccess,
13 destroyCollectionExpectSuccess,
14 IReFungibleTokenDataType,
15} from './util/helpers';
16
17chai.use(chaiAsPromised);
12const idCollection = 12;18const expect = chai.expect;
19
20interface ITokenDataType {
21 Owner: number[];
22 ConstData: number[];
23 VariableData: number[];
24}
25
26describe('Integration Test createMultipleItems(collection_id, owner, items_data):', () => {
27 it('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async () => {
28 await usingApi(async (api: ApiPromise) => {
29 const collectionId = await createCollectionExpectSuccess();
30 const itemsListIndexBefore = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
31 expect(itemsListIndexBefore.toNumber()).to.be.equal(0);
32 const Alice = privateKey('//Alice');
33 const args = [{ nft: ['0x31', '0x31'] }, { nft: ['0x32', '0x32'] }, { nft: ['0x33', '0x33'] }];
34 const createMultipleItemsTx = await api.tx.nft
35 .createMultipleItems(collectionId, Alice.address, args);
36 await submitTransactionAsync(Alice, createMultipleItemsTx);
37 const itemsListIndexAfter = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
38 expect(itemsListIndexAfter.toNumber()).to.be.equal(3);
39 const token1Data = await api.query.nft.nftItemList(collectionId, 1) as unknown as ITokenDataType;
40 const token2Data = await api.query.nft.nftItemList(collectionId, 2) as unknown as ITokenDataType;
41 const token3Data = await api.query.nft.nftItemList(collectionId, 3) as unknown as ITokenDataType;
42
43 expect(token1Data.Owner.toString()).to.be.equal(Alice.address);
44 expect(token2Data.Owner.toString()).to.be.equal(Alice.address);
45 expect(token3Data.Owner.toString()).to.be.equal(Alice.address);
46
47 expect(token1Data.ConstData.toString()).to.be.equal('0x31');
48 expect(token2Data.ConstData.toString()).to.be.equal('0x32');
49 expect(token3Data.ConstData.toString()).to.be.equal('0x33');
50
51 expect(token1Data.VariableData.toString()).to.be.equal('0x31');
52 expect(token2Data.VariableData.toString()).to.be.equal('0x32');
53 expect(token3Data.VariableData.toString()).to.be.equal('0x33');
54 });
55 });
56
57 it('Create 0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', async () => {
58 await usingApi(async (api: ApiPromise) => {
59 const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
60 const itemsListIndexBefore = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
61 expect(itemsListIndexBefore.toNumber()).to.be.equal(0);
62 const Alice = privateKey('//Alice');
63 const args = [
64 { Refungible: ['0x31', '0x31'] },
65 { Refungible: ['0x32', '0x32'] },
66 { Refungible: ['0x33', '0x33'] },
67 ];
68 const createMultipleItemsTx = await api.tx.nft
69 .createMultipleItems(collectionId, Alice.address, args);
70 await submitTransactionAsync(Alice, createMultipleItemsTx);
71 const itemsListIndexAfter = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
72 expect(itemsListIndexAfter.toNumber()).to.be.equal(3);
73 const token1Data = await api.query.nft.reFungibleItemList(collectionId, 1) as unknown as IReFungibleTokenDataType;
74 const token2Data = await api.query.nft.reFungibleItemList(collectionId, 2) as unknown as IReFungibleTokenDataType;
75 const token3Data = await api.query.nft.reFungibleItemList(collectionId, 3) as unknown as IReFungibleTokenDataType;
76
77 expect(token1Data.Owner[0].Owner.toString()).to.be.equal(Alice.address);
78 expect(token1Data.Owner[0].Fraction.toNumber()).to.be.equal(1);
79
80 expect(token2Data.Owner[0].Owner.toString()).to.be.equal(Alice.address);
81 expect(token2Data.Owner[0].Fraction.toNumber()).to.be.equal(1);
82
83 expect(token3Data.Owner[0].Owner.toString()).to.be.equal(Alice.address);
84 expect(token3Data.Owner[0].Fraction.toNumber()).to.be.equal(1);
85
86 expect(token1Data.ConstData.toString()).to.be.equal('0x31');
87 expect(token2Data.ConstData.toString()).to.be.equal('0x32');
88 expect(token3Data.ConstData.toString()).to.be.equal('0x33');
89
90 expect(token1Data.VariableData.toString()).to.be.equal('0x31');
91 expect(token2Data.VariableData.toString()).to.be.equal('0x32');
92 expect(token3Data.VariableData.toString()).to.be.equal('0x33');
93 });
94 });
95});
1396
14describe.skip('integration test: ext. createMultipleItems():', () => {97describe('Negative Integration Test createMultipleItems(collection_id, owner, items_data):', () => {
15 it('Create two NFT tokens in active NFT collection', async () => {98 it('Create token with not existing type', async () => {
16 await usingApi(async (api) => {99 await usingApi(async (api: ApiPromise) => {
17 const AitemListIndex = await api.query.nft.itemListIndex(idCollection);100 const collectionId = await createCollectionExpectSuccess();
18 console.log(`itemListIndex count (before): ${AitemListIndex}`);101 const Alice = privateKey('//Alice');
102 try {
19 const args = ['NFT', 'NFT'];103 const args = [{ invalid: null }, { invalid: null }, { invalid: null }];
20 const alicePrivateKey = privateKey('//Alice');
21 const createMultipleItems = await api.tx.nft104 const createMultipleItemsTx = await api.tx.nft
22 .createMultipleItems(idCollection, alicesPublicKey, args)105 .createMultipleItems(collectionId, Alice.address, args);
23 .signAndSend(alicePrivateKey);
24 // tslint:disable-next-line: no-unused-expression
25 assert.exists(createMultipleItems, 'createMultipleItems is neither `null` or `undefined`');
26 console.log(`Ext. createMultipleItems submitted with hash: ${createMultipleItems}`);
27 await waitNewBlocks(api);
28 const BitemListIndex = await api.query.nft.itemListIndex(idCollection);106 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
29 console.log(`itemListIndex count (after): ${BitemListIndex}`);
30 if (BitemListIndex === AitemListIndex) { assert.fail('Corret token not added in collection!'); }107 } catch (e) {
108 // tslint:disable-next-line:no-unused-expression
109 expect(e).to.be.exist;
110 }
31 });111 });
32 });112 });
113
33 it('(!negative test!) Create two Fungible tokens in active NFT collection', async () => {114 it('Create token in not existing collection', async () => {
34 await usingApi(async (api) => {115 await usingApi(async (api: ApiPromise) => {
35 const AitemListIndex = await api.query.nft.itemListIndex(idCollection);116 const collectionId = parseInt((await api.query.nft.createdCollectionCount()).toString()) + 1;
36 console.log(`itemListIndex count (before): ${AitemListIndex}`);
37 const args = ['Fungible', 'Fungible'];
38 const alicePrivateKey = privateKey('//Alice');117 const Alice = privateKey('//Alice');
39 const createMultipleItems = await api.tx.nft118 const createMultipleItemsTx = await api.tx.nft
40 .createMultipleItems(idCollection, alicesPublicKey, args)119 .createMultipleItems(collectionId, Alice.address, ['NFT', 'NFT', 'NFT']);
41 .signAndSend(alicePrivateKey);
42 // tslint:disable-next-line: no-unused-expression
43 assert.exists(createMultipleItems, 'createMultipleItems is neither `null` or `undefined`');
44 console.log(`Ext. createMultipleItems submitted with hash: ${createMultipleItems}`);
45 await waitNewBlocks(api);
46 const BitemListIndex = await api.query.nft.itemListIndex(idCollection);120 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
47 console.log(`itemListIndex count (after): ${BitemListIndex}`);
48 if (BitemListIndex > AitemListIndex) { assert.fail('Incorrect token added in collection!'); }
49 });121 });
50 });122 });
123
51 it('(!negative test!) Create two ReFungible tokens in active NFT collection', async () => {124 it('Create NFT and Re-fungible tokens that has reached the maximum data limit', async () => {
52 await usingApi(async (api) => {125 await usingApi(async (api: ApiPromise) => {
126 // NFT
53 const AitemListIndex = await api.query.nft.itemListIndex(idCollection);127 const collectionId = await createCollectionExpectSuccess();
54 console.log(`itemListIndex count (before): ${AitemListIndex}`);
55 const args = ['ReFungible', 'ReFungible'];128 const Alice = privateKey('//Alice');
56 const alicePrivateKey = privateKey('//Alice');129 const args = [
130 { nft: ['A'.repeat(2049), 'A'.repeat(2049)] },
131 { nft: ['B'.repeat(2049), 'B'.repeat(2049)] },
132 { nft: ['C'.repeat(2049), 'C'.repeat(2049)] },
133 ];
57 const createMultipleItems = await api.tx.nft134 const createMultipleItemsTx = await api.tx.nft
58 .createMultipleItems(idCollection, alicesPublicKey, args)135 .createMultipleItems(collectionId, Alice.address, args);
59 .signAndSend(alicePrivateKey);
60 // tslint:disable-next-line: no-unused-expression
61 assert.exists(createMultipleItems, 'createMultipleItems is neither `null` or `undefined`');136 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
137
138 // ReFungible
139 const collectionIdReFungible =
62 console.log(`Ext. createMultipleItems submitted with hash: ${createMultipleItems}`);140 await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
141 const argsReFungible = [
63 await waitNewBlocks(api);142 { ReFungible: ['1'.repeat(2049), '1'.repeat(2049)] },
143 { ReFungible: ['2'.repeat(2049), '2'.repeat(2049)] },
144 { ReFungible: ['3'.repeat(2049), '3'.repeat(2049)] },
145 ];
64 const BitemListIndex = await api.query.nft.itemListIndex(idCollection);146 const createMultipleItemsTxFungible = await api.tx.nft
65 console.log(`itemListIndex count (after): ${BitemListIndex}`);147 .createMultipleItems(collectionIdReFungible, Alice.address, argsReFungible);
66 if (BitemListIndex > AitemListIndex) { assert.fail('Incorrect token added in collection!'); }148 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTxFungible)).to.be.rejected;
67 });149 });
68 });150 });
151
152 it('Create tokens with different types', async () => {
153 await usingApi(async (api: ApiPromise) => {
154 const collectionId = await createCollectionExpectSuccess();
155 const Alice = privateKey('//Alice');
156 const createMultipleItemsTx = await api.tx.nft
157 .createMultipleItems(collectionId, Alice.address, ['NFT', 'Fungible', 'ReFungible']);
158 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
159 // garbage collection :-D
160 await destroyCollectionExpectSuccess(collectionId);
161 });
162 });
163
164 it('Create tokens with different data limits <> maximum data limit', async () => {
165 await usingApi(async (api: ApiPromise) => {
166 const collectionId = await createCollectionExpectSuccess();
167 const Alice = privateKey('//Alice');
168 const args = [
169 { nft: ['A', 'A'] },
170 { nft: ['B', 'B'.repeat(2049)] },
171 { nft: ['C'.repeat(2049), 'C'] },
172 ];
173 const createMultipleItemsTx = await api.tx.nft
174 .createMultipleItems(collectionId, Alice.address, args);
175 await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
176 });
177 });
69});178});
70179
modifiedtests/src/substrate/substrate-api.tsdiffbeforeafterboth
123123
124 // console.log('transactionStatus', transactionStatus, 'events', events);124 // console.log('transactionStatus', transactionStatus, 'events', events);
125125
126 if (transactionStatus == TransactionStatus.Success) {126 if (transactionStatus === TransactionStatus.Success) {
127 resolve(events);127 resolve(events);
128 } else if (transactionStatus == TransactionStatus.Fail) {128 } else if (transactionStatus === TransactionStatus.Fail) {
129 reject(events);129 reject(events);
130 }130 }
131 });131 });
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
51 Value: BN;51 Value: BN;
52}52}
5353
54interface IReFungibleTokenDataType {54export interface IReFungibleTokenDataType {
55 Owner: IReFungibleOwner[];55 Owner: IReFungibleOwner[];
56 ConstData: number[];56 ConstData: number[];
57 VariableData: number[];57 VariableData: number[];