fix failed test pushing

Author: potapovDim

lib/commandExecutorBuilder.js

@@ -66,10 +66,14 @@ function buildCommandExecutor(failedByAssert, runOpts) {
 
     proc.on('close', async (code) => {
 
+      let commandToRerun = null
 
       if(debugProcess) {console.log(executionStack, code)}
 
-      let commandToRerun = null
+      // if process code 0 - exit as a success result
+      if(code === 0) {
+        resolve(commandToRerun); return
+      }
       // stackAnalize - check that stack contains or not contains some specific data
       if(code !== 0 && stackAnalize && stackAnalize(executionStack)) {
         commandToRerun = cmd
@@ -90,7 +94,6 @@ function buildCommandExecutor(failedByAssert, runOpts) {
       if(addCommandOptionsAfterRun && commandToRerun) {
         commandToRerun = addCommandOptionsAfterRun(commandToRerun, executionStack)
       }
-
       resolve(commandToRerun)
     })
   })

lib/index.js

@@ -43,23 +43,38 @@ function reRunnerBuilder(runOptions) {
       .map((file) => getFormedRunCommand(file)))
       .filter(function(cmd) {return cmd.includes(grepWord)})
 
-    const failedTests = await new Array(commandRunTriesCount)
+    const failedCommands = await new Array(commandRunTriesCount)
+      // create array with current length
       .fill(commandRunTriesCount)
+      // execute run
       .reduce((resolver, /*current*/ current, index) => {
-        return resolver.then((resolvedCommandsArray) => runCommandsArray(resolvedCommandsArray, [], index)
-          .then((failedCommandsArray) => failedCommandsArray))
+
+        return resolver.then((resolvedCommandsArray) => {
+
+          // console.log(resolvedCommandsArray, 'Commands array', index)
+
+          return runCommandsArray(resolvedCommandsArray, [], index)
+
+            .then((failedCommandsArray) => {
+              console.log(failedCommandsArray, 'failed commands')
+              return failedCommandsArray
+            })
+        })
       }, Promise.resolve(commandsArray))
 
     /**
     * @param {Array} commands command array what should be executed
     * @param {Array} failedCommands array what will contains failed commands
     * @returns {void}
     */
+
     async function runCommand(commands, failedCommands) {
       if(maxSessionCount > currentSessionCount && commands.length) {
         currentSessionCount += 1
-        const result = await executeCommandAsync(commands.splice(0, 1)[0]).catch(console.error);
-        if(result) {failedCommands.push(result)}
+        const result = await executeCommandAsync(commands.splice(0, 1)[0]).catch(console.error)
+        if(result) {
+          failedCommands.push(result)
+        }
         currentSessionCount -= 1
       }
     }
@@ -80,8 +95,11 @@ function reRunnerBuilder(runOptions) {
       return failedCommands
     }
 
-    console.log(failedTests.length, 'Failed test count')
-    return [...failedTests, ...failedByAssert]
+    const combinedFailedProcesses = [...failedCommands, ...failedByAssert]
+
+    console.log(combinedFailedProcesses.length, 'Failed test count')
+
+    return combinedFailedProcesses
   }
 
   return reRunner
@@ -101,7 +119,7 @@ module.exports = {
     formCommanWithOption,
     pollTime = 1000,
     currentExecutionVariable
-  }) => {
+  } = {}) => {
 
     const reformattedArgs = {
       formCommanWithOption,

unit_specs/commandExecutorBuilder.spec.js

@@ -4,22 +4,41 @@ const {buildCommandExecutor} = require('../lib/commandExecutorBuilder')
 
 describe('buildCommandExecutor', () => {
 
-  it('addSpecificOptionsBeforeRun', async () => {
-    const failedByAssert = []
-    let holder = null
+  it.only('addSpecificOptionsBeforeRun', async () => {
+    {
+      const cmd = 'node -e "console.log(\'test\')"'
+      const failedByAssert = []
+      let holder = null
 
-    const addSpecificOptionsBeforeRun = (cmd) => {
-      const reformatedCmd = `${cmd} && echo "FOO"`
-      holder = {cmd: reformatedCmd}
-      const cmdExecutableCB = () => {holder.exec = true}
+      const addSpecificOptionsBeforeRun = (cmd) => {
+        const reformatedCmd = `${cmd} && echo "FOO"`
+        holder = {cmd: reformatedCmd}
+        const cmdExecutableCB = () => {holder.exec = true}
+        return {cmd, cmdExecutableCB}
+      }
 
-      return {cmd, cmdExecutableCB}
+      const executeCommandAsync = buildCommandExecutor(failedByAssert, {addSpecificOptionsBeforeRun})
+      await executeCommandAsync(cmd)
+      expect(holder.cmd).to.eq(`${cmd} && echo "FOO"`)
+      expect(holder.exec).to.eq(undefined)
     }
+    {
+      const cmd = 'node -e "console.log(\'test\'); process.exit(100)"'
+      const failedByAssert = []
+      let holder = null
 
-    const executeCommandAsync = buildCommandExecutor(failedByAssert, {addSpecificOptionsBeforeRun})
-    await executeCommandAsync('node -e "console.log(\'test\')"')
-    expect(holder.cmd).to.eq('node -e "console.log(\'test\')" && echo "FOO"')
-    expect(holder.exec).to.eq(true)
+      const addSpecificOptionsBeforeRun = (cmd) => {
+        const reformatedCmd = `${cmd} && echo "FOO"`
+        holder = {cmd: reformatedCmd}
+        const cmdExecutableCB = () => {holder.exec = true}
+        return {cmd, cmdExecutableCB}
+      }
+
+      const executeCommandAsync = buildCommandExecutor(failedByAssert, {addSpecificOptionsBeforeRun})
+      await executeCommandAsync(cmd)
+      expect(holder.cmd).to.eq(`${cmd} && echo "FOO"`)
+      expect(holder.exec).to.eq(true)
+    }
   })
 
   it('addCommandOptionsAfterRun', async () => {

unit_specs/index.spec.js

@@ -0,0 +1,23 @@
+const {expect} = require('chai')
+const {buildExeRun} = require('../lib')
+
+describe('kernel', () => {
+  it('buildExeRun', async () => {
+    // all negative
+    {
+      const cmd = `node -e "console.log('test'); process.exit(1)"`
+      const cmds = [cmd, cmd, cmd]
+      const reRunner = buildExeRun()
+      const failedCmds = await reRunner(cmds)
+      expect(failedCmds.length).to.eq(3)
+    }
+    // all positive
+    {
+      const cmd = `node -e "console.log('test')"`
+      const cmds = [cmd, cmd, cmd]
+      const reRunner = buildExeRun()
+      const failedCmds = await reRunner(cmds)
+      expect(failedCmds.length).to.eq(0)
+    }
+  })
+})