test(secrets): add tests for helpers

Author: masontikhonov

lib/addNewMask.js

@@ -18,7 +18,7 @@ async function updateMasks(secret) {
         console.log(`successfully updated masks with secret: ${secret.key}`);
         process.exit(0);
     } catch (error) {
-        console.error(`could not create mask for secret: ${secret.key}, due to error: ${error}`);
+        console.error(`could not create mask for secret: ${secret.key}. Error: ${error}`);
         process.exit(1);
     }
 }

lib/const.js

@@ -1,5 +1,8 @@
-const serverAddressPath = '/root/cf-runtime/SERVER_ADDRESS';
+const { tmpdir } = require('node:os');
+const { resolve } = require('node:path');
+
+const SERVER_ADDRESS_PATH = resolve(tmpdir(), 'LOGGER_SERVER_ADDRESS');
 
 module.exports = {
-    serverAddressPath,
+    SERVER_ADDRESS_PATH,
 };

lib/helpers.js

@@ -1,9 +1,9 @@
-const { stat, writeFile, readFile } = require('fs/promises');
+const { stat, writeFile, readFile } = require('node:fs/promises');
 const path = require('path');
 const logger = require('cf-logs').Logger('codefresh:containerLogger');
 const getPromiseWithResolvers = require('core-js-pure/es/promise/with-resolvers');
 const { BuildFinishedSignalFilename } = require('./enums');
-const { serverAddressPath } = require('./const');
+const { SERVER_ADDRESS_PATH } = require('./const');
 
 const checkFileInterval = 1000;
 
@@ -35,19 +35,18 @@ function watchForBuildFinishedSignal() {
     return deferred.promise;
 }
 
