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