1 const { expect
} = require('expect')
8 } = require('../../../lib')
9 const { CircularArray
} = require('../../../lib/circular-array')
10 const { waitPoolEvents
} = require('../../test-utils')
12 describe('Selection strategies test suite', () => {
16 it('Verify that WorkerChoiceStrategies enumeration provides string values', () => {
17 expect(WorkerChoiceStrategies
.ROUND_ROBIN
).toBe('ROUND_ROBIN')
18 expect(WorkerChoiceStrategies
.LEAST_USED
).toBe('LEAST_USED')
19 expect(WorkerChoiceStrategies
.LEAST_BUSY
).toBe('LEAST_BUSY')
20 expect(WorkerChoiceStrategies
.LEAST_ELU
).toBe('LEAST_ELU')
21 expect(WorkerChoiceStrategies
.FAIR_SHARE
).toBe('FAIR_SHARE')
22 expect(WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
).toBe(
23 'WEIGHTED_ROUND_ROBIN'
25 expect(WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
).toBe(
26 'INTERLEAVED_WEIGHTED_ROUND_ROBIN'
30 it('Verify ROUND_ROBIN strategy is the default at pool creation', async () => {
31 const pool
= new DynamicThreadPool(
34 './tests/worker-files/thread/testWorker.js'
36 expect(pool
.opts
.workerChoiceStrategy
).toBe(
37 WorkerChoiceStrategies
.ROUND_ROBIN
39 // We need to clean up the resources after our test
43 it('Verify available strategies are taken at pool creation', async () => {
44 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
45 const pool
= new FixedThreadPool(
47 './tests/worker-files/thread/testWorker.js',
48 { workerChoiceStrategy
}
50 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
51 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
58 it('Verify available strategies can be set after pool creation', async () => {
59 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
60 const pool
= new DynamicThreadPool(
63 './tests/worker-files/thread/testWorker.js'
65 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
66 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
67 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
74 it('Verify available strategies default internals at pool creation', async () => {
75 const pool
= new FixedThreadPool(
77 './tests/worker-files/thread/testWorker.js'
79 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
80 if (workerChoiceStrategy
=== WorkerChoiceStrategies
.ROUND_ROBIN
) {
82 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
86 } else if (workerChoiceStrategy
=== WorkerChoiceStrategies
.FAIR_SHARE
) {
88 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
90 ).workersVirtualTaskEndTimestamp
91 ).toBeInstanceOf(Array
)
93 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
95 ).workersVirtualTaskEndTimestamp
.length
98 workerChoiceStrategy
=== WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
101 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
106 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
108 ).defaultWorkerWeight
111 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
113 ).workerVirtualTaskRunTime
120 it('Verify ROUND_ROBIN strategy default policy', async () => {
121 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
122 let pool
= new FixedThreadPool(
124 './tests/worker-files/thread/testWorker.js',
125 { workerChoiceStrategy
}
127 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
128 useDynamicWorker
: true
131 pool
= new DynamicThreadPool(
134 './tests/worker-files/thread/testWorker.js',
135 { workerChoiceStrategy
}
137 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
138 useDynamicWorker
: true
140 // We need to clean up the resources after our test
144 it('Verify ROUND_ROBIN strategy default tasks statistics requirements', async () => {
145 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
146 let pool
= new FixedThreadPool(
148 './tests/worker-files/thread/testWorker.js',
149 { workerChoiceStrategy
}
152 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
171 pool
= new DynamicThreadPool(
174 './tests/worker-files/thread/testWorker.js',
175 { workerChoiceStrategy
}
178 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
196 // We need to clean up the resources after our test
200 it('Verify ROUND_ROBIN strategy can be run in a fixed pool', async () => {
201 const pool
= new FixedThreadPool(
203 './tests/worker-files/thread/testWorker.js',
204 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
206 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
207 const promises
= new Set()
208 const maxMultiplier
= 2
209 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
210 promises
.add(pool
.execute())
212 await Promise
.all(promises
)
213 for (const workerNode
of pool
.workerNodes
) {
214 expect(workerNode
.usage
).toStrictEqual({
216 executed
: maxMultiplier
,
223 history
: expect
.any(CircularArray
)
226 history
: expect
.any(CircularArray
)
230 history
: expect
.any(CircularArray
)
233 history
: expect
.any(CircularArray
)
239 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
240 WorkerChoiceStrategies
.ROUND_ROBIN
243 // We need to clean up the resources after our test
247 it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
248 const pool
= new DynamicThreadPool(
251 './tests/worker-files/thread/testWorker.js',
252 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
254 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
255 const promises
= new Set()
256 const maxMultiplier
= 2
257 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
258 promises
.add(pool
.execute())
260 await Promise
.all(promises
)
261 for (const workerNode
of pool
.workerNodes
) {
262 expect(workerNode
.usage
).toStrictEqual({
264 executed
: maxMultiplier
,
271 history
: expect
.any(CircularArray
)
274 history
: expect
.any(CircularArray
)
278 history
: expect
.any(CircularArray
)
281 history
: expect
.any(CircularArray
)
287 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
288 WorkerChoiceStrategies
.ROUND_ROBIN
291 // We need to clean up the resources after our test
295 it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
296 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
297 let pool
= new FixedClusterPool(
299 './tests/worker-files/cluster/testWorker.js',
300 { workerChoiceStrategy
}
302 let results
= new Set()
303 for (let i
= 0; i
< max
; i
++) {
304 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.id
)
306 expect(results
.size
).toBe(max
)
308 pool
= new FixedThreadPool(
310 './tests/worker-files/thread/testWorker.js',
311 { workerChoiceStrategy
}
314 for (let i
= 0; i
< max
; i
++) {
315 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.threadId
)
317 expect(results
.size
).toBe(max
)
321 it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
322 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
323 let pool
= new FixedThreadPool(
325 './tests/worker-files/thread/testWorker.js',
326 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
329 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
333 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
335 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
336 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
340 pool
= new DynamicThreadPool(
343 './tests/worker-files/thread/testWorker.js',
344 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
347 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
351 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
353 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
354 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
357 // We need to clean up the resources after our test
361 it('Verify LEAST_USED strategy default policy', async () => {
362 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
363 let pool
= new FixedThreadPool(
365 './tests/worker-files/thread/testWorker.js',
366 { workerChoiceStrategy
}
368 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
369 useDynamicWorker
: false
372 pool
= new DynamicThreadPool(
375 './tests/worker-files/thread/testWorker.js',
376 { workerChoiceStrategy
}
378 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
379 useDynamicWorker
: false
381 // We need to clean up the resources after our test
385 it('Verify LEAST_USED strategy default tasks statistics requirements', async () => {
386 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
387 let pool
= new FixedThreadPool(
389 './tests/worker-files/thread/testWorker.js',
390 { workerChoiceStrategy
}
393 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
412 pool
= new DynamicThreadPool(
415 './tests/worker-files/thread/testWorker.js',
416 { workerChoiceStrategy
}
419 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
437 // We need to clean up the resources after our test
441 it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
442 const pool
= new FixedThreadPool(
444 './tests/worker-files/thread/testWorker.js',
445 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
447 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
448 const promises
= new Set()
449 const maxMultiplier
= 2
450 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
451 promises
.add(pool
.execute())
453 await Promise
.all(promises
)
454 for (const workerNode
of pool
.workerNodes
) {
455 expect(workerNode
.usage
).toStrictEqual({
457 executed
: expect
.any(Number
),
464 history
: expect
.any(CircularArray
)
467 history
: expect
.any(CircularArray
)
471 history
: expect
.any(CircularArray
)
474 history
: expect
.any(CircularArray
)
478 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
479 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
483 // We need to clean up the resources after our test
487 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
488 const pool
= new DynamicThreadPool(
491 './tests/worker-files/thread/testWorker.js',
492 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
494 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
495 const promises
= new Set()
496 const maxMultiplier
= 2
497 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
498 promises
.add(pool
.execute())
500 await Promise
.all(promises
)
501 for (const workerNode
of pool
.workerNodes
) {
502 expect(workerNode
.usage
).toStrictEqual({
504 executed
: expect
.any(Number
),
511 history
: expect
.any(CircularArray
)
514 history
: expect
.any(CircularArray
)
518 history
: expect
.any(CircularArray
)
521 history
: expect
.any(CircularArray
)
525 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
526 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
530 // We need to clean up the resources after our test
534 it('Verify LEAST_BUSY strategy default policy', async () => {
535 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
536 let pool
= new FixedThreadPool(
538 './tests/worker-files/thread/testWorker.js',
539 { workerChoiceStrategy
}
541 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
542 useDynamicWorker
: false
545 pool
= new DynamicThreadPool(
548 './tests/worker-files/thread/testWorker.js',
549 { workerChoiceStrategy
}
551 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
552 useDynamicWorker
: false
554 // We need to clean up the resources after our test
558 it('Verify LEAST_BUSY strategy default tasks statistics requirements', async () => {
559 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
560 let pool
= new FixedThreadPool(
562 './tests/worker-files/thread/testWorker.js',
563 { workerChoiceStrategy
}
566 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
585 pool
= new DynamicThreadPool(
588 './tests/worker-files/thread/testWorker.js',
589 { workerChoiceStrategy
}
592 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
610 // We need to clean up the resources after our test
614 it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
615 const pool
= new FixedThreadPool(
617 './tests/worker-files/thread/testWorker.js',
618 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
620 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
621 const promises
= new Set()
622 const maxMultiplier
= 2
623 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
624 promises
.add(pool
.execute())
626 await Promise
.all(promises
)
627 for (const workerNode
of pool
.workerNodes
) {
628 expect(workerNode
.usage
).toMatchObject({
630 executed
: expect
.any(Number
),
637 history
: expect
.any(CircularArray
)
640 history
: expect
.any(CircularArray
)
644 history
: expect
.any(CircularArray
)
647 history
: expect
.any(CircularArray
)
651 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
652 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
655 if (workerNode
.usage
.runTime
.aggregate
== null) {
656 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
658 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
660 if (workerNode
.usage
.waitTime
.aggregate
== null) {
661 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
663 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
666 // We need to clean up the resources after our test
670 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
671 const pool
= new DynamicThreadPool(
674 './tests/worker-files/thread/testWorker.js',
675 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
677 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
678 const promises
= new Set()
679 const maxMultiplier
= 2
680 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
681 promises
.add(pool
.execute())
683 await Promise
.all(promises
)
684 for (const workerNode
of pool
.workerNodes
) {
685 expect(workerNode
.usage
).toMatchObject({
687 executed
: expect
.any(Number
),
694 history
: expect
.any(CircularArray
)
697 history
: expect
.any(CircularArray
)
701 history
: expect
.any(CircularArray
)
704 history
: expect
.any(CircularArray
)
708 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
709 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
712 if (workerNode
.usage
.runTime
.aggregate
== null) {
713 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
715 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
717 if (workerNode
.usage
.waitTime
.aggregate
== null) {
718 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
720 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
723 // We need to clean up the resources after our test
727 it('Verify LEAST_ELU strategy default policy', async () => {
728 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
729 let pool
= new FixedThreadPool(
731 './tests/worker-files/thread/testWorker.js',
732 { workerChoiceStrategy
}
734 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
735 useDynamicWorker
: false
738 pool
= new DynamicThreadPool(
741 './tests/worker-files/thread/testWorker.js',
742 { workerChoiceStrategy
}
744 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
745 useDynamicWorker
: false
747 // We need to clean up the resources after our test
751 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
752 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
753 let pool
= new FixedThreadPool(
755 './tests/worker-files/thread/testWorker.js',
756 { workerChoiceStrategy
}
759 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
778 pool
= new DynamicThreadPool(
781 './tests/worker-files/thread/testWorker.js',
782 { workerChoiceStrategy
}
785 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
803 // We need to clean up the resources after our test
807 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
808 const pool
= new FixedThreadPool(
810 './tests/worker-files/thread/testWorker.js',
811 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
813 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
814 const promises
= new Set()
815 const maxMultiplier
= 2
816 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
817 promises
.add(pool
.execute())
819 await Promise
.all(promises
)
820 for (const workerNode
of pool
.workerNodes
) {
821 expect(workerNode
.usage
).toMatchObject({
823 executed
: expect
.any(Number
),
830 history
: expect
.any(CircularArray
)
833 history
: expect
.any(CircularArray
)
836 idle
: expect
.objectContaining({
837 history
: expect
.any(CircularArray
)
839 active
: expect
.objectContaining({
840 history
: expect
.any(CircularArray
)
844 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
845 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
848 if (workerNode
.usage
.elu
.utilization
== null) {
849 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
851 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
852 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
855 // We need to clean up the resources after our test
859 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
860 const pool
= new DynamicThreadPool(
863 './tests/worker-files/thread/testWorker.js',
864 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
866 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
867 const promises
= new Set()
868 const maxMultiplier
= 2
869 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
870 promises
.add(pool
.execute())
872 await Promise
.all(promises
)
873 for (const workerNode
of pool
.workerNodes
) {
874 expect(workerNode
.usage
).toMatchObject({
876 executed
: expect
.any(Number
),
883 history
: expect
.any(CircularArray
)
886 history
: expect
.any(CircularArray
)
889 idle
: expect
.objectContaining({
890 history
: expect
.any(CircularArray
)
892 active
: expect
.objectContaining({
893 history
: expect
.any(CircularArray
)
897 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
898 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
901 if (workerNode
.usage
.elu
.utilization
== null) {
902 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
904 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
905 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
908 // We need to clean up the resources after our test
912 it('Verify FAIR_SHARE strategy default policy', async () => {
913 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
914 let pool
= new FixedThreadPool(
916 './tests/worker-files/thread/testWorker.js',
917 { workerChoiceStrategy
}
919 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
920 useDynamicWorker
: false
923 pool
= new DynamicThreadPool(
926 './tests/worker-files/thread/testWorker.js',
927 { workerChoiceStrategy
}
929 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
930 useDynamicWorker
: false
932 // We need to clean up the resources after our test
936 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
937 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
938 let pool
= new FixedThreadPool(
940 './tests/worker-files/thread/testWorker.js',
941 { workerChoiceStrategy
}
944 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
963 pool
= new DynamicThreadPool(
966 './tests/worker-files/thread/testWorker.js',
967 { workerChoiceStrategy
}
970 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
988 // We need to clean up the resources after our test
992 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
993 const pool
= new FixedThreadPool(
995 './tests/worker-files/thread/testWorker.js',
996 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
998 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
999 const promises
= new Set()
1000 const maxMultiplier
= 2
1001 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1002 promises
.add(pool
.execute())
1004 await Promise
.all(promises
)
1005 for (const workerNode
of pool
.workerNodes
) {
1006 expect(workerNode
.usage
).toMatchObject({
1008 executed
: expect
.any(Number
),
1014 runTime
: expect
.objectContaining({
1015 history
: expect
.any(CircularArray
)
1018 history
: expect
.any(CircularArray
)
1021 idle
: expect
.objectContaining({
1022 history
: expect
.any(CircularArray
)
1024 active
: expect
.objectContaining({
1025 history
: expect
.any(CircularArray
)
1029 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1030 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1033 if (workerNode
.usage
.runTime
.aggregate
== null) {
1034 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1036 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1038 if (workerNode
.usage
.runTime
.average
== null) {
1039 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1041 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1043 if (workerNode
.usage
.elu
.utilization
== null) {
1044 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1046 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1047 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1051 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1052 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1053 ).workersVirtualTaskEndTimestamp
.length
1054 ).toBe(pool
.workerNodes
.length
)
1055 // We need to clean up the resources after our test
1056 await pool
.destroy()
1059 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1060 const pool
= new DynamicThreadPool(
1063 './tests/worker-files/thread/testWorker.js',
1064 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1066 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1067 const promises
= new Set()
1068 const maxMultiplier
= 2
1069 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1070 promises
.add(pool
.execute())
1072 await Promise
.all(promises
)
1073 for (const workerNode
of pool
.workerNodes
) {
1074 expect(workerNode
.usage
).toMatchObject({
1076 executed
: expect
.any(Number
),
1082 runTime
: expect
.objectContaining({
1083 history
: expect
.any(CircularArray
)
1086 history
: expect
.any(CircularArray
)
1089 idle
: expect
.objectContaining({
1090 history
: expect
.any(CircularArray
)
1092 active
: expect
.objectContaining({
1093 history
: expect
.any(CircularArray
)
1097 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1098 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1101 if (workerNode
.usage
.runTime
.aggregate
== null) {
1102 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1104 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1106 if (workerNode
.usage
.runTime
.average
== null) {
1107 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1109 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1111 if (workerNode
.usage
.elu
.utilization
== null) {
1112 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1114 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1115 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1119 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1120 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1121 ).workersVirtualTaskEndTimestamp
.length
1122 ).toBe(pool
.workerNodes
.length
)
1123 // We need to clean up the resources after our test
1124 await pool
.destroy()
1127 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1128 const pool
= new DynamicThreadPool(
1131 './tests/worker-files/thread/testWorker.js',
1133 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1134 workerChoiceStrategyOptions
: {
1135 runTime
: { median
: true }
1139 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1140 const promises
= new Set()
1141 const maxMultiplier
= 2
1142 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1143 promises
.add(pool
.execute())
1145 await Promise
.all(promises
)
1146 for (const workerNode
of pool
.workerNodes
) {
1147 expect(workerNode
.usage
).toMatchObject({
1149 executed
: expect
.any(Number
),
1155 runTime
: expect
.objectContaining({
1156 history
: expect
.any(CircularArray
)
1159 history
: expect
.any(CircularArray
)
1162 idle
: expect
.objectContaining({
1163 history
: expect
.any(CircularArray
)
1165 active
: expect
.objectContaining({
1166 history
: expect
.any(CircularArray
)
1170 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1171 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1174 if (workerNode
.usage
.runTime
.aggregate
== null) {
1175 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1177 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1179 if (workerNode
.usage
.runTime
.median
== null) {
1180 expect(workerNode
.usage
.runTime
.median
).toBeUndefined()
1182 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1184 if (workerNode
.usage
.elu
.utilization
== null) {
1185 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1187 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1188 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1192 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1193 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1194 ).workersVirtualTaskEndTimestamp
.length
1195 ).toBe(pool
.workerNodes
.length
)
1196 // We need to clean up the resources after our test
1197 await pool
.destroy()
1200 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1201 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1202 let pool
= new FixedThreadPool(
1204 './tests/worker-files/thread/testWorker.js'
1207 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1208 workerChoiceStrategy
1209 ).workersVirtualTaskEndTimestamp
1210 ).toBeInstanceOf(Array
)
1212 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1213 workerChoiceStrategy
1214 ).workersVirtualTaskEndTimestamp
.length
1216 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1217 workerChoiceStrategy
1218 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1220 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1221 workerChoiceStrategy
1222 ).workersVirtualTaskEndTimestamp
.length
1224 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1226 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1227 workerChoiceStrategy
1228 ).workersVirtualTaskEndTimestamp
1229 ).toBeInstanceOf(Array
)
1231 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1232 workerChoiceStrategy
1233 ).workersVirtualTaskEndTimestamp
.length
1235 await pool
.destroy()
1236 pool
= new DynamicThreadPool(
1239 './tests/worker-files/thread/testWorker.js'
1242 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1243 workerChoiceStrategy
1244 ).workersVirtualTaskEndTimestamp
1245 ).toBeInstanceOf(Array
)
1247 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1248 workerChoiceStrategy
1249 ).workersVirtualTaskEndTimestamp
.length
1251 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1252 workerChoiceStrategy
1253 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1255 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1256 workerChoiceStrategy
1257 ).workersVirtualTaskEndTimestamp
.length
1259 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1261 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1262 workerChoiceStrategy
1263 ).workersVirtualTaskEndTimestamp
1264 ).toBeInstanceOf(Array
)
1266 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1267 workerChoiceStrategy
1268 ).workersVirtualTaskEndTimestamp
.length
1270 // We need to clean up the resources after our test
1271 await pool
.destroy()
1274 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1275 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1276 let pool
= new FixedThreadPool(
1278 './tests/worker-files/thread/testWorker.js',
1279 { workerChoiceStrategy
}
1281 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1282 useDynamicWorker
: true
1284 await pool
.destroy()
1285 pool
= new DynamicThreadPool(
1288 './tests/worker-files/thread/testWorker.js',
1289 { workerChoiceStrategy
}
1291 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1292 useDynamicWorker
: true
1294 // We need to clean up the resources after our test
1295 await pool
.destroy()
1298 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1299 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1300 let pool
= new FixedThreadPool(
1302 './tests/worker-files/thread/testWorker.js',
1303 { workerChoiceStrategy
}
1306 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1324 await pool
.destroy()
1325 pool
= new DynamicThreadPool(
1328 './tests/worker-files/thread/testWorker.js',
1329 { workerChoiceStrategy
}
1332 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1350 // We need to clean up the resources after our test
1351 await pool
.destroy()
1354 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1355 const pool
= new FixedThreadPool(
1357 './tests/worker-files/thread/testWorker.js',
1358 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1360 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1361 const promises
= new Set()
1362 const maxMultiplier
= 2
1363 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1364 promises
.add(pool
.execute())
1366 await Promise
.all(promises
)
1367 for (const workerNode
of pool
.workerNodes
) {
1368 expect(workerNode
.usage
).toStrictEqual({
1370 executed
: expect
.any(Number
),
1376 runTime
: expect
.objectContaining({
1377 history
: expect
.any(CircularArray
)
1380 history
: expect
.any(CircularArray
)
1384 history
: expect
.any(CircularArray
)
1387 history
: expect
.any(CircularArray
)
1391 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1392 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1395 if (workerNode
.usage
.runTime
.aggregate
== null) {
1396 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1398 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1400 if (workerNode
.usage
.runTime
.average
== null) {
1401 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1403 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1407 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1408 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1409 ).defaultWorkerWeight
1410 ).toBeGreaterThan(0)
1412 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1413 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1414 ).workerVirtualTaskRunTime
1415 ).toBeGreaterThanOrEqual(0)
1416 // We need to clean up the resources after our test
1417 await pool
.destroy()
1420 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1421 const pool
= new DynamicThreadPool(
1424 './tests/worker-files/thread/testWorker.js',
1425 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1427 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1428 const promises
= new Set()
1429 const maxMultiplier
= 2
1430 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1431 promises
.add(pool
.execute())
1433 await Promise
.all(promises
)
1434 for (const workerNode
of pool
.workerNodes
) {
1435 expect(workerNode
.usage
).toStrictEqual({
1437 executed
: expect
.any(Number
),
1444 aggregate
: expect
.any(Number
),
1445 maximum
: expect
.any(Number
),
1446 minimum
: expect
.any(Number
),
1447 average
: expect
.any(Number
),
1448 history
: expect
.any(CircularArray
)
1451 history
: expect
.any(CircularArray
)
1455 history
: expect
.any(CircularArray
)
1458 history
: expect
.any(CircularArray
)
1462 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1463 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1466 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1467 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1470 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1471 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1472 ).defaultWorkerWeight
1473 ).toBeGreaterThan(0)
1475 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1476 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1477 ).workerVirtualTaskRunTime
1478 ).toBeGreaterThanOrEqual(0)
1479 // We need to clean up the resources after our test
1480 await pool
.destroy()
1483 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1484 const pool
= new DynamicThreadPool(
1487 './tests/worker-files/thread/testWorker.js',
1489 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1490 workerChoiceStrategyOptions
: {
1491 runTime
: { median
: true }
1495 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1496 const promises
= new Set()
1497 const maxMultiplier
= 2
1498 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1499 promises
.add(pool
.execute())
1501 await Promise
.all(promises
)
1502 for (const workerNode
of pool
.workerNodes
) {
1503 expect(workerNode
.usage
).toStrictEqual({
1505 executed
: expect
.any(Number
),
1512 aggregate
: expect
.any(Number
),
1513 maximum
: expect
.any(Number
),
1514 minimum
: expect
.any(Number
),
1515 median
: expect
.any(Number
),
1516 history
: expect
.any(CircularArray
)
1519 history
: expect
.any(CircularArray
)
1523 history
: expect
.any(CircularArray
)
1526 history
: expect
.any(CircularArray
)
1530 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1531 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1534 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1535 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1538 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1539 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1540 ).defaultWorkerWeight
1541 ).toBeGreaterThan(0)
1543 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1544 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1545 ).workerVirtualTaskRunTime
1546 ).toBeGreaterThanOrEqual(0)
1547 // We need to clean up the resources after our test
1548 await pool
.destroy()
1551 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1552 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1553 let pool
= new FixedThreadPool(
1555 './tests/worker-files/thread/testWorker.js'
1558 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1559 workerChoiceStrategy
1563 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1564 workerChoiceStrategy
1565 ).defaultWorkerWeight
1568 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1569 workerChoiceStrategy
1570 ).workerVirtualTaskRunTime
1572 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1574 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1575 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1579 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1580 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1581 ).defaultWorkerWeight
1582 ).toBeGreaterThan(0)
1584 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1585 workerChoiceStrategy
1586 ).workerVirtualTaskRunTime
1588 await pool
.destroy()
1589 pool
= new DynamicThreadPool(
1592 './tests/worker-files/thread/testWorker.js'
1595 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1596 workerChoiceStrategy
1600 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1601 workerChoiceStrategy
1602 ).defaultWorkerWeight
1605 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1606 workerChoiceStrategy
1607 ).workerVirtualTaskRunTime
1609 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1611 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1612 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1616 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1617 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1618 ).defaultWorkerWeight
1619 ).toBeGreaterThan(0)
1621 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1622 workerChoiceStrategy
1623 ).workerVirtualTaskRunTime
1625 // We need to clean up the resources after our test
1626 await pool
.destroy()
1629 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1630 const workerChoiceStrategy
=
1631 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1632 let pool
= new FixedThreadPool(
1634 './tests/worker-files/thread/testWorker.js',
1635 { workerChoiceStrategy
}
1637 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1638 useDynamicWorker
: true
1640 await pool
.destroy()
1641 pool
= new DynamicThreadPool(
1644 './tests/worker-files/thread/testWorker.js',
1645 { workerChoiceStrategy
}
1647 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1648 useDynamicWorker
: true
1650 // We need to clean up the resources after our test
1651 await pool
.destroy()
1654 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1655 const workerChoiceStrategy
=
1656 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1657 let pool
= new FixedThreadPool(
1659 './tests/worker-files/thread/testWorker.js',
1660 { workerChoiceStrategy
}
1663 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1681 await pool
.destroy()
1682 pool
= new DynamicThreadPool(
1685 './tests/worker-files/thread/testWorker.js',
1686 { workerChoiceStrategy
}
1689 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1707 // We need to clean up the resources after our test
1708 await pool
.destroy()
1711 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1712 const pool
= new FixedThreadPool(
1714 './tests/worker-files/thread/testWorker.js',
1716 workerChoiceStrategy
:
1717 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1720 if (!pool
.info
.ready
) {
1721 await
waitPoolEvents(pool
, PoolEvents
.ready
, 1)
1723 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1724 const promises
= new Set()
1725 const maxMultiplier
= 2
1726 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1727 promises
.add(pool
.execute())
1729 await Promise
.all(promises
)
1730 for (const workerNode
of pool
.workerNodes
) {
1731 expect(workerNode
.usage
).toStrictEqual({
1733 executed
: maxMultiplier
,
1740 history
: expect
.any(CircularArray
)
1743 history
: expect
.any(CircularArray
)
1747 history
: expect
.any(CircularArray
)
1750 history
: expect
.any(CircularArray
)
1756 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1757 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1758 ).defaultWorkerWeight
1759 ).toBeGreaterThan(0)
1761 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1762 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1766 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1767 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1771 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1772 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1775 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1776 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1777 ).defaultWorkerWeight
1779 // We need to clean up the resources after our test
1780 await pool
.destroy()
1783 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1784 const pool
= new DynamicThreadPool(
1787 './tests/worker-files/thread/testWorker.js',
1789 workerChoiceStrategy
:
1790 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1793 if (!pool
.info
.ready
) {
1794 await
waitPoolEvents(pool
, PoolEvents
.ready
, 1)
1796 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1797 const promises
= new Set()
1798 const maxMultiplier
= 2
1799 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1800 promises
.add(pool
.execute())
1802 await Promise
.all(promises
)
1803 for (const workerNode
of pool
.workerNodes
) {
1804 expect(workerNode
.usage
).toStrictEqual({
1806 executed
: expect
.any(Number
),
1813 history
: expect
.any(CircularArray
)
1816 history
: expect
.any(CircularArray
)
1820 history
: expect
.any(CircularArray
)
1823 history
: expect
.any(CircularArray
)
1829 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1830 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1831 ).defaultWorkerWeight
1832 ).toBeGreaterThan(0)
1834 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1835 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1839 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1840 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1844 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1845 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1848 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1849 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1850 ).defaultWorkerWeight
1852 // We need to clean up the resources after our test
1853 await pool
.destroy()
1856 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1857 const workerChoiceStrategy
=
1858 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1859 let pool
= new FixedThreadPool(
1861 './tests/worker-files/thread/testWorker.js'
1864 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1865 workerChoiceStrategy
1869 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1870 workerChoiceStrategy
1874 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1875 workerChoiceStrategy
1876 ).defaultWorkerWeight
1879 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1880 workerChoiceStrategy
1883 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1885 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1886 workerChoiceStrategy
1890 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1891 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1895 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1896 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1897 ).defaultWorkerWeight
1898 ).toBeGreaterThan(0)
1900 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1901 workerChoiceStrategy
1904 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1905 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1906 ).defaultWorkerWeight
1908 await pool
.destroy()
1909 pool
= new DynamicThreadPool(
1912 './tests/worker-files/thread/testWorker.js'
1915 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1916 workerChoiceStrategy
1920 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1921 workerChoiceStrategy
1925 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1926 workerChoiceStrategy
1927 ).defaultWorkerWeight
1930 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1931 workerChoiceStrategy
1934 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1936 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1937 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1941 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1942 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1943 ).defaultWorkerWeight
1944 ).toBeGreaterThan(0)
1946 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1947 workerChoiceStrategy
1950 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1951 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1952 ).defaultWorkerWeight
1954 // We need to clean up the resources after our test
1955 await pool
.destroy()
1958 it('Verify unknown strategy throw error', () => {
1961 new DynamicThreadPool(
1964 './tests/worker-files/thread/testWorker.js',
1965 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
1967 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")