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

difftreelog

set limits test scenarios

kpozdnikin2020-12-31parent: #49640f3.patch.diff
in: master

5 files changed

modifiedtests/package.jsondiffbeforeafterboth
--- a/tests/package.json
+++ b/tests/package.json
@@ -19,6 +19,7 @@
     "test": "mocha --timeout 9999999 -r ts-node/register ./**/*.test.ts",
     "load": "mocha --timeout 9999999 -r ts-node/register ./**/*.load.ts",
     "testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts",
+    "testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts",
     "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",
     "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts"
   },
addedtests/src/setCollectionLimits.test.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/setCollectionLimits.test.ts
@@ -0,0 +1,145 @@
+// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits
+import { ApiPromise, Keyring } from '@polkadot/api';
+import { IKeyringPair } from '@polkadot/types/types';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import usingApi, { submitTransactionAsync } from './substrate/substrate-api';
+import { ICollectionInterface } from './types';
+import {
+  createCollectionExpectSuccess, getCreatedCollectionCount,
+  getCreateItemResult,
+  getDetailedCollectionInfo,
+} from './util/helpers';
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+let alice: IKeyringPair;
+let bob: IKeyringPair;
+let collectionIdForTesting: number;
+
+const accountTokenOwnershipLimit = 0;
+const sponsoredDataSize = 0;
+const sponsoredMintSize = 0;
+const tokenLimit = 0;
+
+describe('hooks', () => {
+  before(async () => {
+    await usingApi(async () => {
+      const keyring = new Keyring({ type: 'sr25519' });
+      alice = keyring.addFromUri('//Alice');
+    });
+  });
+  it('choose or create collection for testing', async () => {
+    await usingApi(async () => {
+      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: 'NFT'});
+      console.log('collectionIdForTesting', collectionIdForTesting);
+    });
+  });
+});
+
+describe('setCollectionLimits positive', () => {
+  let tx;
+  before(async () => {
+    await usingApi(async () => {
+      const keyring = new Keyring({ type: 'sr25519' });
+      alice = keyring.addFromUri('//Alice');
+    });
+  });
+  it('execute setCollectionLimits with predefined params ', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      tx = api.tx.nft.setCollectionLimits(
+        collectionIdForTesting,
+        {
+          accountTokenOwnershipLimit,
+          sponsoredDataSize,
+          sponsoredMintSize,
+          tokenLimit,
+        },
+      );
+      const events = await submitTransactionAsync(alice, tx);
+      const result = getCreateItemResult(events);
+      // tslint:disable-next-line:no-unused-expression
+      expect(result.success).to.be.true;
+    });
+  });
+  it('get collection limits defined in previous test', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const collectionInfo = await getDetailedCollectionInfo(api, collectionIdForTesting) as ICollectionInterface;
+      expect(collectionInfo.Limits.AccountTokenOwnershipLimit.toNumber()).to.be.equal(accountTokenOwnershipLimit);
+      expect(collectionInfo.Limits.SponsoredMintSize.toNumber()).to.be.equal(sponsoredMintSize);
+      expect(collectionInfo.Limits.TokenLimit.toNumber()).to.be.equal(tokenLimit);
+      expect(collectionInfo.Limits.SponsorTimeout.toNumber()).to.be.equal(sponsoredDataSize);
+    });
+  });
+});
+
+describe('setCollectionLimits negative', () => {
+  let tx;
+  before(async () => {
+    await usingApi(async () => {
+      const keyring = new Keyring({ type: 'sr25519' });
+      alice = keyring.addFromUri('//Alice');
+      bob = keyring.addFromUri('//Bob');
+    });
+  });
+  it('execute setCollectionLimits for not exists collection', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const collectionCount = await getCreatedCollectionCount(api);
+      const nonExistedCollectionId = collectionCount + 1;
+      tx = api.tx.nft.setCollectionLimits(
+        nonExistedCollectionId,
+        {
+          accountTokenOwnershipLimit,
+          sponsoredDataSize,
+          sponsoredMintSize,
+          tokenLimit,
+        },
+      );
+      try {
+        await submitTransactionAsync(alice, tx);
+      } catch (e) {
+        // tslint:disable-next-line:no-unused-expression
+        expect(e).to.be.exist;
+      }
+    });
+  });
+  it('execute setCollectionLimits from user who is not owner of this collection', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      tx = api.tx.nft.setCollectionLimits(
+        collectionIdForTesting,
+        {
+          accountTokenOwnershipLimit,
+          sponsoredDataSize,
+          sponsoredMintSize,
+          tokenLimit,
+        },
+      );
+      try {
+        await submitTransactionAsync(bob, tx);
+      } catch (e) {
+        // tslint:disable-next-line:no-unused-expression
+        expect(e).to.be.exist;
+      }
+    });
+  });
+  it('execute setCollectionLimits with incorrect limits', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      tx = api.tx.nft.setCollectionLimits(
+        collectionIdForTesting,
+        {
+          accountTokenOwnershipLimit: 'awdawd',
+          sponsorTransferTimeout: 'awd',
+          sponsoredDataSize: '12312312312312312',
+          tokenLimit: '-100',
+        },
+      );
+      try {
+        await submitTransactionAsync(alice, tx);
+      } catch (e) {
+        // tslint:disable-next-line:no-unused-expression
+        expect(e).to.be.exist;
+      }
+    });
+  });
+});
modifiedtests/src/setSchemaVersion.test.tsdiffbeforeafterboth
1// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits1// https://unique-network.readthedocs.io/en/latest/jsapi.html#setschemaversion
2import { ApiPromise, Keyring } from '@polkadot/api';2import { ApiPromise, Keyring } from '@polkadot/api';
3import { IKeyringPair } from '@polkadot/types/types';3import { IKeyringPair } from '@polkadot/types/types';
4import BN from 'bn.js';4import BN from 'bn.js';
9import { createCollectionExpectSuccess, destroyCollectionExpectSuccess, getCreateItemResult } from './util/helpers';9import {
10  createCollectionExpectSuccess,
11  destroyCollectionExpectSuccess,
12  getCreatedCollectionCount,
13  getCreateItemResult,
14  getDetailedCollectionInfo,
15} from './util/helpers';
1016
11chai.use(chaiAsPromised);17chai.use(chaiAsPromised);
203. Use this id for setSchemaVersion.263. Use this id for setSchemaVersion.
21*/27*/
22
23const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)
24  : Promise<ICollectionInterface | null> => {
25  return await api.query.nft.collection(collectionId) as unknown as ICollectionInterface;
26};
27
28const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {
29  // set global object - collectionsCount
30  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();
31};
3228
33describe('hooks', () => {29describe('hooks', () => {
34  before(async () => {30  before(async () => {
57      tx = api.tx.nft.setSchemaVersion(collectionIdForTesting, 'Unique');53      tx = api.tx.nft.setSchemaVersion(collectionIdForTesting, 'Unique');
58      const events = await submitTransactionAsync(alice, tx);54      const events = await submitTransactionAsync(alice, tx);
59      const result = getCreateItemResult(events);55      const result = getCreateItemResult(events);
60      const collectionInfo = await getDetailedCollectionInfo(api, collectionIdForTesting);56      const collectionInfo = await getDetailedCollectionInfo(api, collectionIdForTesting) as ICollectionInterface;
61      // tslint:disable-next-line:no-unused-expression57      // tslint:disable-next-line:no-unused-expression
62      expect(result.success).to.be.true;58      expect(result.success).to.be.true;
63      // tslint:disable-next-line:no-unused-expression59      // tslint:disable-next-line:no-unused-expression
72      tx = api.tx.nft.setSchemaVersion(collectionIdForTesting, 'ImageURL');68      tx = api.tx.nft.setSchemaVersion(collectionIdForTesting, 'ImageURL');
73      const events = await submitTransactionAsync(alice, tx);69      const events = await submitTransactionAsync(alice, tx);
74      const result = getCreateItemResult(events);70      const result = getCreateItemResult(events);
75      const collectionInfo = await getDetailedCollectionInfo(api, collectionIdForTesting);71      const collectionInfo = await getDetailedCollectionInfo(api, collectionIdForTesting) as ICollectionInterface;
76      // tslint:disable-next-line:no-unused-expression72      // tslint:disable-next-line:no-unused-expression
77      expect(result.success).to.be.true;73      expect(result.success).to.be.true;
78      // tslint:disable-next-line:no-unused-expression74      // tslint:disable-next-line:no-unused-expression
modifiedtests/src/types.tsdiffbeforeafterboth
--- a/tests/src/types.ts
+++ b/tests/src/types.ts
@@ -7,14 +7,20 @@
   // constOnChainSchema
   Description: [BN, BN]; // utf16
   isReFungible: boolean;
+  Limits: {
+    AccountTokenOwnershipLimit: BN;
+    SponsoredMintSize: BN;
+    TokenLimit: BN;
+    SponsorTimeout: BN;
+  };
   MintMode: boolean;
   Mode: {
     Nft: null;
   };
   Name: [BN, BN]; // utf16
   OffchainSchema: [Uint8Array];
+  Owner: [Uint8Array];
   SchemaVersion: string;
-  Owner: [Uint8Array];
   // prefix
   // sponsor
   // tokenPrefix
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -10,11 +10,13 @@
 import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from "../substrate/substrate-api";
 import privateKey from '../substrate/privateKey';
 import { alicesPublicKey, nullPublicKey } from "../accounts";
-import { strToUTF16, utf16ToStr, hexToStr } from '../util/util';
-import { IKeyringPair } from "@polkadot/types/types";
+import { strToUTF16, utf16ToStr, hexToStr } from './util';
+import { IKeyringPair } from '@polkadot/types/types';
 import { BigNumber } from 'bignumber.js';
 import { Struct, Enum } from '@polkadot/types/codec';
 import { u128 } from '@polkadot/types/primitive';
+import { ICollectionInterface } from '../types';
+import BN from "bn.js";
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
@@ -399,3 +401,12 @@
   });
 }
 
+export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)
+  : Promise<ICollectionInterface | null> => {
+  return await api.query.nft.collection(collectionId) as unknown as ICollectionInterface;
+};
+
+export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {
+  // set global object - collectionsCount
+  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();
+};