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

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