add possibility to run functions

Author: potapovDim

lib/executor.circle.ts

@@ -1,5 +1,5 @@
 /* eslint-disable sonarjs/cognitive-complexity */
-import { toArray, isFunction, isAsyncFunction, shuffleArrMutable } from 'sat-utils';
+import { toArray, isFunction, isAsyncFunction, shuffleArrMutable, isString } from 'sat-utils';
 import { buildCommandExecutor } from './command.executor.builder';
 import { sleep } from './helpers';
 import { logger } from './logger';
@@ -64,7 +64,14 @@ async function circleExecutor(runOptions, commandsArray): Promise<{ retriable: s
       if (shuffle) {
         shuffleArrMutable(commands);
       }
-      const result = await executeCommandAsync(commands.splice(0, 1)[0], runIndex).catch(error => logger.error(error));
+      let result;
+
+      const commandToExecute = commands.splice(0, 1)[0];
+      if (isString(commandToExecute)) {
+        result = await executeCommandAsync(commandToExecute, runIndex).catch(error => logger.error(error));
+      } else if (isFunction(commandToExecute) || isAsyncFunction(commandToExecute)) {
+        result = await commandToExecute(runIndex).catch(error => logger.error(error));
+      }
 
       if (result) {
         retriable.push(result);

lib/executor.intime.ts

@@ -1,4 +1,4 @@
-import { shuffleArrMutable } from 'sat-utils';
+import { shuffleArrMutable, isString, isFunction, isAsyncFunction } from 'sat-utils';
 import { buildCommandExecutor } from './command.executor.builder';
 import { sleep } from './helpers';
 import { logger } from './logger';
@@ -55,12 +55,17 @@ async function intimeExecutor(runOptions, commandsArray): Promise<{ retriable: s
       if (shuffle) {
         shuffleArrMutable(commands);
       }
-      const commadData = commands.splice(0, 1)[0] as { cmd: string; attemptsCount: number };
-      const executionIndex = commadData.attemptsCount--;
+      let result;
+      const commadData = commands.splice(0, 1)[0] as { cmd; attemptsCount: number };
 
-      const result = await executeCommandAsync(commadData.cmd, attemptsCount - executionIndex).catch(error =>
-        logger.error(error),
-      );
+      const executionIndex = commadData.attemptsCount--;
+      if (isString(commadData.cmd)) {
+        result = await executeCommandAsync(commadData.cmd, attemptsCount - executionIndex).catch(error =>
+          logger.error(error),
+        );
+      } else if (isFunction(commadData.cmd) || isAsyncFunction(commadData.cmd)) {
+        result = await commadData.cmd(attemptsCount - executionIndex).catch(error => logger.error(error));
+      }
 
       if (result) {
         logIntimeCommand(commadData);

lib/index.ts

@@ -35,7 +35,7 @@ export type TBuildOpts = {
 };
 
 export type TRunner = {
-  (commands: string[]): Promise<{ notRetriable: string[]; retriable: string[] }>;
+  (commands: string[] | Array<(index: number) => any>): Promise<{ notRetriable: string[]; retriable: string[] }>;
 };
 
 const getReruner = ({

package.json

@@ -1,6 +1,6 @@
 {
   "name": "process-rerun",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/potapovDim/protractor-rerun.git"

specs/index.spec.ts

@@ -1,3 +1,4 @@
+import { sleep } from 'sat-utils';
 import { expect } from 'assertior';
 import { getReruner } from '../lib';
 
@@ -41,7 +42,7 @@ describe('index ', () => {
       maxThreads: 4,
       attemptsCount: 1,
       longestProcessTime: 10,
-      processResultAnalyzer: () => null,
+      processResultAnalyzer: () => false,
       pollTime: 10,
       logLevel: 'MUTE',
     });
@@ -73,7 +74,7 @@ describe('index ', () => {
     ];
     let cmdTest = null;
     let stackTraceTest = null;
-    let notRetriableTest = null;
+    let notRetriableTest: any = null;
     const processResultAnalyzer = (cmd, stackTrace, notRetriable) => {
       cmdTest = cmd;
       stackTraceTest = stackTrace;
@@ -112,4 +113,52 @@ describe('index ', () => {
     expect(result.notRetriable).toDeepEqual([]);
     expect(result.retriable).toDeepEqual([]);
   });
+
+  it('[p] successExitCode', async function () {
+    const commands = [
+      async () => {
+        await sleep(500);
+      },
+      async () => {
+        await sleep(500);
+      },
+    ];
+    const processResultAnalyzer = cmd => cmd;
+    const runner = getReruner({
+      maxThreads: 4,
+      attemptsCount: 1,
+      longestProcessTime: 10 * 1000,
+      processResultAnalyzer,
+      successExitCode: 100,
+      pollTime: 10,
+      logLevel: 'MUTE',
+    });
+    const result = await runner(commands);
+    expect(result.notRetriable).toDeepEqual([]);
+    expect(result.retriable).toDeepEqual([]);
+  });
+
+  it('[p] successExitCode', async function () {
+    const commands = [
+      async function test() {
+        await sleep(500);
+      },
+      async () => {
+        await sleep(500);
+      },
+    ];
+    const processResultAnalyzer = cmd => cmd;
+    const runner = getReruner({
+      maxThreads: 4,
+      attemptsCount: 1,
+      longestProcessTime: 10 * 1000,
+      processResultAnalyzer,
+      successExitCode: 100,
+      pollTime: 10,
+      logLevel: 'MUTE',
+    });
+    const result = await runner(commands);
+    expect(result.notRetriable).toDeepEqual([]);
+    expect(result.retriable).toDeepEqual([]);
+  });
 });