tests/pools/abstract-pool.test.mjs

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