perf: speedup core smoke test

package.json

@@ -23,7 +23,7 @@
   "dependencies": {
     "@dashevo/dapi-client": "^0.22.0",
     "@dashevo/dashcore-lib": "~0.19.30",
-    "@dashevo/dashd-rpc": "^2.3.1",
+    "@dashevo/dashd-rpc": "^2.4.0",
     "@dashevo/wallet-lib": "~7.22.0",
     "@grpc/grpc-js": "^1.3.7",
     "bls-signatures": "^0.2.5",

test/smoke/core.js

@@ -11,46 +11,50 @@ const allHosts = inventory.masternodes.hosts.concat(
 
 describe.only('Core', () => {
   describe('All nodes', () => {
+    // Set up vars and functions to hold max height and mn responses
     const blockchainInfo = {};
     let maxBlockHeight = 0;
 
-    before(async function before() {
-      this.slow(allHosts * 2000);
-      this.timeout(allHosts * 3000);
+    const networkInfo = {};
 
+    before('Collect blockchain and network info', function func() {
+      this.timeout(60000); // set mocha timeout
+
+      const promises = [];
       for (const hostName of allHosts) {
+        const timeout = 15000; // set individual rpc client timeout
+
         const client = createRpcClientFromConfig(hostName);
 
-        let result;
+        client.setTimeout(timeout);
 
-        try {
-          ({ result } = await client.getBlockchainInfo());
-        } catch (e) {
-          // eslint-disable-next-line no-continue
-          continue;
-        }
+        const requestBlockchainInfoPromise = client.getBlockchainInfo()
+          // eslint-disable-next-line no-loop-func
+          .then(({ result }) => {
+            if (maxBlockHeight < result.blocks) {
+              maxBlockHeight = result.blocks;
+            }
+            blockchainInfo[hostName] = result;
+          });
 
-        if (maxBlockHeight < result.blocks) {
-          maxBlockHeight = result.blocks;
-        }
+        const requestNetworkInfoPromise = client.getNetworkInfo()
+          .then(({ result }) => {
+            networkInfo[hostName] = result;
+          });
 
-        blockchainInfo[hostName] = result;
+        promises.push(requestBlockchainInfoPromise, requestNetworkInfoPromise);
       }
+
+      return Promise.all(promises).catch(() => Promise.resolve());
     });
 
     for (const hostName of allHosts) {
       // eslint-disable-next-line no-loop-func
       describe(hostName, () => {
-        let dashdClient;
-
-        beforeEach(() => {
-          dashdClient = createRpcClientFromConfig(hostName);
-        });
-
-        it('should have correct network type', async function it() {
-          this.slow(2000);
-
-          const { result: { networkactive, subversion } } = await dashdClient.getNetworkInfo();
+        it('should have correct network type', async () => {
+          if (!blockchainInfo[hostName]) {
+            expect.fail(null, null, 'no blockchain info');
+          }
 
           const chainNames = {
             testnet: 'test',
@@ -61,16 +65,16 @@ describe.only('Core', () => {
 
           expect(blockchainInfo[hostName]).to.be.not.empty();
           expect(blockchainInfo[hostName].chain).to.equal(chainNames[network.type]);
-          expect(networkactive).to.be.equal(true);
+          expect(networkInfo[hostName].networkactive).to.be.equal(true);
 
           if (network.type === 'devnet') {
-            expect(subversion).to.have.string(`(${network.type}.${network.name})/`);
+            expect(networkInfo[hostName].subversion).to.have.string(`(${network.type}.${network.name})/`);
           }
         });
 
         it('should sync blocks', async () => {
           if (!blockchainInfo[hostName]) {
-            expect.fail('Can\'t connect to Core');
+            expect.fail(null, null, 'no blockchain info');
           }
 
           expect(maxBlockHeight - blockchainInfo[hostName].blocks).to.be.below(3);
@@ -80,23 +84,42 @@ describe.only('Core', () => {
   });
 
   describe('Masternodes', () => {
-    for (const hostName of inventory.masternodes.hosts) {
-      describe(hostName, () => {
-        let coreClient;
+    const masternodeListInfo = {};
 
-        beforeEach(() => {
-          coreClient = createRpcClientFromConfig(hostName);
-        });
+    before('Collect masternode list info', function func() {
+      this.timeout(30000); // set mocha timeout
 
-        it('should be in masternodes list', async function it() {
-          this.slow(2000);
+      const promises = [];
+      for (const hostName of inventory.masternodes.hosts) {
+        const timeout = 15000; // set individual rpc client timeout
 
-          const { result: masternodes } = await coreClient.masternodelist();
+        const client = createRpcClientFromConfig(hostName);
+
+        client.setTimeout(timeout);
+
+        const requestMasternodeListInfoPromise = client.masternodelist()
+          .then(({ result }) => {
+            masternodeListInfo[hostName] = result;
+          });
+
+        promises.push(requestMasternodeListInfoPromise);
+      }
+
+      return Promise.all(promises).catch(() => Promise.resolve());
+    });
+
+    for (const hostName of inventory.masternodes.hosts) {
+      describe(hostName, () => {
+        it('should be in masternodes list', async () => {
+          if (!masternodeListInfo[hostName]) {
+            expect.fail(null, null, 'no masternode list info');
+          }
 
-          const nodeFromList = Object.values(masternodes).find((node) => (
+          const nodeFromList = Object.values(masternodeListInfo[hostName])
+            .find((node) => (
             // eslint-disable-next-line no-underscore-dangle
-            inventory._meta.hostvars[hostName].public_ip === node.address.split(':')[0]
-          ));
+              inventory._meta.hostvars[hostName].public_ip === node.address.split(':')[0]
+            ));
 
           expect(nodeFromList, `${hostName} is not present in masternode list`).to.exist();