Adds should not create fedederation tests

Author: jeremy-then

lib/tests/change-federation.js

@@ -92,6 +92,10 @@ const execute = (description, newFederationConfig) => {
     const notAuthorized3PrivateKey = '8a7d07ad23a412558259e3857214d7b521589d0b37509839d7591e6f4026b4df';
 
     const EXPECTED_UNSUCCESSFUL_RESULT = '-10';
+    const PENDING_FEDERATION_ALREADY_EXISTS_ERROR_CODE = '-1';
+    const PROPOSED_FEDERATION_ALREADY_EXISTS_ERROR_CODE = '-4';
+    const EXISTING_FEDERATION_AWAITING_ACTIVATION_ERROR_CODE = '-2';
+    const RETIRING_FEDERATION_ALREADY_EXISTS = '-3';
 
     let fedChangeAuthorizer1Address;
     let fedChangeAuthorizer2Address;
@@ -232,6 +236,29 @@ const execute = (description, newFederationConfig) => {
             await addFederatorsPublicKeys();
         });
 
+        it('should not create a new pending federation when there is one already created', async () => {
+
+            const initialPendingFederationHash = await bridge.methods.getPendingFederationHash().call();
+
+            const createFederationMethod = await bridge.methods.createFederation();
+
+            const message = 'The `createFederation` method should not be callable when there is a pending federation.';
+
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer1Address, result => {
+                expect(result).to.be.equal(PENDING_FEDERATION_ALREADY_EXISTS_ERROR_CODE, message);
+            });
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer2Address, result => {
+                expect(result).to.be.equal(PENDING_FEDERATION_ALREADY_EXISTS_ERROR_CODE, message);
+            });
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer3Address, result => {
+                expect(result).to.be.equal(PENDING_FEDERATION_ALREADY_EXISTS_ERROR_CODE, message);
+            });
+
+            const finalPendingFederationHash = await bridge.methods.getPendingFederationHash().call();
+            expect(initialPendingFederationHash).to.be.equal(finalPendingFederationHash, 'The pending federation hash should not change when calling `createFederation` if there is a pending federation already.');
+
+        });
+
         it('should not be able to call `addFederatorPublicKeyMultikey` without authorization', async () => {
 
             const initialPendingFederationHash = await bridge.methods.getPendingFederationHash().call();
@@ -384,6 +411,30 @@ const execute = (description, newFederationConfig) => {
             expect(proposedFederationPublicKeys).to.be.deep.equal(newFederationPublicKeys, 'The proposed federation public keys should be the expected ones.');
 
         });
+
+        it('should not create a new pending federation when there is a proposed federation', async () => {
+
+            const initialPendingFederationHash = await bridge.methods.getPendingFederationHash().call();
+            expect(initialPendingFederationHash, 'The pending federation hash should be null.').to.be.null;
+
+            const createFederationMethod = await bridge.methods.createFederation();
+
+            const message = 'The `createFederation` method should not be callable when there is a proposed federation.';
+
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer1Address, result => {
+                expect(result).to.be.equal(PROPOSED_FEDERATION_ALREADY_EXISTS_ERROR_CODE, message);
+            });
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer2Address, result => {
+                expect(result).to.be.equal(PROPOSED_FEDERATION_ALREADY_EXISTS_ERROR_CODE, message);
+            });
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer3Address, result => {
+                expect(result).to.be.equal(PROPOSED_FEDERATION_ALREADY_EXISTS_ERROR_CODE, message);
+            });
+
+            const finalPendingFederationHash = await bridge.methods.getPendingFederationHash().call();
+            expect(finalPendingFederationHash, 'The pending federation hash should be null.').to.be.null;
+            
+        });
 
         it('should not have created svp fund transaction and there should not be any SVP values in storage yet', async function () {
 
@@ -416,7 +467,7 @@ const execute = (description, newFederationConfig) => {
 
             const pegoutCreationBlockNumber = Number(svpFundTxWaitingForConfirmations.pegoutCreationBlockNumber);
 
-            const expectedPegoutCreationBlockNumber = commitFederationCreationBlockNumber + 1;
+            const expectedPegoutCreationBlockNumber = commitFederationCreationBlockNumber + 4; // + 4 because a previous test mines 3 blocks, plus 1 for the expected pegout creation block number to be the next block.
             expect(pegoutCreationBlockNumber).to.be.equal(expectedPegoutCreationBlockNumber, 'The svp fund tx pegout creation block number should be the block that contains the first updateCollections call right after the commitFederation call.');
 
             const rawSvpFundTransaction = svpFundTxWaitingForConfirmations.btcRawTx;
@@ -498,7 +549,7 @@ const execute = (description, newFederationConfig) => {
 
         it('should register the SVP Spend transaction and finish the SVP process', async function () {
 
-            const blockNumberBeforeUpdateCollections = await rskTxHelper.getBlockNumber();
+            const blockNumberBeforeUpdateCollections = await rskTxHelper.getBlockNumber() - 3;
             const expectedCountOfSignatures = Math.floor(newFederationPublicKeys.length / 2) + 1;
 
             await waitForExpectedCountOfAddSignatureEventsToBeEmitted(rskTxHelpers, blockNumberBeforeUpdateCollections, expectedCountOfSignatures);
@@ -537,6 +588,30 @@ const execute = (description, newFederationConfig) => {
 
         });
 
+        it('should not create a new pending federation when there is a federation waiting for activation', async () => {
+
+            const initialPendingFederationHash = await bridge.methods.getPendingFederationHash().call();
+            expect(initialPendingFederationHash, 'The pending federation hash should be null.').to.be.null;
+
+            const createFederationMethod = await bridge.methods.createFederation();
+
+            const message = 'The `createFederation` method should not be callable when there is a federation waiting for activation.';
+
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer1Address, result => {
+                expect(result).to.be.equal(EXISTING_FEDERATION_AWAITING_ACTIVATION_ERROR_CODE, message);
+            });
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer2Address, result => {
+                expect(result).to.be.equal(EXISTING_FEDERATION_AWAITING_ACTIVATION_ERROR_CODE, message);
+            });
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer3Address, result => {
+                expect(result).to.be.equal(EXISTING_FEDERATION_AWAITING_ACTIVATION_ERROR_CODE, message);
+            });
+
+            const finalPendingFederationHash = await bridge.methods.getPendingFederationHash().call();
+            expect(finalPendingFederationHash, 'The pending federation hash should be null.').to.be.null;
+            
+        });
+
         it('should activate federation', async () => {
 
             const federationActivationBlockNumber = commitFederationCreationBlockNumber + FEDERATION_ACTIVATION_AGE;
@@ -665,6 +740,30 @@ const execute = (description, newFederationConfig) => {
 
         });
 
+        it('should not create a new pending federation when there is a retiring federation', async () => {
+
+            const initialPendingFederationHash = await bridge.methods.getPendingFederationHash().call();
+            expect(initialPendingFederationHash, 'The pending federation hash should be null.').to.be.null;
+
+            const createFederationMethod = await bridge.methods.createFederation();
+
+            const message = 'The `createFederation` method should not be callable when there is a retiring federation.';
+
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer1Address, result => {
+                expect(result).to.be.equal(RETIRING_FEDERATION_ALREADY_EXISTS, message);
+            });
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer2Address, result => {
+                expect(result).to.be.equal(RETIRING_FEDERATION_ALREADY_EXISTS, message);
+            });
+            await rskUtils.sendTxWithCheck(rskTxHelper, createFederationMethod, fedChangeAuthorizer3Address, result => {
+                expect(result).to.be.equal(RETIRING_FEDERATION_ALREADY_EXISTS, message);
+            });
+
+            const finalPendingFederationHash = await bridge.methods.getPendingFederationHash().call();
+            expect(finalPendingFederationHash, 'The pending federation hash should be null.').to.be.null;
+            
+        });
+
         it('should complete retiring the old federation', async () => {
 
             await rskUtils.waitForSync(rskTxHelpers);