-const persistServerAddress = async (serverAddress) => {
+const saveServerAddress = async (serverAddress) => {
     try {
-        await writeFile(serverAddressPath, serverAddress, { encoding: 'utf8' });
+        await writeFile(SERVER_ADDRESS_PATH, serverAddress, { encoding: 'utf8' });
     } catch (error) {
-        logger.error(`Failed to persist server address: ${error}`);
+        logger.error(`Failed to save server address: ${error}`);
         throw error;
     }
 };
 
 const getServerAddress = async () => {
     try {
-        const serverAddress = await readFile(serverAddressPath, { encoding: 'utf8' });
-        return serverAddress;
+        return await readFile(SERVER_ADDRESS_PATH, { encoding: 'utf8' });
     } catch (error) {
         logger.error(`Failed to read server address: ${error}`);
         throw error;
@@ -61,6 +60,6 @@ module.exports = {
      */
     getPromiseWithResolvers,
     watchForBuildFinishedSignal,
-    persistServerAddress,
+    saveServerAddress,
     getServerAddress,
 };

lib/logger.js

@@ -11,7 +11,7 @@ const { ContainerStatus } = require('./enums');
 const { LoggerStrategy } = require('./enums');
 const { ContainerHandlingStatus } = require('./enums');
 const ContainerLogger = require('./ContainerLogger');
-const { getPromiseWithResolvers, persistServerAddress } = require('./helpers');
+const { getPromiseWithResolvers, saveServerAddress } = require('./helpers');
 
 const initialState = {
     pid: process.pid, status: 'init', lastLogsDate: new Date(), failedHealthChecks: [], restartCounter: 0, containers: {}
@@ -382,7 +382,7 @@ class Logger {
             });
 
             const address = await server.listen({ host, port });
-            await persistServerAddress(address);
+            await saveServerAddress(address);
             logger.info(`listening for engine updates on ${address}`);
         } catch (error) {
             logger.error(`could not start server for engine updates due to error: ${error}`);

package.json

@@ -23,7 +23,7 @@
     "q": "^1.5.1"
   },
   "devDependencies": {
-    "chai": "^4.3.6",
+    "chai": "^4.4.1",
     "eslint": "^7.32.0",
     "eslint-config-airbnb": "^18.2.1",
     "eslint-plugin-chai-friendly": "^0.6.0",
@@ -34,10 +34,10 @@
     "eslint-plugin-promise": "^4.3.1",
     "eslint-plugin-react": "^7.29.4",
     "isparta": "^4.1.1",
-    "mocha": "^8.4.0",
+    "mocha": "^10.6.0",
     "proxyquire": "^1.8.0",
     "shelljs": "^0.6.1",
-    "sinon": "^7.5.0",
+    "sinon": "^18.0.0",
     "sinon-chai": "^3.7.0"
   },
   "engines": {

test/helpers.unit.spec.js

@@ -0,0 +1,97 @@
+const proxyquire = require('proxyquire').noCallThru();
+const chai = require('chai');
+const sinon = require('sinon');
+
+const expect = chai.expect;
+const stubFsPromises = {
+  writeFile: sinon.stub(),
+  readFile: sinon.stub(),
+};
+const stubLogger = {
+  debug: sinon.stub(),
+  log: sinon.stub(),
+  error: sinon.stub(),
+};
+
+describe('helpers', () => {
+  afterEach(() => {
+    for (const stub in stubFsPromises) {
+      stubFsPromises[stub].resetHistory();
+    }
+    for (const stub in stubLogger) {
+      stubLogger[stub].resetHistory();
+    }
+  });
+
+  describe('saveServerAddress() and getServerAddress()', () => {
+    describe('saveServerAddress()', () => {
+      it('should write the server address to the file', async () => {
+        const SERVER_ADDRESS_PATH = 'little/bobby/tables/we/call/him';
+        const serverAddress = 'foo';
+        const { saveServerAddress } = proxyquire('../lib/helpers.js', {
+          'node:fs/promises': stubFsPromises,
+          'cf-logs': { Logger: () => stubLogger },
+          './const': { SERVER_ADDRESS_PATH },
+        });
+        await saveServerAddress(serverAddress);
+        expect(stubFsPromises.writeFile).to.have.been.calledOnceWithExactly(SERVER_ADDRESS_PATH, serverAddress, { encoding: 'utf8' });
+      });
+  
+      it('should fail if the file cannot be written', async () => {
+        const { saveServerAddress } = proxyquire('../lib/helpers.js', {
+          'node:fs/promises': stubFsPromises,
+          'cf-logs': { Logger: () => stubLogger },
+        });
+        const expectedError = new Error('oh no');
+        stubFsPromises.writeFile.rejects(expectedError);
+        try {
+          await saveServerAddress('foo');
+          expect.fail('should have thrown an error');
+        } catch (error) {
+          expect(error).to.be.equal(expectedError);
+          expect(stubLogger.error).to.have.been.calledOnceWithExactly(`Failed to save server address: ${expectedError}`);
+        }
+      });
+    });
+  
+    describe('getServerAddress()', () => {
+      it('should read the server address from the file', async () => {
+        const SERVER_ADDRESS_PATH = 'little/bobby/tables/we/call/him';
+        const serverAddress = 'foo';
+        const { getServerAddress } = proxyquire('../lib/helpers.js', {
+          'node:fs/promises': stubFsPromises,
+          'cf-logs': { Logger: () => stubLogger },
+          './const': { SERVER_ADDRESS_PATH },
+        });
+        stubFsPromises.readFile.resolves(serverAddress);
+        const result = await getServerAddress();
+        expect(result).to.be.equal(serverAddress);
+        expect(stubFsPromises.readFile).to.have.been.calledOnceWithExactly(SERVER_ADDRESS_PATH, { encoding: 'utf8' });
+      });
+  
+      it('should fail if the file cannot be read', async () => {
+        const { getServerAddress } = proxyquire('../lib/helpers.js', {
+          'node:fs/promises': stubFsPromises,
+          'cf-logs': { Logger: () => stubLogger },
+        });
+        const expectedError = new Error('oh no');
+        stubFsPromises.readFile.rejects(expectedError);
+        try {
+          await getServerAddress();
+          expect.fail('should have thrown an error');
+        } catch (error) {
+          expect(error).to.be.equal(expectedError);
+          expect(stubLogger.error).to.have.been.calledOnceWithExactly(`Failed to read server address: ${expectedError}`);
+        }
+      });
+    });
+
+    it('should write/read to/from the same location', async () => {
+      const { saveServerAddress, getServerAddress } = require('../lib/helpers.js');
+      const serverAddress = 'http://g.codefresh.io';
+      await saveServerAddress(serverAddress);
+      const result = await getServerAddress();
+      expect(result).to.be.equal(serverAddress);
+    });
+  });
+});