helia-coord 1.1.0

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

@@ -0,0 +1,186 @@
+/*
+  Unit tests for the Peer Use Case library.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local libraries
+import PeerUseCases from '../../../lib/use-cases/peer-use-cases.js'
+import ThisNodeUseCases from '../../../lib/use-cases/this-node-use-cases.js'
+import AdapterMock from '../../mocks/adapter-mock.js'
+
+const adapters = new AdapterMock()
+// const mockData = require('../../mocks/peers-mock')
+
+describe('#Use-Cases-Peer', () => {
+  let uut
+  let sandbox
+  let thisNode
+
+  beforeEach(async () => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    const thisNodeUseCases = new ThisNodeUseCases({
+      adapters,
+      statusLog: () => {
+      }
+    })
+    thisNode = await thisNodeUseCases.createSelf({ type: 'node.js' })
+    //
+    // uut = new RelayUseCases({
+    //   adapters,
+    //   controllers: {},
+    //   statusLog: () => {}
+    // })
+
+    uut = new PeerUseCases({ adapters, controllers: {} })
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters is not included', () => {
+      try {
+        uut = new PeerUseCases()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Must inject instance of adapters when instantiating Peer Use Cases library.'
+        )
+      }
+    })
+  })
+
+  describe('#sendPrivateMessage', () => {
+    it('should throw an error if peer data can not be found', async () => {
+      try {
+        const result = await uut.sendPrivateMessage(
+          'fakeId',
+          'messageStr',
+          thisNode
+        )
+        console.log('result: ', result)
+      } catch (err) {
+        assert.include(err.message, 'Data for peer')
+      }
+    })
+
+    it('should encrypt a message and add it to the peers OrbitDB', async () => {
+      thisNode.peerData.push({ from: 'fakeId' })
+      // thisNode.orbitData.push({
+      //   ipfsId: 'fakeId',
+      //   db: {
+      //     add: () => {
+      //     }
+      //   }
+      // })
+
+      // Mock dependencies
+      // sandbox.stub(uut.adapters.encryption, 'encryptMsg')
+      sandbox.stub(uut, 'connectToPeer').resolves(true)
+
+      const result = await uut.sendPrivateMessage(
+        'fakeId',
+        'messageStr',
+        thisNode
+      )
+      // console.log('result: ', result)
+
+      assert.equal(result, true)
+    })
+  })
+
+  describe('#connectToPeer', () => {
+    it('should skip if peer is already connected', async () => {
+      // Test data
+      const peerId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsjd'
+      thisNode.peerList = [peerId]
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves([{ peer: peerId }])
+
+      // Connect to that peer
+      const result = await uut.connectToPeer(peerId, thisNode)
+
+      assert.equal(result, true)
+    })
+
+    it('should connect to peer through circuit relay', async () => {
+      // Test data
+      const peerId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsjd'
+      thisNode.peerList = [peerId]
+      thisNode.relayData = [
+        {
+          multiaddr: '/ip4/139.162.76.54/tcp/5269/ws/p2p/QmaKzQTAtoJWYMiG5ATx41uWsMajr1kSxRdtg919s8fK77',
+          connected: true,
+          updatedAt: '2021-09-20T15:59:12.961Z',
+          ipfsId: 'QmaKzQTAtoJWYMiG5ATx41uWsMajr1kSxRdtg919s8fK77',
+          isBootstrap: false,
+          metrics: { aboutLatency: [] },
+          latencyScore: 10000
+        }
+      ]
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves([])
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer').resolves(true)
+      thisNode.useCases = {
+        relays: {
+          sortRelays: () => thisNode.relayData
+        }
+      }
+
+      // Connect to that peer
+      const result = await uut.connectToPeer(peerId, thisNode)
+
+      assert.equal(result, true)
+    })
+
+    it('should return false if not able to connect to peer', async () => {
+      // Test data
+      const peerId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsjd'
+      thisNode.peerList = [peerId]
+      thisNode.relayData = [
+        {
+          multiaddr: '/ip4/139.162.76.54/tcp/5269/ws/p2p/QmaKzQTAtoJWYMiG5ATx41uWsMajr1kSxRdtg919s8fK77',
+          connected: true,
+          updatedAt: '2021-09-20T15:59:12.961Z',
+          ipfsId: 'QmaKzQTAtoJWYMiG5ATx41uWsMajr1kSxRdtg919s8fK77',
+          isBootstrap: false,
+          metrics: { aboutLatency: [] },
+          latencyScore: 10000
+        }
+      ]
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves([])
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer').resolves(false)
+      thisNode.useCases = {
+        relays: {
+          sortRelays: () => thisNode.relayData
+        }
+      }
+
+      // Connect to that peer
+      const result = await uut.connectToPeer(peerId, thisNode)
+
+      assert.equal(result, false)
+    })
+
+    it('should catch and throw errors', async () => {
+      try {
+        await uut.connectToPeer()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, 'Cannot read')
+      }
+    })
+  })
+})

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

@@ -0,0 +1,114 @@
+/*
+  Unit tests for the Pubsub use case.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local libraries
+import PubsubUseCases from '../../../lib/use-cases/pubsub-use-cases.js'
+import ThisNodeUseCases from '../../../lib/use-cases/this-node-use-cases.js'
+import AdapterMock from '../../mocks/adapter-mock.js'
+
+const adapters = new AdapterMock()
+// const mockData = require('../../mocks/peers-mock')
+
+describe('#pubsub-Use-Cases', () => {
+  let uut
+  let sandbox
+  let thisNodeUseCases
+
+  beforeEach(() => {
+    // Restore the sandbox before each test.
+    sandbox = sinon.createSandbox()
+
+    thisNodeUseCases = new ThisNodeUseCases({
+      adapters,
+      statusLog: () => {}
+    })
+
+    uut = new PubsubUseCases({
+      adapters,
+      thisNodeUseCases
+    })
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters is not included', () => {
+      try {
+        uut = new PubsubUseCases()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Must inject instance of adapters when instantiating Pubsub Use Cases library.'
+        )
+      }
+    })
+
+    it('should throw an error if thisNodeUseCases instance is not included', () => {
+      try {
+        uut = new PubsubUseCases({
+          adapters: {},
+          controllers: {}
+        })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'thisNode use cases required when instantiating Pubsub Use Cases library.'
+        )
+      }
+    })
+
+    it('should allow parent app to override coinjoin pubsub handler', () => {
+      const localHandler = () => {}
+
+      // Use default handler
+      uut = new PubsubUseCases({
+        adapters: {},
+        thisNodeUseCases
+      })
+      const normalHandleResult = uut.coinjoinPubsubHandler()
+      assert.equal(normalHandleResult, true)
+
+      // Replace default handler
+      uut = new PubsubUseCases({
+        adapters: {},
+        thisNodeUseCases,
+        coinjoinPubsubHandler: localHandler
+      })
+
+      assert.isOk(uut.coinjoinPubsubHandler)
+    })
+  })
+
+  describe('#initializePubsub', () => {
+    it('should subscribe to a node', async () => {
+      await uut.initializePubsub('fakeNode')
+
+      assert.isOk(true, 'No throwing an error is a pass')
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.adapters.pubsub, 'subscribeToPubsubChannel')
+          .rejects(new Error('test error'))
+
+        await uut.initializePubsub('fakeNode')
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+})