helia-coord 1.1.0

package/test/unit/controllers/timer-controller-unit.js

@@ -0,0 +1,261 @@
+/*
+  Unit tests for the main Controllers index.js file.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local libraries
+import TimerControllers from '../../../lib/controllers/timer-controller.js'
+import AdapterMock from '../../mocks/adapter-mock.js'
+import UseCasesMock from '../../mocks/use-case-mocks.js'
+import ThisNodeUseCases from '../../../lib/use-cases/this-node-use-cases.js'
+
+const adapters = new AdapterMock()
+
+describe('#Controllers-Timer', () => {
+  let uut
+  let sandbox
+  let useCases
+  let thisNode
+  let clock
+
+  beforeEach(async () => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+    clock = sinon.useFakeTimers()
+
+    uut = new TimerControllers({
+      adapters,
+      statusLog: () => {
+      }
+    })
+
+    const thisNodeUseCases = new ThisNodeUseCases({
+      adapters,
+      controllers: {},
+      statusLog: () => {
+      }
+    })
+    thisNode = await thisNodeUseCases.createSelf({ type: 'node.js' })
+
+    useCases = new UseCasesMock()
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+    clock.restore()
+
+    uut.stopAllTimers()
+  })
+
+  after(() => {
+    console.log('Stopping all timers')
+    uut.stopAllTimers()
+  })
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters is not included', () => {
+      try {
+        uut = new TimerControllers()
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of adapters required when instantiating Timer Controllers'
+        )
+      }
+    })
+
+    it('should throw an error if status log handler is not included', () => {
+      try {
+        uut = new TimerControllers({ adapters })
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Handler for status logs required when instantiating Timer Controllers'
+        )
+      }
+    })
+  })
+
+  describe('#startTimers', () => {
+    it('should start the timers', () => {
+      const result = uut.startTimers()
+
+      assert.property(result, 'circuitRelayTimerHandle')
+      assert.property(result, 'announceTimerHandle')
+      assert.property(result, 'peerTimerHandle')
+      assert.property(result, 'relaySearchHandle')
+      assert.property(result, 'checkBlacklistHandle')
+      assert.property(result, 'listPubsubChannelsHandle')
+
+      // Clean up test by stopping the timers.
+      clearInterval(result.circuitRelayTimerHandle)
+      clearInterval(result.announceTimerHandle)
+      clearInterval(result.peerTimerHandle)
+      clearInterval(result.relaySearchHandle)
+      clearInterval(result.checkBlacklistHandle)
+      clearInterval(result.listPubsubChannelsHandle)
+    })
+
+    it('should execute the functions inside the timers', () => {
+      // Mock all functions inside the timers so they don't actually execute.
+      sandbox.stub(uut, 'manageCircuitRelays').resolves()
+      sandbox.stub(uut, 'manageAnnouncement').resolves()
+      sandbox.stub(uut, 'managePeers').resolves()
+      sandbox.stub(uut, 'searchForRelays').resolves()
+      sandbox.stub(uut, 'listPubsubChannels').resolves()
+
+      uut.startTimers()
+      clock.tick(200000)
+
+      assert.isOk(true)
+    })
+  })
+
+  describe('#manageCircuitRelays', () => {
+    it('should refresh connections with known circuit relays', async () => {
+      const result = await uut.manageCircuitRelays(thisNode, useCases)
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, true)
+    })
+
+    it('should catch and report an error', async () => {
+      // Force an error
+      sandbox
+        .stub(useCases.relays, 'connectToCRs')
+        .rejects(new Error('test error'))
+
+      const result = await uut.manageCircuitRelays(thisNode, useCases)
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('#manageAnnouncement', () => {
+    it('should publish an announcement to the general coordination pubsub channel', async () => {
+      const result = await uut.manageAnnouncement(thisNode, useCases)
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, true)
+    })
+
+    it('should catch and report an error', async () => {
+      // Force an error
+      sandbox
+        .stub(thisNode.schema, 'announcement')
+        .throws(new Error('test error'))
+
+      const result = await uut.manageAnnouncement(thisNode, useCases)
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('#managePeers', () => {
+    it('should refresh connections to peers', async () => {
+      const result = await uut.managePeers(thisNode, useCases)
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, true)
+    })
+
+    it('should catch and report an error', async () => {
+      // Force an error
+      sandbox
+        .stub(useCases.thisNode, 'refreshPeerConnections')
+        .throws(new Error('test error'))
+
+      const result = await uut.managePeers(thisNode, useCases)
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('#blacklist', () => {
+    it('should return true after executing the use case', async () => {
+      const result = await uut.blacklist(thisNode, useCases)
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, true)
+    })
+
+    it('should return false on error', async () => {
+      // Force an error
+      // sandbox
+      //   .stub(useCases.thisNode, 'enforceBlacklist')
+      //   .rejects(new Error('test error'))
+      sandbox
+        .stub(useCases.thisNode, 'enforceWhitelist')
+        .rejects(new Error('test error'))
+
+      const result = await uut.blacklist(thisNode, useCases)
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('#searchForRelays', () => {
+    it('should find and relay-potential peers that are not in the relayData array', async () => {
+      // Mock test data
+      const thisNode = {
+        relayData: [{ ipfsId: 'id1' }],
+        peerData: [{ from: 'id2', data: { isCircuitRelay: true } }]
+      }
+
+      const result = await uut.searchForRelays(thisNode, useCases)
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, true)
+    })
+
+    it('should report errors but not throw them', async () => {
+      const result = await uut.searchForRelays()
+
+      // Force the timer interval to excute.
+      clock.tick(200000)
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('#listPubsubChannels', () => {
+    it('should list pubsub channels', async () => {
+      const result = await uut.listPubsubChannels()
+
+      assert.equal(result, true)
+    })
+  })
+
+  // describe('#monitorBandwidth', () => {
+  //   it('should report bandwidth', async () => {
+  //     const result = await uut.monitorBandwidth(thisNode, useCases)
+
+  //     assert.equal(result, true)
+  //   })
+  // })
+})

package/test/unit/entities/this-node.unit.entity.js

@@ -0,0 +1,157 @@
+/*
+  Unit tests for the thisNode Entity
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// local libraries
+import ThisNodeEntity from '../../../lib/entities/this-node-entity.js'
+
+describe('#thisNode-Entity', () => {
+  let sandbox
+  let uut // Unit Under Test
+
+  beforeEach(() => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+  // const bchjs = new BCHJS()
+  // uut = new IpfsCoord({ bchjs, ipfs, type: 'node.js' })
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if ipfsId is not included', () => {
+      try {
+        const configObj = {}
+
+        uut = new ThisNodeEntity(configObj)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'ipfsId required when instantiating thisNode Entity'
+        )
+      }
+    })
+
+    it('should throw an error if multiaddrs are not included', () => {
+      try {
+        const configObj = {
+          ipfsId: 'fake-ipfsId'
+        }
+
+        uut = new ThisNodeEntity(configObj)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'ipfsMultiaddrs required when instantiating thisNode Entity'
+        )
+      }
+    })
+
+    it('should throw an error if bchAddr is not included', () => {
+      try {
+        const configObj = {
+          ipfsId: 'fake-ipfsId',
+          ipfsMultiaddrs: ['fake-addr']
+        }
+
+        uut = new ThisNodeEntity(configObj)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'bchAddr required when instantiating thisNode Entity'
+        )
+      }
+    })
+
+    it('should throw an error if slpAddr is not included', () => {
+      try {
+        const configObj = {
+          ipfsId: 'fake-ipfsId',
+          ipfsMultiaddrs: ['fake-addr'],
+          bchAddr: 'fake-addr'
+        }
+
+        uut = new ThisNodeEntity(configObj)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'slpAddr required when instantiating thisNode Entity'
+        )
+      }
+    })
+
+    it('should throw an error if publicKey is not included', () => {
+      try {
+        const configObj = {
+          ipfsId: 'fake-ipfsId',
+          ipfsMultiaddrs: ['fake-addr'],
+          bchAddr: 'fake-addr',
+          slpAddr: 'fake-addr'
+        }
+
+        uut = new ThisNodeEntity(configObj)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'publicKey required when instantiating thisNode Entity'
+        )
+      }
+    })
+
+    it('should throw an error if node type is not included', () => {
+      try {
+        const configObj = {
+          ipfsId: 'fake-ipfsId',
+          ipfsMultiaddrs: ['fake-addr'],
+          bchAddr: 'fake-addr',
+          slpAddr: 'fake-addr',
+          publicKey: 'fake-key'
+        }
+
+        uut = new ThisNodeEntity(configObj)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          "Node type of 'node.js' or 'browser' required when instantiating thisNode Entity"
+        )
+      }
+    })
+
+    it('should create a thisNode Entity', () => {
+      const configObj = {
+        ipfsId: 'fake-ipfsId',
+        ipfsMultiaddrs: ['fake-addr'],
+        bchAddr: 'fake-addr',
+        slpAddr: 'fake-addr',
+        publicKey: 'fake-key',
+        type: 'node.js'
+      }
+
+      uut = new ThisNodeEntity(configObj)
+
+      assert.property(uut, 'ipfsId')
+      assert.property(uut, 'ipfsMultiaddrs')
+      assert.property(uut, 'bchAddr')
+      assert.property(uut, 'slpAddr')
+      assert.property(uut, 'publicKey')
+      assert.property(uut, 'type')
+    })
+  })
+})

package/test/unit/index-unit.js

@@ -0,0 +1,160 @@
+/*
+  Unit tests for the main index.js file.
+*/
+
+// Global npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+import SlpWallet from 'minimal-slp-wallet'
+
+// Local libraries
+import IpfsCoord from '../../index.js'
+import ipfs from '../mocks/ipfs-mock.js'
+
+describe('#ipfs-coord - index.js', () => {
+  let sandbox
+  let uut // Unit Under Test
+  let wallet
+
+  beforeEach(async () => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    wallet = new SlpWallet()
+    await wallet.walletInfoPromise
+
+    uut = new IpfsCoord({ wallet, ipfs, type: 'node.js' })
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if ipfs instance is not passed as input', () => {
+      try {
+        uut = new IpfsCoord({})
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'An instance of IPFS must be passed when instantiating the ipfs-coord library.'
+        )
+      }
+    })
+
+    it('should throw an error if bch-js instance is not passed as input', () => {
+      try {
+        uut = new IpfsCoord({ ipfs })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'An instance of minimal-slp-wallet must be passed when instantiating the ipfs-coord library.'
+        )
+      }
+    })
+
+    it('should throw an error if node type is not defined', () => {
+      try {
+        const wallet = new SlpWallet()
+        uut = new IpfsCoord({ 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 override default logs', async () => {
+      uut = new IpfsCoord({
+        wallet,
+        ipfs,
+        type: 'node.js',
+        statusLog: console.log,
+        privateLog: console.log
+      })
+    })
+
+    it('should set debugLevel to 0 if not specified', () => {
+      uut = new IpfsCoord({
+        wallet,
+        ipfs,
+        type: 'node.js',
+        statusLog: console.log,
+        privateLog: console.log
+      })
+
+      assert.equal(uut.debugLevel, 0)
+    })
+
+    it('should set debugLevel to 2 if specified', () => {
+      uut = new IpfsCoord({
+        wallet,
+        ipfs,
+        type: 'node.js',
+        statusLog: console.log,
+        privateLog: console.log,
+        debugLevel: 2
+      })
+
+      assert.equal(uut.debugLevel, 2)
+    })
+
+    it('should default debugLevel to 0 non-integer is used', () => {
+      uut = new IpfsCoord({
+        wallet,
+        ipfs,
+        type: 'node.js',
+        statusLog: console.log,
+        privateLog: console.log,
+        debugLevel: 'abcd'
+      })
+
+      assert.equal(uut.debugLevel, 0)
+    })
+  })
+
+  describe('#start', () => {
+    it('should return true after ipfs-coord dependencies have been started.', async () => {
+      // Mock the dependencies.
+      sandbox.stub(uut.adapters.ipfs, 'start').resolves({})
+      sandbox.stub(uut.useCases.thisNode, 'createSelf').resolves({})
+      sandbox.stub(uut.useCases.relays, 'initializeRelays').resolves({})
+      sandbox.stub(uut.useCases.pubsub, 'initializePubsub').resolves({})
+      sandbox.stub(uut.controllers.timer, 'startTimers').resolves({})
+      sandbox.stub(uut, '_initializeConnections').resolves({})
+
+      const result = await uut.start()
+
+      assert.equal(result, true)
+    })
+  })
+
+  describe('#_initializeConnections', () => {
+    it('should kick-off initial connections', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.useCases.relays, 'initializeRelays').resolves()
+      sandbox.stub(uut.useCases.relays, 'getCRGist').resolves()
+      sandbox.stub(uut.useCases.thisNode, 'refreshPeerConnections').resolves()
+
+      const result = await uut._initializeConnections()
+
+      assert.equal(result, true)
+    })
+
+    it('should return falses on error', async () => {
+      // Force and error
+      sandbox
+        .stub(uut.useCases.relays, 'initializeRelays')
+        .rejects(new Error('test error'))
+
+      const result = await uut._initializeConnections()
+
+      assert.equal(result, false)
+    })
+  })
+})