tests/pools/selection-strategies/selection-strategies.test.js

   1 const { expect } = require('expect')
   2 const {
   3   WorkerChoiceStrategies,
   4   DynamicThreadPool,
   5   FixedThreadPool,
   6   FixedClusterPool
   7 } = require('../../../lib')
   8 const { CircularArray } = require('../../../lib/circular-array')
   9
  10 describe('Selection strategies test suite', () => {
  11   const min = 0
  12   const max = 3
  13
  14   it('Verify that WorkerChoiceStrategies enumeration provides string values', () => {
  15     expect(WorkerChoiceStrategies.ROUND_ROBIN).toBe('ROUND_ROBIN')
  16     expect(WorkerChoiceStrategies.LEAST_USED).toBe('LEAST_USED')
  17     expect(WorkerChoiceStrategies.LEAST_BUSY).toBe('LEAST_BUSY')
  18     expect(WorkerChoiceStrategies.FAIR_SHARE).toBe('FAIR_SHARE')
  19     expect(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN).toBe(
  20       'WEIGHTED_ROUND_ROBIN'
  21     )
  22     expect(WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN).toBe(
  23       'INTERLEAVED_WEIGHTED_ROUND_ROBIN'
  24     )
  25   })
  26
  27   it('Verify ROUND_ROBIN strategy is the default at pool creation', async () => {
  28     const pool = new DynamicThreadPool(
  29       min,
  30       max,
  31       './tests/worker-files/thread/testWorker.js'
  32     )
  33     expect(pool.opts.workerChoiceStrategy).toBe(
  34       WorkerChoiceStrategies.ROUND_ROBIN
  35     )
  36     // We need to clean up the resources after our test
  37     await pool.destroy()
  38   })
  39
  40   it('Verify available strategies are taken at pool creation', async () => {
  41     for (const workerChoiceStrategy of Object.values(WorkerChoiceStrategies)) {
  42       const pool = new FixedThreadPool(
  43         max,
  44         './tests/worker-files/thread/testWorker.js',
  45         { workerChoiceStrategy }
  46       )
  47       expect(pool.opts.workerChoiceStrategy).toBe(workerChoiceStrategy)
  48       expect(pool.workerChoiceStrategyContext.workerChoiceStrategy).toBe(
  49         workerChoiceStrategy
  50       )
  51       await pool.destroy()
  52     }
  53   })
  54
  55   it('Verify available strategies can be set after pool creation', async () => {
  56     for (const workerChoiceStrategy of Object.values(WorkerChoiceStrategies)) {
  57       const pool = new DynamicThreadPool(
  58         min,
  59         max,
  60         './tests/worker-files/thread/testWorker.js'
  61       )
  62       pool.setWorkerChoiceStrategy(workerChoiceStrategy)
  63       expect(pool.opts.workerChoiceStrategy).toBe(workerChoiceStrategy)
  64       expect(pool.workerChoiceStrategyContext.workerChoiceStrategy).toBe(
  65         workerChoiceStrategy
  66       )
  67       await pool.destroy()
  68     }
  69   })
  70
  71   it('Verify available strategies default internals at pool creation', async () => {
  72     const pool = new FixedThreadPool(
  73       max,
  74       './tests/worker-files/thread/testWorker.js'
  75     )
  76     for (const workerChoiceStrategy of Object.values(WorkerChoiceStrategies)) {
  77       if (workerChoiceStrategy === WorkerChoiceStrategies.ROUND_ROBIN) {
  78         expect(
  79           pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
  80             workerChoiceStrategy
  81           ).nextWorkerNodeId
  82         ).toBe(0)
  83       } else if (workerChoiceStrategy === WorkerChoiceStrategies.FAIR_SHARE) {
  84         expect(
  85           pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
  86             workerChoiceStrategy
  87           ).workersVirtualTaskEndTimestamp
  88         ).toBeInstanceOf(Array)
  89         expect(
  90           pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
  91             workerChoiceStrategy
  92           ).workersVirtualTaskEndTimestamp.length
  93         ).toBe(0)
  94       } else if (
  95         workerChoiceStrategy === WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
  96       ) {
  97         expect(
  98           pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
  99             workerChoiceStrategy
 100           ).currentWorkerNodeId
 101         ).toBe(0)
 102         expect(
 103           pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 104             workerChoiceStrategy
 105           ).defaultWorkerWeight
 106         ).toBeGreaterThan(0)
 107         expect(
 108           pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 109             workerChoiceStrategy
 110           ).workerVirtualTaskRunTime
 111         ).toBe(0)
 112       }
 113     }
 114     await pool.destroy()
 115   })
 116
 117   it('Verify ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
 118     const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
 119     let pool = new FixedThreadPool(
 120       max,
 121       './tests/worker-files/thread/testWorker.js',
 122       { workerChoiceStrategy }
 123     )
 124     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 125       runTime: false,
 126       avgRunTime: false,
 127       medRunTime: false,
 128       waitTime: false,
 129       avgWaitTime: false,
 130       medWaitTime: false,
 131       elu: false
 132     })
 133     await pool.destroy()
 134     pool = new DynamicThreadPool(
 135       min,
 136       max,
 137       './tests/worker-files/thread/testWorker.js',
 138       { workerChoiceStrategy }
 139     )
 140     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 141       runTime: false,
 142       avgRunTime: false,
 143       medRunTime: false,
 144       waitTime: false,
 145       avgWaitTime: false,
 146       medWaitTime: false,
 147       elu: false
 148     })
 149     // We need to clean up the resources after our test
 150     await pool.destroy()
 151   })
 152
 153   it('Verify ROUND_ROBIN strategy can be run in a fixed pool', async () => {
 154     const pool = new FixedThreadPool(
 155       max,
 156       './tests/worker-files/thread/testWorker.js',
 157       { workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN }
 158     )
 159     // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
 160     const promises = new Set()
 161     const maxMultiplier = 2
 162     for (let i = 0; i < max * maxMultiplier; i++) {
 163       promises.add(pool.execute())
 164     }
 165     await Promise.all(promises)
 166     for (const workerNode of pool.workerNodes) {
 167       expect(workerNode.tasksUsage).toStrictEqual({
 168         ran: maxMultiplier,
 169         running: 0,
 170         runTime: 0,
 171         runTimeHistory: expect.any(CircularArray),
 172         avgRunTime: 0,
 173         medRunTime: 0,
 174         waitTime: 0,
 175         waitTimeHistory: expect.any(CircularArray),
 176         avgWaitTime: 0,
 177         medWaitTime: 0,
 178         error: 0,
 179         elu: undefined
 180       })
 181     }
 182     expect(
 183       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 184         WorkerChoiceStrategies.ROUND_ROBIN
 185       ).nextWorkerNodeId
 186     ).toBe(0)
 187     // We need to clean up the resources after our test
 188     await pool.destroy()
 189   })
 190
 191   it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
 192     const pool = new DynamicThreadPool(
 193       min,
 194       max,
 195       './tests/worker-files/thread/testWorker.js',
 196       { workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN }
 197     )
 198     // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
 199     const promises = new Set()
 200     const maxMultiplier = 2
 201     for (let i = 0; i < max * maxMultiplier; i++) {
 202       promises.add(pool.execute())
 203     }
 204     await Promise.all(promises)
 205     for (const workerNode of pool.workerNodes) {
 206       expect(workerNode.tasksUsage).toStrictEqual({
 207         ran: maxMultiplier,
 208         running: 0,
 209         runTime: 0,
 210         runTimeHistory: expect.any(CircularArray),
 211         avgRunTime: 0,
 212         medRunTime: 0,
 213         waitTime: 0,
 214         waitTimeHistory: expect.any(CircularArray),
 215         avgWaitTime: 0,
 216         medWaitTime: 0,
 217         error: 0,
 218         elu: undefined
 219       })
 220     }
 221     expect(
 222       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 223         WorkerChoiceStrategies.ROUND_ROBIN
 224       ).nextWorkerNodeId
 225     ).toBe(0)
 226     // We need to clean up the resources after our test
 227     await pool.destroy()
 228   })
 229
 230   it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
 231     const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
 232     let pool = new FixedClusterPool(
 233       max,
 234       './tests/worker-files/cluster/testWorker.js',
 235       { workerChoiceStrategy }
 236     )
 237     let results = new Set()
 238     for (let i = 0; i < max; i++) {
 239       results.add(pool.workerNodes[pool.chooseWorkerNode()].worker.id)
 240     }
 241     expect(results.size).toBe(max)
 242     await pool.destroy()
 243     pool = new FixedThreadPool(
 244       max,
 245       './tests/worker-files/thread/testWorker.js',
 246       { workerChoiceStrategy }
 247     )
 248     results = new Set()
 249     for (let i = 0; i < max; i++) {
 250       results.add(pool.workerNodes[pool.chooseWorkerNode()].worker.threadId)
 251     }
 252     expect(results.size).toBe(max)
 253     await pool.destroy()
 254   })
 255
 256   it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
 257     const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
 258     let pool = new FixedThreadPool(
 259       max,
 260       './tests/worker-files/thread/testWorker.js',
 261       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
 262     )
 263     expect(
 264       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 265         workerChoiceStrategy
 266       ).nextWorkerNodeId
 267     ).toBeDefined()
 268     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
 269     expect(
 270       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 271         pool.workerChoiceStrategyContext.workerChoiceStrategy
 272       ).nextWorkerNodeId
 273     ).toBe(0)
 274     await pool.destroy()
 275     pool = new DynamicThreadPool(
 276       min,
 277       max,
 278       './tests/worker-files/thread/testWorker.js',
 279       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
 280     )
 281     expect(
 282       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 283         workerChoiceStrategy
 284       ).nextWorkerNodeId
 285     ).toBeDefined()
 286     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
 287     expect(
 288       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 289         pool.workerChoiceStrategyContext.workerChoiceStrategy
 290       ).nextWorkerNodeId
 291     ).toBe(0)
 292     // We need to clean up the resources after our test
 293     await pool.destroy()
 294   })
 295
 296   it('Verify LEAST_USED strategy default tasks usage statistics requirements', async () => {
 297     const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_USED
 298     let pool = new FixedThreadPool(
 299       max,
 300       './tests/worker-files/thread/testWorker.js',
 301       { workerChoiceStrategy }
 302     )
 303     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 304       runTime: false,
 305       avgRunTime: false,
 306       medRunTime: false,
 307       waitTime: false,
 308       avgWaitTime: false,
 309       medWaitTime: false,
 310       elu: false
 311     })
 312     await pool.destroy()
 313     pool = new DynamicThreadPool(
 314       min,
 315       max,
 316       './tests/worker-files/thread/testWorker.js',
 317       { workerChoiceStrategy }
 318     )
 319     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 320       runTime: false,
 321       avgRunTime: false,
 322       medRunTime: false,
 323       waitTime: false,
 324       avgWaitTime: false,
 325       medWaitTime: false,
 326       elu: false
 327     })
 328     // We need to clean up the resources after our test
 329     await pool.destroy()
 330   })
 331
 332   it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
 333     const pool = new FixedThreadPool(
 334       max,
 335       './tests/worker-files/thread/testWorker.js',
 336       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED }
 337     )
 338     // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
 339     const promises = new Set()
 340     const maxMultiplier = 2
 341     for (let i = 0; i < max * maxMultiplier; i++) {
 342       promises.add(pool.execute())
 343     }
 344     await Promise.all(promises)
 345     for (const workerNode of pool.workerNodes) {
 346       expect(workerNode.tasksUsage).toStrictEqual({
 347         ran: maxMultiplier,
 348         running: 0,
 349         runTime: 0,
 350         runTimeHistory: expect.any(CircularArray),
 351         avgRunTime: 0,
 352         medRunTime: 0,
 353         waitTime: 0,
 354         waitTimeHistory: expect.any(CircularArray),
 355         avgWaitTime: 0,
 356         medWaitTime: 0,
 357         error: 0,
 358         elu: undefined
 359       })
 360     }
 361     // We need to clean up the resources after our test
 362     await pool.destroy()
 363   })
 364
 365   it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
 366     const pool = new DynamicThreadPool(
 367       min,
 368       max,
 369       './tests/worker-files/thread/testWorker.js',
 370       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED }
 371     )
 372     // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
 373     const promises = new Set()
 374     const maxMultiplier = 2
 375     for (let i = 0; i < max * maxMultiplier; i++) {
 376       promises.add(pool.execute())
 377     }
 378     await Promise.all(promises)
 379     for (const workerNode of pool.workerNodes) {
 380       expect(workerNode.tasksUsage).toStrictEqual({
 381         ran: maxMultiplier,
 382         running: 0,
 383         runTime: 0,
 384         runTimeHistory: expect.any(CircularArray),
 385         avgRunTime: 0,
 386         medRunTime: 0,
 387         waitTime: 0,
 388         waitTimeHistory: expect.any(CircularArray),
 389         avgWaitTime: 0,
 390         medWaitTime: 0,
 391         error: 0,
 392         elu: undefined
 393       })
 394     }
 395     // We need to clean up the resources after our test
 396     await pool.destroy()
 397   })
 398
 399   it('Verify LEAST_BUSY strategy default tasks usage statistics requirements', async () => {
 400     const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_BUSY
 401     let pool = new FixedThreadPool(
 402       max,
 403       './tests/worker-files/thread/testWorker.js',
 404       { workerChoiceStrategy }
 405     )
 406     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 407       runTime: true,
 408       avgRunTime: false,
 409       medRunTime: false,
 410       waitTime: false,
 411       avgWaitTime: false,
 412       medWaitTime: false,
 413       elu: false
 414     })
 415     await pool.destroy()
 416     pool = new DynamicThreadPool(
 417       min,
 418       max,
 419       './tests/worker-files/thread/testWorker.js',
 420       { workerChoiceStrategy }
 421     )
 422     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 423       runTime: true,
 424       avgRunTime: false,
 425       medRunTime: false,
 426       waitTime: false,
 427       avgWaitTime: false,
 428       medWaitTime: false,
 429       elu: false
 430     })
 431     // We need to clean up the resources after our test
 432     await pool.destroy()
 433   })
 434
 435   it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
 436     const pool = new FixedThreadPool(
 437       max,
 438       './tests/worker-files/thread/testWorker.js',
 439       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_BUSY }
 440     )
 441     // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
 442     const promises = new Set()
 443     const maxMultiplier = 2
 444     for (let i = 0; i < max * maxMultiplier; i++) {
 445       promises.add(pool.execute())
 446     }
 447     await Promise.all(promises)
 448     for (const workerNode of pool.workerNodes) {
 449       expect(workerNode.tasksUsage).toStrictEqual({
 450         ran: expect.any(Number),
 451         running: 0,
 452         runTime: expect.any(Number),
 453         runTimeHistory: expect.any(CircularArray),
 454         avgRunTime: 0,
 455         medRunTime: 0,
 456         waitTime: 0,
 457         waitTimeHistory: expect.any(CircularArray),
 458         avgWaitTime: 0,
 459         medWaitTime: 0,
 460         error: 0,
 461         elu: undefined
 462       })
 463       expect(workerNode.tasksUsage.ran).toBeGreaterThan(0)
 464       expect(workerNode.tasksUsage.ran).toBeLessThanOrEqual(max * maxMultiplier)
 465       expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
 466     }
 467     // We need to clean up the resources after our test
 468     await pool.destroy()
 469   })
 470
 471   it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
 472     const pool = new DynamicThreadPool(
 473       min,
 474       max,
 475       './tests/worker-files/thread/testWorker.js',
 476       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_BUSY }
 477     )
 478     // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
 479     const promises = new Set()
 480     const maxMultiplier = 2
 481     for (let i = 0; i < max * maxMultiplier; i++) {
 482       promises.add(pool.execute())
 483     }
 484     await Promise.all(promises)
 485     for (const workerNode of pool.workerNodes) {
 486       expect(workerNode.tasksUsage).toStrictEqual({
 487         ran: expect.any(Number),
 488         running: 0,
 489         runTime: expect.any(Number),
 490         runTimeHistory: expect.any(CircularArray),
 491         avgRunTime: 0,
 492         medRunTime: 0,
 493         waitTime: 0,
 494         waitTimeHistory: expect.any(CircularArray),
 495         avgWaitTime: 0,
 496         medWaitTime: 0,
 497         error: 0,
 498         elu: undefined
 499       })
 500       expect(workerNode.tasksUsage.ran).toBeGreaterThan(0)
 501       expect(workerNode.tasksUsage.ran).toBeLessThanOrEqual(max * maxMultiplier)
 502       expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
 503     }
 504     // We need to clean up the resources after our test
 505     await pool.destroy()
 506   })
 507
 508   it('Verify FAIR_SHARE strategy default tasks usage statistics requirements', async () => {
 509     const workerChoiceStrategy = WorkerChoiceStrategies.FAIR_SHARE
 510     let pool = new FixedThreadPool(
 511       max,
 512       './tests/worker-files/thread/testWorker.js',
 513       { workerChoiceStrategy }
 514     )
 515     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 516       runTime: true,
 517       avgRunTime: true,
 518       medRunTime: false,
 519       waitTime: false,
 520       avgWaitTime: false,
 521       medWaitTime: false,
 522       elu: false
 523     })
 524     await pool.destroy()
 525     pool = new DynamicThreadPool(
 526       min,
 527       max,
 528       './tests/worker-files/thread/testWorker.js',
 529       { workerChoiceStrategy }
 530     )
 531     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 532       runTime: true,
 533       avgRunTime: true,
 534       medRunTime: false,
 535       waitTime: false,
 536       avgWaitTime: false,
 537       medWaitTime: false,
 538       elu: false
 539     })
 540     // We need to clean up the resources after our test
 541     await pool.destroy()
 542   })
 543
 544   it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
 545     const pool = new FixedThreadPool(
 546       max,
 547       './tests/worker-files/thread/testWorker.js',
 548       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
 549     )
 550     // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
 551     const promises = new Set()
 552     const maxMultiplier = 2
 553     for (let i = 0; i < max * maxMultiplier; i++) {
 554       promises.add(pool.execute())
 555     }
 556     await Promise.all(promises)
 557     for (const workerNode of pool.workerNodes) {
 558       expect(workerNode.tasksUsage).toStrictEqual({
 559         ran: maxMultiplier,
 560         running: 0,
 561         runTime: expect.any(Number),
 562         runTimeHistory: expect.any(CircularArray),
 563         avgRunTime: expect.any(Number),
 564         medRunTime: 0,
 565         waitTime: 0,
 566         waitTimeHistory: expect.any(CircularArray),
 567         avgWaitTime: 0,
 568         medWaitTime: 0,
 569         error: 0,
 570         elu: undefined
 571       })
 572       expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
 573       expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
 574     }
 575     expect(
 576       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 577         pool.workerChoiceStrategyContext.workerChoiceStrategy
 578       ).workersVirtualTaskEndTimestamp.length
 579     ).toBe(pool.workerNodes.length)
 580     // We need to clean up the resources after our test
 581     await pool.destroy()
 582   })
 583
 584   it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
 585     const pool = new DynamicThreadPool(
 586       min,
 587       max,
 588       './tests/worker-files/thread/testWorker.js',
 589       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
 590     )
 591     // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
 592     const promises = new Set()
 593     const maxMultiplier = 2
 594     for (let i = 0; i < max * maxMultiplier; i++) {
 595       promises.add(pool.execute())
 596     }
 597     await Promise.all(promises)
 598     for (const workerNode of pool.workerNodes) {
 599       expect(workerNode.tasksUsage).toStrictEqual({
 600         ran: maxMultiplier,
 601         running: 0,
 602         runTime: expect.any(Number),
 603         runTimeHistory: expect.any(CircularArray),
 604         avgRunTime: expect.any(Number),
 605         medRunTime: 0,
 606         waitTime: 0,
 607         waitTimeHistory: expect.any(CircularArray),
 608         avgWaitTime: 0,
 609         medWaitTime: 0,
 610         error: 0,
 611         elu: undefined
 612       })
 613       expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
 614       expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
 615     }
 616     expect(
 617       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 618         pool.workerChoiceStrategyContext.workerChoiceStrategy
 619       ).workersVirtualTaskEndTimestamp.length
 620     ).toBe(pool.workerNodes.length)
 621     // We need to clean up the resources after our test
 622     await pool.destroy()
 623   })
 624
 625   it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
 626     const pool = new DynamicThreadPool(
 627       min,
 628       max,
 629       './tests/worker-files/thread/testWorker.js',
 630       {
 631         workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE,
 632         workerChoiceStrategyOptions: {
 633           medRunTime: true
 634         }
 635       }
 636     )
 637     // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
 638     const promises = new Set()
 639     const maxMultiplier = 2
 640     for (let i = 0; i < max * maxMultiplier; i++) {
 641       promises.add(pool.execute())
 642     }
 643     await Promise.all(promises)
 644     for (const workerNode of pool.workerNodes) {
 645       expect(workerNode.tasksUsage).toStrictEqual({
 646         ran: maxMultiplier,
 647         running: 0,
 648         runTime: expect.any(Number),
 649         runTimeHistory: expect.any(CircularArray),
 650         avgRunTime: 0,
 651         medRunTime: expect.any(Number),
 652         waitTime: 0,
 653         waitTimeHistory: expect.any(CircularArray),
 654         avgWaitTime: 0,
 655         medWaitTime: 0,
 656         error: 0,
 657         elu: undefined
 658       })
 659       expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
 660       expect(workerNode.tasksUsage.medRunTime).toBeGreaterThan(0)
 661     }
 662     expect(
 663       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 664         pool.workerChoiceStrategyContext.workerChoiceStrategy
 665       ).workersVirtualTaskEndTimestamp.length
 666     ).toBe(pool.workerNodes.length)
 667     // We need to clean up the resources after our test
 668     await pool.destroy()
 669   })
 670
 671   it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
 672     const workerChoiceStrategy = WorkerChoiceStrategies.FAIR_SHARE
 673     let pool = new FixedThreadPool(
 674       max,
 675       './tests/worker-files/thread/testWorker.js'
 676     )
 677     expect(
 678       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 679         workerChoiceStrategy
 680       ).workersVirtualTaskEndTimestamp
 681     ).toBeInstanceOf(Array)
 682     expect(
 683       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 684         workerChoiceStrategy
 685       ).workersVirtualTaskEndTimestamp.length
 686     ).toBe(0)
 687     pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 688       workerChoiceStrategy
 689     ).workersVirtualTaskEndTimestamp[0] = performance.now()
 690     expect(
 691       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 692         workerChoiceStrategy
 693       ).workersVirtualTaskEndTimestamp.length
 694     ).toBe(1)
 695     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
 696     expect(
 697       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 698         workerChoiceStrategy
 699       ).workersVirtualTaskEndTimestamp
 700     ).toBeInstanceOf(Array)
 701     expect(
 702       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 703         workerChoiceStrategy
 704       ).workersVirtualTaskEndTimestamp.length
 705     ).toBe(0)
 706     await pool.destroy()
 707     pool = new DynamicThreadPool(
 708       min,
 709       max,
 710       './tests/worker-files/thread/testWorker.js'
 711     )
 712     expect(
 713       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 714         workerChoiceStrategy
 715       ).workersVirtualTaskEndTimestamp
 716     ).toBeInstanceOf(Array)
 717     expect(
 718       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 719         workerChoiceStrategy
 720       ).workersVirtualTaskEndTimestamp.length
 721     ).toBe(0)
 722     pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 723       workerChoiceStrategy
 724     ).workersVirtualTaskEndTimestamp[0] = performance.now()
 725     expect(
 726       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 727         workerChoiceStrategy
 728       ).workersVirtualTaskEndTimestamp.length
 729     ).toBe(1)
 730     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
 731     expect(
 732       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 733         workerChoiceStrategy
 734       ).workersVirtualTaskEndTimestamp
 735     ).toBeInstanceOf(Array)
 736     expect(
 737       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 738         workerChoiceStrategy
 739       ).workersVirtualTaskEndTimestamp.length
 740     ).toBe(0)
 741     // We need to clean up the resources after our test
 742     await pool.destroy()
 743   })
 744
 745   it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
 746     const workerChoiceStrategy = WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
 747     let pool = new FixedThreadPool(
 748       max,
 749       './tests/worker-files/thread/testWorker.js',
 750       { workerChoiceStrategy }
 751     )
 752     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 753       runTime: true,
 754       avgRunTime: true,
 755       medRunTime: false,
 756       waitTime: false,
 757       avgWaitTime: false,
 758       medWaitTime: false,
 759       elu: false
 760     })
 761     await pool.destroy()
 762     pool = new DynamicThreadPool(
 763       min,
 764       max,
 765       './tests/worker-files/thread/testWorker.js',
 766       { workerChoiceStrategy }
 767     )
 768     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
 769       runTime: true,
 770       avgRunTime: true,
 771       medRunTime: false,
 772       waitTime: false,
 773       avgWaitTime: false,
 774       medWaitTime: false,
 775       elu: false
 776     })
 777     // We need to clean up the resources after our test
 778     await pool.destroy()
 779   })
 780
 781   it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
 782     const pool = new FixedThreadPool(
 783       max,
 784       './tests/worker-files/thread/testWorker.js',
 785       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
 786     )
 787     // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
 788     const promises = new Set()
 789     const maxMultiplier = 2
 790     for (let i = 0; i < max * maxMultiplier; i++) {
 791       promises.add(pool.execute())
 792     }
 793     await Promise.all(promises)
 794     for (const workerNode of pool.workerNodes) {
 795       expect(workerNode.tasksUsage).toStrictEqual({
 796         ran: expect.any(Number),
 797         running: 0,
 798         runTime: expect.any(Number),
 799         runTimeHistory: expect.any(CircularArray),
 800         avgRunTime: expect.any(Number),
 801         medRunTime: 0,
 802         waitTime: 0,
 803         waitTimeHistory: expect.any(CircularArray),
 804         avgWaitTime: 0,
 805         medWaitTime: 0,
 806         error: 0,
 807         elu: undefined
 808       })
 809       expect(workerNode.tasksUsage.ran).toBeGreaterThanOrEqual(0)
 810       expect(workerNode.tasksUsage.ran).toBeLessThanOrEqual(max * maxMultiplier)
 811       expect(workerNode.tasksUsage.runTime).toBeGreaterThanOrEqual(0)
 812       expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThanOrEqual(0)
 813     }
 814     expect(
 815       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 816         pool.workerChoiceStrategyContext.workerChoiceStrategy
 817       ).defaultWorkerWeight
 818     ).toBeGreaterThan(0)
 819     expect(
 820       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 821         pool.workerChoiceStrategyContext.workerChoiceStrategy
 822       ).workerVirtualTaskRunTime
 823     ).toBeGreaterThanOrEqual(0)
 824     // We need to clean up the resources after our test
 825     await pool.destroy()
 826   })
 827
 828   it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
 829     const pool = new DynamicThreadPool(
 830       min,
 831       max,
 832       './tests/worker-files/thread/testWorker.js',
 833       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
 834     )
 835     // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
 836     const promises = new Set()
 837     const maxMultiplier = 2
 838     for (let i = 0; i < max * maxMultiplier; i++) {
 839       promises.add(pool.execute())
 840     }
 841     await Promise.all(promises)
 842     for (const workerNode of pool.workerNodes) {
 843       expect(workerNode.tasksUsage).toStrictEqual({
 844         ran: expect.any(Number),
 845         running: 0,
 846         runTime: expect.any(Number),
 847         runTimeHistory: expect.any(CircularArray),
 848         avgRunTime: expect.any(Number),
 849         medRunTime: 0,
 850         waitTime: 0,
 851         waitTimeHistory: expect.any(CircularArray),
 852         avgWaitTime: 0,
 853         medWaitTime: 0,
 854         error: 0,
 855         elu: undefined
 856       })
 857       expect(workerNode.tasksUsage.ran).toBeGreaterThan(0)
 858       expect(workerNode.tasksUsage.ran).toBeLessThanOrEqual(max * maxMultiplier)
 859       expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
 860       expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
 861     }
 862     expect(
 863       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 864         pool.workerChoiceStrategyContext.workerChoiceStrategy
 865       ).defaultWorkerWeight
 866     ).toBeGreaterThan(0)
 867     expect(
 868       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 869         pool.workerChoiceStrategyContext.workerChoiceStrategy
 870       ).workerVirtualTaskRunTime
 871     ).toBeGreaterThanOrEqual(0)
 872     // We need to clean up the resources after our test
 873     await pool.destroy()
 874   })
 875
 876   it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
 877     const pool = new DynamicThreadPool(
 878       min,
 879       max,
 880       './tests/worker-files/thread/testWorker.js',
 881       {
 882         workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN,
 883         workerChoiceStrategyOptions: {
 884           medRunTime: true
 885         }
 886       }
 887     )
 888     // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
 889     const promises = new Set()
 890     const maxMultiplier = 2
 891     for (let i = 0; i < max * maxMultiplier; i++) {
 892       promises.add(pool.execute())
 893     }
 894     await Promise.all(promises)
 895     for (const workerNode of pool.workerNodes) {
 896       expect(workerNode.tasksUsage).toStrictEqual({
 897         ran: expect.any(Number),
 898         running: 0,
 899         runTime: expect.any(Number),
 900         runTimeHistory: expect.any(CircularArray),
 901         avgRunTime: 0,
 902         medRunTime: expect.any(Number),
 903         waitTime: 0,
 904         waitTimeHistory: expect.any(CircularArray),
 905         avgWaitTime: 0,
 906         medWaitTime: 0,
 907         error: 0,
 908         elu: undefined
 909       })
 910       expect(workerNode.tasksUsage.ran).toBeGreaterThan(0)
 911       expect(workerNode.tasksUsage.ran).toBeLessThanOrEqual(max * maxMultiplier)
 912       expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
 913       expect(workerNode.tasksUsage.medRunTime).toBeGreaterThan(0)
 914     }
 915     expect(
 916       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 917         pool.workerChoiceStrategyContext.workerChoiceStrategy
 918       ).defaultWorkerWeight
 919     ).toBeGreaterThan(0)
 920     expect(
 921       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 922         pool.workerChoiceStrategyContext.workerChoiceStrategy
 923       ).workerVirtualTaskRunTime
 924     ).toBeGreaterThanOrEqual(0)
 925     // We need to clean up the resources after our test
 926     await pool.destroy()
 927   })
 928
 929   it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
 930     const workerChoiceStrategy = WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
 931     let pool = new FixedThreadPool(
 932       max,
 933       './tests/worker-files/thread/testWorker.js'
 934     )
 935     expect(
 936       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 937         workerChoiceStrategy
 938       ).currentWorkerNodeId
 939     ).toBeDefined()
 940     expect(
 941       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 942         workerChoiceStrategy
 943       ).defaultWorkerWeight
 944     ).toBeDefined()
 945     expect(
 946       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 947         workerChoiceStrategy
 948       ).workerVirtualTaskRunTime
 949     ).toBeDefined()
 950     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
 951     expect(
 952       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 953         pool.workerChoiceStrategyContext.workerChoiceStrategy
 954       ).currentWorkerNodeId
 955     ).toBe(0)
 956     expect(
 957       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 958         pool.workerChoiceStrategyContext.workerChoiceStrategy
 959       ).defaultWorkerWeight
 960     ).toBeGreaterThan(0)
 961     expect(
 962       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 963         workerChoiceStrategy
 964       ).workerVirtualTaskRunTime
 965     ).toBe(0)
 966     await pool.destroy()
 967     pool = new DynamicThreadPool(
 968       min,
 969       max,
 970       './tests/worker-files/thread/testWorker.js'
 971     )
 972     expect(
 973       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 974         workerChoiceStrategy
 975       ).currentWorkerNodeId
 976     ).toBeDefined()
 977     expect(
 978       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 979         workerChoiceStrategy
 980       ).defaultWorkerWeight
 981     ).toBeDefined()
 982     expect(
 983       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 984         workerChoiceStrategy
 985       ).workerVirtualTaskRunTime
 986     ).toBeDefined()
 987     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
 988     expect(
 989       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 990         pool.workerChoiceStrategyContext.workerChoiceStrategy
 991       ).currentWorkerNodeId
 992     ).toBe(0)
 993     expect(
 994       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
 995         pool.workerChoiceStrategyContext.workerChoiceStrategy
 996       ).defaultWorkerWeight
 997     ).toBeGreaterThan(0)
 998     expect(
 999       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1000         workerChoiceStrategy
1001       ).workerVirtualTaskRunTime
1002     ).toBe(0)
1003     // We need to clean up the resources after our test
1004     await pool.destroy()
1005   })
1006
1007   it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
1008     const workerChoiceStrategy =
1009       WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1010     let pool = new FixedThreadPool(
1011       max,
1012       './tests/worker-files/thread/testWorker.js',
1013       { workerChoiceStrategy }
1014     )
1015     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
1016       runTime: false,
1017       avgRunTime: false,
1018       medRunTime: false,
1019       waitTime: false,
1020       avgWaitTime: false,
1021       medWaitTime: false,
1022       elu: false
1023     })
1024     await pool.destroy()
1025     pool = new DynamicThreadPool(
1026       min,
1027       max,
1028       './tests/worker-files/thread/testWorker.js',
1029       { workerChoiceStrategy }
1030     )
1031     expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
1032       runTime: false,
1033       avgRunTime: false,
1034       medRunTime: false,
1035       waitTime: false,
1036       avgWaitTime: false,
1037       medWaitTime: false,
1038       elu: false
1039     })
1040     // We need to clean up the resources after our test
1041     await pool.destroy()
1042   })
1043
1044   it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1045     const pool = new FixedThreadPool(
1046       max,
1047       './tests/worker-files/thread/testWorker.js',
1048       {
1049         workerChoiceStrategy:
1050           WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1051       }
1052     )
1053     // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1054     const promises = new Set()
1055     const maxMultiplier = 2
1056     for (let i = 0; i < max * maxMultiplier; i++) {
1057       promises.add(pool.execute())
1058     }
1059     await Promise.all(promises)
1060     for (const workerNode of pool.workerNodes) {
1061       expect(workerNode.tasksUsage).toStrictEqual({
1062         ran: maxMultiplier,
1063         running: 0,
1064         runTime: 0,
1065         runTimeHistory: expect.any(CircularArray),
1066         avgRunTime: 0,
1067         medRunTime: 0,
1068         waitTime: 0,
1069         waitTimeHistory: expect.any(CircularArray),
1070         avgWaitTime: 0,
1071         medWaitTime: 0,
1072         error: 0,
1073         elu: undefined
1074       })
1075     }
1076     expect(
1077       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1078         pool.workerChoiceStrategyContext.workerChoiceStrategy
1079       ).defaultWorkerWeight
1080     ).toBeGreaterThan(0)
1081     expect(
1082       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1083         pool.workerChoiceStrategyContext.workerChoiceStrategy
1084       ).currentRoundId
1085     ).toBe(0)
1086     expect(
1087       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1088         pool.workerChoiceStrategyContext.workerChoiceStrategy
1089       ).currentWorkerNodeId
1090     ).toBe(0)
1091     expect(
1092       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1093         pool.workerChoiceStrategyContext.workerChoiceStrategy
1094       ).roundWeights
1095     ).toStrictEqual([
1096       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1097         pool.workerChoiceStrategyContext.workerChoiceStrategy
1098       ).defaultWorkerWeight
1099     ])
1100     // We need to clean up the resources after our test
1101     await pool.destroy()
1102   })
1103
1104   it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1105     const pool = new DynamicThreadPool(
1106       min,
1107       max,
1108       './tests/worker-files/thread/testWorker.js',
1109       {
1110         workerChoiceStrategy:
1111           WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1112       }
1113     )
1114     // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1115     const promises = new Set()
1116     const maxMultiplier = 2
1117     for (let i = 0; i < max * maxMultiplier; i++) {
1118       promises.add(pool.execute())
1119     }
1120     await Promise.all(promises)
1121     for (const workerNode of pool.workerNodes) {
1122       expect(workerNode.tasksUsage).toStrictEqual({
1123         ran: maxMultiplier,
1124         running: 0,
1125         runTime: 0,
1126         runTimeHistory: expect.any(CircularArray),
1127         avgRunTime: 0,
1128         medRunTime: 0,
1129         waitTime: 0,
1130         waitTimeHistory: expect.any(CircularArray),
1131         avgWaitTime: 0,
1132         medWaitTime: 0,
1133         error: 0,
1134         elu: undefined
1135       })
1136     }
1137     expect(
1138       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1139         pool.workerChoiceStrategyContext.workerChoiceStrategy
1140       ).defaultWorkerWeight
1141     ).toBeGreaterThan(0)
1142     expect(
1143       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1144         pool.workerChoiceStrategyContext.workerChoiceStrategy
1145       ).currentRoundId
1146     ).toBe(0)
1147     expect(
1148       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1149         pool.workerChoiceStrategyContext.workerChoiceStrategy
1150       ).currentWorkerNodeId
1151     ).toBe(0)
1152     expect(
1153       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1154         pool.workerChoiceStrategyContext.workerChoiceStrategy
1155       ).roundWeights
1156     ).toStrictEqual([
1157       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1158         pool.workerChoiceStrategyContext.workerChoiceStrategy
1159       ).defaultWorkerWeight
1160     ])
1161     // We need to clean up the resources after our test
1162     await pool.destroy()
1163   })
1164
1165   it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1166     const workerChoiceStrategy =
1167       WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1168     let pool = new FixedThreadPool(
1169       max,
1170       './tests/worker-files/thread/testWorker.js'
1171     )
1172     expect(
1173       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1174         workerChoiceStrategy
1175       ).currentRoundId
1176     ).toBeDefined()
1177     expect(
1178       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1179         workerChoiceStrategy
1180       ).currentWorkerNodeId
1181     ).toBeDefined()
1182     expect(
1183       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1184         workerChoiceStrategy
1185       ).defaultWorkerWeight
1186     ).toBeDefined()
1187     expect(
1188       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1189         workerChoiceStrategy
1190       ).roundWeights
1191     ).toBeDefined()
1192     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
1193     expect(
1194       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1195         workerChoiceStrategy
1196       ).currentRoundId
1197     ).toBe(0)
1198     expect(
1199       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1200         pool.workerChoiceStrategyContext.workerChoiceStrategy
1201       ).currentWorkerNodeId
1202     ).toBe(0)
1203     expect(
1204       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1205         pool.workerChoiceStrategyContext.workerChoiceStrategy
1206       ).defaultWorkerWeight
1207     ).toBeGreaterThan(0)
1208     expect(
1209       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1210         workerChoiceStrategy
1211       ).roundWeights
1212     ).toStrictEqual([
1213       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1214         pool.workerChoiceStrategyContext.workerChoiceStrategy
1215       ).defaultWorkerWeight
1216     ])
1217     await pool.destroy()
1218     pool = new DynamicThreadPool(
1219       min,
1220       max,
1221       './tests/worker-files/thread/testWorker.js'
1222     )
1223     expect(
1224       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1225         workerChoiceStrategy
1226       ).currentRoundId
1227     ).toBeDefined()
1228     expect(
1229       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1230         workerChoiceStrategy
1231       ).currentWorkerNodeId
1232     ).toBeDefined()
1233     expect(
1234       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1235         workerChoiceStrategy
1236       ).defaultWorkerWeight
1237     ).toBeDefined()
1238     expect(
1239       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1240         workerChoiceStrategy
1241       ).roundWeights
1242     ).toBeDefined()
1243     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
1244     expect(
1245       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1246         pool.workerChoiceStrategyContext.workerChoiceStrategy
1247       ).currentWorkerNodeId
1248     ).toBe(0)
1249     expect(
1250       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1251         pool.workerChoiceStrategyContext.workerChoiceStrategy
1252       ).defaultWorkerWeight
1253     ).toBeGreaterThan(0)
1254     expect(
1255       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1256         workerChoiceStrategy
1257       ).roundWeights
1258     ).toStrictEqual([
1259       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
1260         pool.workerChoiceStrategyContext.workerChoiceStrategy
1261       ).defaultWorkerWeight
1262     ])
1263     // We need to clean up the resources after our test
1264     await pool.destroy()
1265   })
1266
1267   it('Verify unknown strategy throw error', () => {
1268     expect(
1269       () =>
1270         new DynamicThreadPool(
1271           min,
1272           max,
1273           './tests/worker-files/thread/testWorker.js',
1274           { workerChoiceStrategy: 'UNKNOWN_STRATEGY' }
1275         )
1276     ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")
1277   })
1278 })