tests/pools/abstract-pool.test.mjs

   1 // eslint-disable-next-line n/no-unsupported-features/node-builtins
   2 import { createHook, executionAsyncId } from 'node:async_hooks'
   3 import { EventEmitterAsyncResource } from 'node:events'
   4 import { readFileSync } from 'node:fs'
   5 import { dirname, join } from 'node:path'
   6 import { fileURLToPath } from 'node:url'
   7
   8 import { expect } from 'expect'
   9 import { restore, stub } from 'sinon'
  10
  11 import { CircularArray } from '../../lib/circular-array.cjs'
  12 import {
  13   DynamicClusterPool,
  14   DynamicThreadPool,
  15   FixedClusterPool,
  16   FixedThreadPool,
  17   PoolEvents,
  18   PoolTypes,
  19   WorkerChoiceStrategies,
  20   WorkerTypes
  21 } from '../../lib/index.cjs'
  22 import { WorkerNode } from '../../lib/pools/worker-node.cjs'
  23 import { PriorityQueue } from '../../lib/priority-queue.cjs'
  24 import { DEFAULT_TASK_NAME } from '../../lib/utils.cjs'
  25 import { waitPoolEvents } from '../test-utils.cjs'
  26
  27 describe('Abstract pool test suite', () => {
  28   const version = JSON.parse(
  29     readFileSync(
  30       join(dirname(fileURLToPath(import.meta.url)), '../..', 'package.json'),
  31       'utf8'
  32     )
  33   ).version
  34   const numberOfWorkers = 2
  35   class StubPoolWithIsMain extends FixedThreadPool {
  36     isMain () {
  37       return false
  38     }
  39   }
  40
  41   afterEach(() => {
  42     restore()
  43   })
  44
  45   it('Verify that pool can be created and destroyed', async () => {
  46     const pool = new FixedThreadPool(
  47       numberOfWorkers,
  48       './tests/worker-files/thread/testWorker.mjs'
  49     )
  50     expect(pool).toBeInstanceOf(FixedThreadPool)
  51     await pool.destroy()
  52   })
  53
  54   it('Verify that pool cannot be created from a non main thread/process', () => {
  55     expect(
  56       () =>
  57         new StubPoolWithIsMain(
  58           numberOfWorkers,
  59           './tests/worker-files/thread/testWorker.mjs',
  60           {
  61             errorHandler: e => console.error(e)
  62           }
  63         )
  64     ).toThrow(
  65       new Error(
  66         'Cannot start a pool from a worker with the same type as the pool'
  67       )
  68     )
  69   })
  70
  71   it('Verify that pool statuses properties are set', async () => {
  72     const pool = new FixedThreadPool(
  73       numberOfWorkers,
  74       './tests/worker-files/thread/testWorker.mjs'
  75     )
  76     expect(pool.started).toBe(true)
  77     expect(pool.starting).toBe(false)
  78     expect(pool.destroying).toBe(false)
  79     await pool.destroy()
  80   })
  81
  82   it('Verify that filePath is checked', () => {
  83     expect(() => new FixedThreadPool(numberOfWorkers)).toThrow(
  84       new TypeError('The worker file path must be specified')
  85     )
  86     expect(() => new FixedThreadPool(numberOfWorkers, 0)).toThrow(
  87       new TypeError('The worker file path must be a string')
  88     )
  89     expect(
  90       () => new FixedThreadPool(numberOfWorkers, './dummyWorker.ts')
  91     ).toThrow(new Error("Cannot find the worker file './dummyWorker.ts'"))
  92   })
  93
  94   it('Verify that numberOfWorkers is checked', () => {
  95     expect(
  96       () =>
  97         new FixedThreadPool(
  98           undefined,
  99           './tests/worker-files/thread/testWorker.mjs'
 100         )
 101     ).toThrow(
 102       new Error(
 103         'Cannot instantiate a pool without specifying the number of workers'
 104       )
 105     )
 106   })
 107
 108   it('Verify that a negative number of workers is checked', () => {
 109     expect(
 110       () =>
 111         new FixedClusterPool(-1, './tests/worker-files/cluster/testWorker.cjs')
 112     ).toThrow(
 113       new RangeError(
 114         'Cannot instantiate a pool with a negative number of workers'
 115       )
 116     )
 117   })
 118
 119   it('Verify that a non integer number of workers is checked', () => {
 120     expect(
 121       () =>
 122         new FixedThreadPool(0.25, './tests/worker-files/thread/testWorker.mjs')
 123     ).toThrow(
 124       new TypeError(
 125         'Cannot instantiate a pool with a non safe integer number of workers'
 126       )
 127     )
 128   })
 129
 130   it('Verify that pool arguments number and pool type are checked', () => {
 131     expect(
 132       () =>
 133         new FixedThreadPool(
 134           numberOfWorkers,
 135           './tests/worker-files/thread/testWorker.mjs',
 136           undefined,
 137           numberOfWorkers * 2
 138         )
 139     ).toThrow(
 140       new Error(
 141         'Cannot instantiate a fixed pool with a maximum number of workers specified at initialization'
 142       )
 143     )
 144   })
 145
 146   it('Verify that dynamic pool sizing is checked', () => {
 147     expect(
 148       () =>
 149         new DynamicClusterPool(
 150           1,
 151           undefined,
 152           './tests/worker-files/cluster/testWorker.cjs'
 153         )
 154     ).toThrow(
 155       new TypeError(
 156         'Cannot instantiate a dynamic pool without specifying the maximum pool size'
 157       )
 158     )
 159     expect(
 160       () =>
 161         new DynamicThreadPool(
 162           0.5,
 163           1,
 164           './tests/worker-files/thread/testWorker.mjs'
 165         )
 166     ).toThrow(
 167       new TypeError(
 168         'Cannot instantiate a pool with a non safe integer number of workers'
 169       )
 170     )
 171     expect(
 172       () =>
 173         new DynamicClusterPool(
 174           0,
 175           0.5,
 176           './tests/worker-files/cluster/testWorker.cjs'
 177         )
 178     ).toThrow(
 179       new TypeError(
 180         'Cannot instantiate a dynamic pool with a non safe integer maximum pool size'
 181       )
 182     )
 183     expect(
 184       () =>
 185         new DynamicThreadPool(
 186           2,
 187           1,
 188           './tests/worker-files/thread/testWorker.mjs'
 189         )
 190     ).toThrow(
 191       new RangeError(
 192         'Cannot instantiate a dynamic pool with a maximum pool size inferior to the minimum pool size'
 193       )
 194     )
 195     expect(
 196       () =>
 197         new DynamicThreadPool(
 198           0,
 199           0,
 200           './tests/worker-files/thread/testWorker.mjs'
 201         )
 202     ).toThrow(
 203       new RangeError(
 204         'Cannot instantiate a dynamic pool with a maximum pool size equal to zero'
 205       )
 206     )
 207     expect(
 208       () =>
 209         new DynamicClusterPool(
 210           1,
 211           1,
 212           './tests/worker-files/cluster/testWorker.cjs'
 213         )
 214     ).toThrow(
 215       new RangeError(
 216         'Cannot instantiate a dynamic pool with a minimum pool size equal to the maximum pool size. Use a fixed pool instead'
 217       )
 218     )
 219   })
 220
 221   it('Verify that pool options are checked', async () => {
 222     let pool = new FixedThreadPool(
 223       numberOfWorkers,
 224       './tests/worker-files/thread/testWorker.mjs'
 225     )
 226     expect(pool.emitter).toBeInstanceOf(EventEmitterAsyncResource)
 227     expect(pool.emitter.eventNames()).toStrictEqual([])
 228     expect(pool.opts).toStrictEqual({
 229       startWorkers: true,
 230       enableEvents: true,
 231       restartWorkerOnError: true,
 232       enableTasksQueue: false,
 233       workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN
 234     })
 235     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategiesContext
 236       .workerChoiceStrategies) {
 237       expect(workerChoiceStrategy.opts).toStrictEqual({
 238         runTime: { median: false },
 239         waitTime: { median: false },
 240         elu: { median: false },
 241         weights: expect.objectContaining({
 242           0: expect.any(Number),
 243           [pool.info.maxSize - 1]: expect.any(Number)
 244         })
 245       })
 246     }
 247     await pool.destroy()
 248     const testHandler = () => console.info('test handler executed')
 249     pool = new FixedThreadPool(
 250       numberOfWorkers,
 251       './tests/worker-files/thread/testWorker.mjs',
 252       {
 253         workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED,
 254         workerChoiceStrategyOptions: {
 255           runTime: { median: true },
 256           weights: { 0: 300, 1: 200 }
 257         },
 258         enableEvents: false,
 259         restartWorkerOnError: false,
 260         enableTasksQueue: true,
 261         tasksQueueOptions: { concurrency: 2 },
 262         messageHandler: testHandler,
 263         errorHandler: testHandler,
 264         onlineHandler: testHandler,
 265         exitHandler: testHandler
 266       }
 267     )
 268     expect(pool.emitter).toBeUndefined()
 269     expect(pool.opts).toStrictEqual({
 270       startWorkers: true,
 271       enableEvents: false,
 272       restartWorkerOnError: false,
 273       enableTasksQueue: true,
 274       tasksQueueOptions: {
 275         concurrency: 2,
 276         size: Math.pow(numberOfWorkers, 2),
 277         taskStealing: true,
 278         tasksStealingOnBackPressure: true,
 279         tasksFinishedTimeout: 2000
 280       },
 281       workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED,
 282       workerChoiceStrategyOptions: {
 283         runTime: { median: true },
 284         weights: { 0: 300, 1: 200 }
 285       },
 286       onlineHandler: testHandler,
 287       messageHandler: testHandler,
 288       errorHandler: testHandler,
 289       exitHandler: testHandler
 290     })
 291     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategiesContext
 292       .workerChoiceStrategies) {
 293       expect(workerChoiceStrategy.opts).toStrictEqual({
 294         runTime: { median: true },
 295         waitTime: { median: false },
 296         elu: { median: false },
 297         weights: { 0: 300, 1: 200 }
 298       })
 299     }
 300     await pool.destroy()
 301   })
 302
 303   it('Verify that pool options are validated', () => {
 304     expect(
 305       () =>
 306         new FixedThreadPool(
 307           numberOfWorkers,
 308           './tests/worker-files/thread/testWorker.mjs',
 309           {
 310             workerChoiceStrategy: 'invalidStrategy'
 311           }
 312         )
 313     ).toThrow(new Error("Invalid worker choice strategy 'invalidStrategy'"))
 314     expect(
 315       () =>
 316         new FixedThreadPool(
 317           numberOfWorkers,
 318           './tests/worker-files/thread/testWorker.mjs',
 319           {
 320             workerChoiceStrategyOptions: { weights: {} }
 321           }
 322         )
 323     ).toThrow(
 324       new Error(
 325         'Invalid worker choice strategy options: must have a weight for each worker node'
 326       )
 327     )
 328     expect(
 329       () =>
 330         new FixedThreadPool(
 331           numberOfWorkers,
 332           './tests/worker-files/thread/testWorker.mjs',
 333           {
 334             workerChoiceStrategyOptions: { measurement: 'invalidMeasurement' }
 335           }
 336         )
 337     ).toThrow(
 338       new Error(
 339         "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
 340       )
 341     )
 342     expect(
 343       () =>
 344         new FixedThreadPool(
 345           numberOfWorkers,
 346           './tests/worker-files/thread/testWorker.mjs',
 347           {
 348             enableTasksQueue: true,
 349             tasksQueueOptions: 'invalidTasksQueueOptions'
 350           }
 351         )
 352     ).toThrow(
 353       new TypeError('Invalid tasks queue options: must be a plain object')
 354     )
 355     expect(
 356       () =>
 357         new FixedThreadPool(
 358           numberOfWorkers,
 359           './tests/worker-files/thread/testWorker.mjs',
 360           {
 361             enableTasksQueue: true,
 362             tasksQueueOptions: { concurrency: 0 }
 363           }
 364         )
 365     ).toThrow(
 366       new RangeError(
 367         'Invalid worker node tasks concurrency: 0 is a negative integer or zero'
 368       )
 369     )
 370     expect(
 371       () =>
 372         new FixedThreadPool(
 373           numberOfWorkers,
 374           './tests/worker-files/thread/testWorker.mjs',
 375           {
 376             enableTasksQueue: true,
 377             tasksQueueOptions: { concurrency: -1 }
 378           }
 379         )
 380     ).toThrow(
 381       new RangeError(
 382         'Invalid worker node tasks concurrency: -1 is a negative integer or zero'
 383       )
 384     )
 385     expect(
 386       () =>
 387         new FixedThreadPool(
 388           numberOfWorkers,
 389           './tests/worker-files/thread/testWorker.mjs',
 390           {
 391             enableTasksQueue: true,
 392             tasksQueueOptions: { concurrency: 0.2 }
 393           }
 394         )
 395     ).toThrow(
 396       new TypeError('Invalid worker node tasks concurrency: must be an integer')
 397     )
 398     expect(
 399       () =>
 400         new FixedThreadPool(
 401           numberOfWorkers,
 402           './tests/worker-files/thread/testWorker.mjs',
 403           {
 404             enableTasksQueue: true,
 405             tasksQueueOptions: { size: 0 }
 406           }
 407         )
 408     ).toThrow(
 409       new RangeError(
 410         'Invalid worker node tasks queue size: 0 is a negative integer or zero'
 411       )
 412     )
 413     expect(
 414       () =>
 415         new FixedThreadPool(
 416           numberOfWorkers,
 417           './tests/worker-files/thread/testWorker.mjs',
 418           {
 419             enableTasksQueue: true,
 420             tasksQueueOptions: { size: -1 }
 421           }
 422         )
 423     ).toThrow(
 424       new RangeError(
 425         'Invalid worker node tasks queue size: -1 is a negative integer or zero'
 426       )
 427     )
 428     expect(
 429       () =>
 430         new FixedThreadPool(
 431           numberOfWorkers,
 432           './tests/worker-files/thread/testWorker.mjs',
 433           {
 434             enableTasksQueue: true,
 435             tasksQueueOptions: { size: 0.2 }
 436           }
 437         )
 438     ).toThrow(
 439       new TypeError('Invalid worker node tasks queue size: must be an integer')
 440     )
 441   })
 442
 443   it('Verify that pool worker choice strategy options can be set', async () => {
 444     const pool = new FixedThreadPool(
 445       numberOfWorkers,
 446       './tests/worker-files/thread/testWorker.mjs',
 447       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
 448     )
 449     expect(pool.opts.workerChoiceStrategyOptions).toBeUndefined()
 450     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategiesContext
 451       .workerChoiceStrategies) {
 452       expect(workerChoiceStrategy.opts).toStrictEqual({
 453         runTime: { median: false },
 454         waitTime: { median: false },
 455         elu: { median: false },
 456         weights: expect.objectContaining({
 457           0: expect.any(Number),
 458           [pool.info.maxSize - 1]: expect.any(Number)
 459         })
 460       })
 461     }
 462     expect(
 463       pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
 464     ).toStrictEqual({
 465       runTime: {
 466         aggregate: true,
 467         average: true,
 468         median: false
 469       },
 470       waitTime: {
 471         aggregate: true,
 472         average: true,
 473         median: false
 474       },
 475       elu: {
 476         aggregate: true,
 477         average: true,
 478         median: false
 479       }
 480     })
 481     pool.setWorkerChoiceStrategyOptions({
 482       runTime: { median: true },
 483       elu: { median: true }
 484     })
 485     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
 486       runTime: { median: true },
 487       elu: { median: true }
 488     })
 489     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategiesContext
 490       .workerChoiceStrategies) {
 491       expect(workerChoiceStrategy.opts).toStrictEqual({
 492         runTime: { median: true },
 493         waitTime: { median: false },
 494         elu: { median: true },
 495         weights: expect.objectContaining({
 496           0: expect.any(Number),
 497           [pool.info.maxSize - 1]: expect.any(Number)
 498         })
 499       })
 500     }
 501     expect(
 502       pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
 503     ).toStrictEqual({
 504       runTime: {
 505         aggregate: true,
 506         average: false,
 507         median: true
 508       },
 509       waitTime: {
 510         aggregate: true,
 511         average: true,
 512         median: false
 513       },
 514       elu: {
 515         aggregate: true,
 516         average: false,
 517         median: true
 518       }
 519     })
 520     pool.setWorkerChoiceStrategyOptions({
 521       runTime: { median: false },
 522       elu: { median: false }
 523     })
 524     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
 525       runTime: { median: false },
 526       elu: { median: false }
 527     })
 528     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategiesContext
 529       .workerChoiceStrategies) {
 530       expect(workerChoiceStrategy.opts).toStrictEqual({
 531         runTime: { median: false },
 532         waitTime: { median: false },
 533         elu: { median: false },
 534         weights: expect.objectContaining({
 535           0: expect.any(Number),
 536           [pool.info.maxSize - 1]: expect.any(Number)
 537         })
 538       })
 539     }
 540     expect(
 541       pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
 542     ).toStrictEqual({
 543       runTime: {
 544         aggregate: true,
 545         average: true,
 546         median: false
 547       },
 548       waitTime: {
 549         aggregate: true,
 550         average: true,
 551         median: false
 552       },
 553       elu: {
 554         aggregate: true,
 555         average: true,
 556         median: false
 557       }
 558     })
 559     expect(() =>
 560       pool.setWorkerChoiceStrategyOptions('invalidWorkerChoiceStrategyOptions')
 561     ).toThrow(
 562       new TypeError(
 563         'Invalid worker choice strategy options: must be a plain object'
 564       )
 565     )
 566     expect(() => pool.setWorkerChoiceStrategyOptions({ weights: {} })).toThrow(
 567       new Error(
 568         'Invalid worker choice strategy options: must have a weight for each worker node'
 569       )
 570     )
 571     expect(() =>
 572       pool.setWorkerChoiceStrategyOptions({ measurement: 'invalidMeasurement' })
 573     ).toThrow(
 574       new Error(
 575         "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
 576       )
 577     )
 578     await pool.destroy()
 579   })
 580
 581   it('Verify that pool tasks queue can be enabled/disabled', async () => {
 582     const pool = new FixedThreadPool(
 583       numberOfWorkers,
 584       './tests/worker-files/thread/testWorker.mjs'
 585     )
 586     expect(pool.opts.enableTasksQueue).toBe(false)
 587     expect(pool.opts.tasksQueueOptions).toBeUndefined()
 588     pool.enableTasksQueue(true)
 589     expect(pool.opts.enableTasksQueue).toBe(true)
 590     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 591       concurrency: 1,
 592       size: Math.pow(numberOfWorkers, 2),
 593       taskStealing: true,
 594       tasksStealingOnBackPressure: true,
 595       tasksFinishedTimeout: 2000
 596     })
 597     pool.enableTasksQueue(true, { concurrency: 2 })
 598     expect(pool.opts.enableTasksQueue).toBe(true)
 599     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 600       concurrency: 2,
 601       size: Math.pow(numberOfWorkers, 2),
 602       taskStealing: true,
 603       tasksStealingOnBackPressure: true,
 604       tasksFinishedTimeout: 2000
 605     })
 606     pool.enableTasksQueue(false)
 607     expect(pool.opts.enableTasksQueue).toBe(false)
 608     expect(pool.opts.tasksQueueOptions).toBeUndefined()
 609     await pool.destroy()
 610   })
 611
 612   it('Verify that pool tasks queue options can be set', async () => {
 613     const pool = new FixedThreadPool(
 614       numberOfWorkers,
 615       './tests/worker-files/thread/testWorker.mjs',
 616       { enableTasksQueue: true }
 617     )
 618     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 619       concurrency: 1,
 620       size: Math.pow(numberOfWorkers, 2),
 621       taskStealing: true,
 622       tasksStealingOnBackPressure: true,
 623       tasksFinishedTimeout: 2000
 624     })
 625     for (const workerNode of pool.workerNodes) {
 626       expect(workerNode.tasksQueueBackPressureSize).toBe(
 627         pool.opts.tasksQueueOptions.size
 628       )
 629     }
 630     pool.setTasksQueueOptions({
 631       concurrency: 2,
 632       size: 2,
 633       taskStealing: false,
 634       tasksStealingOnBackPressure: false,
 635       tasksFinishedTimeout: 3000
 636     })
 637     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 638       concurrency: 2,
 639       size: 2,
 640       taskStealing: false,
 641       tasksStealingOnBackPressure: false,
 642       tasksFinishedTimeout: 3000
 643     })
 644     for (const workerNode of pool.workerNodes) {
 645       expect(workerNode.tasksQueueBackPressureSize).toBe(
 646         pool.opts.tasksQueueOptions.size
 647       )
 648     }
 649     pool.setTasksQueueOptions({
 650       concurrency: 1,
 651       taskStealing: true,
 652       tasksStealingOnBackPressure: true
 653     })
 654     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 655       concurrency: 1,
 656       size: Math.pow(numberOfWorkers, 2),
 657       taskStealing: true,
 658       tasksStealingOnBackPressure: true,
 659       tasksFinishedTimeout: 2000
 660     })
 661     for (const workerNode of pool.workerNodes) {
 662       expect(workerNode.tasksQueueBackPressureSize).toBe(
 663         pool.opts.tasksQueueOptions.size
 664       )
 665     }
 666     expect(() => pool.setTasksQueueOptions('invalidTasksQueueOptions')).toThrow(
 667       new TypeError('Invalid tasks queue options: must be a plain object')
 668     )
 669     expect(() => pool.setTasksQueueOptions({ concurrency: 0 })).toThrow(
 670       new RangeError(
 671         'Invalid worker node tasks concurrency: 0 is a negative integer or zero'
 672       )
 673     )
 674     expect(() => pool.setTasksQueueOptions({ concurrency: -1 })).toThrow(
 675       new RangeError(
 676         'Invalid worker node tasks concurrency: -1 is a negative integer or zero'
 677       )
 678     )
 679     expect(() => pool.setTasksQueueOptions({ concurrency: 0.2 })).toThrow(
 680       new TypeError('Invalid worker node tasks concurrency: must be an integer')
 681     )
 682     expect(() => pool.setTasksQueueOptions({ size: 0 })).toThrow(
 683       new RangeError(
 684         'Invalid worker node tasks queue size: 0 is a negative integer or zero'
 685       )
 686     )
 687     expect(() => pool.setTasksQueueOptions({ size: -1 })).toThrow(
 688       new RangeError(
 689         'Invalid worker node tasks queue size: -1 is a negative integer or zero'
 690       )
 691     )
 692     expect(() => pool.setTasksQueueOptions({ size: 0.2 })).toThrow(
 693       new TypeError('Invalid worker node tasks queue size: must be an integer')
 694     )
 695     await pool.destroy()
 696   })
 697
 698   it('Verify that pool info is set', async () => {
 699     let pool = new FixedThreadPool(
 700       numberOfWorkers,
 701       './tests/worker-files/thread/testWorker.mjs'
 702     )
 703     expect(pool.info).toStrictEqual({
 704       version,
 705       type: PoolTypes.fixed,
 706       worker: WorkerTypes.thread,
 707       started: true,
 708       ready: true,
 709       defaultStrategy: WorkerChoiceStrategies.ROUND_ROBIN,
 710       strategyRetries: 0,
 711       minSize: numberOfWorkers,
 712       maxSize: numberOfWorkers,
 713       workerNodes: numberOfWorkers,
 714       idleWorkerNodes: numberOfWorkers,
 715       busyWorkerNodes: 0,
 716       executedTasks: 0,
 717       executingTasks: 0,
 718       failedTasks: 0
 719     })
 720     await pool.destroy()
 721     pool = new DynamicClusterPool(
 722       Math.floor(numberOfWorkers / 2),
 723       numberOfWorkers,
 724       './tests/worker-files/cluster/testWorker.cjs'
 725     )
 726     expect(pool.info).toStrictEqual({
 727       version,
 728       type: PoolTypes.dynamic,
 729       worker: WorkerTypes.cluster,
 730       started: true,
 731       ready: true,
 732       defaultStrategy: WorkerChoiceStrategies.ROUND_ROBIN,
 733       strategyRetries: 0,
 734       minSize: Math.floor(numberOfWorkers / 2),
 735       maxSize: numberOfWorkers,
 736       workerNodes: Math.floor(numberOfWorkers / 2),
 737       idleWorkerNodes: Math.floor(numberOfWorkers / 2),
 738       busyWorkerNodes: 0,
 739       executedTasks: 0,
 740       executingTasks: 0,
 741       failedTasks: 0
 742     })
 743     await pool.destroy()
 744   })
 745
 746   it('Verify that pool worker tasks usage are initialized', async () => {
 747     const pool = new FixedClusterPool(
 748       numberOfWorkers,
 749       './tests/worker-files/cluster/testWorker.cjs'
 750     )
 751     for (const workerNode of pool.workerNodes) {
 752       expect(workerNode).toBeInstanceOf(WorkerNode)
 753       expect(workerNode.usage).toStrictEqual({
 754         tasks: {
 755           executed: 0,
 756           executing: 0,
 757           queued: 0,
 758           maxQueued: 0,
 759           sequentiallyStolen: 0,
 760           stolen: 0,
 761           failed: 0
 762         },
 763         runTime: {
 764           history: new CircularArray()
 765         },
 766         waitTime: {
 767           history: new CircularArray()
 768         },
 769         elu: {
 770           idle: {
 771             history: new CircularArray()
 772           },
 773           active: {
 774             history: new CircularArray()
 775           }
 776         }
 777       })
 778     }
 779     await pool.destroy()
 780   })
 781
 782   it('Verify that pool worker tasks queue are initialized', async () => {
 783     let pool = new FixedClusterPool(
 784       numberOfWorkers,
 785       './tests/worker-files/cluster/testWorker.cjs'
 786     )
 787     for (const workerNode of pool.workerNodes) {
 788       expect(workerNode).toBeInstanceOf(WorkerNode)
 789       expect(workerNode.tasksQueue).toBeInstanceOf(PriorityQueue)
 790       expect(workerNode.tasksQueue.size).toBe(0)
 791       expect(workerNode.tasksQueue.maxSize).toBe(0)
 792       expect(workerNode.tasksQueue.k).toBe(numberOfWorkers * 2)
 793     }
 794     await pool.destroy()
 795     pool = new DynamicThreadPool(
 796       Math.floor(numberOfWorkers / 2),
 797       numberOfWorkers,
 798       './tests/worker-files/thread/testWorker.mjs'
 799     )
 800     for (const workerNode of pool.workerNodes) {
 801       expect(workerNode).toBeInstanceOf(WorkerNode)
 802       expect(workerNode.tasksQueue).toBeInstanceOf(PriorityQueue)
 803       expect(workerNode.tasksQueue.size).toBe(0)
 804       expect(workerNode.tasksQueue.maxSize).toBe(0)
 805       expect(workerNode.tasksQueue.k).toBe(numberOfWorkers * 2)
 806     }
 807     await pool.destroy()
 808   })
 809
 810   it('Verify that pool worker info are initialized', async () => {
 811     let pool = new FixedClusterPool(
 812       numberOfWorkers,
 813       './tests/worker-files/cluster/testWorker.cjs'
 814     )
 815     for (const workerNode of pool.workerNodes) {
 816       expect(workerNode).toBeInstanceOf(WorkerNode)
 817       expect(workerNode.info).toStrictEqual({
 818         id: expect.any(Number),
 819         type: WorkerTypes.cluster,
 820         dynamic: false,
 821         ready: true,
 822         stealing: false
 823       })
 824     }
 825     await pool.destroy()
 826     pool = new DynamicThreadPool(
 827       Math.floor(numberOfWorkers / 2),
 828       numberOfWorkers,
 829       './tests/worker-files/thread/testWorker.mjs'
 830     )
 831     for (const workerNode of pool.workerNodes) {
 832       expect(workerNode).toBeInstanceOf(WorkerNode)
 833       expect(workerNode.info).toStrictEqual({
 834         id: expect.any(Number),
 835         type: WorkerTypes.thread,
 836         dynamic: false,
 837         ready: true,
 838         stealing: false
 839       })
 840     }
 841     await pool.destroy()
 842   })
 843
 844   it('Verify that pool statuses are checked at start or destroy', async () => {
 845     const pool = new FixedThreadPool(
 846       numberOfWorkers,
 847       './tests/worker-files/thread/testWorker.mjs'
 848     )
 849     expect(pool.info.started).toBe(true)
 850     expect(pool.info.ready).toBe(true)
 851     expect(() => pool.start()).toThrow(
 852       new Error('Cannot start an already started pool')
 853     )
 854     await pool.destroy()
 855     expect(pool.info.started).toBe(false)
 856     expect(pool.info.ready).toBe(false)
 857     await expect(pool.destroy()).rejects.toThrow(
 858       new Error('Cannot destroy an already destroyed pool')
 859     )
 860   })
 861
 862   it('Verify that pool can be started after initialization', async () => {
 863     const pool = new FixedClusterPool(
 864       numberOfWorkers,
 865       './tests/worker-files/cluster/testWorker.cjs',
 866       {
 867         startWorkers: false
 868       }
 869     )
 870     expect(pool.info.started).toBe(false)
 871     expect(pool.info.ready).toBe(false)
 872     expect(pool.workerNodes).toStrictEqual([])
 873     expect(pool.readyEventEmitted).toBe(false)
 874     await expect(pool.execute()).rejects.toThrow(
 875       new Error('Cannot execute a task on not started pool')
 876     )
 877     pool.start()
 878     expect(pool.info.started).toBe(true)
 879     expect(pool.info.ready).toBe(true)
 880     await waitPoolEvents(pool, PoolEvents.ready, 1)
 881     expect(pool.readyEventEmitted).toBe(true)
 882     expect(pool.workerNodes.length).toBe(numberOfWorkers)
 883     for (const workerNode of pool.workerNodes) {
 884       expect(workerNode).toBeInstanceOf(WorkerNode)
 885     }
 886     await pool.destroy()
 887   })
 888
 889   it('Verify that pool execute() arguments are checked', async () => {
 890     const pool = new FixedClusterPool(
 891       numberOfWorkers,
 892       './tests/worker-files/cluster/testWorker.cjs'
 893     )
 894     await expect(pool.execute(undefined, 0)).rejects.toThrow(
 895       new TypeError('name argument must be a string')
 896     )
 897     await expect(pool.execute(undefined, '')).rejects.toThrow(
 898       new TypeError('name argument must not be an empty string')
 899     )
 900     await expect(pool.execute(undefined, undefined, {})).rejects.toThrow(
 901       new TypeError('transferList argument must be an array')
 902     )
 903     await expect(pool.execute(undefined, 'unknown')).rejects.toBe(
 904       "Task function 'unknown' not found"
 905     )
 906     await pool.destroy()
 907     await expect(pool.execute()).rejects.toThrow(
 908       new Error('Cannot execute a task on not started pool')
 909     )
 910   })
 911
 912   it('Verify that pool worker tasks usage are computed', async () => {
 913     const pool = new FixedClusterPool(
 914       numberOfWorkers,
 915       './tests/worker-files/cluster/testWorker.cjs'
 916     )
 917     const promises = new Set()
 918     const maxMultiplier = 2
 919     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
 920       promises.add(pool.execute())
 921     }
 922     for (const workerNode of pool.workerNodes) {
 923       expect(workerNode.usage).toStrictEqual({
 924         tasks: {
 925           executed: 0,
 926           executing: maxMultiplier,
 927           queued: 0,
 928           maxQueued: 0,
 929           sequentiallyStolen: 0,
 930           stolen: 0,
 931           failed: 0
 932         },
 933         runTime: {
 934           history: expect.any(CircularArray)
 935         },
 936         waitTime: {
 937           history: expect.any(CircularArray)
 938         },
 939         elu: {
 940           idle: {
 941             history: expect.any(CircularArray)
 942           },
 943           active: {
 944             history: expect.any(CircularArray)
 945           }
 946         }
 947       })
 948     }
 949     await Promise.all(promises)
 950     for (const workerNode of pool.workerNodes) {
 951       expect(workerNode.usage).toStrictEqual({
 952         tasks: {
 953           executed: maxMultiplier,
 954           executing: 0,
 955           queued: 0,
 956           maxQueued: 0,
 957           sequentiallyStolen: 0,
 958           stolen: 0,
 959           failed: 0
 960         },
 961         runTime: {
 962           history: expect.any(CircularArray)
 963         },
 964         waitTime: {
 965           history: expect.any(CircularArray)
 966         },
 967         elu: {
 968           idle: {
 969             history: expect.any(CircularArray)
 970           },
 971           active: {
 972             history: expect.any(CircularArray)
 973           }
 974         }
 975       })
 976     }
 977     await pool.destroy()
 978   })
 979
 980   it("Verify that pool worker tasks usage aren't reset at worker choice strategy change", async () => {
 981     const pool = new DynamicThreadPool(
 982       Math.floor(numberOfWorkers / 2),
 983       numberOfWorkers,
 984       './tests/worker-files/thread/testWorker.mjs'
 985     )
 986     const promises = new Set()
 987     const maxMultiplier = 2
 988     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
 989       promises.add(pool.execute())
 990     }
 991     await Promise.all(promises)
 992     for (const workerNode of pool.workerNodes) {
 993       expect(workerNode.usage).toStrictEqual({
 994         tasks: {
 995           executed: expect.any(Number),
 996           executing: 0,
 997           queued: 0,
 998           maxQueued: 0,
 999           sequentiallyStolen: 0,
1000           stolen: 0,
1001           failed: 0
1002         },
1003         runTime: {
1004           history: expect.any(CircularArray)
1005         },
1006         waitTime: {
1007           history: expect.any(CircularArray)
1008         },
1009         elu: {
1010           idle: {
1011             history: expect.any(CircularArray)
1012           },
1013           active: {
1014             history: expect.any(CircularArray)
1015           }
1016         }
1017       })
1018       expect(workerNode.usage.tasks.executed).toBeGreaterThan(0)
1019       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
1020         numberOfWorkers * maxMultiplier
1021       )
1022       expect(workerNode.usage.runTime.history.length).toBe(0)
1023       expect(workerNode.usage.waitTime.history.length).toBe(0)
1024       expect(workerNode.usage.elu.idle.history.length).toBe(0)
1025       expect(workerNode.usage.elu.active.history.length).toBe(0)
1026     }
1027     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
1028     for (const workerNode of pool.workerNodes) {
1029       expect(workerNode.usage).toStrictEqual({
1030         tasks: {
1031           executed: expect.any(Number),
1032           executing: 0,
1033           queued: 0,
1034           maxQueued: 0,
1035           sequentiallyStolen: 0,
1036           stolen: 0,
1037           failed: 0
1038         },
1039         runTime: {
1040           history: expect.any(CircularArray)
1041         },
1042         waitTime: {
1043           history: expect.any(CircularArray)
1044         },
1045         elu: {
1046           idle: {
1047             history: expect.any(CircularArray)
1048           },
1049           active: {
1050             history: expect.any(CircularArray)
1051           }
1052         }
1053       })
1054       expect(workerNode.usage.tasks.executed).toBeGreaterThan(0)
1055       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
1056         numberOfWorkers * maxMultiplier
1057       )
1058       expect(workerNode.usage.runTime.history.length).toBe(0)
1059       expect(workerNode.usage.waitTime.history.length).toBe(0)
1060       expect(workerNode.usage.elu.idle.history.length).toBe(0)
1061       expect(workerNode.usage.elu.active.history.length).toBe(0)
1062     }
1063     await pool.destroy()
1064   })
1065
1066   it("Verify that pool event emitter 'ready' event can register a callback", async () => {
1067     const pool = new DynamicClusterPool(
1068       Math.floor(numberOfWorkers / 2),
1069       numberOfWorkers,
1070       './tests/worker-files/cluster/testWorker.cjs'
1071     )
1072     expect(pool.emitter.eventNames()).toStrictEqual([])
1073     let poolInfo
1074     let poolReady = 0
1075     pool.emitter.on(PoolEvents.ready, info => {
1076       ++poolReady
1077       poolInfo = info
1078     })
1079     await waitPoolEvents(pool, PoolEvents.ready, 1)
1080     expect(pool.emitter.eventNames()).toStrictEqual([PoolEvents.ready])
1081     expect(poolReady).toBe(1)
1082     expect(poolInfo).toStrictEqual({
1083       version,
1084       type: PoolTypes.dynamic,
1085       worker: WorkerTypes.cluster,
1086       started: true,
1087       ready: true,
1088       defaultStrategy: WorkerChoiceStrategies.ROUND_ROBIN,
1089       strategyRetries: expect.any(Number),
1090       minSize: expect.any(Number),
1091       maxSize: expect.any(Number),
1092       workerNodes: expect.any(Number),
1093       idleWorkerNodes: expect.any(Number),
1094       busyWorkerNodes: expect.any(Number),
1095       executedTasks: expect.any(Number),
1096       executingTasks: expect.any(Number),
1097       failedTasks: expect.any(Number)
1098     })
1099     await pool.destroy()
1100   })
1101
1102   it("Verify that pool event emitter 'busy' event can register a callback", async () => {
1103     const pool = new FixedThreadPool(
1104       numberOfWorkers,
1105       './tests/worker-files/thread/testWorker.mjs'
1106     )
1107     expect(pool.emitter.eventNames()).toStrictEqual([])
1108     const promises = new Set()
1109     let poolBusy = 0
1110     let poolInfo
1111     pool.emitter.on(PoolEvents.busy, info => {
1112       ++poolBusy
1113       poolInfo = info
1114     })
1115     expect(pool.emitter.eventNames()).toStrictEqual([PoolEvents.busy])
1116     for (let i = 0; i < numberOfWorkers * 2; i++) {
1117       promises.add(pool.execute())
1118     }
1119     await Promise.all(promises)
1120     // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
1121     // So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
1122     expect(poolBusy).toBe(numberOfWorkers + 1)
1123     expect(poolInfo).toStrictEqual({
1124       version,
1125       type: PoolTypes.fixed,
1126       worker: WorkerTypes.thread,
1127       started: true,
1128       ready: true,
1129       defaultStrategy: WorkerChoiceStrategies.ROUND_ROBIN,
1130       strategyRetries: expect.any(Number),
1131       minSize: expect.any(Number),
1132       maxSize: expect.any(Number),
1133       workerNodes: expect.any(Number),
1134       idleWorkerNodes: expect.any(Number),
1135       busyWorkerNodes: expect.any(Number),
1136       executedTasks: expect.any(Number),
1137       executingTasks: expect.any(Number),
1138       failedTasks: expect.any(Number)
1139     })
1140     await pool.destroy()
1141   })
1142
1143   it("Verify that pool event emitter 'full' event can register a callback", async () => {
1144     const pool = new DynamicThreadPool(
1145       Math.floor(numberOfWorkers / 2),
1146       numberOfWorkers,
1147       './tests/worker-files/thread/testWorker.mjs'
1148     )
1149     expect(pool.emitter.eventNames()).toStrictEqual([])
1150     const promises = new Set()
1151     let poolFull = 0
1152     let poolInfo
1153     pool.emitter.on(PoolEvents.full, info => {
1154       ++poolFull
1155       poolInfo = info
1156     })
1157     expect(pool.emitter.eventNames()).toStrictEqual([PoolEvents.full])
1158     for (let i = 0; i < numberOfWorkers * 2; i++) {
1159       promises.add(pool.execute())
1160     }
1161     await Promise.all(promises)
1162     expect(poolFull).toBe(1)
1163     expect(poolInfo).toStrictEqual({
1164       version,
1165       type: PoolTypes.dynamic,
1166       worker: WorkerTypes.thread,
1167       started: true,
1168       ready: true,
1169       defaultStrategy: WorkerChoiceStrategies.ROUND_ROBIN,
1170       strategyRetries: expect.any(Number),
1171       minSize: expect.any(Number),
1172       maxSize: expect.any(Number),
1173       workerNodes: expect.any(Number),
1174       idleWorkerNodes: expect.any(Number),
1175       busyWorkerNodes: expect.any(Number),
1176       executedTasks: expect.any(Number),
1177       executingTasks: expect.any(Number),
1178       failedTasks: expect.any(Number)
1179     })
1180     await pool.destroy()
1181   })
1182
1183   it("Verify that pool event emitter 'backPressure' event can register a callback", async () => {
1184     const pool = new FixedThreadPool(
1185       numberOfWorkers,
1186       './tests/worker-files/thread/testWorker.mjs',
1187       {
1188         enableTasksQueue: true
1189       }
1190     )
1191     stub(pool, 'hasBackPressure').returns(true)
1192     expect(pool.emitter.eventNames()).toStrictEqual([])
1193     const promises = new Set()
1194     let poolBackPressure = 0
1195     let poolInfo
1196     pool.emitter.on(PoolEvents.backPressure, info => {
1197       ++poolBackPressure
1198       poolInfo = info
1199     })
1200     expect(pool.emitter.eventNames()).toStrictEqual([PoolEvents.backPressure])
1201     for (let i = 0; i < numberOfWorkers + 1; i++) {
1202       promises.add(pool.execute())
1203     }
1204     await Promise.all(promises)
1205     expect(poolBackPressure).toBe(1)
1206     expect(poolInfo).toStrictEqual({
1207       version,
1208       type: PoolTypes.fixed,
1209       worker: WorkerTypes.thread,
1210       started: true,
1211       ready: true,
1212       defaultStrategy: WorkerChoiceStrategies.ROUND_ROBIN,
1213       strategyRetries: expect.any(Number),
1214       minSize: expect.any(Number),
1215       maxSize: expect.any(Number),
1216       workerNodes: expect.any(Number),
1217       idleWorkerNodes: expect.any(Number),
1218       stealingWorkerNodes: expect.any(Number),
1219       busyWorkerNodes: expect.any(Number),
1220       executedTasks: expect.any(Number),
1221       executingTasks: expect.any(Number),
1222       maxQueuedTasks: expect.any(Number),
1223       queuedTasks: expect.any(Number),
1224       backPressure: true,
1225       stolenTasks: expect.any(Number),
1226       failedTasks: expect.any(Number)
1227     })
1228     expect(pool.hasBackPressure.callCount).toBeGreaterThanOrEqual(7)
1229     await pool.destroy()
1230   })
1231
1232   it('Verify that destroy() waits for queued tasks to finish', async () => {
1233     const tasksFinishedTimeout = 2500
1234     const pool = new FixedThreadPool(
1235       numberOfWorkers,
1236       './tests/worker-files/thread/asyncWorker.mjs',
1237       {
1238         enableTasksQueue: true,
1239         tasksQueueOptions: { tasksFinishedTimeout }
1240       }
1241     )
1242     const maxMultiplier = 4
1243     let tasksFinished = 0
1244     for (const workerNode of pool.workerNodes) {
1245       workerNode.on('taskFinished', () => {
1246         ++tasksFinished
1247       })
1248     }
1249     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
1250       pool.execute()
1251     }
1252     expect(pool.info.queuedTasks).toBeGreaterThan(0)
1253     const startTime = performance.now()
1254     await pool.destroy()
1255     const elapsedTime = performance.now() - startTime
1256     expect(tasksFinished).toBeLessThanOrEqual(numberOfWorkers * maxMultiplier)
1257     expect(elapsedTime).toBeGreaterThanOrEqual(2000)
1258     expect(elapsedTime).toBeLessThanOrEqual(tasksFinishedTimeout + 800)
1259   })
1260
1261   it('Verify that destroy() waits until the tasks finished timeout is reached', async () => {
1262     const tasksFinishedTimeout = 1000
1263     const pool = new FixedThreadPool(
1264       numberOfWorkers,
1265       './tests/worker-files/thread/asyncWorker.mjs',
1266       {
1267         enableTasksQueue: true,
1268         tasksQueueOptions: { tasksFinishedTimeout }
1269       }
1270     )
1271     const maxMultiplier = 4
1272     let tasksFinished = 0
1273     for (const workerNode of pool.workerNodes) {
1274       workerNode.on('taskFinished', () => {
1275         ++tasksFinished
1276       })
1277     }
1278     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
1279       pool.execute()
1280     }
1281     expect(pool.info.queuedTasks).toBeGreaterThan(0)
1282     const startTime = performance.now()
1283     await pool.destroy()
1284     const elapsedTime = performance.now() - startTime
1285     expect(tasksFinished).toBe(0)
1286     expect(elapsedTime).toBeLessThanOrEqual(tasksFinishedTimeout + 800)
1287   })
1288
1289   it('Verify that pool asynchronous resource track tasks execution', async () => {
1290     let taskAsyncId
1291     let initCalls = 0
1292     let beforeCalls = 0
1293     let afterCalls = 0
1294     let resolveCalls = 0
1295     const hook = createHook({
1296       init (asyncId, type) {
1297         if (type === 'poolifier:task') {
1298           initCalls++
1299           taskAsyncId = asyncId
1300         }
1301       },
1302       before (asyncId) {
1303         if (asyncId === taskAsyncId) beforeCalls++
1304       },
1305       after (asyncId) {
1306         if (asyncId === taskAsyncId) afterCalls++
1307       },
1308       promiseResolve () {
1309         if (executionAsyncId() === taskAsyncId) resolveCalls++
1310       }
1311     })
1312     const pool = new FixedThreadPool(
1313       numberOfWorkers,
1314       './tests/worker-files/thread/testWorker.mjs'
1315     )
1316     hook.enable()
1317     await pool.execute()
1318     hook.disable()
1319     expect(initCalls).toBe(1)
1320     expect(beforeCalls).toBe(1)
1321     expect(afterCalls).toBe(1)
1322     expect(resolveCalls).toBe(1)
1323     await pool.destroy()
1324   })
1325
1326   it('Verify that hasTaskFunction() is working', async () => {
1327     const dynamicThreadPool = new DynamicThreadPool(
1328       Math.floor(numberOfWorkers / 2),
1329       numberOfWorkers,
1330       './tests/worker-files/thread/testMultipleTaskFunctionsWorker.mjs'
1331     )
1332     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1333     expect(dynamicThreadPool.hasTaskFunction(DEFAULT_TASK_NAME)).toBe(true)
1334     expect(dynamicThreadPool.hasTaskFunction('jsonIntegerSerialization')).toBe(
1335       true
1336     )
1337     expect(dynamicThreadPool.hasTaskFunction('factorial')).toBe(true)
1338     expect(dynamicThreadPool.hasTaskFunction('fibonacci')).toBe(true)
1339     expect(dynamicThreadPool.hasTaskFunction('unknown')).toBe(false)
1340     await dynamicThreadPool.destroy()
1341     const fixedClusterPool = new FixedClusterPool(
1342       numberOfWorkers,
1343       './tests/worker-files/cluster/testMultipleTaskFunctionsWorker.cjs'
1344     )
1345     await waitPoolEvents(fixedClusterPool, PoolEvents.ready, 1)
1346     expect(fixedClusterPool.hasTaskFunction(DEFAULT_TASK_NAME)).toBe(true)
1347     expect(fixedClusterPool.hasTaskFunction('jsonIntegerSerialization')).toBe(
1348       true
1349     )
1350     expect(fixedClusterPool.hasTaskFunction('factorial')).toBe(true)
1351     expect(fixedClusterPool.hasTaskFunction('fibonacci')).toBe(true)
1352     expect(fixedClusterPool.hasTaskFunction('unknown')).toBe(false)
1353     await fixedClusterPool.destroy()
1354   })
1355
1356   it('Verify that addTaskFunction() is working', async () => {
1357     const dynamicThreadPool = new DynamicThreadPool(
1358       Math.floor(numberOfWorkers / 2),
1359       numberOfWorkers,
1360       './tests/worker-files/thread/testWorker.mjs'
1361     )
1362     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1363     await expect(
1364       dynamicThreadPool.addTaskFunction(0, () => {})
1365     ).rejects.toThrow(new TypeError('name argument must be a string'))
1366     await expect(
1367       dynamicThreadPool.addTaskFunction('', () => {})
1368     ).rejects.toThrow(
1369       new TypeError('name argument must not be an empty string')
1370     )
1371     await expect(dynamicThreadPool.addTaskFunction('test', 0)).rejects.toThrow(
1372       new TypeError('taskFunction property must be a function')
1373     )
1374     await expect(dynamicThreadPool.addTaskFunction('test', '')).rejects.toThrow(
1375       new TypeError('taskFunction property must be a function')
1376     )
1377     await expect(
1378       dynamicThreadPool.addTaskFunction('test', { taskFunction: 0 })
1379     ).rejects.toThrow(new TypeError('taskFunction property must be a function'))
1380     await expect(
1381       dynamicThreadPool.addTaskFunction('test', { taskFunction: '' })
1382     ).rejects.toThrow(new TypeError('taskFunction property must be a function'))
1383     await expect(
1384       dynamicThreadPool.addTaskFunction('test', {
1385         taskFunction: () => {},
1386         priority: -21
1387       })
1388     ).rejects.toThrow(
1389       new RangeError("Property 'priority' must be between -20 and 19")
1390     )
1391     await expect(
1392       dynamicThreadPool.addTaskFunction('test', {
1393         taskFunction: () => {},
1394         priority: 20
1395       })
1396     ).rejects.toThrow(
1397       new RangeError("Property 'priority' must be between -20 and 19")
1398     )
1399     await expect(
1400       dynamicThreadPool.addTaskFunction('test', {
1401         taskFunction: () => {},
1402         strategy: 'invalidStrategy'
1403       })
1404     ).rejects.toThrow(
1405       new Error("Invalid worker choice strategy 'invalidStrategy'")
1406     )
1407     expect(dynamicThreadPool.listTaskFunctionsProperties()).toStrictEqual([
1408       { name: DEFAULT_TASK_NAME },
1409       { name: 'test' }
1410     ])
1411     expect([
1412       ...dynamicThreadPool.workerChoiceStrategiesContext.workerChoiceStrategies.keys()
1413     ]).toStrictEqual([WorkerChoiceStrategies.ROUND_ROBIN])
1414     const echoTaskFunction = data => {
1415       return data
1416     }
1417     await expect(
1418       dynamicThreadPool.addTaskFunction('echo', {
1419         taskFunction: echoTaskFunction,
1420         strategy: WorkerChoiceStrategies.LEAST_ELU
1421       })
1422     ).resolves.toBe(true)
1423     expect(dynamicThreadPool.taskFunctions.size).toBe(1)
1424     expect(dynamicThreadPool.taskFunctions.get('echo')).toStrictEqual({
1425       taskFunction: echoTaskFunction,
1426       strategy: WorkerChoiceStrategies.LEAST_ELU
1427     })
1428     expect([
1429       ...dynamicThreadPool.workerChoiceStrategiesContext.workerChoiceStrategies.keys()
1430     ]).toStrictEqual([
1431       WorkerChoiceStrategies.ROUND_ROBIN,
1432       WorkerChoiceStrategies.LEAST_ELU
1433     ])
1434     expect(dynamicThreadPool.listTaskFunctionsProperties()).toStrictEqual([
1435       { name: DEFAULT_TASK_NAME },
1436       { name: 'test' },
1437       { name: 'echo', strategy: WorkerChoiceStrategies.LEAST_ELU }
1438     ])
1439     const taskFunctionData = { test: 'test' }
1440     const echoResult = await dynamicThreadPool.execute(taskFunctionData, 'echo')
1441     expect(echoResult).toStrictEqual(taskFunctionData)
1442     for (const workerNode of dynamicThreadPool.workerNodes) {
1443       expect(workerNode.getTaskFunctionWorkerUsage('echo')).toStrictEqual({
1444         tasks: {
1445           executed: expect.any(Number),
1446           executing: 0,
1447           queued: 0,
1448           sequentiallyStolen: 0,
1449           stolen: 0,
1450           failed: 0
1451         },
1452         runTime: {
1453           history: new CircularArray()
1454         },
1455         waitTime: {
1456           history: new CircularArray()
1457         },
1458         elu: expect.objectContaining({
1459           idle: expect.objectContaining({
1460             history: expect.any(CircularArray)
1461           }),
1462           active: expect.objectContaining({
1463             history: expect.any(CircularArray)
1464           })
1465         })
1466       })
1467       expect(
1468         workerNode.getTaskFunctionWorkerUsage('echo').tasks.executed
1469       ).toBeGreaterThan(0)
1470       if (
1471         workerNode.getTaskFunctionWorkerUsage('echo').elu.active.aggregate ==
1472         null
1473       ) {
1474         expect(
1475           workerNode.getTaskFunctionWorkerUsage('echo').elu.active.aggregate
1476         ).toBeUndefined()
1477       } else {
1478         expect(
1479           workerNode.getTaskFunctionWorkerUsage('echo').elu.active.aggregate
1480         ).toBeGreaterThan(0)
1481       }
1482       if (
1483         workerNode.getTaskFunctionWorkerUsage('echo').elu.idle.aggregate == null
1484       ) {
1485         expect(
1486           workerNode.getTaskFunctionWorkerUsage('echo').elu.idle.aggregate
1487         ).toBeUndefined()
1488       } else {
1489         expect(
1490           workerNode.getTaskFunctionWorkerUsage('echo').elu.idle.aggregate
1491         ).toBeGreaterThanOrEqual(0)
1492       }
1493       if (
1494         workerNode.getTaskFunctionWorkerUsage('echo').elu.utilization == null
1495       ) {
1496         expect(
1497           workerNode.getTaskFunctionWorkerUsage('echo').elu.utilization
1498         ).toBeUndefined()
1499       } else {
1500         expect(
1501           workerNode.getTaskFunctionWorkerUsage('echo').elu.utilization
1502         ).toBeGreaterThanOrEqual(0)
1503         expect(
1504           workerNode.getTaskFunctionWorkerUsage('echo').elu.utilization
1505         ).toBeLessThanOrEqual(1)
1506       }
1507     }
1508     await dynamicThreadPool.destroy()
1509   })
1510
1511   it('Verify that removeTaskFunction() is working', async () => {
1512     const dynamicThreadPool = new DynamicThreadPool(
1513       Math.floor(numberOfWorkers / 2),
1514       numberOfWorkers,
1515       './tests/worker-files/thread/testWorker.mjs'
1516     )
1517     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1518     expect(dynamicThreadPool.listTaskFunctionsProperties()).toStrictEqual([
1519       { name: DEFAULT_TASK_NAME },
1520       { name: 'test' }
1521     ])
1522     await expect(dynamicThreadPool.removeTaskFunction('test')).rejects.toThrow(
1523       new Error('Cannot remove a task function not handled on the pool side')
1524     )
1525     const echoTaskFunction = data => {
1526       return data
1527     }
1528     await dynamicThreadPool.addTaskFunction('echo', {
1529       taskFunction: echoTaskFunction,
1530       strategy: WorkerChoiceStrategies.LEAST_ELU
1531     })
1532     expect(dynamicThreadPool.taskFunctions.size).toBe(1)
1533     expect(dynamicThreadPool.taskFunctions.get('echo')).toStrictEqual({
1534       taskFunction: echoTaskFunction,
1535       strategy: WorkerChoiceStrategies.LEAST_ELU
1536     })
1537     expect([
1538       ...dynamicThreadPool.workerChoiceStrategiesContext.workerChoiceStrategies.keys()
1539     ]).toStrictEqual([
1540       WorkerChoiceStrategies.ROUND_ROBIN,
1541       WorkerChoiceStrategies.LEAST_ELU
1542     ])
1543     expect(dynamicThreadPool.listTaskFunctionsProperties()).toStrictEqual([
1544       { name: DEFAULT_TASK_NAME },
1545       { name: 'test' },
1546       { name: 'echo', strategy: WorkerChoiceStrategies.LEAST_ELU }
1547     ])
1548     await expect(dynamicThreadPool.removeTaskFunction('echo')).resolves.toBe(
1549       true
1550     )
1551     expect(dynamicThreadPool.taskFunctions.size).toBe(0)
1552     expect(dynamicThreadPool.taskFunctions.get('echo')).toBeUndefined()
1553     expect([
1554       ...dynamicThreadPool.workerChoiceStrategiesContext.workerChoiceStrategies.keys()
1555     ]).toStrictEqual([WorkerChoiceStrategies.ROUND_ROBIN])
1556     expect(dynamicThreadPool.listTaskFunctionsProperties()).toStrictEqual([
1557       { name: DEFAULT_TASK_NAME },
1558       { name: 'test' }
1559     ])
1560     await dynamicThreadPool.destroy()
1561   })
1562
1563   it('Verify that listTaskFunctionsProperties() is working', async () => {
1564     const dynamicThreadPool = new DynamicThreadPool(
1565       Math.floor(numberOfWorkers / 2),
1566       numberOfWorkers,
1567       './tests/worker-files/thread/testMultipleTaskFunctionsWorker.mjs'
1568     )
1569     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1570     expect(dynamicThreadPool.listTaskFunctionsProperties()).toStrictEqual([
1571       { name: DEFAULT_TASK_NAME },
1572       { name: 'jsonIntegerSerialization' },
1573       { name: 'factorial' },
1574       { name: 'fibonacci' }
1575     ])
1576     await dynamicThreadPool.destroy()
1577     const fixedClusterPool = new FixedClusterPool(
1578       numberOfWorkers,
1579       './tests/worker-files/cluster/testMultipleTaskFunctionsWorker.cjs'
1580     )
1581     await waitPoolEvents(fixedClusterPool, PoolEvents.ready, 1)
1582     expect(fixedClusterPool.listTaskFunctionsProperties()).toStrictEqual([
1583       { name: DEFAULT_TASK_NAME },
1584       { name: 'jsonIntegerSerialization' },
1585       { name: 'factorial' },
1586       { name: 'fibonacci' }
1587     ])
1588     await fixedClusterPool.destroy()
1589   })
1590
1591   it('Verify that setDefaultTaskFunction() is working', async () => {
1592     const dynamicThreadPool = new DynamicThreadPool(
1593       Math.floor(numberOfWorkers / 2),
1594       numberOfWorkers,
1595       './tests/worker-files/thread/testMultipleTaskFunctionsWorker.mjs'
1596     )
1597     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1598     const workerId = dynamicThreadPool.workerNodes[0].info.id
1599     await expect(dynamicThreadPool.setDefaultTaskFunction(0)).rejects.toThrow(
1600       new Error(
1601         `Task function operation 'default' failed on worker ${workerId} with error: 'TypeError: name parameter is not a string'`
1602       )
1603     )
1604     await expect(
1605       dynamicThreadPool.setDefaultTaskFunction(DEFAULT_TASK_NAME)
1606     ).rejects.toThrow(
1607       new Error(
1608         `Task function operation 'default' failed on worker ${workerId} with error: 'Error: Cannot set the default task function reserved name as the default task function'`
1609       )
1610     )
1611     await expect(
1612       dynamicThreadPool.setDefaultTaskFunction('unknown')
1613     ).rejects.toThrow(
1614       new Error(
1615         `Task function operation 'default' failed on worker ${workerId} with error: 'Error: Cannot set the default task function to a non-existing task function'`
1616       )
1617     )
1618     expect(dynamicThreadPool.listTaskFunctionsProperties()).toStrictEqual([
1619       { name: DEFAULT_TASK_NAME },
1620       { name: 'jsonIntegerSerialization' },
1621       { name: 'factorial' },
1622       { name: 'fibonacci' }
1623     ])
1624     await expect(
1625       dynamicThreadPool.setDefaultTaskFunction('factorial')
1626     ).resolves.toBe(true)
1627     expect(dynamicThreadPool.listTaskFunctionsProperties()).toStrictEqual([
1628       { name: DEFAULT_TASK_NAME },
1629       { name: 'factorial' },
1630       { name: 'jsonIntegerSerialization' },
1631       { name: 'fibonacci' }
1632     ])
1633     await expect(
1634       dynamicThreadPool.setDefaultTaskFunction('fibonacci')
1635     ).resolves.toBe(true)
1636     expect(dynamicThreadPool.listTaskFunctionsProperties()).toStrictEqual([
1637       { name: DEFAULT_TASK_NAME },
1638       { name: 'fibonacci' },
1639       { name: 'jsonIntegerSerialization' },
1640       { name: 'factorial' }
1641     ])
1642     await dynamicThreadPool.destroy()
1643   })
1644
1645   it('Verify that multiple task functions worker is working', async () => {
1646     const pool = new DynamicClusterPool(
1647       Math.floor(numberOfWorkers / 2),
1648       numberOfWorkers,
1649       './tests/worker-files/cluster/testMultipleTaskFunctionsWorker.cjs'
1650     )
1651     const data = { n: 10 }
1652     const result0 = await pool.execute(data)
1653     expect(result0).toStrictEqual({ ok: 1 })
1654     const result1 = await pool.execute(data, 'jsonIntegerSerialization')
1655     expect(result1).toStrictEqual({ ok: 1 })
1656     const result2 = await pool.execute(data, 'factorial')
1657     expect(result2).toBe(3628800)
1658     const result3 = await pool.execute(data, 'fibonacci')
1659     expect(result3).toBe(55)
1660     expect(pool.info.executingTasks).toBe(0)
1661     expect(pool.info.executedTasks).toBe(4)
1662     for (const workerNode of pool.workerNodes) {
1663       expect(workerNode.info.taskFunctionsProperties).toStrictEqual([
1664         { name: DEFAULT_TASK_NAME },
1665         { name: 'jsonIntegerSerialization' },
1666         { name: 'factorial' },
1667         { name: 'fibonacci' }
1668       ])
1669       expect(workerNode.taskFunctionsUsage.size).toBe(3)
1670       for (const taskFunctionProperties of pool.listTaskFunctionsProperties()) {
1671         expect(
1672           workerNode.getTaskFunctionWorkerUsage(taskFunctionProperties.name)
1673         ).toStrictEqual({
1674           tasks: {
1675             executed: expect.any(Number),
1676             executing: 0,
1677             failed: 0,
1678             queued: 0,
1679             sequentiallyStolen: 0,
1680             stolen: 0
1681           },
1682           runTime: {
1683             history: expect.any(CircularArray)
1684           },
1685           waitTime: {
1686             history: expect.any(CircularArray)
1687           },
1688           elu: {
1689             idle: {
1690               history: expect.any(CircularArray)
1691             },
1692             active: {
1693               history: expect.any(CircularArray)
1694             }
1695           }
1696         })
1697         expect(
1698           workerNode.getTaskFunctionWorkerUsage(taskFunctionProperties.name)
1699             .tasks.executed
1700         ).toBeGreaterThan(0)
1701       }
1702       expect(
1703         workerNode.getTaskFunctionWorkerUsage(DEFAULT_TASK_NAME)
1704       ).toStrictEqual(
1705         workerNode.getTaskFunctionWorkerUsage(
1706           workerNode.info.taskFunctionsProperties[1].name
1707         )
1708       )
1709     }
1710     await pool.destroy()
1711   })
1712
1713   it('Verify sendKillMessageToWorker()', async () => {
1714     const pool = new DynamicClusterPool(
1715       Math.floor(numberOfWorkers / 2),
1716       numberOfWorkers,
1717       './tests/worker-files/cluster/testWorker.cjs'
1718     )
1719     const workerNodeKey = 0
1720     await expect(
1721       pool.sendKillMessageToWorker(workerNodeKey)
1722     ).resolves.toBeUndefined()
1723     await pool.destroy()
1724   })
1725
1726   it('Verify sendTaskFunctionOperationToWorker()', async () => {
1727     const pool = new DynamicClusterPool(
1728       Math.floor(numberOfWorkers / 2),
1729       numberOfWorkers,
1730       './tests/worker-files/cluster/testWorker.cjs'
1731     )
1732     const workerNodeKey = 0
1733     await expect(
1734       pool.sendTaskFunctionOperationToWorker(workerNodeKey, {
1735         taskFunctionOperation: 'add',
1736         taskFunctionProperties: { name: 'empty' },
1737         taskFunction: (() => {}).toString()
1738       })
1739     ).resolves.toBe(true)
1740     expect(
1741       pool.workerNodes[workerNodeKey].info.taskFunctionsProperties
1742     ).toStrictEqual([
1743       { name: DEFAULT_TASK_NAME },
1744       { name: 'test' },
1745       { name: 'empty' }
1746     ])
1747     await pool.destroy()
1748   })
1749
1750   it('Verify sendTaskFunctionOperationToWorkers()', async () => {
1751     const pool = new DynamicClusterPool(
1752       Math.floor(numberOfWorkers / 2),
1753       numberOfWorkers,
1754       './tests/worker-files/cluster/testWorker.cjs'
1755     )
1756     await expect(
1757       pool.sendTaskFunctionOperationToWorkers({
1758         taskFunctionOperation: 'add',
1759         taskFunctionProperties: { name: 'empty' },
1760         taskFunction: (() => {}).toString()
1761       })
1762     ).resolves.toBe(true)
1763     for (const workerNode of pool.workerNodes) {
1764       expect(workerNode.info.taskFunctionsProperties).toStrictEqual([
1765         { name: DEFAULT_TASK_NAME },
1766         { name: 'test' },
1767         { name: 'empty' }
1768       ])
1769     }
1770     await pool.destroy()
1771   })
1772 })