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/index')
   8
   9 describe('Selection strategies test suite', () => {
  10   const min = 0
  11   const max = 3
  12
  13   it('Verify that WorkerChoiceStrategies enumeration provides string values', () => {
  14     expect(WorkerChoiceStrategies.ROUND_ROBIN).toBe('ROUND_ROBIN')
  15     expect(WorkerChoiceStrategies.LESS_USED).toBe('LESS_USED')
  16     expect(WorkerChoiceStrategies.LESS_BUSY).toBe('LESS_BUSY')
  17     expect(WorkerChoiceStrategies.FAIR_SHARE).toBe('FAIR_SHARE')
  18     expect(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN).toBe(
  19       'WEIGHTED_ROUND_ROBIN'
  20     )
  21   })
  22
  23   it('Verify ROUND_ROBIN strategy is the default at pool creation', async () => {
  24     const pool = new DynamicThreadPool(
  25       min,
  26       max,
  27       './tests/worker-files/thread/testWorker.js'
  28     )
  29     expect(pool.opts.workerChoiceStrategy).toBe(
  30       WorkerChoiceStrategies.ROUND_ROBIN
  31     )
  32     // We need to clean up the resources after our test
  33     await pool.destroy()
  34   })
  35
  36   it('Verify ROUND_ROBIN strategy is taken at pool creation', async () => {
  37     const pool = new FixedThreadPool(
  38       max,
  39       './tests/worker-files/thread/testWorker.js',
  40       { workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN }
  41     )
  42     expect(pool.opts.workerChoiceStrategy).toBe(
  43       WorkerChoiceStrategies.ROUND_ROBIN
  44     )
  45     expect(
  46       pool.workerChoiceStrategyContext.workerChoiceStrategy.nextWorkerId
  47     ).toBe(0)
  48     // We need to clean up the resources after our test
  49     await pool.destroy()
  50   })
  51
  52   it('Verify ROUND_ROBIN strategy can be set after pool creation', async () => {
  53     const pool = new DynamicThreadPool(
  54       min,
  55       max,
  56       './tests/worker-files/thread/testWorker.js'
  57     )
  58     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.ROUND_ROBIN)
  59     expect(pool.opts.workerChoiceStrategy).toBe(
  60       WorkerChoiceStrategies.ROUND_ROBIN
  61     )
  62     // We need to clean up the resources after our test
  63     await pool.destroy()
  64   })
  65
  66   it('Verify ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
  67     let pool = new FixedThreadPool(
  68       max,
  69       './tests/worker-files/thread/testWorker.js'
  70     )
  71     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.ROUND_ROBIN)
  72     expect(
  73       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
  74     ).toBe(false)
  75     await pool.destroy()
  76     pool = new DynamicThreadPool(
  77       min,
  78       max,
  79       './tests/worker-files/thread/testWorker.js'
  80     )
  81     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.ROUND_ROBIN)
  82     expect(
  83       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
  84     ).toBe(false)
  85     // We need to clean up the resources after our test
  86     await pool.destroy()
  87   })
  88
  89   it('Verify ROUND_ROBIN strategy can be run in a fixed pool', async () => {
  90     const pool = new FixedThreadPool(
  91       max,
  92       './tests/worker-files/thread/testWorker.js',
  93       { workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN }
  94     )
  95     expect(pool.opts.workerChoiceStrategy).toBe(
  96       WorkerChoiceStrategies.ROUND_ROBIN
  97     )
  98     // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
  99     const promises = []
 100     for (let i = 0; i < max * 2; i++) {
 101       promises.push(pool.execute())
 102     }
 103     await Promise.all(promises)
 104     // We need to clean up the resources after our test
 105     await pool.destroy()
 106   })
 107
 108   it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
 109     const pool = new DynamicThreadPool(
 110       min,
 111       max,
 112       './tests/worker-files/thread/testWorker.js',
 113       { workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN }
 114     )
 115     expect(pool.opts.workerChoiceStrategy).toBe(
 116       WorkerChoiceStrategies.ROUND_ROBIN
 117     )
 118     // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
 119     const promises = []
 120     for (let i = 0; i < max * 2; i++) {
 121       promises.push(pool.execute())
 122     }
 123     await Promise.all(promises)
 124     // We need to clean up the resources after our test
 125     await pool.destroy()
 126   })
 127
 128   it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
 129     let pool = new FixedClusterPool(
 130       max,
 131       './tests/worker-files/cluster/testWorker.js'
 132     )
 133     let results = new Set()
 134     for (let i = 0; i < max; i++) {
 135       results.add(pool.chooseWorker()[1].id)
 136     }
 137     expect(results.size).toBe(max)
 138     await pool.destroy()
 139     pool = new FixedThreadPool(max, './tests/worker-files/thread/testWorker.js')
 140     results = new Set()
 141     for (let i = 0; i < max; i++) {
 142       results.add(pool.chooseWorker()[1].threadId)
 143     }
 144     expect(results.size).toBe(max)
 145     await pool.destroy()
 146   })
 147
 148   it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
 149     let pool = new FixedThreadPool(
 150       max,
 151       './tests/worker-files/thread/testWorker.js',
 152       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
 153     )
 154     expect(
 155       pool.workerChoiceStrategyContext.workerChoiceStrategy.nextWorkerId
 156     ).toBeUndefined()
 157     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.ROUND_ROBIN)
 158     expect(
 159       pool.workerChoiceStrategyContext.workerChoiceStrategy.nextWorkerId
 160     ).toBe(0)
 161     await pool.destroy()
 162     pool = new DynamicThreadPool(
 163       min,
 164       max,
 165       './tests/worker-files/thread/testWorker.js',
 166       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
 167     )
 168     expect(
 169       pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy
 170         .nextWorkerId
 171     ).toBeUndefined()
 172     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.ROUND_ROBIN)
 173     expect(
 174       pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy
 175         .nextWorkerId
 176     ).toBe(0)
 177     // We need to clean up the resources after our test
 178     await pool.destroy()
 179   })
 180
 181   it('Verify LESS_USED strategy is taken at pool creation', async () => {
 182     const pool = new FixedThreadPool(
 183       max,
 184       './tests/worker-files/thread/testWorker.js',
 185       { workerChoiceStrategy: WorkerChoiceStrategies.LESS_USED }
 186     )
 187     expect(pool.opts.workerChoiceStrategy).toBe(
 188       WorkerChoiceStrategies.LESS_USED
 189     )
 190     // We need to clean up the resources after our test
 191     await pool.destroy()
 192   })
 193
 194   it('Verify LESS_USED strategy can be set after pool creation', async () => {
 195     const pool = new FixedThreadPool(
 196       max,
 197       './tests/worker-files/thread/testWorker.js'
 198     )
 199     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.LESS_USED)
 200     expect(pool.opts.workerChoiceStrategy).toBe(
 201       WorkerChoiceStrategies.LESS_USED
 202     )
 203     // We need to clean up the resources after our test
 204     await pool.destroy()
 205   })
 206
 207   it('Verify LESS_USED strategy default tasks usage statistics requirements', async () => {
 208     let pool = new FixedThreadPool(
 209       max,
 210       './tests/worker-files/thread/testWorker.js'
 211     )
 212     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.LESS_USED)
 213     expect(
 214       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
 215     ).toBe(false)
 216     await pool.destroy()
 217     pool = new DynamicThreadPool(
 218       min,
 219       max,
 220       './tests/worker-files/thread/testWorker.js'
 221     )
 222     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.LESS_USED)
 223     expect(
 224       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
 225     ).toBe(false)
 226     // We need to clean up the resources after our test
 227     await pool.destroy()
 228   })
 229
 230   it('Verify LESS_USED strategy can be run in a fixed pool', async () => {
 231     const pool = new FixedThreadPool(
 232       max,
 233       './tests/worker-files/thread/testWorker.js',
 234       { workerChoiceStrategy: WorkerChoiceStrategies.LESS_USED }
 235     )
 236     // TODO: Create a better test to cover `LessUsedWorkerChoiceStrategy#choose`
 237     const promises = []
 238     for (let i = 0; i < max * 2; i++) {
 239       promises.push(pool.execute())
 240     }
 241     await Promise.all(promises)
 242     // We need to clean up the resources after our test
 243     await pool.destroy()
 244   })
 245
 246   it('Verify LESS_USED strategy can be run in a dynamic pool', async () => {
 247     const pool = new DynamicThreadPool(
 248       min,
 249       max,
 250       './tests/worker-files/thread/testWorker.js',
 251       { workerChoiceStrategy: WorkerChoiceStrategies.LESS_USED }
 252     )
 253     // TODO: Create a better test to cover `LessUsedWorkerChoiceStrategy#choose`
 254     const promises = []
 255     for (let i = 0; i < max * 2; i++) {
 256       promises.push(pool.execute())
 257     }
 258     await Promise.all(promises)
 259     // We need to clean up the resources after our test
 260     await pool.destroy()
 261   })
 262
 263   it('Verify LESS_BUSY strategy is taken at pool creation', async () => {
 264     const pool = new FixedThreadPool(
 265       max,
 266       './tests/worker-files/thread/testWorker.js',
 267       { workerChoiceStrategy: WorkerChoiceStrategies.LESS_BUSY }
 268     )
 269     expect(pool.opts.workerChoiceStrategy).toBe(
 270       WorkerChoiceStrategies.LESS_BUSY
 271     )
 272     // We need to clean up the resources after our test
 273     await pool.destroy()
 274   })
 275
 276   it('Verify LESS_BUSY strategy can be set after pool creation', async () => {
 277     const pool = new FixedThreadPool(
 278       max,
 279       './tests/worker-files/thread/testWorker.js'
 280     )
 281     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.LESS_BUSY)
 282     expect(pool.opts.workerChoiceStrategy).toBe(
 283       WorkerChoiceStrategies.LESS_BUSY
 284     )
 285     // We need to clean up the resources after our test
 286     await pool.destroy()
 287   })
 288
 289   it('Verify LESS_BUSY strategy default tasks usage statistics requirements', async () => {
 290     let pool = new FixedThreadPool(
 291       max,
 292       './tests/worker-files/thread/testWorker.js'
 293     )
 294     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.LESS_BUSY)
 295     expect(
 296       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
 297     ).toBe(true)
 298     await pool.destroy()
 299     pool = new DynamicThreadPool(
 300       min,
 301       max,
 302       './tests/worker-files/thread/testWorker.js'
 303     )
 304     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.LESS_BUSY)
 305     expect(
 306       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
 307     ).toBe(true)
 308     // We need to clean up the resources after our test
 309     await pool.destroy()
 310   })
 311
 312   it('Verify LESS_BUSY strategy can be run in a fixed pool', async () => {
 313     const pool = new FixedThreadPool(
 314       max,
 315       './tests/worker-files/thread/testWorker.js',
 316       { workerChoiceStrategy: WorkerChoiceStrategies.LESS_BUSY }
 317     )
 318     // TODO: Create a better test to cover `LessBusyWorkerChoiceStrategy#choose`
 319     const promises = []
 320     for (let i = 0; i < max * 2; i++) {
 321       promises.push(pool.execute())
 322     }
 323     await Promise.all(promises)
 324     // We need to clean up the resources after our test
 325     await pool.destroy()
 326   })
 327
 328   it('Verify LESS_BUSY strategy can be run in a dynamic pool', async () => {
 329     const pool = new DynamicThreadPool(
 330       min,
 331       max,
 332       './tests/worker-files/thread/testWorker.js',
 333       { workerChoiceStrategy: WorkerChoiceStrategies.LESS_BUSY }
 334     )
 335     // TODO: Create a better test to cover `LessBusyWorkerChoiceStrategy#choose`
 336     const promises = []
 337     for (let i = 0; i < max * 2; i++) {
 338       promises.push(pool.execute())
 339     }
 340     await Promise.all(promises)
 341     // We need to clean up the resources after our test
 342     await pool.destroy()
 343   })
 344
 345   it('Verify FAIR_SHARE strategy is taken at pool creation', async () => {
 346     const pool = new FixedThreadPool(
 347       max,
 348       './tests/worker-files/thread/testWorker.js',
 349       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
 350     )
 351     expect(pool.opts.workerChoiceStrategy).toBe(
 352       WorkerChoiceStrategies.FAIR_SHARE
 353     )
 354     for (const workerKey of pool.workerChoiceStrategyContext.workerChoiceStrategy.workerLastVirtualTaskTimestamp.keys()) {
 355       expect(
 356         pool.workerChoiceStrategyContext.workerChoiceStrategy.workerLastVirtualTaskTimestamp.get(
 357           workerKey
 358         ).start
 359       ).toBe(0)
 360       expect(
 361         pool.workerChoiceStrategyContext.workerChoiceStrategy.workerLastVirtualTaskTimestamp.get(
 362           workerKey
 363         ).end
 364       ).toBe(0)
 365     }
 366     // We need to clean up the resources after our test
 367     await pool.destroy()
 368   })
 369
 370   it('Verify FAIR_SHARE strategy can be set after pool creation', async () => {
 371     const pool = new FixedThreadPool(
 372       max,
 373       './tests/worker-files/thread/testWorker.js'
 374     )
 375     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
 376     expect(pool.opts.workerChoiceStrategy).toBe(
 377       WorkerChoiceStrategies.FAIR_SHARE
 378     )
 379     // We need to clean up the resources after our test
 380     await pool.destroy()
 381   })
 382
 383   it('Verify FAIR_SHARE strategy default tasks usage statistics requirements', async () => {
 384     let pool = new FixedThreadPool(
 385       max,
 386       './tests/worker-files/thread/testWorker.js'
 387     )
 388     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
 389     expect(
 390       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
 391     ).toBe(true)
 392     await pool.destroy()
 393     pool = new DynamicThreadPool(
 394       min,
 395       max,
 396       './tests/worker-files/thread/testWorker.js'
 397     )
 398     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
 399     expect(
 400       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
 401     ).toBe(true)
 402     // We need to clean up the resources after our test
 403     await pool.destroy()
 404   })
 405
 406   it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
 407     const pool = new FixedThreadPool(
 408       max,
 409       './tests/worker-files/thread/testWorker.js',
 410       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
 411     )
 412     // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
 413     const promises = []
 414     for (let i = 0; i < max * 2; i++) {
 415       promises.push(pool.execute())
 416     }
 417     await Promise.all(promises)
 418     expect(
 419       pool.workerChoiceStrategyContext.workerChoiceStrategy
 420         .workerLastVirtualTaskTimestamp.size
 421     ).toBe(pool.workers.length)
 422     // We need to clean up the resources after our test
 423     await pool.destroy()
 424   })
 425
 426   it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
 427     const pool = new DynamicThreadPool(
 428       min,
 429       max,
 430       './tests/worker-files/thread/testWorker.js',
 431       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
 432     )
 433     // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
 434     const promises = []
 435     const maxMultiplier = 10
 436     for (let i = 0; i < max * maxMultiplier; i++) {
 437       promises.push(pool.execute())
 438     }
 439     await Promise.all(promises)
 440     if (process.platform !== 'win32') {
 441       expect(
 442         pool.workerChoiceStrategyContext.workerChoiceStrategy
 443           .workerChoiceStrategy.workerLastVirtualTaskTimestamp.size
 444       ).toBe(pool.workers.length)
 445     }
 446     // We need to clean up the resources after our test
 447     await pool.destroy()
 448   })
 449
 450   it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
 451     let pool = new FixedThreadPool(
 452       max,
 453       './tests/worker-files/thread/testWorker.js'
 454     )
 455     expect(
 456       pool.workerChoiceStrategyContext.workerChoiceStrategy
 457         .workerLastVirtualTaskTimestamp
 458     ).toBeUndefined()
 459     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
 460     for (const workerKey of pool.workerChoiceStrategyContext.workerChoiceStrategy.workerLastVirtualTaskTimestamp.keys()) {
 461       expect(
 462         pool.workerChoiceStrategyContext.workerChoiceStrategy.workerLastVirtualTaskTimestamp.get(
 463           workerKey
 464         ).start
 465       ).toBe(0)
 466       expect(
 467         pool.workerChoiceStrategyContext.workerChoiceStrategy.workerLastVirtualTaskTimestamp.get(
 468           workerKey
 469         ).end
 470       ).toBe(0)
 471     }
 472     await pool.destroy()
 473     pool = new DynamicThreadPool(
 474       min,
 475       max,
 476       './tests/worker-files/thread/testWorker.js'
 477     )
 478     expect(
 479       pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy
 480         .workerLastVirtualTaskTimestamp
 481     ).toBeUndefined()
 482     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
 483     for (const workerKey of pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy.workerLastVirtualTaskTimestamp.keys()) {
 484       expect(
 485         pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy.workerLastVirtualTaskTimestamp.get(
 486           workerKey
 487         ).start
 488       ).toBe(0)
 489       expect(
 490         pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy.workerLastVirtualTaskTimestamp.get(
 491           workerKey
 492         ).end
 493       ).toBe(0)
 494     }
 495     // We need to clean up the resources after our test
 496     await pool.destroy()
 497   })
 498
 499   it('Verify WEIGHTED_ROUND_ROBIN strategy is taken at pool creation', async () => {
 500     const pool = new FixedThreadPool(
 501       max,
 502       './tests/worker-files/thread/testWorker.js',
 503       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
 504     )
 505     expect(pool.opts.workerChoiceStrategy).toBe(
 506       WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
 507     )
 508     expect(
 509       pool.workerChoiceStrategyContext.workerChoiceStrategy.currentWorkerId
 510     ).toBe(0)
 511     expect(
 512       pool.workerChoiceStrategyContext.workerChoiceStrategy.defaultWorkerWeight
 513     ).toBeGreaterThan(0)
 514     for (const workerKey of pool.workerChoiceStrategyContext.workerChoiceStrategy.workersTaskRunTime.keys()) {
 515       expect(
 516         pool.workerChoiceStrategyContext.workerChoiceStrategy.workersTaskRunTime.get(
 517           workerKey
 518         ).weight
 519       ).toBeGreaterThan(0)
 520       expect(
 521         pool.workerChoiceStrategyContext.workerChoiceStrategy.workersTaskRunTime.get(
 522           workerKey
 523         ).runTime
 524       ).toBe(0)
 525     }
 526     // We need to clean up the resources after our test
 527     await pool.destroy()
 528   })
 529
 530   it('Verify WEIGHTED_ROUND_ROBIN strategy can be set after pool creation', async () => {
 531     const pool = new FixedThreadPool(
 532       max,
 533       './tests/worker-files/thread/testWorker.js'
 534     )
 535     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN)
 536     expect(pool.opts.workerChoiceStrategy).toBe(
 537       WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
 538     )
 539     // We need to clean up the resources after our test
 540     await pool.destroy()
 541   })
 542
 543   it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
 544     let pool = new FixedThreadPool(
 545       max,
 546       './tests/worker-files/thread/testWorker.js'
 547     )
 548     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN)
 549     expect(
 550       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
 551     ).toBe(true)
 552     await pool.destroy()
 553     pool = new DynamicThreadPool(
 554       min,
 555       max,
 556       './tests/worker-files/thread/testWorker.js'
 557     )
 558     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN)
 559     expect(
 560       pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
 561     ).toBe(true)
 562     // We need to clean up the resources after our test
 563     await pool.destroy()
 564   })
 565
 566   it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
 567     const pool = new FixedThreadPool(
 568       max,
 569       './tests/worker-files/thread/testWorker.js',
 570       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
 571     )
 572     // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
 573     const promises = []
 574     for (let i = 0; i < max * 2; i++) {
 575       promises.push(pool.execute())
 576     }
 577     await Promise.all(promises)
 578     expect(
 579       pool.workerChoiceStrategyContext.workerChoiceStrategy.workersTaskRunTime
 580         .size
 581     ).toBe(pool.workers.length)
 582     // We need to clean up the resources after our test
 583     await pool.destroy()
 584   })
 585
 586   it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
 587     const pool = new DynamicThreadPool(
 588       min,
 589       max,
 590       './tests/worker-files/thread/testWorker.js',
 591       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
 592     )
 593     // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
 594     const promises = []
 595     const maxMultiplier =
 596       pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy
 597         .defaultWorkerWeight * 2
 598     for (let i = 0; i < max * maxMultiplier; i++) {
 599       promises.push(pool.execute())
 600     }
 601     await Promise.all(promises)
 602     if (process.platform !== 'win32') {
 603       expect(
 604         pool.workerChoiceStrategyContext.workerChoiceStrategy
 605           .workerChoiceStrategy.workersTaskRunTime.size
 606       ).toBe(pool.workers.length)
 607     }
 608     // We need to clean up the resources after our test
 609     await pool.destroy()
 610   })
 611
 612   it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
 613     let pool = new FixedThreadPool(
 614       max,
 615       './tests/worker-files/thread/testWorker.js'
 616     )
 617     expect(
 618       pool.workerChoiceStrategyContext.workerChoiceStrategy.currentWorkerId
 619     ).toBeUndefined()
 620     expect(
 621       pool.workerChoiceStrategyContext.workerChoiceStrategy.defaultWorkerWeight
 622     ).toBeUndefined()
 623     expect(
 624       pool.workerChoiceStrategyContext.workerChoiceStrategy.workersTaskRunTime
 625     ).toBeUndefined()
 626     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN)
 627     expect(
 628       pool.workerChoiceStrategyContext.workerChoiceStrategy.currentWorkerId
 629     ).toBe(0)
 630     expect(
 631       pool.workerChoiceStrategyContext.workerChoiceStrategy.defaultWorkerWeight
 632     ).toBeGreaterThan(0)
 633     for (const workerKey of pool.workerChoiceStrategyContext.workerChoiceStrategy.workersTaskRunTime.keys()) {
 634       expect(
 635         pool.workerChoiceStrategyContext.workerChoiceStrategy.workersTaskRunTime.get(
 636           workerKey
 637         ).runTime
 638       ).toBe(0)
 639     }
 640     await pool.destroy()
 641     pool = new DynamicThreadPool(
 642       min,
 643       max,
 644       './tests/worker-files/thread/testWorker.js'
 645     )
 646     expect(
 647       pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy
 648         .currentWorkerId
 649     ).toBeUndefined()
 650     expect(
 651       pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy
 652         .defaultWorkerWeight
 653     ).toBeUndefined()
 654     expect(
 655       pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy
 656         .workersTaskRunTime
 657     ).toBeUndefined()
 658     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN)
 659     expect(
 660       pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy
 661         .currentWorkerId
 662     ).toBe(0)
 663     expect(
 664       pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy
 665         .defaultWorkerWeight
 666     ).toBeGreaterThan(0)
 667     for (const workerKey of pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy.workersTaskRunTime.keys()) {
 668       expect(
 669         pool.workerChoiceStrategyContext.workerChoiceStrategy.workerChoiceStrategy.workersTaskRunTime.get(
 670           workerKey
 671         ).runTime
 672       ).toBe(0)
 673     }
 674     // We need to clean up the resources after our test
 675     await pool.destroy()
 676   })
 677
 678   it('Verify unknown strategies throw error', () => {
 679     expect(
 680       () =>
 681         new DynamicThreadPool(
 682           min,
 683           max,
 684           './tests/worker-files/thread/testWorker.js',
 685           { workerChoiceStrategy: 'UNKNOWN_STRATEGY' }
 686         )
 687     ).toThrowError(
 688       new Error("Worker choice strategy 'UNKNOWN_STRATEGY' not found")
 689     )
 690   })
 691 })