Create system proxy endpoint (#2229)

StuAA78 · web-flow · commit dd056223406d · 2022-11-03T11:17:48.000Z
https://eaflood.atlassian.net/browse/WATER-3787 DEFRA/water-abstraction-team#54 Going forward, we intend all new functionality to be built in the [water-abstraction-system](https://github.com/DEFRA/water-abstraction-system) repo. We even intend to _try_ and migrate any existing functionality we touch. In a perfect world, we'll end up with all the existing repos becoming defunct and a clean, performant service all in one repo. To get there though, we still need to work with the existing services and the existing environments. In those, the only apps exposed are the internal and eternal UI which are based on this repo. So, for any requests we want the water-abstraction-system to handle we need to 'proxy' them via the water-abstraction-ui. So, this change adds the ability for the UI to proxy all requests sent to `/system` to the water-abstraction-system app behind the scenes. One of the challenges we hit was assets. We realised when we requested a view, assets would also be requested. So, included in the change is the ability for the UI to proxy asset requests for the system as well.
diff --git a/.env.example b/.env.example
@@ -13,6 +13,7 @@ CRM_URI=
 IDM_URI=
 PERMIT_URI=
 RETURNS_URI=
+SYSTEM_URI=
 
 # Remote log capturing details
 ERRBIT_KEY=
diff --git a/src/internal/config.js b/src/internal/config.js
@@ -110,7 +110,8 @@ module.exports = {
     crm_v2: crmUri.replace('1.0', '2.0'),
     idm: process.env.IDM_URI || 'http://127.0.0.1:8003/idm/1.0',
     permits: process.env.PERMIT_URI || 'http://127.0.0.1:8004/API/1.0/',
-    returns: process.env.RETURNS_URI || 'http://127.0.0.1:8006/returns/1.0'
+    returns: process.env.RETURNS_URI || 'http://127.0.0.1:8006/returns/1.0',
+    system: process.env.SYSTEM_URI || 'http://127.0.0.1:8013'
   },
 
   testMode,
diff --git a/src/internal/lib/connectors/services/water/SystemProxyService.js b/src/internal/lib/connectors/services/water/SystemProxyService.js
@@ -0,0 +1,12 @@
+const ServiceClient = require('shared/lib/connectors/services/ServiceClient')
+
+class SystemProxyService extends ServiceClient {
+  async getToPath (path) {
+    // joinUrl appends the given path to the service url, hence we still need to call it here
+    const url = this.joinUrl(path)
+    const result = await this.serviceRequest.get(url)
+    return result
+  }
+}
+
+module.exports = SystemProxyService
diff --git a/src/internal/modules/routes.js b/src/internal/modules/routes.js
@@ -2,7 +2,7 @@
 
 const config = require('../config')
 
-// External only routes
+// Internal only routes
 const acceptanceTestsProxyRoutes = require('./acceptance-tests-proxy/routes')
 const coreRoutes = require('./core/routes')
 const contentRoutes = require('./content/routes')
@@ -28,6 +28,7 @@ const viewLicences = require('./view-licences/routes')
 const gaugingStations = require('./gauging-stations/routes')
 const customers = require('./customers/routes')
 const notes = require('./notes/routes')
+const systemProxyRoutes = require('./system-proxy/routes')
 
 // Shared routes
 const healthRoutes = require('../../shared/modules/health/routes')
@@ -60,7 +61,8 @@ const routes = [
   ...Object.values(gaugingStations),
   ...Object.values(customers),
   ...Object.values(notes),
-  ...Object.values(healthRoutes)
+  ...Object.values(healthRoutes),
+  ...systemProxyRoutes
 ]
 
 if (config.featureToggles.acceptanceTestsProxy) {
diff --git a/src/internal/modules/system-proxy/controller.js b/src/internal/modules/system-proxy/controller.js
@@ -0,0 +1,70 @@
+'use strict'
+
+const SystemProxyService = require('../../lib/connectors/services/water/SystemProxyService')
+
+const config = require('../../config')
+const { logger } = require('../../logger')
+
+/**
+ * Forwards GET requests to the water-abstraction-system
+ *
+ * When the app runs in AWS you can't access the water-abstraction-service because port 8001 is not exposed. So, this
+ * endpoint and controller in the app allows us to still run acceptance tests by providing a proxy to the internal API
+ * service.
+ *
+ * The route is only added in our non-production environments.
+ */
+const getSystemProxy = async (request, h) => {
+  const service = new SystemProxyService(config.services.system, logger)
+  let result
+
+  try {
+    result = await service.getToPath(request.params.tail)
+  } catch (error) {
+    result = error.error
+  }
+
+  return h.response(result)
+}
+
+const getSystemJsProxy = async (request, h) => {
+  let response
+
+  const service = new SystemProxyService(config.services.system, logger)
+
+  try {
+    const result = await service.getToPath('assets/all.js')
+
+    response = h.response(result)
+      .header('cache-control', 'no-cache')
+      .type('application/javascript')
+  } catch (error) {
+    response = h.response().code(error.statusCode)
+  }
+
+  return response
+}
+
+const getSystemCssProxy = async (request, h) => {
+  let response
+
+  const service = new SystemProxyService(config.services.system, logger)
+
+  try {
+    const result = await service.getToPath('assets/stylesheets/application.css')
+
+    response = h.response(result)
+      .header('cache-control', 'no-cache')
+      .type('text/css')
+  } catch (error) {
+    response = h.response().code(error.statusCode)
+  }
+
+  return response
+}
+
+module.exports = {
+  getSystemProxy,
+  getSystemJsProxy,
+  getSystemCssProxy
+}
diff --git a/src/internal/modules/system-proxy/routes.js b/src/internal/modules/system-proxy/routes.js
@@ -0,0 +1,35 @@
+'use strict'
+
+const controller = require('./controller')
+
+const routes = [
+  {
+    method: 'GET',
+    path: '/system/{tail*}',
+    handler: controller.getSystemProxy,
+    config: {
+      auth: false,
+      description: 'Proxies requests to the Water Abstraction System'
+    }
+  },
+  {
+    method: 'GET',
+    path: '/assets/all.js',
+    handler: controller.getSystemJsProxy,
+    config: {
+      auth: false,
+      description: 'Proxies JS asset requests to the Water Abstraction System'
+    }
+  },
+  {
+    method: 'GET',
+    path: '/assets/stylesheets/application.css',
+    handler: controller.getSystemCssProxy,
+    config: {
+      auth: false,
+      description: 'Proxies CSS asset requests to the Water Abstraction System'
+    }
+  }
+]
+
+module.exports = routes
diff --git a/test/internal/modules/system-proxy/controller.test.js b/test/internal/modules/system-proxy/controller.test.js
@@ -0,0 +1,202 @@
+'use strict'
+
+// Test framework dependencies
+const Lab = require('@hapi/lab')
+const Code = require('@hapi/code')
+const Sinon = require('sinon')
+
+const { experiment, test, beforeEach, afterEach } = exports.lab = Lab.script()
+const { expect } = Code
+const sandbox = Sinon.createSandbox()
+
+// Things we need to stub
+const SystemProxyService = require(
+  '../../../../src/internal/lib/connectors/services/water/SystemProxyService'
+)
+
+// Thing under test
+const controller = require('../../../../src/internal/modules/system-proxy/controller')
+
+experiment('System proxy controller', () => {
+  let request
+  let h
+
+  let codeFake
+  let typeFake
+  let headerFake
+  let responseFake
+
+  beforeEach(async () => {
+    codeFake = sandbox.fake()
+    typeFake = sandbox.fake()
+    headerFake = sandbox.fake.returns({ type: typeFake })
+    responseFake = sandbox.fake.returns({ header: headerFake, code: codeFake })
+
+    h = {
+      response: responseFake
+    }
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  experiment('.getSystemProxy', () => {
+    beforeEach(() => {
+      request = {
+        params: {
+          tail: 'status'
+        },
+        payload: null
+      }
+    })
+
+    experiment('when the request is valid', () => {
+      beforeEach(() => {
+        sandbox.stub(SystemProxyService.prototype, 'getToPath').resolves('OK')
+      })
+
+      test('returns whatever the system returns', async () => {
+        await controller.getSystemProxy(request, h)
+
+        const result = responseFake.lastCall.args[0]
+
+        expect(result).to.equal('OK')
+      })
+    })
+
+    experiment('when the request is invalid', () => {
+      let error
+
+      beforeEach(() => {
+        error = {
+          error: 'OH NO',
+          statusCode: 404,
+          message: '404 - "OH NO"',
+          name: 'StatusCodeError'
+        }
+        sandbox.stub(SystemProxyService.prototype, 'getToPath').rejects(error)
+      })
+
+      test('returns the system error details', async () => {
+        await controller.getSystemProxy(request, h)
+
+        const result = responseFake.lastCall.args[0]
+
+        expect(result).to.equal(error.error)
+      })
+    })
+  })
+
+  experiment('.getSystemJsProxy', () => {
+    beforeEach(() => {
+      request = {
+        payload: null
+      }
+    })
+
+    experiment('when the request is valid', () => {
+      beforeEach(() => {
+        sandbox.stub(SystemProxyService.prototype, 'getToPath').resolves('OK')
+      })
+
+      test('returns whatever the system returns', async () => {
+        await controller.getSystemJsProxy(request, h)
+
+        const result = responseFake.lastCall.args[0]
+
+        expect(result).to.equal('OK')
+      })
+
+      test('sets the expected header', async () => {
+        await controller.getSystemJsProxy(request, h)
+
+        const result = headerFake.lastCall.args
+
+        expect(result).to.include(['cache-control', 'no-cache'])
+      })
+
+      test('sets the expected type', async () => {
+        await controller.getSystemJsProxy(request, h)
+
+        const result = typeFake.lastCall.args[0]
+
+        expect(result).to.equal('application/javascript')
+      })
+    })
+
+    experiment('when the request is invalid', () => {
+      beforeEach(() => {
+        const error = {
+          statusCode: 404,
+          message: 'OH NO'
+        }
+        sandbox.stub(SystemProxyService.prototype, 'getToPath').rejects(error)
+      })
+
+      test('returns the system error status code', async () => {
+        await controller.getSystemJsProxy(request, h)
+
+        const result = codeFake.lastCall.firstArg
+
+        expect(result).to.equal(404)
+      })
+    })
+  })
+
+  experiment('.getSystemCssProxy', () => {
+    beforeEach(() => {
+      request = {
+        payload: null
+      }
+    })
+
+    experiment('when the request is valid', () => {
+      beforeEach(() => {
+        sandbox.stub(SystemProxyService.prototype, 'getToPath').resolves('OK')
+      })
+
+      test('returns whatever the system returns', async () => {
+        await controller.getSystemCssProxy(request, h)
+
+        const result = responseFake.lastCall.args[0]
+
+        expect(result).to.equal('OK')
+      })
+
+      test('sets the expected header', async () => {
+        await controller.getSystemCssProxy(request, h)
+
+        const result = headerFake.lastCall.args
+
+        expect(result).to.include(['cache-control', 'no-cache'])
+      })
+
+      test('sets the expected type', async () => {
+        await controller.getSystemCssProxy(request, h)
+
+        const result = typeFake.lastCall.args[0]
+
+        expect(result).to.equal('text/css')
+      })
+    })
+
+    experiment('when the request is invalid', () => {
+      beforeEach(() => {
+        const error = {
+          statusCode: 404,
+          message: 'OH NO'
+        }
+        sandbox.stub(SystemProxyService.prototype, 'getToPath').rejects(error)
+      })
+
+      test('returns the system error status code', async () => {
+        await controller.getSystemCssProxy(request, h)
+
+        const result = codeFake.lastCall.firstArg
+
+        expect(result).to.equal(404)
+      })
+    })
+  })
+})
diff --git a/test/internal/modules/system-proxy/routes.test.js b/test/internal/modules/system-proxy/routes.test.js
