fix(control): Added control and DS Proof endpoints

test/unit/controllers/control-controller-unit.js

@@ -0,0 +1,88 @@
+/*
+  Unit tests for ControlRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import ControlRESTController from '../../../src/controllers/rest-api/full-node/control/controller.js'
+import { createMockRequest, createMockResponse } from '../mocks/controller-mocks.js'
+
+describe('#control-controller.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+    mockUseCases = {
+      control: {
+        getNetworkInfo: sandbox.stub().resolves({ version: 1 })
+      }
+    }
+
+    uut = new ControlRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new ControlRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require control use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new ControlRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /Control use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return control status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'control' })
+    })
+  })
+
+  describe('#getNetworkInfo()', () => {
+    it('should return network info on success', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getNetworkInfo(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { version: 1 })
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('failure')
+      error.status = 503
+      mockUseCases.control.getNetworkInfo.rejects(error)
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getNetworkInfo(req, res)
+
+      assert.equal(res.statusValue, 503)
+      assert.deepEqual(res.jsonData, { error: 'failure' })
+    })
+  })
+})

test/unit/controllers/dsproof-controller-unit.js

@@ -0,0 +1,117 @@
+/*
+  Unit tests for DSProofRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import DSProofRESTController from '../../../src/controllers/rest-api/full-node/dsproof/controller.js'
+import { createMockRequest, createMockResponse } from '../mocks/controller-mocks.js'
+
+describe('#dsproof-controller.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+    mockUseCases = {
+      dsproof: {
+        getDSProof: sandbox.stub().resolves({ proof: true })
+      }
+    }
+
+    uut = new DSProofRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new DSProofRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require dsproof use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new DSProofRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /DSProof use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return dsproof status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'dsproof' })
+    })
+  })
+
+  describe('#getDSProof()', () => {
+    it('should validate txid presence', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getDSProof(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.include(res.jsonData.error, 'txid can not be empty')
+    })
+
+    it('should validate txid length', async () => {
+      const req = createMockRequest({ params: { txid: 'abc' } })
+      const res = createMockResponse()
+
+      await uut.getDSProof(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.include(res.jsonData.error, 'txid must be of length 64')
+    })
+
+    it('should call use case with derived verbose when valid', async () => {
+      const txid = 'a'.repeat(64)
+      const req = createMockRequest({
+        params: { txid },
+        query: { verbose: 'true' }
+      })
+      const res = createMockResponse()
+
+      await uut.getDSProof(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockUseCases.dsproof.getDSProof.calledOnceWithExactly({
+        txid,
+        verbose: 3
+      }))
+      assert.deepEqual(res.jsonData, { proof: true })
+    })
+
+    it('should handle errors via handleError', async () => {
+      const txid = 'a'.repeat(64)
+      const error = new Error('failure')
+      error.status = 422
+      mockUseCases.dsproof.getDSProof.rejects(error)
+      const req = createMockRequest({ params: { txid } })
+      const res = createMockResponse()
+
+      await uut.getDSProof(req, res)
+
+      assert.equal(res.statusValue, 422)
+      assert.deepEqual(res.jsonData, { error: 'failure' })
+    })
+  })
+})

test/unit/controllers/rest-api-index-unit.js

@@ -7,6 +7,8 @@ import sinon from 'sinon'
 
 import RESTControllers from '../../../src/controllers/rest-api/index.js'
 import BlockchainRouter from '../../../src/controllers/rest-api/full-node/blockchain/index.js'
+import ControlRouter from '../../../src/controllers/rest-api/full-node/control/index.js'
+import DSProofRouter from '../../../src/controllers/rest-api/full-node/dsproof/index.js'
 
 describe('#controllers/rest-api/index.js', () => {
   let sandbox
@@ -43,7 +45,13 @@ describe('#controllers/rest-api/index.js', () => {
       }
     }
     mockUseCases = {
-      blockchain: createBlockchainUseCaseStubs()
+      blockchain: createBlockchainUseCaseStubs(),
+      control: {
+        getNetworkInfo: () => {}
+      },
+      dsproof: {
+        getDSProof: () => {}
+      }
     }
   })
 
@@ -68,8 +76,10 @@ describe('#controllers/rest-api/index.js', () => {
   })
 
   describe('#attachRESTControllers()', () => {
-    it('should instantiate blockchain router and attach to app', () => {
-      const attachStub = sandbox.stub(BlockchainRouter.prototype, 'attach')
+    it('should instantiate routers and attach to app', () => {
+      const blockchainAttachStub = sandbox.stub(BlockchainRouter.prototype, 'attach')
+      const controlAttachStub = sandbox.stub(ControlRouter.prototype, 'attach')
+      const dsproofAttachStub = sandbox.stub(DSProofRouter.prototype, 'attach')
       const restControllers = new RESTControllers({
         adapters: mockAdapters,
         useCases: mockUseCases
@@ -78,8 +88,12 @@ describe('#controllers/rest-api/index.js', () => {
 
       restControllers.attachRESTControllers(app)
 
-      assert.isTrue(attachStub.calledOnce)
-      assert.equal(attachStub.getCall(0).args[0], app)
+      assert.isTrue(blockchainAttachStub.calledOnce)
+      assert.equal(blockchainAttachStub.getCall(0).args[0], app)
+      assert.isTrue(controlAttachStub.calledOnce)
+      assert.equal(controlAttachStub.getCall(0).args[0], app)
+      assert.isTrue(dsproofAttachStub.calledOnce)
+      assert.equal(dsproofAttachStub.getCall(0).args[0], app)
     })
   })
 })

test/unit/use-cases/full-node-control-use-cases-unit.js

@@ -0,0 +1,53 @@
+/*
+  Unit tests for ControlUseCases.
+*/
+
+import { assert } from 'chai'
+
+import ControlUseCases from '../../../src/use-cases/full-node-control-use-cases.js'
+
+describe('#full-node-control-use-cases.js', () => {
+  let mockAdapters
+  let uut
+
+  beforeEach(() => {
+    mockAdapters = {
+      fullNode: {
+        call: async () => ({})
+      }
+    }
+
+    uut = new ControlUseCases({ adapters: mockAdapters })
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new ControlUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require full node adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new ControlUseCases({ adapters: {} })
+      }, /Full node adapter required/)
+    })
+  })
+
+  describe('#getNetworkInfo()', () => {
+    it('should call full node adapter with correct method', async () => {
+      let capturedMethod = ''
+      mockAdapters.fullNode.call = async method => {
+        capturedMethod = method
+        return { version: 1 }
+      }
+
+      const result = await uut.getNetworkInfo()
+
+      assert.equal(capturedMethod, 'getnetworkinfo')
+      assert.deepEqual(result, { version: 1 })
+    })
+  })
+})

