refactor: inject forest-server-requester

src/context/init.js

@@ -7,11 +7,11 @@ const logger = require('../services/logger');
 const pathService = require('../services/path');
 const errorHandler = require('../services/exposed/error-handler');
 const ipWhitelist = require('../services/ip-whitelist');
-const forestServerRequester = require('../services/forest-server-requester');
 const ApimapSorter = require('../services/apimap-sorter');
 const ApimapSender = require('../services/apimap-sender');
 const ApimapFieldsFormater = require('../services/apimap-fields-formater');
 const AuthorizationFinder = require('../services/authorization-finder');
+const ForestServerRequester = require('../services/forest-server-requester');
 const SchemaFileUpdater = require('../services/schema-file-updater');
 const schemasGenerator = require('../generators/schemas');
 
@@ -61,8 +61,8 @@ function initServices(context) {
   context.addInstance('logger', logger);
   context.addInstance('pathService', pathService);
   context.addInstance('errorHandler', errorHandler);
+  context.addClass(ForestServerRequester);
   context.addInstance('ipWhitelist', ipWhitelist);
-  context.addInstance('forestServerRequester', forestServerRequester);
   context.addInstance('writeFileSync', (...args) => fs.writeFileSync(...args));
   context.addInstance('schemasGenerator', schemasGenerator);
   context.addClass(ApimapFieldsFormater);

src/services/forest-server-requester.js

@@ -1,51 +1,51 @@
-const P = require('bluebird');
 const superagent = require('superagent');
 const VError = require('verror');
-const errorMessages = require('../utils/error-messages');
-const context = require('../context');
 
-function perform(route, environmentSecret, queryParameters, headers) {
-  const { forestUrl } = context.inject();
+class ForestServerRequester {
+  constructor({ forestUrl, errorMessages }) {
+    this.forestUrl = forestUrl;
+    this.errorMessages = errorMessages;
+  }
 
-  return new P((resolve, reject) => {
-    const request = superagent
-      .get(forestUrl + route)
-      .set('forest-secret-key', environmentSecret);
+  perform(route, environmentSecret, queryParameters, headers) {
+    return new Promise((resolve, reject) => {
+      const request = superagent
+        .get(this.forestUrl + route)
+        .set('forest-secret-key', environmentSecret);
 
-    if (headers) {
-      request.set(headers);
-    }
+      if (headers) {
+        request.set(headers);
+      }
 
-    if (queryParameters) {
-      request.query(queryParameters);
-    }
+      if (queryParameters) {
+        request.query(queryParameters);
+      }
 
-    request.end((error, result) => {
-      if (result) {
-        if (result.status === 200 && result.body) {
-          return resolve(result.body);
-        }
-        if (result.status === 0) {
-          return reject(new Error(errorMessages.SERVER_TRANSACTION.SERVER_DOWN));
-        }
-        if (result.status === 404) {
-          return reject(new Error(errorMessages.SERVER_TRANSACTION.SECRET_NOT_FOUND));
+      request.end((error, result) => {
+        if (result) {
+          if (result.status === 200 && result.body) {
+            return resolve(result.body);
+          }
+          if (result.status === 0) {
+            return reject(new Error(this.errorMessages.SERVER_TRANSACTION.SERVER_DOWN));
+          }
+          if (result.status === 404) {
+            return reject(new Error(this.errorMessages.SERVER_TRANSACTION.SECRET_NOT_FOUND));
+          }
+          if (result.status === 422) {
+            return reject(new Error(this.errorMessages
+              .SERVER_TRANSACTION.SECRET_AND_RENDERINGID_INCONSISTENT));
+          }
         }
-        if (result.status === 422) {
-          return reject(new Error(errorMessages
-            .SERVER_TRANSACTION.SECRET_AND_RENDERINGID_INCONSISTENT));
-        }
-      }
 
-      if (error) {
-        return reject(new VError(error, 'Forest server request error'));
-      }
+        if (error) {
+          return reject(new VError(error, 'Forest server request error'));
+        }
 
-      return reject(new Error(errorMessages.SERVER_TRANSACTION.UNEXPECTED, error));
+        return reject(new Error(this.errorMessages.SERVER_TRANSACTION.UNEXPECTED, error));
+      });
     });
-  });
+  }
 }
 
-module.exports = {
-  perform,
-};
+module.exports = ForestServerRequester;

src/services/ip-whitelist.js

@@ -4,13 +4,15 @@ const VError = require('verror');
 const ipUtil = require('forest-ip-utils');
 const logger = require('../services/logger');
 const errorMessages = require('../utils/error-messages');
-const forestServerRequester = require('./forest-server-requester');
 const IpWhitelistDeserializer = require('../deserializers/ip-whitelist');
+const context = require('../context');
 
 let ipWhitelistRules = null;
 let useIpWhitelist = true;
 
 function retrieve(environmentSecret) {
+  const { forestServerRequester } = context.inject();
+
   return forestServerRequester
     .perform('/liana/v1/ip-whitelist-rules', environmentSecret)
     .then((responseBody) => {

src/services/permissions-checker.js

@@ -2,8 +2,8 @@ const P = require('bluebird');
 const moment = require('moment');
 const VError = require('verror');
 const _ = require('lodash');
-const forestServerRequester = require('./forest-server-requester');
 const { perform } = require('./base-filters-parser');
+const context = require('../context');
 
 let permissionsPerRendering = {};
 
@@ -14,6 +14,8 @@ function PermissionsChecker(
   permissionName,
   permissionInfos = undefined,
 ) {
+  const { forestServerRequester } = context.inject();
+
   const EXPIRATION_IN_SECONDS = process.env.FOREST_PERMISSIONS_EXPIRATION_IN_SECONDS || 3600;
 
   function isSmartActionAllowed(smartActionsPermissions) {

test/helpers/request.js

@@ -20,4 +20,20 @@ function init() {
     });
 }
 
-module.exports = { init, request };
+function addNock(url, method, route, reqheaders = {}) {
+  return nock(url, { reqheaders })[method](route);
+}
+
+function addForestNock(method, route, reqheaders = {}) {
+  const { forestUrl } = context.inject();
+
+  return addNock(forestUrl, method, route, reqheaders);
+}
+
+
+module.exports = {
+  addNock,
+  addForestNock,
+  init,
+  request,
+};

test/routes/sessions-google.test.js

@@ -1,95 +1,57 @@
-const sinon = require('sinon');
 const jsonwebtoken = require('jsonwebtoken');
-const P = require('bluebird');
-const { request } = require('../helpers/request');
+const { request, addForestNock } = require('../helpers/request');
 const createServer = require('../helpers/create-server');
 
 const envSecret = Array(65).join('0');
 const authSecret = Array(65).join('1');
 const googleAccessToken = 'google-access-token';
 
 describe('routes > session Google', () => {
-  let app;
-  let sandbox;
-
-  async function initializeSandbox() {
-    sandbox = sinon.createSandbox();
-    // eslint-disable-next-line global-require
-    const forestServerRequester = require('../../src/services/forest-server-requester');
-
-    app = await createServer(envSecret, authSecret);
-
-    const stubPerform = sandbox.stub(forestServerRequester, 'perform');
-
-    stubPerform.withArgs('/liana/v1/ip-whitelist-rules').returns({
-      then: () => P.resolve({
-        data: {
-          attributes: {
-            use_ip_whitelist: false,
-          },
-        },
-      }),
-    });
-
-    stubPerform.withArgs(
-      '/liana/v2/renderings/1/google-authorization',
-      envSecret,
-      null,
-      { 'forest-token': googleAccessToken },
-    ).resolves({
-      data: {
-        id: '654',
-        type: 'users',
-        attributes: {
-          email: '[email protected]',
-          first_name: 'FirstName',
-          last_name: 'LastName',
-          teams: ['Operations'],
-        },
-      },
-      relationships: {
-        renderings: {
-          data: [{
-            id: 1,
-            type: 'renderings',
-          }],
-        },
-      },
-    });
-  }
-
-  function restoreSandbox() {
-    sandbox.restore();
-  }
-
   describe('#POST /forest/sessions-google', () => {
-    it('should return a valid jwt token', async () => {
-      expect.assertions(2);
-      await initializeSandbox();
-      await new Promise((done) => {
-        request(app)
-          .post('/forest/sessions-google')
-          .send({ renderingId: 1, forestToken: googleAccessToken })
-          .expect(200)
-          .end((error, response) => {
-            expect(error).toBeNull();
-
-            const { token } = response.body;
-            const decodedJWT = jsonwebtoken.verify(token, authSecret);
-
-            expect(decodedJWT).toMatchObject({
-              id: '654',
+    const init = () => {
+      addForestNock('get', '/liana/v2/renderings/1/google-authorization')
+        .reply(200, {
+          data: {
+            id: '654',
+            type: 'users',
+            attributes: {
               email: '[email protected]',
-              firstName: 'FirstName',
-              lastName: 'LastName',
-              renderingId: 1,
-              team: 'Operations',
-            });
+              first_name: 'FirstName',
+              last_name: 'LastName',
+              teams: ['Operations'],
+            },
+          },
+          relationships: {
+            renderings: {
+              data: [{
+                id: 1,
+                type: 'renderings',
+              }],
+            },
+          },
+        });
+    };
 
-            done();
-          });
+    it('should return a valid jwt token', async () => {
+      expect.assertions(1);
+      init();
+      const app = await createServer(envSecret, authSecret);
+      const response = await request(app)
+        .post('/forest/sessions-google')
+        .send({ renderingId: 1, forestToken: googleAccessToken })
+        .expect(200);
+
+      const { token } = response.body;
+      const decodedJWT = jsonwebtoken.verify(token, authSecret);
+
+      expect(decodedJWT).toMatchObject({
+        id: '654',
+        email: '[email protected]',
+        firstName: 'FirstName',
+        lastName: 'LastName',
+        renderingId: 1,
+        team: 'Operations',
       });
-      restoreSandbox();
     });
   });
 });