helia-coord 1.1.0

package/test/unit/adapters/gist.unit.adapters.js

@@ -0,0 +1,58 @@
+/*
+  Unit tests for the schema.js library.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// local libraries
+import Gist from '../../../lib/adapters/gist.js'
+
+describe('#Adapter-Gist', () => {
+  let sandbox
+  let uut
+
+  beforeEach(() => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    uut = new Gist()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#getCRList', () => {
+    it('should get data from GitHub', async () => {
+      // Mock network dependencies
+      sandbox.stub(uut.axios, 'get').resolves({
+        data: {
+          files: {
+            'psf-public-circuit-relays.json': {
+              content: JSON.stringify({ key: 'value' })
+            }
+          }
+        }
+      })
+
+      const result = await uut.getCRList()
+      // console.log('result: ', result)
+
+      assert.property(result, 'key')
+      assert.equal(result.key, 'value')
+    })
+
+    it('should catch and throw errors', async () => {
+      try {
+        // Force desired code path
+        sandbox.stub(uut.axios, 'get').rejects(new Error('test error'))
+
+        await uut.getCRList()
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+})

package/test/unit/adapters/index-adapters-unit.js

@@ -0,0 +1,79 @@
+/*
+  Unit tests for the main Adapters index.js file.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import SlpWallet from 'minimal-slp-wallet'
+
+// Local libraries
+import Adapters from '../../../lib/adapters/index.js'
+import ipfs from '../../mocks/ipfs-mock.js'
+
+// const Adapters = require('../../../lib/adapters')
+// const BCHJS = require('@psf/bch-js')
+// const bchjs = new BCHJS()
+// const ipfs = require('../../mocks/ipfs-mock')
+// const wallet = new SlpWallet()
+
+describe('#Adapters - index.js', () => {
+  let uut, wallet
+
+  beforeEach(async () => {
+    wallet = new SlpWallet()
+    await wallet.walletInfoPromise
+  })
+
+  describe('#constructor', () => {
+    it('should throw an error if ipfs is not included', () => {
+      try {
+        uut = new Adapters()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'An instance of IPFS must be passed when instantiating the Adapters library.'
+        )
+      }
+    })
+
+    it('should throw an error if minimal-slp-wallet is not included', () => {
+      try {
+        uut = new Adapters({ ipfs: {} })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'An instance of minimal-slp-wallet must be passed when instantiating the Adapters library.'
+        )
+      }
+    })
+
+    it('should throw an error if node type is not specified', () => {
+      try {
+        uut = new Adapters({ ipfs: {}, wallet: {} })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'The type of IPFS node (browser or node.js) must be specified.'
+        )
+      }
+    })
+
+    it('should instantiate other adapter libraries', () => {
+      uut = new Adapters({
+        ipfs,
+        wallet,
+        type: 'node.js',
+        statusLog: () => {},
+        privateLog: () => {}
+      })
+
+      assert.property(uut, 'log')
+    })
+  })
+})

package/test/unit/adapters/ipfs-adapter-unit.js

@@ -0,0 +1,215 @@
+/*
+  Unit tests for the ipfs-adapters.js library
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// local libraries
+import IPFSAdapter from '../../../lib/adapters/ipfs-adapter.js'
+import ipfs from '../../mocks/ipfs-mock.js'
+
+describe('#Adapter - IPFS', () => {
+  let sandbox
+  let uut
+
+  beforeEach(() => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    const log = {
+      statusLog: () => {}
+    }
+    uut = new IPFSAdapter({ ipfs, log })
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if ipfs instance is not passed in', () => {
+      try {
+        uut = new IPFSAdapter({})
+      } catch (err) {
+        assert.include(
+          err.message,
+          'An instance of IPFS must be passed when instantiating the IPFS adapter library.'
+        )
+      }
+    })
+
+    it('should throw an error if log instance is not passed in', () => {
+      try {
+        uut = new IPFSAdapter({ ipfs })
+      } catch (err) {
+        assert.include(
+          err.message,
+          'A status log handler must be specified when instantiating IPFS adapter library.'
+        )
+      }
+    })
+
+    it('should overwrite default ports when user specifies them at run time', async () => {
+      const log = {
+        statusLog: () => {}
+      }
+      uut = new IPFSAdapter({ ipfs, log, tcpPort: 6000, wsPort: 6001 })
+
+      assert.equal(uut.tcpPort, 6000)
+      assert.equal(uut.wsPort, 6001)
+    })
+  })
+
+  describe('#start', () => {
+    it('should populate ID and multiaddrs', async () => {
+      await uut.start()
+
+      // console.log('uut: ', uut)
+
+      assert.property(uut, 'ipfsPeerId')
+      assert.property(uut, 'ipfsMultiaddrs')
+    })
+
+    it('should configure an exteranl go-ipfs node', async () => {
+      const log = {
+        statusLog: () => {}
+      }
+      uut = new IPFSAdapter({ ipfs, log, nodeType: 'external' })
+
+      await uut.start()
+
+      // console.log('uut: ', uut)
+
+      assert.equal(uut.nodeType, 'external')
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        // sandbox.stub(uut.ipfs, 'id').rejects(new Error('test error'))
+        sandbox.stub(uut.ipfs.libp2p.peerId, 'toString').throws(new Error('test error'))
+
+        await uut.start()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#connectToPeer', () => {
+    it('should return true after connecting to peer', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.ipfs.libp2p, 'dial').resolves()
+      sandbox.stub(uut, 'multiaddr').returns()
+
+      const result = await uut.connectToPeer('fakeId')
+
+      assert.equal(result, true)
+    })
+
+    it('should return false when issues connecting to peer', async () => {
+      // Force an error
+      sandbox.stub(uut.ipfs.swarm, 'connect').rejects(new Error('test error'))
+
+      const result = await uut.connectToPeer('fakeId')
+
+      assert.equal(result, false)
+    })
+
+    it('should report connection errors at debugLevel 1', async () => {
+      uut.debugLevel = 1
+
+      // Force an error
+      sandbox.stub(uut.ipfs.swarm, 'connect').rejects(new Error('test error'))
+
+      const result = await uut.connectToPeer('fakeId')
+
+      assert.equal(result, false)
+    })
+
+    it('should report full errors at debugLevel 2', async () => {
+      uut.debugLevel = 2
+
+      // Force an error
+      sandbox.stub(uut.ipfs.swarm, 'connect').rejects(new Error('test error'))
+
+      const result = await uut.connectToPeer('fakeId')
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('#getPeers', () => {
+    it('should return an array of peers', async () => {
+      const result = await uut.getPeers()
+
+      assert.isArray(result)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox.stub(uut.ipfs.libp2p, 'getPeers').rejects(new Error('test error'))
+
+        await uut.getPeers()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#disconnectFromPeer', () => {
+    it('should return true if thisNode is not connected to the peer', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'getPeers').resolves([])
+
+      const result = await uut.disconnectFromPeer('testId')
+
+      assert.equal(result, true)
+    })
+
+    it('should disconnect if thisNode is connected to the peer', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'getPeers').resolves([{ peer: 'testId' }])
+
+      const result = await uut.disconnectFromPeer('testId')
+
+      assert.equal(result, true)
+    })
+
+    it('should return false on error', async () => {
+      // Force an error
+      sandbox.stub(uut, 'getPeers').rejects(new Error('test error'))
+
+      const result = await uut.disconnectFromPeer('testId')
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('#disconnectFromMultiaddr', () => {
+    it('should return true when disconnect succeeds', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.ipfs.swarm, 'disconnect').resolves()
+
+      const result = await uut.disconnectFromMultiaddr()
+
+      assert.equal(result, true)
+    })
+
+    it('should return false on error', async () => {
+      // Mock dependencies
+      sandbox
+        .stub(uut.ipfs.swarm, 'disconnect')
+        .rejects(new Error('test error'))
+
+      const result = await uut.disconnectFromMultiaddr()
+
+      assert.equal(result, false)
+    })
+  })
+})

package/test/unit/adapters/logs-adapter-unit.js

@@ -0,0 +1,55 @@
+/*
+  Unit tests for log adapter.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// local libraries
+import LogsAdapter from '../../../lib/adapters/logs-adapter.js'
+
+describe('#Adapters - Logs', () => {
+  let uut
+  let sandbox
+
+  beforeEach(() => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    const config = {
+      debugLevel: 2,
+      statusLog: () => {}
+    }
+
+    // Instantiate the library under test. Must instantiate dependencies first.
+    uut = new LogsAdapter(config)
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if log handler is specified', async () => {
+      try {
+        uut = new LogsAdapter()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'statusLog must be specified when instantiating Logs adapter library.'
+        )
+      }
+    })
+  })
+
+  describe('#statusLog', () => {
+    it('should include object if defined', () => {
+      uut.statusLog(1, 'test string', { message: 'obj message' })
+    })
+
+    it('should exclude object if undefined', () => {
+      uut.statusLog(1, 'test string')
+    })
+  })
+})

package/test/unit/adapters/pubsub/about-adapter-unit.js

@@ -0,0 +1,129 @@
+/*
+  Unit tests for the about adapter library.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// local libraries
+import AboutAdapter from '../../../../lib/adapters/pubsub-adapter/about-adapter.js'
+
+describe('#About-adapter', () => {
+  let uut
+  let sandbox
+
+  beforeEach(() => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    // Instantiate the library under test. Must instantiate dependencies first.
+    uut = new AboutAdapter()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#sendRPC', () => {
+    it('should return false if response is not recieved in time', async () => {
+      // Prep test data.
+      uut.waitPeriod = 1
+      const ipfsId = 'testId'
+      const cmdStr = 'fakeCmd'
+      const id = 1
+      const thisNode = {
+        useCases: {
+          peer: {
+            sendPrivateMessage: async () => {
+            },
+            adapters: {
+              bch: {
+                bchjs: {
+                  Util: {
+                    sleep: () => {
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      const result = await uut.sendRPC(ipfsId, cmdStr, id, thisNode)
+      // console.log('result: ', result)
+
+      assert.equal(result, false)
+    })
+
+    it('should return the result of the RPC call', async () => {
+      // Prep test data.
+      uut.waitPeriod = 2000
+      const ipfsId = 'testId'
+      const cmdStr = 'fakeCmd'
+      const id = 1
+      const thisNode = {
+        useCases: {
+          peer: {
+            sendPrivateMessage: async () => {
+            },
+            adapters: {
+              bch: {
+                bchjs: {
+                  Util: {
+                    sleep: () => {
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      // Force positive code path.
+      uut.incomingData = '{"id": 1}'
+
+      const result = await uut.sendRPC(ipfsId, cmdStr, id, thisNode)
+      // console.log('result: ', result)
+
+      assert.equal(result, true)
+    })
+
+    it('should catch and throw errors', async () => {
+      try {
+        await uut.sendRPC()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, 'Cannot read')
+      }
+    })
+  })
+
+  describe('#queryAbout', () => {
+    it('should return true after peer responds to RPC', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'sendRPC').resolves(true)
+
+      const result = await uut.queryAbout()
+      assert.equal(result, true)
+    })
+
+    it('should return false if peer never responds to RPC', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'sendRPC').resolves(false)
+
+      const result = await uut.queryAbout()
+      assert.equal(result, false)
+    })
+
+    it('should return false when there is an error', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'sendRPC').rejects(new Error('test error'))
+
+      const result = await uut.queryAbout()
+      assert.equal(result, false)
+    })
+  })
+})