add test for current variable

Author: potapovDim

bin/rerun

@@ -15,7 +15,7 @@ if(argv.protractor) {
     stackAnalize: () => true,
     everyCycleCallback: async () => true,
     grepWord: argv.grepWord || '',
-    longestTestTime: 450000,
+    longestProcessTime: 450000,
     debugProcess: false,
     formCommanWithOption: undefined,
     pollTime: 1000

lib/commandExecutorBuilder.js

@@ -6,7 +6,7 @@ function buildCommandExecutor(failedByAssert, runOpts) {
   const {
     addSpecificOptionsBeforeRun,
     currentExecutionVariable,
-    longestTestTime,
+    longestProcessTime,
     debugProcess,
     addCommandOptionsAfterRun,
     stackAnalize
@@ -15,9 +15,16 @@ function buildCommandExecutor(failedByAssert, runOpts) {
 
   const executeCommandAsync = (cmd, index) => new Promise((resolve) => {
 
+    let watcher = null
     let specificCallBack = null
+    let killTooLongExecution = null
     let executionStack = ''
 
+    /**
+     * @now this variable will be used for process kill if time more than @longestProcessTime
+     */
+    const now = +Date.now()
+
     /**
      * @param {undefined|function} addSpecificOptions if function cmd will go to this function as argument
      */
@@ -37,12 +44,17 @@ function buildCommandExecutor(failedByAssert, runOpts) {
 
     if(debugProcess) {console.log(cmd)}
 
-    const now = +Date.now()
     const proc = exec(cmd)
 
-    const killTooLongExecution = () => {if(+Date.now() - now > longestTestTime) {clearInterval(watcher); proc.kill(); resolve(cmd)} };
+    killTooLongExecution = () => {
+      if(+Date.now() - now > longestProcessTime) {
+        clearInterval(watcher)
+        proc.kill()
+        resolve(cmd)
+      }
+    };
 
-    const watcher = setInterval(killTooLongExecution, 15000)
+    watcher = setInterval(killTooLongExecution, 5000)
 
     proc.on('exit', () => {clearInterval(watcher)})
 

lib/index.js

@@ -14,7 +14,7 @@ function reRunnerBuilder(runOptions) {
     intervalPoll,
     everyCycleCallback: afterSingleRunCallBack,
     specsDir,
-    longestTestTime,
+    longestProcessTime,
     formCommanWithOption: addSpecificOptionsBeforeRun,
     currentExecutionVariable
   } = runOptions
@@ -30,7 +30,7 @@ function reRunnerBuilder(runOptions) {
   const executeCommandAsync = buildCommandExecutor(failedByAssert, {
     addSpecificOptionsBeforeRun,
     currentExecutionVariable,
-    longestTestTime,
+    longestProcessTime,
     debugProcess,
     addCommandOptionsAfterRun,
     stackAnalize
@@ -96,7 +96,7 @@ module.exports = {
     everyCycleCallback,
     reformatCommand,
     grepWord = '',
-    longestTestTime = 450000,
+    longestProcessTime = 450000,
     debugProcess = false,
     formCommanWithOption,
     pollTime = 1000,
@@ -106,7 +106,7 @@ module.exports = {
     const reformattedArgs = {
       formCommanWithOption,
       debugProcess,
-      longestTestTime,
+      longestProcessTime,
       maxSessionCount,
       specRerunCount,
       reformatCommand,

unit_specs/commandExecutorBuilder.spec.js

@@ -62,4 +62,81 @@ describe('buildCommandExecutor', () => {
     expect(holder.cmd).to.eq(cmd)
     expect(holder.stack).to.eq('test\n')
   })
+
+  it('longestProcessTime', async () => {
+    {
+      const failedByAssert = []
+      let holder = null
+      const stackAnalize = (stack) => {
+        holder = {}
+        holder.fromStackAnalize = stack
+        return false
+      }
+      const cmd = `node -e "(async function() {await new Promise((res) => setTimeout(() => {
+        res(process.exit(1))
+      }, 25000))})()"`
+
+      const executeCommandAsync = buildCommandExecutor(failedByAssert, {stackAnalize, longestProcessTime: 1})
+      await executeCommandAsync(cmd)
+      expect(holder).to.eq(null)
+    }
+    {
+      const failedByAssert = []
+      let holder = null
+      const stackAnalize = (stack) => {
+        holder = {}
+        holder.fromStackAnalize = stack
+        return false
+      }
+      const cmd = `node -e "(async function() {await new Promise((res) => setTimeout(() => {
+        res(process.exit(1))
+      }, 1))})()"`
+
+      const executeCommandAsync = buildCommandExecutor(failedByAssert, {stackAnalize, longestProcessTime: 10000})
+      await executeCommandAsync(cmd)
+      expect(holder).to.not.eq(null)
+    }
+  })
+
+  it('currentExecutionVariable', async () => {
+    const failedByAssert = []
+    let holder = null
+    const cmd = `node -e "console.log('test'); process.exit(1)"`
+
+    const stackAnalize = (stack) => {
+      holder = {}
+      holder.fromStackAnalize = stack
+      return false
+    }
+
+    const addCommandOptionsAfterRun = (cmd, stack) => {
+      if(!holder) holder = {}
+      holder.cmd = cmd
+      holder.stack = stack
+    }
+    const currentExecutionVariable = 'CURRENT_COUNT'
+
+    const executeCommandAsync = buildCommandExecutor(failedByAssert, {
+      stackAnalize,
+      addCommandOptionsAfterRun,
+      currentExecutionVariable
+    })
+
+    const expetedReformatedCommandFirstIteration = `${currentExecutionVariable}=${1} ${cmd}`
+    const expetedReformatedCommandSecondIteration = `${currentExecutionVariable}=${2} ${cmd}`
+
+    // first iteration
+    await executeCommandAsync(cmd, 1)
+
+    expect(holder.fromStackAnalize).to.eq('test\n')
+    expect(holder.cmd).to.eq(expetedReformatedCommandFirstIteration)
+    expect(holder.stack).to.eq('test\n')
+
+    await executeCommandAsync(expetedReformatedCommandFirstIteration, 2)
+
+    expect(holder.fromStackAnalize).to.eq('test\n')
+    expect(holder.cmd).to.eq(expetedReformatedCommandSecondIteration)
+    expect(holder.stack).to.eq('test\n')
+
+  })
 })