test/unit/use-cases/full-node-dsproof-use-cases-unit.js

@@ -0,0 +1,54 @@
+/*
+  Unit tests for DSProofUseCases.
+*/
+
+import { assert } from 'chai'
+
+import DSProofUseCases from '../../../src/use-cases/full-node-dsproof-use-cases.js'
+
+describe('#full-node-dsproof-use-cases.js', () => {
+  let mockAdapters
+  let uut
+
+  beforeEach(() => {
+    mockAdapters = {
+      fullNode: {
+        call: async () => ({})
+      }
+    }
+
+    uut = new DSProofUseCases({ adapters: mockAdapters })
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new DSProofUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require full node adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new DSProofUseCases({ adapters: {} })
+      }, /Full node adapter required/)
+    })
+  })
+
+  describe('#getDSProof()', () => {
+    it('should pass txid and verbose parameters to adapter', async () => {
+      let capturedArgs = null
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedArgs = { method, params }
+        return { success: true }
+      }
+
+      const result = await uut.getDSProof({ txid: 'a'.repeat(64), verbose: 2 })
+
+      assert.equal(capturedArgs.method, 'getdsproof')
+      assert.deepEqual(capturedArgs.params, ['a'.repeat(64), 2])
+      assert.deepEqual(result, { success: true })
+    })
+  })
+})