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