Update electrum servers for tests

We use public Keep Network's server for integration tests.

Author: nkuba

test/config.js

@@ -1,27 +1,29 @@
-const servers = {
-  tcp: {
-    protocol: 'tcp', port: '50001', host: 'electrum.bitaroo.net',
+const servers = [
+  {
+    protocol: "tcp",
+    port: "80",
+    host: "electrumx-server.test.tbtc.network",
   },
-  ssl: {
-    protocol: 'ssl', port: '50002', host: 'electrum.bitaroo.net',
+  {
+    protocol: "ws",
+    port: "8080",
+    host: "electrumx-server.test.tbtc.network",
   },
-  ws: {
-    protocol: 'ws', port: '50003', host: 'electrumx-server.tbtc.svc.cluster.local',
-  },
-  wss: {
-    protocol: 'wss', port: '50004', host: 'electrumx-server.tbtc.svc.cluster.local',
-  },
-}
 
-const serversArray = [
-  servers.tcp,
-  servers.ssl,
-  // FIXME: WebSocket is commented out for CI, until we find public servers for this protocol.
-  // electrumServers.ws,
-  // electrumServers.wss,
+  // FIXME: The client doesn't work with SSL connection.
+  // ssl: {
+  //   protocol: "ssl",
+  //   port: "443",
+  //   host: "electrumx-server.test.tbtc.network",
+  // },
+  // FIXME: The client doesn't work with WSS connection.
+  // wss: {
+  //   protocol: "wss",
+  //   port: "8443",
+  // host: "electrumx-server.test.tbtc.network",
+  // },
 ]
 
 module.exports = {
   servers,
-  serversArray,
 }

test/integration_test.js

@@ -1,80 +1,82 @@
-const ElectrumClient = require('../.')
+const ElectrumClient = require("../.")
 
-const chai = require('chai')
+const chai = require("chai")
 const assert = chai.assert
 
-const fs = require('fs')
+const fs = require("fs")
 
-const config = require('./config')
+const { servers } = require("./config")
 
-describe('ElectrumClient', async () => {
+describe("ElectrumClient", async () => {
   let txData
 
   before(async () => {
-    txData = JSON.parse(await fs.readFileSync('./test/tx.json', 'utf8'))
+    txData = JSON.parse(fs.readFileSync("./test/tx.json", "utf8"))
   })
 
-  context('when connected', async () => {
-    config.serversArray.forEach((server) => {
-      describe(`for ${server.protocol} protocol`, async () => {
-        let client
+  describe("for all protocols", async () => {
+    servers.forEach((server) => {
+      describe(`${server.protocol}://${server.host}:${server.port}`, async () => {
+        describe("when connected", async () => {
+          let client
 
-        before(async () => {
-          client = new ElectrumClient(
-            server.host,
-            server.port,
-            server.protocol,
-            server.options
-          )
+          before(async () => {
+            client = new ElectrumClient(
+              server.host,
+              server.port,
+              server.protocol,
+              server.options
+            )
 
-          await client
-            .connect('test_client' + server.protocol, '1.4.2')
-            .catch((err) => {
-              console.error(
-                `failed to connect with config [${JSON.stringify(
-                  server
-                )}]: [${err}]`
-              )
-            })
-        })
+            await client
+              .connect("test_client" + server.protocol, "1.4.2")
+              .catch((err) => {
+                console.error(
+                  `failed to connect with config [${JSON.stringify(
+                    server
+                  )}]: [${err}]`
+                )
+              })
+          })
 
-        after(async () => {
-          await client.close()
-        })
+          after(async () => {
+            await client.close()
+          })
 
-        it('request returns result', async () => {
-          const expectedResult = txData.hex
-          const result = await client.blockchain_transaction_get(txData.hash)
+          it("request returns result", async () => {
+            const expectedResult = txData.hex
+            const result = await client.blockchain_transaction_get(txData.hash)
 
-          assert.equal(result, expectedResult, 'unexpected result')
+            assert.equal(result, expectedResult, "unexpected result")
+          })
         })
-      })
-    })
-  })
 
-  context('when not connected', async () => {
-    before(async () => {
-      const server = config.servers.tcp
+        describe("when not connected", async () => {
+          let client
 
-      client = new ElectrumClient(
-        server.host,
-        server.port,
-        server.protocol,
-        server.options
-      )
-    })
+          before(async () => {
+            client = new ElectrumClient(
+              server.host,
+              server.port,
+              server.protocol,
+              server.options
+            )
+          })
 
-    it('request throws error', async () => {
-      await client.blockchain_transaction_get(txData.hash).then(
-        (value) => {
-          // onFulfilled
-          assert.fail('not failed as expected')
-        },
-        (reason) => {
-          // onRejected
-          assert.include(reason.toString(), `connection not established`)
-        }
-      )
+          it("request throws error", async () => {
+            await client.blockchain_transaction_get(txData.hash).then(
+              (value) => {
+                // onFulfilled
+                assert.fail("not failed as expected")
+              },
+              (reason) => {
+                // onRejected
+                assert.include(reason.toString(), `connection not established`)
+              }
+            )
+          })
+        })
+      })
     })
   })
   // TODO: Add tests