git.delta.rocks / unique-network / refs/commits / 96967bb10fde

difftreelog

Integration tests for setCollectionSponsor

Greg Zaitsev2020-12-23parent: #8686594.patch.diff
in: master

6 files changed

modifiednode/src/chain_spec.rsdiffbeforeafterboth
--- a/node/src/chain_spec.rs
+++ b/node/src/chain_spec.rs
@@ -193,7 +193,7 @@
 					offchain_schema: vec![],
 					schema_version: SchemaVersion::default(),
                     sponsor: get_account_id_from_seed::<sr25519::Public>("Alice"),
-                    unconfirmed_sponsor: get_account_id_from_seed::<sr25519::Public>("Alice"),
+                    sponsor_confirmed: true,
                     const_on_chain_schema: vec![],
 					variable_on_chain_schema: vec![],
 					limits: CollectionLimits::default()
modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
136    pub offchain_schema: Vec<u8>,136    pub offchain_schema: Vec<u8>,
137    pub schema_version: SchemaVersion,137    pub schema_version: SchemaVersion,
138    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender138    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender
139    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship139    pub sponsor_confirmed: bool, // False if sponsor address has not yet confirmed sponsorship. True otherwise.
140    pub limits: CollectionLimits, // Collection private restrictions 140    pub limits: CollectionLimits, // Collection private restrictions 
141    pub variable_on_chain_schema: Vec<u8>, //141    pub variable_on_chain_schema: Vec<u8>, //
142    pub const_on_chain_schema: Vec<u8>, //142    pub const_on_chain_schema: Vec<u8>, //
591                offchain_schema: Vec::new(),591                offchain_schema: Vec::new(),
592                schema_version: SchemaVersion::ImageURL,592                schema_version: SchemaVersion::ImageURL,
593                sponsor: T::AccountId::default(),593                sponsor: T::AccountId::default(),
594                unconfirmed_sponsor: T::AccountId::default(),594                sponsor_confirmed: false,
595                variable_on_chain_schema: Vec::new(),595                variable_on_chain_schema: Vec::new(),
596                const_on_chain_schema: Vec::new(),596                const_on_chain_schema: Vec::new(),
597                limits: CollectionLimits::default(),597                limits: CollectionLimits::default(),
869            let mut target_collection = <Collection<T>>::get(collection_id);869            let mut target_collection = <Collection<T>>::get(collection_id);
870            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);870            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);
871871
872            target_collection.unconfirmed_sponsor = new_sponsor;872            target_collection.sponsor = new_sponsor;
873            target_collection.sponsor_confirmed = false;
873            <Collection<T>>::insert(collection_id, target_collection);874            <Collection<T>>::insert(collection_id, target_collection);
874875
875            Ok(())876            Ok(())
889            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);890            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);
890891
891            let mut target_collection = <Collection<T>>::get(collection_id);892            let mut target_collection = <Collection<T>>::get(collection_id);
892            ensure!(sender == target_collection.unconfirmed_sponsor, Error::<T>::ConfirmUnsetSponsorFail);893            ensure!(sender == target_collection.sponsor, Error::<T>::ConfirmUnsetSponsorFail);
893894
894            target_collection.sponsor = target_collection.unconfirmed_sponsor;895            target_collection.sponsor_confirmed = true;
895            target_collection.unconfirmed_sponsor = T::AccountId::default();
896            <Collection<T>>::insert(collection_id, target_collection);896            <Collection<T>>::insert(collection_id, target_collection);
897897
898            Ok(())898            Ok(())
917            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);917            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);
918918
919            target_collection.sponsor = T::AccountId::default();919            target_collection.sponsor = T::AccountId::default();
920            target_collection.sponsor_confirmed = false;
920            <Collection<T>>::insert(collection_id, target_collection);921            <Collection<T>>::insert(collection_id, target_collection);
921922
922            Ok(())923            Ok(())
2338            Some(Call::create_item(collection_id, _owner, _properties)) => {2339            Some(Call::create_item(collection_id, _owner, _properties)) => {
23392340
2340                // check free create limit2341                // check free create limit
2341                if <Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)2342                if (<Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)) &&
2343                   (<Collection<T>>::get(collection_id).sponsor_confirmed)
2342                {2344                {
2343                    <Collection<T>>::get(collection_id).sponsor2345                    <Collection<T>>::get(collection_id).sponsor
2344                } else {2346                } else {
2347            }2349            }
2348            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {2350            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {
2349                2351                
2352                let mut sponsor_transfer = false;
2353                if <Collection<T>>::get(collection_id).sponsor_confirmed {
2350                let _collection_limits = <Collection<T>>::get(collection_id).limits;2354                    let _collection_limits = <Collection<T>>::get(collection_id).limits;
2351                let _collection_mode = <Collection<T>>::get(collection_id).mode;2355                    let _collection_mode = <Collection<T>>::get(collection_id).mode;
23522356    
2353                // sponsor timeout2357                    // sponsor timeout
2354                let sponsor_transfer = match _collection_mode {2358                    sponsor_transfer = match _collection_mode {
2355                    CollectionMode::NFT => {2359                        CollectionMode::NFT => {
23562360    
2357                        // get correct limit2361                            // get correct limit
2425                        false2429                            false
2426                    },2430                        },
2427                };2431                    };
2432                }
24282433
2429                if !sponsor_transfer {2434                if !sponsor_transfer {
2430                    T::AccountId::default()2435                    T::AccountId::default()
modifiedruntime_types.jsondiffbeforeafterboth
--- a/runtime_types.json
+++ b/runtime_types.json
@@ -70,7 +70,7 @@
       "OffchainSchema": "Vec<u8>",
       "SchemaVersion": "SchemaVersion",
       "Sponsor": "AccountId",
-      "UnconfirmedSponsor": "AccountId",
+      "SponsorConfirmed": "bool",
       "Limits": "CollectionLimits",
       "VariableOnChainSchema": "Vec<u8>",
       "ConstOnChainSchema": "Vec<u8>"
modifiedtests/src/destroyCollection.test.tsdiffbeforeafterboth
--- a/tests/src/destroyCollection.test.ts
+++ b/tests/src/destroyCollection.test.ts
@@ -1,55 +1,12 @@
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import { default as usingApi, submitTransactionAsync } from "./substrate/substrate-api";
-import { createCollectionExpectSuccess, createCollectionExpectFailure } from "./util/helpers";
+import { createCollectionExpectSuccess, createCollectionExpectFailure, destroyCollectionExpectSuccess, destroyCollectionExpectFailure } from "./util/helpers";
 import type { AccountId, EventRecord } from '@polkadot/types/interfaces';
 import privateKey from './substrate/privateKey';
-import { nullPublicKey } from './accounts'; 
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
-
-function getDestroyResult(events: EventRecord[]): boolean {
-  let success: boolean = false;
-  events.forEach(({ phase, event: { data, method, section } }) => {
-    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);
-    if (method == 'ExtrinsicSuccess') {
-      success = true;
-    }
-  });
-  return success;
-}
-
-async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {
-  await usingApi(async (api) => {
-    // Run the DestroyCollection transaction
-    const alicePrivateKey = privateKey(senderSeed);
-    const tx = api.tx.nft.destroyCollection(collectionId);
-    const events = await submitTransactionAsync(alicePrivateKey, tx);
-    const result = getDestroyResult(events);
-
-    // Get the collection 
-    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
-
-    // What to expect
-    expect(result).to.be.true;
-    expect(collection).to.be.not.null;
-    expect(collection.Owner).to.be.equal(nullPublicKey);
-  });
-}
-
-async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {
-  await usingApi(async (api) => {
-    // Run the DestroyCollection transaction
-    const alicePrivateKey = privateKey(senderSeed);
-    const tx = api.tx.nft.destroyCollection(collectionId);
-    const events = await submitTransactionAsync(alicePrivateKey, tx);
-    const result = getDestroyResult(events);
-
-    // What to expect
-    expect(result).to.be.false;
-  });
-}
 
 describe('integration test: ext. destroyCollection():', () => {
   it('NFT collection can be destroyed', async () => {
addedtests/src/setCollectionSponsor.test.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/setCollectionSponsor.test.ts
@@ -0,0 +1,78 @@
+//
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE', which is part of this source code package.
+//
+
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import { default as usingApi } from "./substrate/substrate-api";
+import { createCollectionExpectSuccess, setCollectionSponsorExpectSuccess, destroyCollectionExpectSuccess, setCollectionSponsorExpectFailure } from "./util/helpers";
+import { Keyring } from "@polkadot/api";
+import { IKeyringPair } from "@polkadot/types/types";
+import type { AccountId } from '@polkadot/types/interfaces';
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+let bob: IKeyringPair;
+
+describe('integration test: ext. setCollectionSponsor():', () => {
+
+  before(async () => {
+    await usingApi(async (api) => {
+      const keyring = new Keyring({ type: 'sr25519' });
+      bob = keyring.addFromUri(`//Bob`);
+    });
+  });
+
+  it('Set NFT collection sponsor', async () => {
+    const collectionId = await createCollectionExpectSuccess('A', 'B', 'C', 'NFT');
+    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+  });
+  it('Set Fungible collection sponsor', async () => {
+    const collectionId = await createCollectionExpectSuccess('A', 'B', 'C', 'Fungible');
+    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+  });
+  it('Set ReFungible collection sponsor', async () => {
+    const collectionId = await createCollectionExpectSuccess('A', 'B', 'C', 'ReFungible');
+    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+  });
+
+  it('Set the same sponsor repeatedly', async () => {
+    const collectionId = await createCollectionExpectSuccess('A', 'B', 'C', 'NFT');
+    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+  });
+  it('Replace collection sponsor', async () => {
+    const collectionId = await createCollectionExpectSuccess('A', 'B', 'C', 'NFT');
+
+    const keyring = new Keyring({ type: 'sr25519' });
+    const charlie = keyring.addFromUri(`//Charlie`);
+    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+    await setCollectionSponsorExpectSuccess(collectionId, charlie.address);
+  });
+});
+
+describe('(!negative test!) integration test: ext. setCollectionSponsor():', () => {
+  before(async () => {
+    await usingApi(async (api) => {
+      const keyring = new Keyring({ type: 'sr25519' });
+      bob = keyring.addFromUri(`//Bob`);
+    });
+  });
+
+  it('(!negative test!) Add sponsor to a collection that never existed', async () => {
+    // Find the collection that never existed
+    const collectionId = 0;
+    await usingApi(async (api) => {
+      const collectionId = parseInt((await api.query.nft.createdCollectionCount()).toString()) + 1;
+    });
+
+    await setCollectionSponsorExpectFailure(collectionId, bob.address);
+  });
+  it('(!negative test!) Add sponsor to a collection that was destroyed', async () => {
+    const collectionId = await createCollectionExpectSuccess('A', 'B', 'C', 'NFT');
+    await destroyCollectionExpectSuccess(collectionId);
+    await setCollectionSponsorExpectFailure(collectionId, bob.address);
+  });
+});
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -9,7 +9,7 @@
 import { ApiPromise, Keyring } from "@polkadot/api";
 import { default as usingApi, submitTransactionAsync } from "../substrate/substrate-api";
 import privateKey from '../substrate/privateKey';
-import { alicesPublicKey } from "../accounts";
+import { alicesPublicKey, nullPublicKey } from "../accounts";
 import { strToUTF16, utf16ToStr, hexToStr } from '../util/util';
 import { IKeyringPair } from "@polkadot/types/types";
 import { BigNumber } from 'bignumber.js';
@@ -121,4 +121,79 @@
     bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());
   } while (bal.toFixed() != '0');
   return unused; 
-}
\ No newline at end of file
+}
+
+function getDestroyResult(events: EventRecord[]): boolean {
+  let success: boolean = false;
+  events.forEach(({ phase, event: { data, method, section } }) => {
+    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);
+    if (method == 'ExtrinsicSuccess') {
+      success = true;
+    }
+  });
+  return success;
+}
+
+export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {
+  await usingApi(async (api) => {
+
+    // Run the transaction
+    const alicePrivateKey = privateKey('//Alice');
+    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);
+    const events = await submitTransactionAsync(alicePrivateKey, tx);
+    const result = getGenericResult(events);
+
+    // Get the collection 
+    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
+
+    // What to expect
+    expect(result.success).to.be.true;
+    expect(collection.Sponsor.toString()).to.be.equal(sponsor.toString());
+    expect(collection.SponsorConfirmed).to.be.false;
+  });
+}
+
+export async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {
+  await usingApi(async (api) => {
+    // Run the DestroyCollection transaction
+    const alicePrivateKey = privateKey(senderSeed);
+    const tx = api.tx.nft.destroyCollection(collectionId);
+    const events = await submitTransactionAsync(alicePrivateKey, tx);
+    const result = getDestroyResult(events);
+
+    // What to expect
+    expect(result).to.be.false;
+  });
+}
+
+export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {
+  await usingApi(async (api) => {
+    // Run the DestroyCollection transaction
+    const alicePrivateKey = privateKey(senderSeed);
+    const tx = api.tx.nft.destroyCollection(collectionId);
+    const events = await submitTransactionAsync(alicePrivateKey, tx);
+    const result = getDestroyResult(events);
+
+    // Get the collection 
+    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
+
+    // What to expect
+    expect(result).to.be.true;
+    expect(collection).to.be.not.null;
+    expect(collection.Owner).to.be.equal(nullPublicKey);
+  });
+}
+
+export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string) {
+  await usingApi(async (api) => {
+
+    // Run the transaction
+    const alicePrivateKey = privateKey('//Alice');
+    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);
+    const events = await submitTransactionAsync(alicePrivateKey, tx);
+    const result = getGenericResult(events);
+
+    // What to expect
+    expect(result.success).to.be.false;
+  });
+}