providing the option to do a setup and teardown (#18)

package.json

@@ -2,7 +2,7 @@
   "name": "@idrinth/api-bench",
   "description": "A library to benchmark apis, no matter if rest or soap",
   "license": "MIT",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "homepage": "https://github.com/Idrinth/api-bench",
   "repository": {
     "type": "git",

src/executor.ts

@@ -4,9 +4,6 @@ import {
 import {
   FinishedSet,
 } from './finished-set';
-import {
-  Task,
-} from './task';
 import {
   ResultSet,
 } from './result-set';
@@ -22,8 +19,10 @@ import {
 import Reporter from './reporter/reporter';
 import * as Progress from 'cli-progress';
 import validateTasks from './validate-tasks';
+import Job from './job';
 
 const EMPTY = 0;
+const SINGLE = 1;
 
 export interface WorkerConstructor {
   new(path: string);
@@ -42,7 +41,7 @@ export interface Thread {
 const executor = (
   threads: number,
   repetitions: number,
-  tasks: Array<Task>,
+  job: Job,
   resultHandler: Reporter,
   logger: Logger,
   Worker: WorkerConstructor,
@@ -51,7 +50,7 @@ const executor = (
     const path = `${ __dirname }/../worker/${ file }.js`;
     return new Worker(realpathSync(path,),);
   };
-  validateTasks(repetitions, threads, tasks,);
+  validateTasks(repetitions, threads, job.main,);
   const validator: Thread = buildWorker('validator',);
   const calculator: Thread = buildWorker('calculator',);
   const bar = new Progress.SingleBar({
@@ -69,12 +68,21 @@ const executor = (
     'initializing tasks to have '+
    `${ threads } Threads x ${ repetitions } Repetitions todos`,
   );
-  for (const task of tasks) {
+  for (const task of job.main) {
     for (let i=0; i<threads*repetitions; i ++) {
       internalTasks.push(task,);
     }
   }
-  bar.start(internalTasks.length + internalTasks.length + tasks.length, EMPTY,);
+  const barLength = (() => {
+    const main = job.main.length * repetitions * threads;
+    const mainFactor = SINGLE + job.afterEach.length + job.beforeEach.length;
+    const validation = job.main.length * repetitions * threads;
+    const calculation = job.main.length;
+    const pre = job.before.length + job.beforeTask.length * job.main.length;
+    const post = job.after.length + job.afterTask.length * job.main.length;
+    return pre + main * mainFactor + post + validation + calculation;
+  })();
+  bar.start(barLength, EMPTY,);
   calculator.on('message', (data: FinishedSet,) => {
     finished[data.id] = data;
     logger.debug(`Analyzation of ${ data.id } finished`,);
@@ -106,25 +114,64 @@ const executor = (
       logger.info('Validations done',);
     }
   },);
-  logger.debug(`starting up ${ threads } Workers`,);
-  for (let j=0; j<threads; j ++) {
-    workers.push(buildWorker('webrequest',),);
-    workers[j].on('message', (data: Result,) => {
-      logger.debug(`Starting validation of ${ data.id }`,);
-      checking ++;
-      bar.increment();
-      validator.postMessage(data,);
-      if (internalTasks.length > EMPTY) {
-        logger.debug('Starting next request',);
-        workers[j].postMessage(internalTasks.shift(),);
-        return;
-      }
-      active --;
-      workers[j].terminate();
-      logger.info('All requests done, terminating thread',);
-    },);
-    active ++;
-    workers[j].postMessage(internalTasks.shift(),);
+  const before = buildWorker('webrequest',);
+  const after = buildWorker('webrequest',);
+  const startMain = () => {
+    logger.debug(`starting up ${ threads } Workers`,);
+    for (let j=0; j<threads; j ++) {
+      workers.push(buildWorker('webrequest',),);
+      workers[j].on('message', (data: Result,) => {
+        logger.debug(`Starting validation of ${ data.id }`,);
+        checking ++;
+        bar.increment();
+        validator.postMessage(data,);
+        if (internalTasks.length > EMPTY) {
+          logger.debug('Starting next request',);
+          workers[j].postMessage(internalTasks.shift(),);
+          return;
+        }
+        active --;
+        workers[j].terminate();
+        logger.info('All requests done, terminating thread',);
+        if (active === EMPTY) {
+          if (job.after.length > EMPTY) {
+            logger.debug('Starting next request',);
+            after.postMessage(job.after.shift(),);
+          } else {
+            after.terminate();
+            before.terminate();
+          }
+        }
+      },);
+      active ++;
+      workers[j].postMessage(internalTasks.shift(),);
+    }
+  };
+  after.on('message', () => {
+    bar.increment();
+    if (job.after.length > EMPTY) {
+      logger.debug('Starting next request',);
+      after.postMessage(job.after.shift(),);
+      return;
+    }
+    after.terminate();
+    before.terminate();
+  },);
+  before.on('message', () => {
+    bar.increment();
+    if (job.before.length > EMPTY) {
+      logger.debug('Starting next request',);
+      before.postMessage(job.before.shift(),);
+      return;
+    }
+    before.terminate();
+    startMain();
+  },);
+  if (job.before.length > EMPTY) {
+    logger.debug('Starting next request',);
+    before.postMessage(job.before.shift(),);
+  } else {
+    startMain();
   }
 };
 

src/job.ts

@@ -0,0 +1,14 @@
+import {
+  Task,
+} from './task';
+
+interface Job {
+    before: Task[],
+    beforeTask: Task[],
+    beforeEach: Task[],
+    main: Task[],
+    afterEach: Task[],
+    afterTask: Task[],
+    after: Task[],
+}
+export default Job;

src/main.ts

@@ -13,20 +13,42 @@ import executor from './executor';
 import {
   Worker,
 } from 'worker_threads';
+import Job from './job';
 
 /* eslint max-params:0 */
-export default (
+const run = (
   threads: number,
   repetitions: number,
-  tasks: Array<Task>,
+  job: Job,
   resultHandler?: Reporter|undefined,
   logger?: Logger|undefined,
-): void => {
+) => {
   if (typeof logger === 'undefined') {
     logger = new NullLogger();
   }
   if (typeof resultHandler === 'undefined') {
     resultHandler = defaultReporter;
   }
-  executor(threads, repetitions, tasks, resultHandler, logger, Worker,);
+  executor(threads, repetitions, job, resultHandler, logger, Worker,);
+};
+
+/* eslint max-params:0 */
+export default (
+  threads: number,
+  repetitions: number,
+  tasks: Array<Task>,
+  resultHandler?: Reporter|undefined,
+  logger?: Logger|undefined,
+): void => {
+  const job: Job = {
+    before: [],
+    beforeTask: [],
+    beforeEach: [],
+    main: tasks,
+    afterEach: [],
+    afterTask: [],
+    after: [],
+  };
+  run(threads, repetitions, job, resultHandler, logger,);
 };
+//export run;

test/executor.ts

@@ -23,6 +23,7 @@ import {
 import {
   realpathSync,
 } from 'fs';
+import Job from '../src/job';
 
 // eslint-disable-next-line @typescript-eslint/no-empty-function
 const NOOP = () => {};
@@ -126,34 +127,55 @@ class FakeWorker implements Thread {
 describe('executor', () => {
   const repeats = 2;
   const threads = 3;
+  const setup = 2;
   const tasks = [ <Task> {
     id: 'test',
   }, ];
+  const noJob: Job = {
+    before: [],
+    beforeTask: [],
+    beforeEach: [],
+    main: [],
+    afterEach: [],
+    afterTask: [],
+    after: [],
+  };
+  const job: Job = {
+    ...noJob,
+    main: tasks,
+  };
   const once = 1;
   it('should be a function', () => {
     expect(executor,).to.be.a('function',);
   },);
   it('should not try to execute no tasks(0 tasks)', () => {
     expect(
-      () => executor(threads, repeats, [], NOOP, new NullLogger(), FakeWorker,),
+      () => executor(
+        threads,
+        repeats,
+        noJob,
+        NOOP,
+        new NullLogger(),
+        FakeWorker,
+      ),
     ).to.throw('Can\'t measure no tasks.',);
   },);
   it('should not try to execute no tasks(0 threads)', () => {
     expect(
-      () => executor(NONE, repeats, tasks, NOOP, new NullLogger(), FakeWorker,),
+      () => executor(NONE, repeats, job, NOOP, new NullLogger(), FakeWorker,),
     ).to.throw('Can\'t measure no tasks.',);
   },);
   it('should not try to execute no tasks (0 repeats)', () => {
     expect(
-      () => executor(threads, NONE, tasks, NOOP, new NullLogger(), FakeWorker,),
+      () => executor(threads, NONE, job, NOOP, new NullLogger(), FakeWorker,),
     ).to.throw('Can\'t measure no tasks.',);
   },);
   it('should execute all tasks', (done,) => {
     expect(
       () => executor(
         threads,
         repeats,
-        tasks,
+        job,
         () => done(),
         new NullLogger(),
         FakeWorker,
@@ -164,14 +186,14 @@ describe('executor', () => {
     const output = {};
     output[realpathSync('./worker/calculator.js',)] = once;
     output[realpathSync('./worker/validator.js',)] = once;
-    output[realpathSync('./worker/webrequest.js',)] = threads;
+    output[realpathSync('./worker/webrequest.js',)] = threads + setup;
     expect(FakeWorker.built,).to.deep.equal(output,);
   },);
   it('should have shut down the right workers', () => {
     const output = {};
     output[realpathSync('./worker/calculator.js',)] = once;
     output[realpathSync('./worker/validator.js',)] = once;
-    output[realpathSync('./worker/webrequest.js',)] = threads;
+    output[realpathSync('./worker/webrequest.js',)] = threads + setup;
     expect(FakeWorker.terminated,).to.deep.equal(output,);
   },);
 },);