Added transaction endpoint

test/unit/adapters/bch.adapter.unit.js

@@ -164,4 +164,94 @@ describe('#bch-use-case', () => {
       }
     })
   })
+
+  describe('#broadcast', () => {
+    it('should broadcast a transaction', async () => {
+      // Force connection to a wallet service
+      uut.ipfs.ipfsCoordAdapter.state = {
+        selectedServiceProvider: 'abc123'
+      }
+
+      // Mock depenencies
+      sandbox.stub(uut, 'waitForRPCResponse').resolves({ key: 'value' })
+
+      const hex = 'abc123'
+
+      const result = await uut.broadcast(hex)
+      // console.log('result: ', result)
+
+      assert.equal(result.key, 'value')
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        await uut.broadcast()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.equal(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#getTransactions', () => {
+    it('should get transactions history for an address', async () => {
+      // Force connection to a wallet service
+      uut.ipfs.ipfsCoordAdapter.state = {
+        selectedServiceProvider: 'abc123'
+      }
+
+      // Mock depenencies
+      sandbox.stub(uut, 'waitForRPCResponse').resolves({ key: 'value' })
+
+      const addr = 'abc123'
+
+      const result = await uut.getTransactions(addr)
+      // console.log('result: ', result)
+
+      assert.equal(result.key, 'value')
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        await uut.getTransactions()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.equal(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#getTransaction', () => {
+    it('should get transaction details for a txid', async () => {
+      // Force connection to a wallet service
+      uut.ipfs.ipfsCoordAdapter.state = {
+        selectedServiceProvider: 'abc123'
+      }
+
+      // Mock depenencies
+      sandbox.stub(uut, 'waitForRPCResponse').resolves({ key: 'value' })
+
+      const txid = 'abc123'
+
+      const result = await uut.getTransaction(txid)
+      // console.log('result: ', result)
+
+      assert.equal(result.key, 'value')
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        await uut.getTransaction()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.equal(err.message, 'test error')
+      }
+    })
+  })
 })

test/unit/controllers/rest-api/bch/bch.rest.controller.unit.js

@@ -106,7 +106,7 @@ describe('#BCH-REST-Controller', () => {
   })
 
   describe('#balance', () => {
-    it('should return 422 status on arbitrary biz logic error', async () => {
+    it('should return 422 status on arbitrary error', async () => {
       try {
         // Force an error
         sandbox
@@ -134,10 +134,154 @@ describe('#BCH-REST-Controller', () => {
         addresses: 'blah'
       }
 
-      await uut.getStatus(ctx)
+      await uut.balance(ctx)
 
       // Assert the expected HTTP response
       assert.equal(ctx.status, 200)
     })
   })
+
+  describe('#utxos', () => {
+    it('should return 422 status on arbitrary error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.adapters.bch, 'getUtxos')
+          .rejects(new Error('test error'))
+
+        ctx.request.body = {
+          address: 'blah'
+        }
+
+        await uut.utxos(ctx)
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        console.log('err: ', err)
+        assert.equal(err.status, 422)
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    it('should return 200 status on success', async () => {
+      sandbox.stub(uut.adapters.bch, 'getUtxos').resolves({ status: 200 })
+
+      ctx.request.body = {
+        address: 'blah'
+      }
+
+      await uut.utxos(ctx)
+
+      // Assert the expected HTTP response
+      assert.equal(ctx.status, 200)
+    })
+  })
+
+  describe('#broadcast', () => {
+    it('should return 422 status on arbitrary error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.adapters.bch, 'broadcast')
+          .rejects(new Error('test error'))
+
+        ctx.request.body = {
+          hex: 'blah'
+        }
+
+        await uut.broadcast(ctx)
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        console.log('err: ', err)
+        assert.equal(err.status, 422)
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    it('should return 200 status on success', async () => {
+      sandbox.stub(uut.adapters.bch, 'broadcast').resolves({ status: 200 })
+
+      ctx.request.body = {
+        hex: 'blah'
+      }
+
+      await uut.broadcast(ctx)
+
+      // Assert the expected HTTP response
+      assert.equal(ctx.status, 200)
+    })
+  })
+
+  describe('#transactions', () => {
+    it('should return 422 status on arbitrary error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.adapters.bch, 'getTransactions')
+          .rejects(new Error('test error'))
+
+        ctx.request.body = {
+          address: 'blah'
+        }
+
+        await uut.transactions(ctx)
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        console.log('err: ', err)
+        assert.equal(err.status, 422)
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    it('should return 200 status on success', async () => {
+      sandbox.stub(uut.adapters.bch, 'getUtxos').resolves({ status: 200 })
+
+      ctx.request.body = {
+        address: 'blah'
+      }
+
+      await uut.transactions(ctx)
+
+      // Assert the expected HTTP response
+      assert.equal(ctx.status, 200)
+    })
+  })
+
+  describe('#transaction', () => {
+    it('should return 422 status on arbitrary error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.adapters.bch, 'getTransaction')
+          .rejects(new Error('test error'))
+
+        ctx.request.body = {
+          txid: 'blah'
+        }
+
+        await uut.transaction(ctx)
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        console.log('err: ', err)
+        assert.equal(err.status, 422)
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    // it('should return 200 status on success', async () => {
+    //   sandbox.stub(uut.adapters.bch, 'getUtxos').resolves({ status: 200 })
+    //
+    //   ctx.request.body = {
+    //     address: 'blah'
+    //   }
+    //
+    //   await uut.transactions(ctx)
+    //
+    //   // Assert the expected HTTP response
+    //   assert.equal(ctx.status, 200)
+    // })
+  })
 })

test/unit/mocks/adapters/index.js

@@ -67,6 +67,26 @@ class BchUseCaseMock {
     return {}
   }
 
+  async getUtxos () {
+    return {}
+  }
+
+  async broadcast () {
+    return {}
+  }
+
+  async getTransaction () {
+    return {}
+  }
+
+  async getTransactions () {
+    return {}
+  }
+
+  async getPubKey () {
+    return {}
+  }
+
   async waitForRPCResponse () {
     return {}
   }