helia-coord 1.1.0

package/test/unit/use-cases/schema-use-case-unit.js

@@ -0,0 +1,101 @@
+/*
+  Unit tests for the schema.js library.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// local libraries
+import Schema from '../../../lib/use-cases/schema.js'
+
+describe('#schema', () => {
+  let sandbox
+  let uut
+
+  beforeEach(() => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    const schemaConfig = {
+      ipfsId: 'myIpfsId',
+      type: 'node.js',
+      ipfsMultiaddrs: ['addr1', 'addr2']
+    }
+    uut = new Schema(schemaConfig)
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#announcement', () => {
+    it('should return an announcement object', () => {
+      const result = uut.announcement()
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      // Assert that expected properties exist.
+      assert.property(result, 'apiName')
+      assert.property(result, 'apiVersion')
+      assert.property(result, 'apiInfo')
+      assert.property(result, 'ipfsId')
+      assert.property(result, 'type')
+      assert.property(result, 'ipfsMultiaddrs')
+      assert.property(result, 'circuitRelays')
+      assert.property(result, 'isCircuitRelay')
+      assert.property(result, 'cryptoAddresses')
+      assert.property(result, 'encryptPubKey')
+      assert.property(result, 'orbitdb')
+
+      // Assert that properties have the expected type.
+      assert.isArray(result.ipfsMultiaddrs)
+      assert.isArray(result.circuitRelays)
+      assert.isArray(result.cryptoAddresses)
+
+      // Assert expected values.
+      assert.equal(result.isCircuitRelay, false)
+      assert.equal(result.apiName, 'ipfs-coord-announce')
+      assert.equal(result.type, 'node.js')
+    })
+
+    it('should update orbitdbId in state when different', () => {
+      const announceObj = {
+        orbitdbId: '567'
+      }
+
+      const result = uut.announcement(announceObj)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'orbitdb')
+      assert.equal(result.orbitdb, '567')
+    })
+  })
+
+  describe('#chat', () => {
+    it('should return a chat object', () => {
+      const msgObj = {
+        message: 'Some arbitrary text.',
+        handle: 'Testy Tester'
+      }
+
+      const result = uut.chat(msgObj)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      // Assert that expected properties exist.
+      assert.property(result, 'apiName')
+      assert.property(result, 'apiVersion')
+      assert.property(result, 'apiInfo')
+      assert.property(result, 'cryptoAddresses')
+      assert.property(result, 'encryptPubKey')
+      assert.property(result, 'data')
+      assert.property(result.data, 'message')
+      assert.property(result.data, 'handle')
+      assert.property(result, 'ipfsId')
+
+      // Assert that properties have the expected type.
+      assert.isArray(result.cryptoAddresses)
+
+      // Assert expected values.
+      assert.equal(result.apiName, 'chat')
+      assert.equal(result.type, 'node.js')
+    })
+  })
+})

package/test/unit/use-cases/this-node-use-cases-unit.js

@@ -0,0 +1,427 @@
+/*
+  Unit tests for the this-node use case.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local libraries
+import ThisNodeUseCases from '../../../lib/use-cases/this-node-use-cases.js'
+import AdapterMock from '../../mocks/adapter-mock.js'
+import mockData from '../../mocks/peers-mock.js'
+import UseCasesMock from '../../mocks/use-case-mocks.js'
+
+const adapters = new AdapterMock()
+
+describe('#thisNode-Use-Cases', () => {
+  let uut
+  let sandbox
+
+  beforeEach(() => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    uut = new ThisNodeUseCases({
+      adapters
+    })
+
+    const useCases = new UseCasesMock()
+    uut.updateUseCases(useCases)
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters is not included', () => {
+      try {
+        uut = new ThisNodeUseCases()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Must inject instance of adapters when instantiating thisNode Use Cases library.'
+        )
+      }
+    })
+
+    // it('should throw an error if controllers are not included', () => {
+    //   try {
+    //     uut = new ThisNodeUseCases({ adapters: {} })
+    //
+    //     assert.fail('Unexpected code path')
+    //   } catch (err) {
+    //     assert.include(
+    //       err.message,
+    //       'Must inject instance of controllers when instantiating thisNode Use Cases library.'
+    //     )
+    //   }
+    // })
+
+    it('should instantiate the use cases library', () => {
+      uut = new ThisNodeUseCases({
+        adapters: {}
+      })
+
+      assert.property(uut, 'adapters')
+    })
+  })
+
+  describe('#createSelf', () => {
+    it('should create a thisNode entity', async () => {
+      uut = new ThisNodeUseCases({ adapters, statusLog: {} })
+
+      const result = await uut.createSelf({ type: 'node.js' })
+      // console.log('result: ', result)
+
+      assert.property(result, 'ipfsId')
+      assert.property(result, 'type')
+    })
+  })
+
+  describe('#addSubnetPeer', () => {
+    it('should track a new peer', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+
+      const announceObj = {
+        from: 'peerId',
+        data: {}
+      }
+
+      await uut.createSelf({ type: 'node.js' })
+      const result = await uut.addSubnetPeer(announceObj)
+      // console.log('result: ', result)
+
+      assert.equal(result, true)
+    })
+
+    it('should track a new Relay peer', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.useCases.relays, 'addRelay').resolves()
+
+      const announceObj = {
+        from: 'peerId',
+        data: {
+          isCircuitRelay: true
+        }
+      }
+
+      await uut.createSelf({ type: 'node.js' })
+      const result = await uut.addSubnetPeer(announceObj)
+      // console.log('result: ', result)
+
+      assert.equal(result, true)
+    })
+
+    it('should update an existing peer', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+
+      const announceObj = {
+        from: 'peerId',
+        data: {
+          orbitdb: 'orbitdbId'
+        }
+      }
+
+      await uut.createSelf({ type: 'node.js' })
+
+      // Add the new peer
+      await uut.addSubnetPeer(announceObj)
+
+      // Simulate a second announcement object.
+      const result = await uut.addSubnetPeer(announceObj)
+      // console.log('result: ', result)
+
+      assert.equal(result, true)
+
+      // peerData array should only have one peer.
+      assert.equal(uut.thisNode.peerData.length, 1)
+    })
+
+    it('should not update an existing peer if broadcast message is older the current one', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+
+      const announceObj1 = {
+        from: 'peerId',
+        data: {
+          orbitdb: 'orbitdbId',
+          broadcastedAt: new Date('10/07/2023')
+        }
+      }
+
+      const announceObj2 = {
+        from: 'peerId',
+        data: {
+          orbitdb: 'orbitdbId',
+          broadcastedAt: new Date('10/05/2023')
+        }
+      }
+
+      await uut.createSelf({ type: 'node.js' })
+
+      // Add the new peer
+      await uut.addSubnetPeer(announceObj1)
+
+      // Simulate a second announcement object.
+      const result = await uut.addSubnetPeer(announceObj2)
+      // console.log('result: ', result)
+
+      assert.equal(result, true)
+
+      // peerData array should only have one peer.
+      assert.equal(uut.thisNode.peerData.length, 1)
+    })
+
+    it('should catch and report an error', async () => {
+      try {
+        const announceObj = {
+          from: 'peerId'
+        }
+
+        await uut.addSubnetPeer(announceObj)
+
+        assert.isOk(true, 'Not throwing an error is a pass')
+      } catch (err) {
+        // console.log(err)
+        assert.fail('Unexpected code path')
+      }
+    })
+  })
+
+  describe('#refreshPeerConnections', () => {
+    it('should execute with no connected peers', async () => {
+      await uut.createSelf({ type: 'node.js' })
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+
+      // Connect to that peer.
+      await uut.refreshPeerConnections()
+    })
+
+    it('should skip if peer is already connected', async () => {
+      await uut.createSelf({ type: 'node.js' })
+      // Add a peer that is already in the list of connected peers.
+      uut.thisNode.peerList = ['QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsjd']
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj2)
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
+
+    it('should refresh a connection', async () => {
+      await uut.createSelf({ type: 'node.js' })
+      // Add a peer that is not in the list of connected peers.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer').resolves(true)
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
+
+    it('should skip if peer is stale', async () => {
+      await uut.createSelf({ type: 'node.js' })
+      // Add a peer that is not in the list of connected peers.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer').resolves(true)
+      sandbox.stub(uut, 'isFreshPeer').returns(false)
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        await uut.createSelf({ type: 'node.js' })
+
+        // Add a peer
+        await uut.addSubnetPeer(mockData.announceObj)
+
+        // Force error
+        sandbox
+          .stub(uut.adapters.ipfs, 'getPeers')
+          .rejects(new Error('test error'))
+
+        // Connect to that peer.
+        await uut.refreshPeerConnections()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#isFreshPeer', () => {
+    it('should return false if peer data has no broadcastedAt property', () => {
+      const announceObj = {
+        data: {}
+      }
+
+      const result = uut.isFreshPeer(announceObj)
+
+      assert.equal(result, false)
+    })
+
+    it('should return false if broadcast is older than 10 minutes', () => {
+      const now = new Date()
+      const fifteenMinutes = 15 * 60000
+      let fifteenMinutesAgo = now.getTime() - fifteenMinutes
+      fifteenMinutesAgo = new Date(fifteenMinutesAgo)
+
+      const announceObj = {
+        data: {
+          broadcastedAt: fifteenMinutesAgo.toISOString()
+        }
+      }
+
+      const result = uut.isFreshPeer(announceObj)
+
+      assert.equal(result, false)
+    })
+
+    it('should return true if broadcast is newer than 10 minutes', () => {
+      const now = new Date()
+      const fiveMinutes = 5 * 60000
+      let fiveMinutesAgo = now.getTime() - fiveMinutes
+      fiveMinutesAgo = new Date(fiveMinutesAgo)
+
+      const announceObj = {
+        data: {
+          broadcastedAt: fiveMinutesAgo.toISOString()
+        }
+      }
+
+      const result = uut.isFreshPeer(announceObj)
+
+      assert.equal(result, true)
+    })
+  })
+
+  describe('#enforceBlacklist', () => {
+    it('should disconnect from blacklisted peers', async () => {
+      await uut.createSelf({ type: 'node.js' })
+
+      // Set up test data
+      uut.thisNode.blacklistPeers = ['testId']
+      uut.thisNode.blacklistMultiaddrs = ['testId']
+
+      const result = await uut.enforceBlacklist()
+
+      assert.equal(result, true)
+    })
+
+    it('catch and throw an error', async () => {
+      try {
+        await uut.enforceBlacklist()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, 'Cannot read')
+      }
+    })
+  })
+
+  describe('#enforceWhitelist', () => {
+    it('should disconnect from non-ipfs-coord peers', async () => {
+      await uut.createSelf({ type: 'node.js' })
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves([{ peer: 'badId' }])
+      const spy1 = sandbox
+        .stub(uut.adapters.ipfs, 'disconnectFromPeer')
+        .resolves()
+
+      const result = await uut.enforceWhitelist()
+
+      // Assert that the method completed.
+      assert.equal(result, true)
+
+      // Assert that disconnectFromPeer() was called.
+      assert.equal(spy1.called, true)
+    })
+
+    it('should skip ipfs-coord peers', async () => {
+      await uut.createSelf({ type: 'node.js' })
+      uut.thisNode.peerData = [
+        {
+          from: 'goodId',
+          data: {
+            jsonLd: {
+              name: 'good-name'
+            }
+          }
+        }
+      ]
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves([{ peer: 'goodId' }])
+      const spy1 = sandbox
+        .stub(uut.adapters.ipfs, 'disconnectFromPeer')
+        .resolves()
+
+      const result = await uut.enforceWhitelist()
+
+      // Assert that the method completed.
+      assert.equal(result, true)
+
+      // Assert that disconnectFromPeer() was not called.
+      assert.equal(spy1.called, false)
+    })
+
+    it('should catch and throw errors', async () => {
+      try {
+        await uut.enforceWhitelist()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, 'Cannot read')
+      }
+    })
+  })
+})

package/test/unit/use-cases/use-cases-index-unit.js

@@ -0,0 +1,47 @@
+/*
+  Unit tests for Use Cases index.js file
+*/
+
+// npm libraries
+import { assert } from 'chai'
+
+// Local libraries
+import UseCases from '../../../lib/use-cases/index.js'
+
+describe('#Use-Cases-index.js', () => {
+  let uut
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters is not included', () => {
+      try {
+        uut = new UseCases()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Must inject instance of adapters when instantiating Use Cases library.'
+        )
+      }
+    })
+
+    // it('should throw an error if controllers are not included', () => {
+    //   try {
+    //     uut = new UseCases({ adapters: {} })
+    //
+    //     assert.fail('Unexpected code path')
+    //   } catch (err) {
+    //     assert.include(
+    //       err.message,
+    //       'Must inject instance of controllers when instantiating Use Cases library.'
+    //     )
+    //   }
+    // })
+
+    it('should instantiate the use cases library', () => {
+      uut = new UseCases({ adapters: {}, statusLog: {} })
+
+      assert.property(uut, 'adapters')
+    })
+  })
+})

package/test/unit/util/utils-unit.js

@@ -0,0 +1,31 @@
+/*
+*/
+
+// Global npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local libraries
+import Util from '../../../lib/util/utils.js'
+
+describe('#utils.js', () => {
+  let sandbox
+  let uut // Unit Under Test
+
+  beforeEach(async () => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    uut = new Util()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#sleep', () => {
+    it('should sleep for 1 ms', async () => {
+      await uut.sleep(1)
+
+      assert.isOk(true)
+    })
+  })
+})