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

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