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