tests/pools/abstract/abstract-pool.test.js

   1 const { expect } = require('expect')
   2 const {
   3   DynamicClusterPool,
   4   DynamicThreadPool,
   5   FixedClusterPool,
   6   FixedThreadPool,
   7   PoolEvents,
   8   WorkerChoiceStrategies,
   9   PoolTypes,
  10   WorkerTypes
  11 } = require('../../../lib')
  12 const { CircularArray } = require('../../../lib/circular-array')
  13 const { Queue } = require('../../../lib/queue')
  14 const { version } = require('../../../package.json')
  15
  16 describe('Abstract pool test suite', () => {
  17   const numberOfWorkers = 2
  18   class StubPoolWithRemoveAllWorker extends FixedThreadPool {
  19     removeAllWorker () {
  20       this.workerNodes = []
  21       this.promiseResponseMap.clear()
  22     }
  23   }
  24   class StubPoolWithIsMain extends FixedThreadPool {
  25     isMain () {
  26       return false
  27     }
  28   }
  29
  30   it('Simulate pool creation from a non main thread/process', () => {
  31     expect(
  32       () =>
  33         new StubPoolWithIsMain(
  34           numberOfWorkers,
  35           './tests/worker-files/thread/testWorker.js',
  36           {
  37             errorHandler: e => console.error(e)
  38           }
  39         )
  40     ).toThrowError('Cannot start a pool from a worker!')
  41   })
  42
  43   it('Verify that filePath is checked', () => {
  44     const expectedError = new Error(
  45       'Please specify a file with a worker implementation'
  46     )
  47     expect(() => new FixedThreadPool(numberOfWorkers)).toThrowError(
  48       expectedError
  49     )
  50     expect(() => new FixedThreadPool(numberOfWorkers, '')).toThrowError(
  51       expectedError
  52     )
  53   })
  54
  55   it('Verify that numberOfWorkers is checked', () => {
  56     expect(() => new FixedThreadPool()).toThrowError(
  57       'Cannot instantiate a pool without specifying the number of workers'
  58     )
  59   })
  60
  61   it('Verify that a negative number of workers is checked', () => {
  62     expect(
  63       () =>
  64         new FixedClusterPool(-1, './tests/worker-files/cluster/testWorker.js')
  65     ).toThrowError(
  66       new RangeError(
  67         'Cannot instantiate a pool with a negative number of workers'
  68       )
  69     )
  70   })
  71
  72   it('Verify that a non integer number of workers is checked', () => {
  73     expect(
  74       () =>
  75         new FixedThreadPool(0.25, './tests/worker-files/thread/testWorker.js')
  76     ).toThrowError(
  77       new TypeError(
  78         'Cannot instantiate a pool with a non safe integer number of workers'
  79       )
  80     )
  81   })
  82
  83   it('Verify that pool options are checked', async () => {
  84     let pool = new FixedThreadPool(
  85       numberOfWorkers,
  86       './tests/worker-files/thread/testWorker.js'
  87     )
  88     expect(pool.emitter).toBeDefined()
  89     expect(pool.opts.enableEvents).toBe(true)
  90     expect(pool.opts.restartWorkerOnError).toBe(true)
  91     expect(pool.opts.enableTasksQueue).toBe(false)
  92     expect(pool.opts.tasksQueueOptions).toBeUndefined()
  93     expect(pool.opts.workerChoiceStrategy).toBe(
  94       WorkerChoiceStrategies.ROUND_ROBIN
  95     )
  96     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
  97       runTime: { median: false },
  98       waitTime: { median: false },
  99       elu: { median: false }
 100     })
 101     expect(pool.opts.messageHandler).toBeUndefined()
 102     expect(pool.opts.errorHandler).toBeUndefined()
 103     expect(pool.opts.onlineHandler).toBeUndefined()
 104     expect(pool.opts.exitHandler).toBeUndefined()
 105     await pool.destroy()
 106     const testHandler = () => console.log('test handler executed')
 107     pool = new FixedThreadPool(
 108       numberOfWorkers,
 109       './tests/worker-files/thread/testWorker.js',
 110       {
 111         workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED,
 112         workerChoiceStrategyOptions: {
 113           runTime: { median: true },
 114           weights: { 0: 300, 1: 200 }
 115         },
 116         enableEvents: false,
 117         restartWorkerOnError: false,
 118         enableTasksQueue: true,
 119         tasksQueueOptions: { concurrency: 2 },
 120         messageHandler: testHandler,
 121         errorHandler: testHandler,
 122         onlineHandler: testHandler,
 123         exitHandler: testHandler
 124       }
 125     )
 126     expect(pool.emitter).toBeUndefined()
 127     expect(pool.opts.enableEvents).toBe(false)
 128     expect(pool.opts.restartWorkerOnError).toBe(false)
 129     expect(pool.opts.enableTasksQueue).toBe(true)
 130     expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 2 })
 131     expect(pool.opts.workerChoiceStrategy).toBe(
 132       WorkerChoiceStrategies.LEAST_USED
 133     )
 134     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
 135       runTime: { median: true },
 136       weights: { 0: 300, 1: 200 }
 137     })
 138     expect(pool.opts.messageHandler).toStrictEqual(testHandler)
 139     expect(pool.opts.errorHandler).toStrictEqual(testHandler)
 140     expect(pool.opts.onlineHandler).toStrictEqual(testHandler)
 141     expect(pool.opts.exitHandler).toStrictEqual(testHandler)
 142     await pool.destroy()
 143   })
 144
 145   it('Verify that pool options are validated', async () => {
 146     expect(
 147       () =>
 148         new FixedThreadPool(
 149           numberOfWorkers,
 150           './tests/worker-files/thread/testWorker.js',
 151           {
 152             workerChoiceStrategy: 'invalidStrategy'
 153           }
 154         )
 155     ).toThrowError("Invalid worker choice strategy 'invalidStrategy'")
 156     expect(
 157       () =>
 158         new FixedThreadPool(
 159           numberOfWorkers,
 160           './tests/worker-files/thread/testWorker.js',
 161           {
 162             workerChoiceStrategyOptions: 'invalidOptions'
 163           }
 164         )
 165     ).toThrowError(
 166       'Invalid worker choice strategy options: must be a plain object'
 167     )
 168     expect(
 169       () =>
 170         new FixedThreadPool(
 171           numberOfWorkers,
 172           './tests/worker-files/thread/testWorker.js',
 173           {
 174             workerChoiceStrategyOptions: { weights: {} }
 175           }
 176         )
 177     ).toThrowError(
 178       'Invalid worker choice strategy options: must have a weight for each worker node'
 179     )
 180     expect(
 181       () =>
 182         new FixedThreadPool(
 183           numberOfWorkers,
 184           './tests/worker-files/thread/testWorker.js',
 185           {
 186             workerChoiceStrategyOptions: { measurement: 'invalidMeasurement' }
 187           }
 188         )
 189     ).toThrowError(
 190       "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
 191     )
 192     expect(
 193       () =>
 194         new FixedThreadPool(
 195           numberOfWorkers,
 196           './tests/worker-files/thread/testWorker.js',
 197           {
 198             enableTasksQueue: true,
 199             tasksQueueOptions: { concurrency: 0 }
 200           }
 201         )
 202     ).toThrowError("Invalid worker tasks concurrency '0'")
 203     expect(
 204       () =>
 205         new FixedThreadPool(
 206           numberOfWorkers,
 207           './tests/worker-files/thread/testWorker.js',
 208           {
 209             enableTasksQueue: true,
 210             tasksQueueOptions: 'invalidTasksQueueOptions'
 211           }
 212         )
 213     ).toThrowError('Invalid tasks queue options: must be a plain object')
 214     expect(
 215       () =>
 216         new FixedThreadPool(
 217           numberOfWorkers,
 218           './tests/worker-files/thread/testWorker.js',
 219           {
 220             enableTasksQueue: true,
 221             tasksQueueOptions: { concurrency: 0.2 }
 222           }
 223         )
 224     ).toThrowError('Invalid worker tasks concurrency: must be an integer')
 225   })
 226
 227   it('Verify that worker choice strategy options can be set', async () => {
 228     const pool = new FixedThreadPool(
 229       numberOfWorkers,
 230       './tests/worker-files/thread/testWorker.js',
 231       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
 232     )
 233     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
 234       runTime: { median: false },
 235       waitTime: { median: false },
 236       elu: { median: false }
 237     })
 238     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
 239       .workerChoiceStrategies) {
 240       expect(workerChoiceStrategy.opts).toStrictEqual({
 241         runTime: { median: false },
 242         waitTime: { median: false },
 243         elu: { median: false }
 244       })
 245     }
 246     expect(
 247       pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
 248     ).toStrictEqual({
 249       runTime: {
 250         aggregate: true,
 251         average: true,
 252         median: false
 253       },
 254       waitTime: {
 255         aggregate: false,
 256         average: false,
 257         median: false
 258       },
 259       elu: {
 260         aggregate: true,
 261         average: true,
 262         median: false
 263       }
 264     })
 265     pool.setWorkerChoiceStrategyOptions({
 266       runTime: { median: true },
 267       elu: { median: true }
 268     })
 269     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
 270       runTime: { median: true },
 271       elu: { median: true }
 272     })
 273     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
 274       .workerChoiceStrategies) {
 275       expect(workerChoiceStrategy.opts).toStrictEqual({
 276         runTime: { median: true },
 277         elu: { median: true }
 278       })
 279     }
 280     expect(
 281       pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
 282     ).toStrictEqual({
 283       runTime: {
 284         aggregate: true,
 285         average: false,
 286         median: true
 287       },
 288       waitTime: {
 289         aggregate: false,
 290         average: false,
 291         median: false
 292       },
 293       elu: {
 294         aggregate: true,
 295         average: false,
 296         median: true
 297       }
 298     })
 299     pool.setWorkerChoiceStrategyOptions({
 300       runTime: { median: false },
 301       elu: { median: false }
 302     })
 303     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
 304       runTime: { median: false },
 305       elu: { median: false }
 306     })
 307     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
 308       .workerChoiceStrategies) {
 309       expect(workerChoiceStrategy.opts).toStrictEqual({
 310         runTime: { median: false },
 311         elu: { median: false }
 312       })
 313     }
 314     expect(
 315       pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
 316     ).toStrictEqual({
 317       runTime: {
 318         aggregate: true,
 319         average: true,
 320         median: false
 321       },
 322       waitTime: {
 323         aggregate: false,
 324         average: false,
 325         median: false
 326       },
 327       elu: {
 328         aggregate: true,
 329         average: true,
 330         median: false
 331       }
 332     })
 333     expect(() =>
 334       pool.setWorkerChoiceStrategyOptions('invalidWorkerChoiceStrategyOptions')
 335     ).toThrowError(
 336       'Invalid worker choice strategy options: must be a plain object'
 337     )
 338     expect(() =>
 339       pool.setWorkerChoiceStrategyOptions({ weights: {} })
 340     ).toThrowError(
 341       'Invalid worker choice strategy options: must have a weight for each worker node'
 342     )
 343     expect(() =>
 344       pool.setWorkerChoiceStrategyOptions({ measurement: 'invalidMeasurement' })
 345     ).toThrowError(
 346       "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
 347     )
 348     await pool.destroy()
 349   })
 350
 351   it('Verify that tasks queue can be enabled/disabled', async () => {
 352     const pool = new FixedThreadPool(
 353       numberOfWorkers,
 354       './tests/worker-files/thread/testWorker.js'
 355     )
 356     expect(pool.opts.enableTasksQueue).toBe(false)
 357     expect(pool.opts.tasksQueueOptions).toBeUndefined()
 358     pool.enableTasksQueue(true)
 359     expect(pool.opts.enableTasksQueue).toBe(true)
 360     expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 1 })
 361     pool.enableTasksQueue(true, { concurrency: 2 })
 362     expect(pool.opts.enableTasksQueue).toBe(true)
 363     expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 2 })
 364     pool.enableTasksQueue(false)
 365     expect(pool.opts.enableTasksQueue).toBe(false)
 366     expect(pool.opts.tasksQueueOptions).toBeUndefined()
 367     await pool.destroy()
 368   })
 369
 370   it('Verify that tasks queue options can be set', async () => {
 371     const pool = new FixedThreadPool(
 372       numberOfWorkers,
 373       './tests/worker-files/thread/testWorker.js',
 374       { enableTasksQueue: true }
 375     )
 376     expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 1 })
 377     pool.setTasksQueueOptions({ concurrency: 2 })
 378     expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 2 })
 379     expect(() =>
 380       pool.setTasksQueueOptions('invalidTasksQueueOptions')
 381     ).toThrowError('Invalid tasks queue options: must be a plain object')
 382     expect(() => pool.setTasksQueueOptions({ concurrency: 0 })).toThrowError(
 383       "Invalid worker tasks concurrency '0'"
 384     )
 385     expect(() => pool.setTasksQueueOptions({ concurrency: 0.2 })).toThrowError(
 386       'Invalid worker tasks concurrency: must be an integer'
 387     )
 388     await pool.destroy()
 389   })
 390
 391   it('Verify that pool info is set', async () => {
 392     let pool = new FixedThreadPool(
 393       numberOfWorkers,
 394       './tests/worker-files/thread/testWorker.js'
 395     )
 396     expect(pool.info).toStrictEqual({
 397       version,
 398       type: PoolTypes.fixed,
 399       worker: WorkerTypes.thread,
 400       minSize: numberOfWorkers,
 401       maxSize: numberOfWorkers,
 402       workerNodes: numberOfWorkers,
 403       idleWorkerNodes: numberOfWorkers,
 404       busyWorkerNodes: 0,
 405       executedTasks: 0,
 406       executingTasks: 0,
 407       queuedTasks: 0,
 408       maxQueuedTasks: 0,
 409       failedTasks: 0
 410     })
 411     await pool.destroy()
 412     pool = new DynamicClusterPool(
 413       numberOfWorkers,
 414       numberOfWorkers * 2,
 415       './tests/worker-files/cluster/testWorker.js'
 416     )
 417     expect(pool.info).toStrictEqual({
 418       version,
 419       type: PoolTypes.dynamic,
 420       worker: WorkerTypes.cluster,
 421       minSize: numberOfWorkers,
 422       maxSize: numberOfWorkers * 2,
 423       workerNodes: numberOfWorkers,
 424       idleWorkerNodes: numberOfWorkers,
 425       busyWorkerNodes: 0,
 426       executedTasks: 0,
 427       executingTasks: 0,
 428       queuedTasks: 0,
 429       maxQueuedTasks: 0,
 430       failedTasks: 0
 431     })
 432     await pool.destroy()
 433   })
 434
 435   it('Simulate worker not found', async () => {
 436     const pool = new StubPoolWithRemoveAllWorker(
 437       numberOfWorkers,
 438       './tests/worker-files/thread/testWorker.js',
 439       {
 440         errorHandler: e => console.error(e)
 441       }
 442     )
 443     expect(pool.workerNodes.length).toBe(numberOfWorkers)
 444     // Simulate worker not found.
 445     pool.removeAllWorker()
 446     expect(pool.workerNodes.length).toBe(0)
 447     await pool.destroy()
 448   })
 449
 450   it('Verify that worker pool tasks usage are initialized', async () => {
 451     const pool = new FixedClusterPool(
 452       numberOfWorkers,
 453       './tests/worker-files/cluster/testWorker.js'
 454     )
 455     for (const workerNode of pool.workerNodes) {
 456       expect(workerNode.usage).toStrictEqual({
 457         tasks: {
 458           executed: 0,
 459           executing: 0,
 460           queued: 0,
 461           maxQueued: 0,
 462           failed: 0
 463         },
 464         runTime: {
 465           history: expect.any(CircularArray)
 466         },
 467         waitTime: {
 468           history: expect.any(CircularArray)
 469         },
 470         elu: {
 471           idle: {
 472             history: expect.any(CircularArray)
 473           },
 474           active: {
 475             history: expect.any(CircularArray)
 476           }
 477         }
 478       })
 479     }
 480     await pool.destroy()
 481   })
 482
 483   it('Verify that worker pool tasks queue are initialized', async () => {
 484     const pool = new FixedClusterPool(
 485       numberOfWorkers,
 486       './tests/worker-files/cluster/testWorker.js'
 487     )
 488     for (const workerNode of pool.workerNodes) {
 489       expect(workerNode.tasksQueue).toBeDefined()
 490       expect(workerNode.tasksQueue).toBeInstanceOf(Queue)
 491       expect(workerNode.tasksQueue.size).toBe(0)
 492       expect(workerNode.tasksQueue.maxSize).toBe(0)
 493     }
 494     await pool.destroy()
 495   })
 496
 497   it('Verify that worker pool tasks usage are computed', async () => {
 498     const pool = new FixedClusterPool(
 499       numberOfWorkers,
 500       './tests/worker-files/cluster/testWorker.js'
 501     )
 502     const promises = new Set()
 503     const maxMultiplier = 2
 504     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
 505       promises.add(pool.execute())
 506     }
 507     for (const workerNode of pool.workerNodes) {
 508       expect(workerNode.usage).toStrictEqual({
 509         tasks: {
 510           executed: 0,
 511           executing: maxMultiplier,
 512           queued: 0,
 513           maxQueued: 0,
 514           failed: 0
 515         },
 516         runTime: {
 517           history: expect.any(CircularArray)
 518         },
 519         waitTime: {
 520           history: expect.any(CircularArray)
 521         },
 522         elu: {
 523           idle: {
 524             history: expect.any(CircularArray)
 525           },
 526           active: {
 527             history: expect.any(CircularArray)
 528           }
 529         }
 530       })
 531     }
 532     await Promise.all(promises)
 533     for (const workerNode of pool.workerNodes) {
 534       expect(workerNode.usage).toStrictEqual({
 535         tasks: {
 536           executed: maxMultiplier,
 537           executing: 0,
 538           queued: 0,
 539           maxQueued: 0,
 540           failed: 0
 541         },
 542         runTime: {
 543           history: expect.any(CircularArray)
 544         },
 545         waitTime: {
 546           history: expect.any(CircularArray)
 547         },
 548         elu: {
 549           idle: {
 550             history: expect.any(CircularArray)
 551           },
 552           active: {
 553             history: expect.any(CircularArray)
 554           }
 555         }
 556       })
 557     }
 558     await pool.destroy()
 559   })
 560
 561   it('Verify that worker pool tasks usage are reset at worker choice strategy change', async () => {
 562     const pool = new DynamicThreadPool(
 563       numberOfWorkers,
 564       numberOfWorkers,
 565       './tests/worker-files/thread/testWorker.js'
 566     )
 567     const promises = new Set()
 568     const maxMultiplier = 2
 569     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
 570       promises.add(pool.execute())
 571     }
 572     await Promise.all(promises)
 573     for (const workerNode of pool.workerNodes) {
 574       expect(workerNode.usage).toStrictEqual({
 575         tasks: {
 576           executed: expect.any(Number),
 577           executing: 0,
 578           queued: 0,
 579           maxQueued: 0,
 580           failed: 0
 581         },
 582         runTime: {
 583           history: expect.any(CircularArray)
 584         },
 585         waitTime: {
 586           history: expect.any(CircularArray)
 587         },
 588         elu: {
 589           idle: {
 590             history: expect.any(CircularArray)
 591           },
 592           active: {
 593             history: expect.any(CircularArray)
 594           }
 595         }
 596       })
 597       expect(workerNode.usage.tasks.executed).toBeGreaterThan(0)
 598       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(maxMultiplier)
 599     }
 600     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
 601     for (const workerNode of pool.workerNodes) {
 602       expect(workerNode.usage).toStrictEqual({
 603         tasks: {
 604           executed: 0,
 605           executing: 0,
 606           queued: 0,
 607           maxQueued: 0,
 608           failed: 0
 609         },
 610         runTime: {
 611           history: expect.any(CircularArray)
 612         },
 613         waitTime: {
 614           history: expect.any(CircularArray)
 615         },
 616         elu: {
 617           idle: {
 618             history: expect.any(CircularArray)
 619           },
 620           active: {
 621             history: expect.any(CircularArray)
 622           }
 623         }
 624       })
 625       expect(workerNode.usage.runTime.history.length).toBe(0)
 626       expect(workerNode.usage.waitTime.history.length).toBe(0)
 627     }
 628     await pool.destroy()
 629   })
 630
 631   it("Verify that pool event emitter 'full' event can register a callback", async () => {
 632     const pool = new DynamicThreadPool(
 633       numberOfWorkers,
 634       numberOfWorkers,
 635       './tests/worker-files/thread/testWorker.js'
 636     )
 637     const promises = new Set()
 638     let poolFull = 0
 639     let poolInfo
 640     pool.emitter.on(PoolEvents.full, info => {
 641       ++poolFull
 642       poolInfo = info
 643     })
 644     for (let i = 0; i < numberOfWorkers * 2; i++) {
 645       promises.add(pool.execute())
 646     }
 647     await Promise.all(promises)
 648     // The `full` event is triggered when the number of submitted tasks at once reach the max number of workers in the dynamic pool.
 649     // So in total numberOfWorkers * 2 times for a loop submitting up to numberOfWorkers * 2 tasks to the dynamic pool with min = max = numberOfWorkers.
 650     expect(poolFull).toBe(numberOfWorkers * 2)
 651     expect(poolInfo).toStrictEqual({
 652       version,
 653       type: PoolTypes.dynamic,
 654       worker: WorkerTypes.thread,
 655       minSize: expect.any(Number),
 656       maxSize: expect.any(Number),
 657       workerNodes: expect.any(Number),
 658       idleWorkerNodes: expect.any(Number),
 659       busyWorkerNodes: expect.any(Number),
 660       executedTasks: expect.any(Number),
 661       executingTasks: expect.any(Number),
 662       queuedTasks: expect.any(Number),
 663       maxQueuedTasks: expect.any(Number),
 664       failedTasks: expect.any(Number)
 665     })
 666     await pool.destroy()
 667   })
 668
 669   it("Verify that pool event emitter 'busy' event can register a callback", async () => {
 670     const pool = new FixedThreadPool(
 671       numberOfWorkers,
 672       './tests/worker-files/thread/testWorker.js'
 673     )
 674     const promises = new Set()
 675     let poolBusy = 0
 676     let poolInfo
 677     pool.emitter.on(PoolEvents.busy, info => {
 678       ++poolBusy
 679       poolInfo = info
 680     })
 681     for (let i = 0; i < numberOfWorkers * 2; i++) {
 682       promises.add(pool.execute())
 683     }
 684     await Promise.all(promises)
 685     // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
 686     // So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
 687     expect(poolBusy).toBe(numberOfWorkers + 1)
 688     expect(poolInfo).toStrictEqual({
 689       version,
 690       type: PoolTypes.fixed,
 691       worker: WorkerTypes.thread,
 692       minSize: expect.any(Number),
 693       maxSize: expect.any(Number),
 694       workerNodes: expect.any(Number),
 695       idleWorkerNodes: expect.any(Number),
 696       busyWorkerNodes: expect.any(Number),
 697       executedTasks: expect.any(Number),
 698       executingTasks: expect.any(Number),
 699       queuedTasks: expect.any(Number),
 700       maxQueuedTasks: expect.any(Number),
 701       failedTasks: expect.any(Number)
 702     })
 703     await pool.destroy()
 704   })
 705
 706   it('Verify that multiple tasks worker is working', async () => {
 707     const pool = new DynamicClusterPool(
 708       numberOfWorkers,
 709       numberOfWorkers * 2,
 710       './tests/worker-files/cluster/testMultiTasksWorker.js'
 711     )
 712     const data = { n: 10 }
 713     const result0 = await pool.execute(data)
 714     expect(result0).toStrictEqual({ ok: 1 })
 715     const result1 = await pool.execute(data, 'jsonIntegerSerialization')
 716     expect(result1).toStrictEqual({ ok: 1 })
 717     const result2 = await pool.execute(data, 'factorial')
 718     expect(result2).toBe(3628800)
 719     const result3 = await pool.execute(data, 'fibonacci')
 720     expect(result3).toBe(55)
 721   })
 722 })