test: improve test coverage

Signed-off-by: Lenin Mehedy <[email protected]>

src/commands/base.mjs

@@ -18,20 +18,7 @@
 import { FullstackTestingError, MissingArgumentError } from '../core/errors.mjs'
 import { ConfigManager } from '../core/index.mjs'
 import { ShellRunner } from '../core/shell_runner.mjs'
-
-/**
- * This is a default command error handler used by handleCommand
- * @param err error
- * @param logger logger
- */
-const defaultErrorHandler = (err, logger) => {
-  logger.showUserError(err)
-
-  // do not exit immediately so that logger can flush properly
-  setTimeout(() => {
-    process.exit(1)
-  }, 1)
-}
+import * as helpers from '../core/helpers.mjs'
 
 export class BaseCommand extends ShellRunner {
   async prepareChartPath (chartDir, chartRepo, chartName) {
@@ -74,14 +61,14 @@ export class BaseCommand extends ShellRunner {
    * @param errHandler error handler
    * @return {Promise<void>}
    */
-  async handleCommand (argv, handleFunc, errHandler = defaultErrorHandler) {
+  async handleCommand (argv, handleFunc, errHandler = helpers.defaultErrorHandler) {
     if (!argv) throw new MissingArgumentError('argv is required')
     if (!handleFunc) throw new MissingArgumentError('handleFunc is required')
 
     let error = null
     try {
       this.logger.debug(`==== Start: '${argv._.join(' ')}' ===`, { config: this.configManager.config, argv })
-      await ConfigManager.acquireProcessLock(this.logger)
+      await ConfigManager.acquireProcessLock(this.logger, errHandler)
       await handleFunc(argv)
     } catch (e) {
       error = new FullstackTestingError(`Error occurred: ${e.message}`, e)

src/commands/init.mjs

@@ -165,8 +165,7 @@ export class InitCommand extends BaseCommand {
       },
       handler: argv => initCmd.handleCommand(
         argv,
-        async (args) => await initCmd.init(args),
-        initCmd.logger
+        async (args) => await initCmd.init(args)
       )
     }
   }

src/core/config_manager.mjs

@@ -240,7 +240,7 @@ export class ConfigManager {
    * @param lockExistHandler error handler when lock exists
    * @return {void}
    */
-  static acquireProcessLock (logger, lockExistHandler = (existingPid) => { process.exit(1) }) {
+  static async acquireProcessLock (logger, lockExistHandler = helpers.defaultErrorHandler) {
     const pid = process.pid.toString()
     const pidFile = path.normalize(constants.SOLO_PID_FILE)
     if (!fs.existsSync(pidFile)) {
@@ -254,10 +254,9 @@ export class ConfigManager {
 
     // pid lock exists
     const existingPid = fs.readFileSync(pidFile).toString()
-    logger.showUserError(new FullstackTestingError(`Process lock exists: ${constants.SOLO_PID_FILE}` +
-      `\nEnsure process '${existingPid}' is not running [ ps -p ${existingPid} ]`))
-
-    return lockExistHandler(existingPid)
+    const err = new FullstackTestingError(`Process lock exists: ${constants.SOLO_PID_FILE}` +
+      `\nEnsure process '${existingPid}' is not running [ ps -p ${existingPid} ]`)
+    return lockExistHandler(err, logger)
   }
 
   /**
@@ -269,7 +268,7 @@ export class ConfigManager {
    * @param logger
    * @return {Promise<void>}
    */
-  static releaseProcessLock (logger) {
+  static async releaseProcessLock (logger) {
     const pidFile = path.normalize(constants.SOLO_PID_FILE)
     if (fs.existsSync(pidFile)) {
       const existingPid = fs.readFileSync(pidFile).toString()

src/core/helpers.mjs

@@ -138,3 +138,17 @@ export function getRootImageRepository (releaseTag) {
 export function getTmpDir () {
   return fs.mkdtempSync(path.join(constants.SOLO_TMP_DIR, 'solo-'))
 }
+
+/**
+ * This is a default command error handler used by handleCommand
+ * @param err error
+ * @param logger logger
+ */
+export function defaultErrorHandler (err, logger) {
+  logger.showUserError(err)
+
+  // do not exit immediately so that logger can flush properly
+  setTimeout(() => {
+    process.exit(1)
+  }, 1)
+}

test/unit/commands/base.test.mjs

@@ -15,7 +15,9 @@
  *
  */
 import { expect, it, describe } from '@jest/globals'
+import fs from 'fs'
 import {
+  constants,
   DependencyManager,
   ChartManager,
   ConfigManager,
@@ -51,4 +53,38 @@ describe('BaseCommand', () => {
       await expect(baseCmd.run('date')).resolves.not.toBeNull()
     })
   })
+
+  describe('handle command', () => {
+    it('should succeed in running a valid command handler', async () => {
+      expect.assertions(2)
+      expect(fs.existsSync(constants.SOLO_PID_FILE)).toBeFalsy()
+
+      const argv = {}
+      argv._ = ['test']
+
+      let error = null
+      await baseCmd.handleCommand(argv,
+        async () => {
+        },
+        (err, logger) => {
+          error = err
+        }
+      )
+      expect(error).toBeNull()
+    })
+
+    it('should throw error if it fails to do process lock', async () => {
+      expect.assertions(2)
+      expect(fs.existsSync(constants.SOLO_PID_FILE)).toBeFalsy()
+      await ConfigManager.acquireProcessLock(testLogger)
+
+      const argv = {}
+      argv._ = ['test']
+      await baseCmd.handleCommand(argv, async () => {
+      }, (err, logger) => {
+        expect(err.message.startsWith('Process lock exists')).toBeTruthy()
+      })
+      await ConfigManager.releaseProcessLock(testLogger)
+    })
+  })
 })

test/unit/core/config_manager.test.mjs

@@ -313,15 +313,17 @@ describe('ConfigManager', () => {
   })
 
   describe('process lock', () => {
-    it('should be able to acquire process lock', () => {
+    it('should be able to acquire process lock', async () => {
       expect(fs.existsSync(constants.SOLO_PID_FILE)).toBeFalsy()
-      ConfigManager.acquireProcessLock(testLogger)
+      await ConfigManager.acquireProcessLock(testLogger)
       expect(fs.existsSync(constants.SOLO_PID_FILE)).toBeTruthy()
       expect(fs.readFileSync(constants.SOLO_PID_FILE).toString()).toStrictEqual(process.pid.toString())
-      ConfigManager.acquireProcessLock(testLogger, (existingPid) => {
-        expect(existingPid).toStrictEqual(process.pid.toString())
+
+      // re-attempt should fail
+      await ConfigManager.acquireProcessLock(testLogger, (err, _) => {
+        expect(err.message.startsWith('Process lock exists'))
       })
-      ConfigManager.releaseProcessLock(testLogger)
+      await ConfigManager.releaseProcessLock(testLogger)
       expect(fs.existsSync(constants.SOLO_PID_FILE)).toBeFalsy()
     })
   })