1 const { expect
} = require('expect')
3 WorkerChoiceStrategies
,
7 } = require('../../../lib')
8 const { CircularArray
} = require('../../../lib/circular-array')
10 describe('Selection strategies test suite', () => {
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'
24 it('Verify ROUND_ROBIN strategy is the default at pool creation', async () => {
25 const pool
= new DynamicThreadPool(
28 './tests/worker-files/thread/testWorker.js'
30 expect(pool
.opts
.workerChoiceStrategy
).toBe(
31 WorkerChoiceStrategies
.ROUND_ROBIN
33 // We need to clean up the resources after our test
37 it('Verify available strategies are taken at pool creation', async () => {
38 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
39 const pool
= new FixedThreadPool(
41 './tests/worker-files/thread/testWorker.js',
42 { workerChoiceStrategy
}
44 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
45 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
52 it('Verify available strategies can be set after pool creation', async () => {
53 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
54 const pool
= new DynamicThreadPool(
57 './tests/worker-files/thread/testWorker.js'
59 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
60 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
61 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
68 it('Verify available strategies default internals at pool creation', async () => {
69 const pool
= new FixedThreadPool(
71 './tests/worker-files/thread/testWorker.js'
73 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
74 if (workerChoiceStrategy
=== WorkerChoiceStrategies
.ROUND_ROBIN
) {
76 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
80 } else if (workerChoiceStrategy
=== WorkerChoiceStrategies
.FAIR_SHARE
) {
82 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
84 ).workersVirtualTaskEndTimestamp
85 ).toBeInstanceOf(Array
)
87 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
89 ).workersVirtualTaskEndTimestamp
.length
92 workerChoiceStrategy
=== WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
95 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
100 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
102 ).defaultWorkerWeight
105 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
107 ).workerVirtualTaskRunTime
114 it('Verify ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
115 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
116 let pool
= new FixedThreadPool(
118 './tests/worker-files/thread/testWorker.js',
119 { workerChoiceStrategy
}
122 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
132 pool
= new DynamicThreadPool(
135 './tests/worker-files/thread/testWorker.js',
136 { workerChoiceStrategy
}
139 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
148 // We need to clean up the resources after our test
152 it('Verify ROUND_ROBIN strategy can be run in a fixed pool', async () => {
153 const pool
= new FixedThreadPool(
155 './tests/worker-files/thread/testWorker.js',
156 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
158 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
160 const maxMultiplier
= 2
161 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
162 promises
.push(pool
.execute())
164 await Promise
.all(promises
)
165 for (const workerNode
of pool
.workerNodes
) {
166 expect(workerNode
.tasksUsage
).toStrictEqual({
167 run
: expect
.any(Number
),
170 runTimeHistory
: expect
.any(CircularArray
),
174 waitTimeHistory
: expect
.any(CircularArray
),
179 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
181 // We need to clean up the resources after our test
185 it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
186 const pool
= new DynamicThreadPool(
189 './tests/worker-files/thread/testWorker.js',
190 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
192 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
194 const maxMultiplier
= 2
195 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
196 promises
.push(pool
.execute())
198 await Promise
.all(promises
)
199 for (const workerNode
of pool
.workerNodes
) {
200 expect(workerNode
.tasksUsage
).toStrictEqual({
201 run
: expect
.any(Number
),
204 runTimeHistory
: expect
.any(CircularArray
),
208 waitTimeHistory
: expect
.any(CircularArray
),
213 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
215 // We need to clean up the resources after our test
219 it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
220 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
221 let pool
= new FixedClusterPool(
223 './tests/worker-files/cluster/testWorker.js',
224 { workerChoiceStrategy
}
226 let results
= new Set()
227 for (let i
= 0; i
< max
; i
++) {
228 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.id
)
230 expect(results
.size
).toBe(max
)
232 pool
= new FixedThreadPool(
234 './tests/worker-files/thread/testWorker.js',
235 { workerChoiceStrategy
}
238 for (let i
= 0; i
< max
; i
++) {
239 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.threadId
)
241 expect(results
.size
).toBe(max
)
245 it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
246 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
247 let pool
= new FixedThreadPool(
249 './tests/worker-files/thread/testWorker.js',
250 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
253 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
257 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
259 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
260 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
264 pool
= new DynamicThreadPool(
267 './tests/worker-files/thread/testWorker.js',
268 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
271 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
275 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
277 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
278 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
281 // We need to clean up the resources after our test
285 it('Verify LEAST_USED strategy default tasks usage statistics requirements', async () => {
286 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
287 let pool
= new FixedThreadPool(
289 './tests/worker-files/thread/testWorker.js',
290 { workerChoiceStrategy
}
293 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
303 pool
= new DynamicThreadPool(
306 './tests/worker-files/thread/testWorker.js',
307 { workerChoiceStrategy
}
310 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
319 // We need to clean up the resources after our test
323 it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
324 const pool
= new FixedThreadPool(
326 './tests/worker-files/thread/testWorker.js',
327 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
329 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
331 const maxMultiplier
= 2
332 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
333 promises
.push(pool
.execute())
335 await Promise
.all(promises
)
336 for (const workerNode
of pool
.workerNodes
) {
337 expect(workerNode
.tasksUsage
).toStrictEqual({
338 run
: expect
.any(Number
),
341 runTimeHistory
: expect
.any(CircularArray
),
345 waitTimeHistory
: expect
.any(CircularArray
),
350 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
352 // We need to clean up the resources after our test
356 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
357 const pool
= new DynamicThreadPool(
360 './tests/worker-files/thread/testWorker.js',
361 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
363 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
365 const maxMultiplier
= 2
366 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
367 promises
.push(pool
.execute())
369 await Promise
.all(promises
)
370 for (const workerNode
of pool
.workerNodes
) {
371 expect(workerNode
.tasksUsage
).toStrictEqual({
372 run
: expect
.any(Number
),
375 runTimeHistory
: expect
.any(CircularArray
),
379 waitTimeHistory
: expect
.any(CircularArray
),
384 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
386 // We need to clean up the resources after our test
390 it('Verify LEAST_BUSY strategy default tasks usage statistics requirements', async () => {
391 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
392 let pool
= new FixedThreadPool(
394 './tests/worker-files/thread/testWorker.js',
395 { workerChoiceStrategy
}
398 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
408 pool
= new DynamicThreadPool(
411 './tests/worker-files/thread/testWorker.js',
412 { workerChoiceStrategy
}
415 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
424 // We need to clean up the resources after our test
428 it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
429 const pool
= new FixedThreadPool(
431 './tests/worker-files/thread/testWorker.js',
432 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
434 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
436 const maxMultiplier
= 2
437 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
438 promises
.push(pool
.execute())
440 await Promise
.all(promises
)
441 for (const workerNode
of pool
.workerNodes
) {
442 expect(workerNode
.tasksUsage
).toStrictEqual({
443 run
: expect
.any(Number
),
445 runTime
: expect
.any(Number
),
446 runTimeHistory
: expect
.any(CircularArray
),
450 waitTimeHistory
: expect
.any(CircularArray
),
455 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
456 expect(workerNode
.tasksUsage
.runTime
).toBeGreaterThan(0)
458 // We need to clean up the resources after our test
462 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
463 const pool
= new DynamicThreadPool(
466 './tests/worker-files/thread/testWorker.js',
467 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
469 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
471 const maxMultiplier
= 2
472 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
473 promises
.push(pool
.execute())
475 await Promise
.all(promises
)
476 for (const workerNode
of pool
.workerNodes
) {
477 expect(workerNode
.tasksUsage
).toStrictEqual({
478 run
: expect
.any(Number
),
480 runTime
: expect
.any(Number
),
481 runTimeHistory
: expect
.any(CircularArray
),
485 waitTimeHistory
: expect
.any(CircularArray
),
490 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
491 expect(workerNode
.tasksUsage
.runTime
).toBeGreaterThan(0)
493 // We need to clean up the resources after our test
497 it('Verify FAIR_SHARE strategy default tasks usage statistics requirements', async () => {
498 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
499 let pool
= new FixedThreadPool(
501 './tests/worker-files/thread/testWorker.js',
502 { workerChoiceStrategy
}
505 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
515 pool
= new DynamicThreadPool(
518 './tests/worker-files/thread/testWorker.js',
519 { workerChoiceStrategy
}
522 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
531 // We need to clean up the resources after our test
535 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
536 const pool
= new FixedThreadPool(
538 './tests/worker-files/thread/testWorker.js',
539 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
541 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
543 const maxMultiplier
= 2
544 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
545 promises
.push(pool
.execute())
547 await Promise
.all(promises
)
548 for (const workerNode
of pool
.workerNodes
) {
549 expect(workerNode
.tasksUsage
).toStrictEqual({
550 run
: expect
.any(Number
),
552 runTime
: expect
.any(Number
),
553 runTimeHistory
: expect
.any(CircularArray
),
554 avgRunTime
: expect
.any(Number
),
557 waitTimeHistory
: expect
.any(CircularArray
),
562 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
563 expect(workerNode
.tasksUsage
.runTime
).toBeGreaterThan(0)
564 expect(workerNode
.tasksUsage
.avgRunTime
).toBeGreaterThan(0)
567 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
568 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
569 ).workersVirtualTaskEndTimestamp
.length
570 ).toBe(pool
.workerNodes
.length
)
571 // We need to clean up the resources after our test
575 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
576 const pool
= new DynamicThreadPool(
579 './tests/worker-files/thread/testWorker.js',
580 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
582 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
584 const maxMultiplier
= 2
585 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
586 promises
.push(pool
.execute())
588 await Promise
.all(promises
)
589 for (const workerNode
of pool
.workerNodes
) {
590 expect(workerNode
.tasksUsage
).toStrictEqual({
591 run
: expect
.any(Number
),
593 runTime
: expect
.any(Number
),
594 runTimeHistory
: expect
.any(CircularArray
),
595 avgRunTime
: expect
.any(Number
),
598 waitTimeHistory
: expect
.any(CircularArray
),
603 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
604 expect(workerNode
.tasksUsage
.runTime
).toBeGreaterThan(0)
605 expect(workerNode
.tasksUsage
.avgRunTime
).toBeGreaterThan(0)
608 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
609 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
610 ).workersVirtualTaskEndTimestamp
.length
611 ).toBe(pool
.workerNodes
.length
)
612 // We need to clean up the resources after our test
616 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
617 const pool
= new DynamicThreadPool(
620 './tests/worker-files/thread/testWorker.js',
622 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
623 workerChoiceStrategyOptions
: {
628 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
630 const maxMultiplier
= 2
631 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
632 promises
.push(pool
.execute())
634 await Promise
.all(promises
)
635 for (const workerNode
of pool
.workerNodes
) {
636 expect(workerNode
.tasksUsage
).toStrictEqual({
637 run
: expect
.any(Number
),
639 runTime
: expect
.any(Number
),
640 runTimeHistory
: expect
.any(CircularArray
),
642 medRunTime
: expect
.any(Number
),
644 waitTimeHistory
: expect
.any(CircularArray
),
649 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
650 expect(workerNode
.tasksUsage
.runTime
).toBeGreaterThan(0)
651 expect(workerNode
.tasksUsage
.medRunTime
).toBeGreaterThan(0)
654 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
655 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
656 ).workersVirtualTaskEndTimestamp
.length
657 ).toBe(pool
.workerNodes
.length
)
658 // We need to clean up the resources after our test
662 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
663 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
664 let pool
= new FixedThreadPool(
666 './tests/worker-files/thread/testWorker.js'
669 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
671 ).workersVirtualTaskEndTimestamp
672 ).toBeInstanceOf(Array
)
674 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
676 ).workersVirtualTaskEndTimestamp
.length
678 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
680 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
682 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
684 ).workersVirtualTaskEndTimestamp
.length
686 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
688 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
690 ).workersVirtualTaskEndTimestamp
691 ).toBeInstanceOf(Array
)
693 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
695 ).workersVirtualTaskEndTimestamp
.length
698 pool
= new DynamicThreadPool(
701 './tests/worker-files/thread/testWorker.js'
704 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
706 ).workersVirtualTaskEndTimestamp
707 ).toBeInstanceOf(Array
)
709 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
711 ).workersVirtualTaskEndTimestamp
.length
713 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
715 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
717 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
719 ).workersVirtualTaskEndTimestamp
.length
721 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
723 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
725 ).workersVirtualTaskEndTimestamp
726 ).toBeInstanceOf(Array
)
728 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
730 ).workersVirtualTaskEndTimestamp
.length
732 // We need to clean up the resources after our test
736 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
737 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
738 let pool
= new FixedThreadPool(
740 './tests/worker-files/thread/testWorker.js',
741 { workerChoiceStrategy
}
744 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
754 pool
= new DynamicThreadPool(
757 './tests/worker-files/thread/testWorker.js',
758 { workerChoiceStrategy
}
761 pool
.workerChoiceStrategyContext
.getRequiredStatistics()
770 // We need to clean up the resources after our test
774 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
775 const pool
= new FixedThreadPool(
777 './tests/worker-files/thread/testWorker.js',
778 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
780 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
782 const maxMultiplier
= 2
783 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
784 promises
.push(pool
.execute())
786 await Promise
.all(promises
)
787 for (const workerNode
of pool
.workerNodes
) {
788 expect(workerNode
.tasksUsage
).toStrictEqual({
789 run
: expect
.any(Number
),
791 runTime
: expect
.any(Number
),
792 runTimeHistory
: expect
.any(CircularArray
),
793 avgRunTime
: expect
.any(Number
),
796 waitTimeHistory
: expect
.any(CircularArray
),
801 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
802 expect(workerNode
.tasksUsage
.runTime
).toBeGreaterThan(0)
803 expect(workerNode
.tasksUsage
.avgRunTime
).toBeGreaterThan(0)
806 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
807 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
808 ).defaultWorkerWeight
811 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
812 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
813 ).workerVirtualTaskRunTime
814 ).toBeGreaterThanOrEqual(0)
815 // We need to clean up the resources after our test
819 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
820 const pool
= new DynamicThreadPool(
823 './tests/worker-files/thread/testWorker.js',
824 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
826 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
828 const maxMultiplier
= 2
829 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
830 promises
.push(pool
.execute())
832 await Promise
.all(promises
)
833 for (const workerNode
of pool
.workerNodes
) {
834 expect(workerNode
.tasksUsage
).toStrictEqual({
835 run
: expect
.any(Number
),
837 runTime
: expect
.any(Number
),
838 runTimeHistory
: expect
.any(CircularArray
),
839 avgRunTime
: expect
.any(Number
),
842 waitTimeHistory
: expect
.any(CircularArray
),
847 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
848 expect(workerNode
.tasksUsage
.runTime
).toBeGreaterThan(0)
849 expect(workerNode
.tasksUsage
.avgRunTime
).toBeGreaterThan(0)
852 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
853 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
854 ).defaultWorkerWeight
857 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
858 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
859 ).workerVirtualTaskRunTime
860 ).toBeGreaterThanOrEqual(0)
861 // We need to clean up the resources after our test
865 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
866 const pool
= new DynamicThreadPool(
869 './tests/worker-files/thread/testWorker.js',
871 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
872 workerChoiceStrategyOptions
: {
877 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
879 const maxMultiplier
= 2
880 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
881 promises
.push(pool
.execute())
883 await Promise
.all(promises
)
884 for (const workerNode
of pool
.workerNodes
) {
885 expect(workerNode
.tasksUsage
).toStrictEqual({
886 run
: expect
.any(Number
),
888 runTime
: expect
.any(Number
),
889 runTimeHistory
: expect
.any(CircularArray
),
891 medRunTime
: expect
.any(Number
),
893 waitTimeHistory
: expect
.any(CircularArray
),
898 expect(workerNode
.tasksUsage
.run
).toBeGreaterThan(0)
899 expect(workerNode
.tasksUsage
.runTime
).toBeGreaterThan(0)
900 expect(workerNode
.tasksUsage
.medRunTime
).toBeGreaterThan(0)
903 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
904 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
905 ).defaultWorkerWeight
908 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
909 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
910 ).workerVirtualTaskRunTime
911 ).toBeGreaterThanOrEqual(0)
912 // We need to clean up the resources after our test
916 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
917 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
918 let pool
= new FixedThreadPool(
920 './tests/worker-files/thread/testWorker.js'
923 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
925 ).currentWorkerNodeId
928 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
930 ).defaultWorkerWeight
933 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
935 ).workerVirtualTaskRunTime
937 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
939 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
940 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
941 ).currentWorkerNodeId
944 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
945 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
946 ).defaultWorkerWeight
949 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
951 ).workerVirtualTaskRunTime
954 pool
= new DynamicThreadPool(
957 './tests/worker-files/thread/testWorker.js'
960 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
962 ).currentWorkerNodeId
965 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
967 ).defaultWorkerWeight
970 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
972 ).workerVirtualTaskRunTime
974 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
976 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
977 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
978 ).currentWorkerNodeId
981 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
982 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
983 ).defaultWorkerWeight
986 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
988 ).workerVirtualTaskRunTime
990 // We need to clean up the resources after our test
994 it('Verify unknown strategy throw error', () => {
997 new DynamicThreadPool(
1000 './tests/worker-files/thread/testWorker.js',
1001 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
1003 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")