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
.LEAST_ELU
).toBe('LEAST_ELU')
19 expect(WorkerChoiceStrategies
.FAIR_SHARE
).toBe('FAIR_SHARE')
20 expect(WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
).toBe(
21 'WEIGHTED_ROUND_ROBIN'
23 expect(WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
).toBe(
24 'INTERLEAVED_WEIGHTED_ROUND_ROBIN'
28 it('Verify ROUND_ROBIN strategy is the default at pool creation', async () => {
29 const pool
= new DynamicThreadPool(
32 './tests/worker-files/thread/testWorker.js'
34 expect(pool
.opts
.workerChoiceStrategy
).toBe(
35 WorkerChoiceStrategies
.ROUND_ROBIN
37 // We need to clean up the resources after our test
41 it('Verify available strategies are taken at pool creation', async () => {
42 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
43 const pool
= new FixedThreadPool(
45 './tests/worker-files/thread/testWorker.js',
46 { workerChoiceStrategy
}
48 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
49 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
56 it('Verify available strategies can be set after pool creation', async () => {
57 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
58 const pool
= new DynamicThreadPool(
61 './tests/worker-files/thread/testWorker.js'
63 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
64 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
65 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
72 it('Verify available strategies default internals at pool creation', async () => {
73 const pool
= new FixedThreadPool(
75 './tests/worker-files/thread/testWorker.js'
77 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
78 if (workerChoiceStrategy
=== WorkerChoiceStrategies
.ROUND_ROBIN
) {
80 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
84 } else if (workerChoiceStrategy
=== WorkerChoiceStrategies
.FAIR_SHARE
) {
86 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
88 ).workersVirtualTaskEndTimestamp
89 ).toBeInstanceOf(Array
)
91 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
93 ).workersVirtualTaskEndTimestamp
.length
96 workerChoiceStrategy
=== WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
99 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
104 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
106 ).defaultWorkerWeight
109 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
111 ).workerVirtualTaskRunTime
118 it('Verify ROUND_ROBIN strategy default policy', async () => {
119 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
120 let pool
= new FixedThreadPool(
122 './tests/worker-files/thread/testWorker.js',
123 { workerChoiceStrategy
}
125 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
126 useDynamicWorker
: true
129 pool
= new DynamicThreadPool(
132 './tests/worker-files/thread/testWorker.js',
133 { workerChoiceStrategy
}
135 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
136 useDynamicWorker
: true
138 // We need to clean up the resources after our test
142 it('Verify ROUND_ROBIN strategy default tasks statistics requirements', async () => {
143 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
144 let pool
= new FixedThreadPool(
146 './tests/worker-files/thread/testWorker.js',
147 { workerChoiceStrategy
}
150 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
169 pool
= new DynamicThreadPool(
172 './tests/worker-files/thread/testWorker.js',
173 { workerChoiceStrategy
}
176 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
194 // We need to clean up the resources after our test
198 it('Verify ROUND_ROBIN strategy can be run in a fixed pool', async () => {
199 const pool
= new FixedThreadPool(
201 './tests/worker-files/thread/testWorker.js',
202 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
204 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
205 const promises
= new Set()
206 const maxMultiplier
= 2
207 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
208 promises
.add(pool
.execute())
210 await Promise
.all(promises
)
211 for (const workerNode
of pool
.workerNodes
) {
212 expect(workerNode
.usage
).toStrictEqual({
214 executed
: maxMultiplier
,
221 history
: expect
.any(CircularArray
)
224 history
: expect
.any(CircularArray
)
228 history
: expect
.any(CircularArray
)
231 history
: expect
.any(CircularArray
)
237 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
238 WorkerChoiceStrategies
.ROUND_ROBIN
241 // We need to clean up the resources after our test
245 it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
246 const pool
= new DynamicThreadPool(
249 './tests/worker-files/thread/testWorker.js',
250 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
252 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
253 const promises
= new Set()
254 const maxMultiplier
= 2
255 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
256 promises
.add(pool
.execute())
258 await Promise
.all(promises
)
259 for (const workerNode
of pool
.workerNodes
) {
260 expect(workerNode
.usage
).toStrictEqual({
262 executed
: maxMultiplier
,
269 history
: expect
.any(CircularArray
)
272 history
: expect
.any(CircularArray
)
276 history
: expect
.any(CircularArray
)
279 history
: expect
.any(CircularArray
)
285 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
286 WorkerChoiceStrategies
.ROUND_ROBIN
289 // We need to clean up the resources after our test
293 it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
294 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
295 let pool
= new FixedClusterPool(
297 './tests/worker-files/cluster/testWorker.js',
298 { workerChoiceStrategy
}
300 let results
= new Set()
301 for (let i
= 0; i
< max
; i
++) {
302 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.id
)
304 expect(results
.size
).toBe(max
)
306 pool
= new FixedThreadPool(
308 './tests/worker-files/thread/testWorker.js',
309 { workerChoiceStrategy
}
312 for (let i
= 0; i
< max
; i
++) {
313 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.threadId
)
315 expect(results
.size
).toBe(max
)
319 it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
320 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
321 let pool
= new FixedThreadPool(
323 './tests/worker-files/thread/testWorker.js',
324 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
327 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
331 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
333 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
334 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
338 pool
= new DynamicThreadPool(
341 './tests/worker-files/thread/testWorker.js',
342 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
345 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
349 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
351 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
352 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
355 // We need to clean up the resources after our test
359 it('Verify LEAST_USED strategy default policy', async () => {
360 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
361 let pool
= new FixedThreadPool(
363 './tests/worker-files/thread/testWorker.js',
364 { workerChoiceStrategy
}
366 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
367 useDynamicWorker
: false
370 pool
= new DynamicThreadPool(
373 './tests/worker-files/thread/testWorker.js',
374 { workerChoiceStrategy
}
376 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
377 useDynamicWorker
: false
379 // We need to clean up the resources after our test
383 it('Verify LEAST_USED strategy default tasks statistics requirements', async () => {
384 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
385 let pool
= new FixedThreadPool(
387 './tests/worker-files/thread/testWorker.js',
388 { workerChoiceStrategy
}
391 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
410 pool
= new DynamicThreadPool(
413 './tests/worker-files/thread/testWorker.js',
414 { workerChoiceStrategy
}
417 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
435 // We need to clean up the resources after our test
439 it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
440 const pool
= new FixedThreadPool(
442 './tests/worker-files/thread/testWorker.js',
443 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
445 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
446 const promises
= new Set()
447 const maxMultiplier
= 2
448 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
449 promises
.add(pool
.execute())
451 await Promise
.all(promises
)
452 for (const workerNode
of pool
.workerNodes
) {
453 expect(workerNode
.usage
).toStrictEqual({
455 executed
: expect
.any(Number
),
462 history
: expect
.any(CircularArray
)
465 history
: expect
.any(CircularArray
)
469 history
: expect
.any(CircularArray
)
472 history
: expect
.any(CircularArray
)
476 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
477 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
481 // We need to clean up the resources after our test
485 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
486 const pool
= new DynamicThreadPool(
489 './tests/worker-files/thread/testWorker.js',
490 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
492 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
493 const promises
= new Set()
494 const maxMultiplier
= 2
495 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
496 promises
.add(pool
.execute())
498 await Promise
.all(promises
)
499 for (const workerNode
of pool
.workerNodes
) {
500 expect(workerNode
.usage
).toStrictEqual({
502 executed
: expect
.any(Number
),
509 history
: expect
.any(CircularArray
)
512 history
: expect
.any(CircularArray
)
516 history
: expect
.any(CircularArray
)
519 history
: expect
.any(CircularArray
)
523 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
524 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
528 // We need to clean up the resources after our test
532 it('Verify LEAST_BUSY strategy default policy', async () => {
533 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
534 let pool
= new FixedThreadPool(
536 './tests/worker-files/thread/testWorker.js',
537 { workerChoiceStrategy
}
539 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
540 useDynamicWorker
: false
543 pool
= new DynamicThreadPool(
546 './tests/worker-files/thread/testWorker.js',
547 { workerChoiceStrategy
}
549 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
550 useDynamicWorker
: false
552 // We need to clean up the resources after our test
556 it('Verify LEAST_BUSY strategy default tasks statistics requirements', async () => {
557 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
558 let pool
= new FixedThreadPool(
560 './tests/worker-files/thread/testWorker.js',
561 { workerChoiceStrategy
}
564 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
583 pool
= new DynamicThreadPool(
586 './tests/worker-files/thread/testWorker.js',
587 { workerChoiceStrategy
}
590 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
608 // We need to clean up the resources after our test
612 it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
613 const pool
= new FixedThreadPool(
615 './tests/worker-files/thread/testWorker.js',
616 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
618 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
619 const promises
= new Set()
620 const maxMultiplier
= 2
621 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
622 promises
.add(pool
.execute())
624 await Promise
.all(promises
)
625 for (const workerNode
of pool
.workerNodes
) {
626 expect(workerNode
.usage
).toStrictEqual({
628 executed
: expect
.any(Number
),
635 aggregate
: expect
.any(Number
),
636 maximum
: expect
.any(Number
),
637 minimum
: expect
.any(Number
),
638 history
: expect
.any(CircularArray
)
641 aggregate
: expect
.any(Number
),
642 maximum
: expect
.any(Number
),
643 minimum
: expect
.any(Number
),
644 history
: expect
.any(CircularArray
)
648 history
: expect
.any(CircularArray
)
651 history
: expect
.any(CircularArray
)
655 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
656 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
659 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
660 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThanOrEqual(0)
662 // We need to clean up the resources after our test
666 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
667 const pool
= new DynamicThreadPool(
670 './tests/worker-files/thread/testWorker.js',
671 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
673 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
674 const promises
= new Set()
675 const maxMultiplier
= 2
676 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
677 promises
.add(pool
.execute())
679 await Promise
.all(promises
)
680 for (const workerNode
of pool
.workerNodes
) {
681 expect(workerNode
.usage
).toStrictEqual({
683 executed
: expect
.any(Number
),
690 aggregate
: expect
.any(Number
),
691 maximum
: expect
.any(Number
),
692 minimum
: expect
.any(Number
),
693 history
: expect
.any(CircularArray
)
696 aggregate
: expect
.any(Number
),
697 maximum
: expect
.any(Number
),
698 minimum
: expect
.any(Number
),
699 history
: expect
.any(CircularArray
)
703 history
: expect
.any(CircularArray
)
706 history
: expect
.any(CircularArray
)
710 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
711 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
714 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
715 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThanOrEqual(0)
717 // We need to clean up the resources after our test
721 it('Verify LEAST_ELU strategy default policy', async () => {
722 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
723 let pool
= new FixedThreadPool(
725 './tests/worker-files/thread/testWorker.js',
726 { workerChoiceStrategy
}
728 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
729 useDynamicWorker
: false
732 pool
= new DynamicThreadPool(
735 './tests/worker-files/thread/testWorker.js',
736 { workerChoiceStrategy
}
738 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
739 useDynamicWorker
: false
741 // We need to clean up the resources after our test
745 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
746 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
747 let pool
= new FixedThreadPool(
749 './tests/worker-files/thread/testWorker.js',
750 { workerChoiceStrategy
}
753 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
772 pool
= new DynamicThreadPool(
775 './tests/worker-files/thread/testWorker.js',
776 { workerChoiceStrategy
}
779 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
797 // We need to clean up the resources after our test
801 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
802 const pool
= new FixedThreadPool(
804 './tests/worker-files/thread/testWorker.js',
805 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
807 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
808 const promises
= new Set()
809 const maxMultiplier
= 2
810 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
811 promises
.add(pool
.execute())
813 await Promise
.all(promises
)
814 for (const workerNode
of pool
.workerNodes
) {
815 expect(workerNode
.usage
).toMatchObject({
817 executed
: expect
.any(Number
),
824 history
: expect
.any(CircularArray
)
827 history
: expect
.any(CircularArray
)
830 idle
: expect
.objectContaining({
831 history
: expect
.any(CircularArray
)
833 active
: expect
.objectContaining({
834 history
: expect
.any(CircularArray
)
838 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
839 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
842 if (workerNode
.usage
.elu
.utilization
== null) {
843 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
845 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
846 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
849 // We need to clean up the resources after our test
853 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
854 const pool
= new DynamicThreadPool(
857 './tests/worker-files/thread/testWorker.js',
858 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
860 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
861 const promises
= new Set()
862 const maxMultiplier
= 2
863 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
864 promises
.add(pool
.execute())
866 await Promise
.all(promises
)
867 for (const workerNode
of pool
.workerNodes
) {
868 expect(workerNode
.usage
).toMatchObject({
870 executed
: expect
.any(Number
),
877 history
: expect
.any(CircularArray
)
880 history
: expect
.any(CircularArray
)
883 idle
: expect
.objectContaining({
884 history
: expect
.any(CircularArray
)
886 active
: expect
.objectContaining({
887 history
: expect
.any(CircularArray
)
891 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
892 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
895 if (workerNode
.usage
.elu
.utilization
== null) {
896 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
898 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
899 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
902 // We need to clean up the resources after our test
906 it('Verify FAIR_SHARE strategy default policy', async () => {
907 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
908 let pool
= new FixedThreadPool(
910 './tests/worker-files/thread/testWorker.js',
911 { workerChoiceStrategy
}
913 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
914 useDynamicWorker
: false
917 pool
= new DynamicThreadPool(
920 './tests/worker-files/thread/testWorker.js',
921 { workerChoiceStrategy
}
923 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
924 useDynamicWorker
: false
926 // We need to clean up the resources after our test
930 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
931 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
932 let pool
= new FixedThreadPool(
934 './tests/worker-files/thread/testWorker.js',
935 { workerChoiceStrategy
}
938 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
957 pool
= new DynamicThreadPool(
960 './tests/worker-files/thread/testWorker.js',
961 { workerChoiceStrategy
}
964 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
982 // We need to clean up the resources after our test
986 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
987 const pool
= new FixedThreadPool(
989 './tests/worker-files/thread/testWorker.js',
990 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
992 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
993 const promises
= new Set()
994 const maxMultiplier
= 2
995 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
996 promises
.add(pool
.execute())
998 await Promise
.all(promises
)
999 for (const workerNode
of pool
.workerNodes
) {
1000 expect(workerNode
.usage
).toMatchObject({
1002 executed
: expect
.any(Number
),
1008 runTime
: expect
.objectContaining({
1009 history
: expect
.any(CircularArray
)
1012 history
: expect
.any(CircularArray
)
1015 idle
: expect
.objectContaining({
1016 history
: expect
.any(CircularArray
)
1018 active
: expect
.objectContaining({
1019 history
: expect
.any(CircularArray
)
1023 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1024 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1027 if (workerNode
.usage
.runTime
.aggregate
== null) {
1028 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1030 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1032 if (workerNode
.usage
.runTime
.average
== null) {
1033 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1035 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1037 if (workerNode
.usage
.elu
.utilization
== null) {
1038 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1040 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1041 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1045 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1046 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1047 ).workersVirtualTaskEndTimestamp
.length
1048 ).toBe(pool
.workerNodes
.length
)
1049 // We need to clean up the resources after our test
1050 await pool
.destroy()
1053 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1054 const pool
= new DynamicThreadPool(
1057 './tests/worker-files/thread/testWorker.js',
1058 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1060 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1061 const promises
= new Set()
1062 const maxMultiplier
= 2
1063 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1064 promises
.add(pool
.execute())
1066 await Promise
.all(promises
)
1067 for (const workerNode
of pool
.workerNodes
) {
1068 expect(workerNode
.usage
).toMatchObject({
1070 executed
: expect
.any(Number
),
1076 runTime
: expect
.objectContaining({
1077 history
: expect
.any(CircularArray
)
1080 history
: expect
.any(CircularArray
)
1083 idle
: expect
.objectContaining({
1084 history
: expect
.any(CircularArray
)
1086 active
: expect
.objectContaining({
1087 history
: expect
.any(CircularArray
)
1091 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1092 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1095 if (workerNode
.usage
.runTime
.aggregate
== null) {
1096 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1098 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1100 if (workerNode
.usage
.runTime
.average
== null) {
1101 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1103 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1105 if (workerNode
.usage
.elu
.utilization
== null) {
1106 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1108 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1109 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1113 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1114 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1115 ).workersVirtualTaskEndTimestamp
.length
1116 ).toBe(pool
.workerNodes
.length
)
1117 // We need to clean up the resources after our test
1118 await pool
.destroy()
1121 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1122 const pool
= new DynamicThreadPool(
1125 './tests/worker-files/thread/testWorker.js',
1127 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1128 workerChoiceStrategyOptions
: {
1129 runTime
: { median
: true }
1133 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1134 const promises
= new Set()
1135 const maxMultiplier
= 2
1136 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1137 promises
.add(pool
.execute())
1139 await Promise
.all(promises
)
1140 for (const workerNode
of pool
.workerNodes
) {
1141 expect(workerNode
.usage
).toMatchObject({
1143 executed
: expect
.any(Number
),
1149 runTime
: expect
.objectContaining({
1150 history
: expect
.any(CircularArray
)
1153 history
: expect
.any(CircularArray
)
1156 idle
: expect
.objectContaining({
1157 history
: expect
.any(CircularArray
)
1159 active
: expect
.objectContaining({
1160 history
: expect
.any(CircularArray
)
1164 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1165 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1168 if (workerNode
.usage
.runTime
.aggregate
== null) {
1169 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1171 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1173 if (workerNode
.usage
.runTime
.median
== null) {
1174 expect(workerNode
.usage
.runTime
.median
).toBeUndefined()
1176 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1178 if (workerNode
.usage
.elu
.utilization
== null) {
1179 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1181 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1182 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1186 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1187 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1188 ).workersVirtualTaskEndTimestamp
.length
1189 ).toBe(pool
.workerNodes
.length
)
1190 // We need to clean up the resources after our test
1191 await pool
.destroy()
1194 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1195 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1196 let pool
= new FixedThreadPool(
1198 './tests/worker-files/thread/testWorker.js'
1201 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1202 workerChoiceStrategy
1203 ).workersVirtualTaskEndTimestamp
1204 ).toBeInstanceOf(Array
)
1206 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1207 workerChoiceStrategy
1208 ).workersVirtualTaskEndTimestamp
.length
1210 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1211 workerChoiceStrategy
1212 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1214 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1215 workerChoiceStrategy
1216 ).workersVirtualTaskEndTimestamp
.length
1218 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1220 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1221 workerChoiceStrategy
1222 ).workersVirtualTaskEndTimestamp
1223 ).toBeInstanceOf(Array
)
1225 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1226 workerChoiceStrategy
1227 ).workersVirtualTaskEndTimestamp
.length
1229 await pool
.destroy()
1230 pool
= new DynamicThreadPool(
1233 './tests/worker-files/thread/testWorker.js'
1236 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1237 workerChoiceStrategy
1238 ).workersVirtualTaskEndTimestamp
1239 ).toBeInstanceOf(Array
)
1241 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1242 workerChoiceStrategy
1243 ).workersVirtualTaskEndTimestamp
.length
1245 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1246 workerChoiceStrategy
1247 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1249 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1250 workerChoiceStrategy
1251 ).workersVirtualTaskEndTimestamp
.length
1253 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1255 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1256 workerChoiceStrategy
1257 ).workersVirtualTaskEndTimestamp
1258 ).toBeInstanceOf(Array
)
1260 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1261 workerChoiceStrategy
1262 ).workersVirtualTaskEndTimestamp
.length
1264 // We need to clean up the resources after our test
1265 await pool
.destroy()
1268 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1269 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1270 let pool
= new FixedThreadPool(
1272 './tests/worker-files/thread/testWorker.js',
1273 { workerChoiceStrategy
}
1275 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1276 useDynamicWorker
: true
1278 await pool
.destroy()
1279 pool
= new DynamicThreadPool(
1282 './tests/worker-files/thread/testWorker.js',
1283 { workerChoiceStrategy
}
1285 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1286 useDynamicWorker
: true
1288 // We need to clean up the resources after our test
1289 await pool
.destroy()
1292 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1293 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1294 let pool
= new FixedThreadPool(
1296 './tests/worker-files/thread/testWorker.js',
1297 { workerChoiceStrategy
}
1300 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1318 await pool
.destroy()
1319 pool
= new DynamicThreadPool(
1322 './tests/worker-files/thread/testWorker.js',
1323 { workerChoiceStrategy
}
1326 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1344 // We need to clean up the resources after our test
1345 await pool
.destroy()
1348 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1349 const pool
= new FixedThreadPool(
1351 './tests/worker-files/thread/testWorker.js',
1352 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1354 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1355 const promises
= new Set()
1356 const maxMultiplier
= 2
1357 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1358 promises
.add(pool
.execute())
1360 await Promise
.all(promises
)
1361 for (const workerNode
of pool
.workerNodes
) {
1362 expect(workerNode
.usage
).toStrictEqual({
1364 executed
: expect
.any(Number
),
1370 runTime
: expect
.objectContaining({
1371 history
: expect
.any(CircularArray
)
1374 history
: expect
.any(CircularArray
)
1378 history
: expect
.any(CircularArray
)
1381 history
: expect
.any(CircularArray
)
1385 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1386 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1389 if (workerNode
.usage
.runTime
.aggregate
== null) {
1390 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1392 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1394 if (workerNode
.usage
.runTime
.average
== null) {
1395 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1397 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1401 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1402 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1403 ).defaultWorkerWeight
1404 ).toBeGreaterThan(0)
1406 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1407 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1408 ).workerVirtualTaskRunTime
1409 ).toBeGreaterThanOrEqual(0)
1410 // We need to clean up the resources after our test
1411 await pool
.destroy()
1414 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1415 const pool
= new DynamicThreadPool(
1418 './tests/worker-files/thread/testWorker.js',
1419 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1421 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1422 const promises
= new Set()
1423 const maxMultiplier
= 2
1424 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1425 promises
.add(pool
.execute())
1427 await Promise
.all(promises
)
1428 for (const workerNode
of pool
.workerNodes
) {
1429 expect(workerNode
.usage
).toStrictEqual({
1431 executed
: expect
.any(Number
),
1438 aggregate
: expect
.any(Number
),
1439 maximum
: expect
.any(Number
),
1440 minimum
: expect
.any(Number
),
1441 average
: expect
.any(Number
),
1442 history
: expect
.any(CircularArray
)
1445 history
: expect
.any(CircularArray
)
1449 history
: expect
.any(CircularArray
)
1452 history
: expect
.any(CircularArray
)
1456 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1457 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1460 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1461 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1464 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1465 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1466 ).defaultWorkerWeight
1467 ).toBeGreaterThan(0)
1469 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1470 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1471 ).workerVirtualTaskRunTime
1472 ).toBeGreaterThanOrEqual(0)
1473 // We need to clean up the resources after our test
1474 await pool
.destroy()
1477 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1478 const pool
= new DynamicThreadPool(
1481 './tests/worker-files/thread/testWorker.js',
1483 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1484 workerChoiceStrategyOptions
: {
1485 runTime
: { median
: true }
1489 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1490 const promises
= new Set()
1491 const maxMultiplier
= 2
1492 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1493 promises
.add(pool
.execute())
1495 await Promise
.all(promises
)
1496 for (const workerNode
of pool
.workerNodes
) {
1497 expect(workerNode
.usage
).toStrictEqual({
1499 executed
: expect
.any(Number
),
1506 aggregate
: expect
.any(Number
),
1507 maximum
: expect
.any(Number
),
1508 minimum
: expect
.any(Number
),
1509 median
: expect
.any(Number
),
1510 history
: expect
.any(CircularArray
)
1513 history
: expect
.any(CircularArray
)
1517 history
: expect
.any(CircularArray
)
1520 history
: expect
.any(CircularArray
)
1524 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1525 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1528 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1529 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1532 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1533 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1534 ).defaultWorkerWeight
1535 ).toBeGreaterThan(0)
1537 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1538 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1539 ).workerVirtualTaskRunTime
1540 ).toBeGreaterThanOrEqual(0)
1541 // We need to clean up the resources after our test
1542 await pool
.destroy()
1545 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1546 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1547 let pool
= new FixedThreadPool(
1549 './tests/worker-files/thread/testWorker.js'
1552 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1553 workerChoiceStrategy
1557 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1558 workerChoiceStrategy
1559 ).defaultWorkerWeight
1562 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1563 workerChoiceStrategy
1564 ).workerVirtualTaskRunTime
1566 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1568 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1569 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1573 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1574 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1575 ).defaultWorkerWeight
1576 ).toBeGreaterThan(0)
1578 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1579 workerChoiceStrategy
1580 ).workerVirtualTaskRunTime
1582 await pool
.destroy()
1583 pool
= new DynamicThreadPool(
1586 './tests/worker-files/thread/testWorker.js'
1589 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1590 workerChoiceStrategy
1594 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1595 workerChoiceStrategy
1596 ).defaultWorkerWeight
1599 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1600 workerChoiceStrategy
1601 ).workerVirtualTaskRunTime
1603 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1605 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1606 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1610 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1611 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1612 ).defaultWorkerWeight
1613 ).toBeGreaterThan(0)
1615 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1616 workerChoiceStrategy
1617 ).workerVirtualTaskRunTime
1619 // We need to clean up the resources after our test
1620 await pool
.destroy()
1623 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1624 const workerChoiceStrategy
=
1625 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1626 let pool
= new FixedThreadPool(
1628 './tests/worker-files/thread/testWorker.js',
1629 { workerChoiceStrategy
}
1631 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1632 useDynamicWorker
: true
1634 await pool
.destroy()
1635 pool
= new DynamicThreadPool(
1638 './tests/worker-files/thread/testWorker.js',
1639 { workerChoiceStrategy
}
1641 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1642 useDynamicWorker
: true
1644 // We need to clean up the resources after our test
1645 await pool
.destroy()
1648 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1649 const workerChoiceStrategy
=
1650 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1651 let pool
= new FixedThreadPool(
1653 './tests/worker-files/thread/testWorker.js',
1654 { workerChoiceStrategy
}
1657 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1675 await pool
.destroy()
1676 pool
= new DynamicThreadPool(
1679 './tests/worker-files/thread/testWorker.js',
1680 { workerChoiceStrategy
}
1683 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1701 // We need to clean up the resources after our test
1702 await pool
.destroy()
1705 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1706 const pool
= new FixedThreadPool(
1708 './tests/worker-files/thread/testWorker.js',
1710 workerChoiceStrategy
:
1711 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1714 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1715 const promises
= new Set()
1716 const maxMultiplier
= 2
1717 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1718 promises
.add(pool
.execute())
1720 await Promise
.all(promises
)
1721 for (const workerNode
of pool
.workerNodes
) {
1722 expect(workerNode
.usage
).toStrictEqual({
1724 executed
: maxMultiplier
,
1731 history
: expect
.any(CircularArray
)
1734 history
: expect
.any(CircularArray
)
1738 history
: expect
.any(CircularArray
)
1741 history
: expect
.any(CircularArray
)
1747 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1748 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1749 ).defaultWorkerWeight
1750 ).toBeGreaterThan(0)
1752 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1753 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1757 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1758 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1762 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1763 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1766 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1767 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1768 ).defaultWorkerWeight
1770 // We need to clean up the resources after our test
1771 await pool
.destroy()
1774 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1775 const pool
= new DynamicThreadPool(
1778 './tests/worker-files/thread/testWorker.js',
1780 workerChoiceStrategy
:
1781 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1784 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1785 const promises
= new Set()
1786 const maxMultiplier
= 2
1787 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1788 promises
.add(pool
.execute())
1790 await Promise
.all(promises
)
1791 for (const workerNode
of pool
.workerNodes
) {
1792 expect(workerNode
.usage
).toStrictEqual({
1794 executed
: maxMultiplier
,
1801 history
: expect
.any(CircularArray
)
1804 history
: expect
.any(CircularArray
)
1808 history
: expect
.any(CircularArray
)
1811 history
: expect
.any(CircularArray
)
1817 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1818 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1819 ).defaultWorkerWeight
1820 ).toBeGreaterThan(0)
1822 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1823 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1827 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1828 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1832 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1833 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1836 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1837 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1838 ).defaultWorkerWeight
1840 // We need to clean up the resources after our test
1841 await pool
.destroy()
1844 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1845 const workerChoiceStrategy
=
1846 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1847 let pool
= new FixedThreadPool(
1849 './tests/worker-files/thread/testWorker.js'
1852 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1853 workerChoiceStrategy
1857 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1858 workerChoiceStrategy
1862 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1863 workerChoiceStrategy
1864 ).defaultWorkerWeight
1867 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1868 workerChoiceStrategy
1871 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1873 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1874 workerChoiceStrategy
1878 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1879 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1883 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1884 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1885 ).defaultWorkerWeight
1886 ).toBeGreaterThan(0)
1888 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1889 workerChoiceStrategy
1892 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1893 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1894 ).defaultWorkerWeight
1896 await pool
.destroy()
1897 pool
= new DynamicThreadPool(
1900 './tests/worker-files/thread/testWorker.js'
1903 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1904 workerChoiceStrategy
1908 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1909 workerChoiceStrategy
1913 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1914 workerChoiceStrategy
1915 ).defaultWorkerWeight
1918 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1919 workerChoiceStrategy
1922 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1924 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1925 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1929 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1930 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1931 ).defaultWorkerWeight
1932 ).toBeGreaterThan(0)
1934 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1935 workerChoiceStrategy
1938 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1939 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1940 ).defaultWorkerWeight
1942 // We need to clean up the resources after our test
1943 await pool
.destroy()
1946 it('Verify unknown strategy throw error', () => {
1949 new DynamicThreadPool(
1952 './tests/worker-files/thread/testWorker.js',
1953 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
1955 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")