1 const { expect
} = require('expect')
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 dynamicWorkerUsage
: false,
127 dynamicWorkerReady
: true
130 pool
= new DynamicThreadPool(
133 './tests/worker-files/thread/testWorker.js',
134 { workerChoiceStrategy
}
136 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
137 dynamicWorkerUsage
: false,
138 dynamicWorkerReady
: 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
,
224 history
: expect
.any(CircularArray
)
227 history
: expect
.any(CircularArray
)
231 history
: expect
.any(CircularArray
)
234 history
: expect
.any(CircularArray
)
240 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
241 WorkerChoiceStrategies
.ROUND_ROBIN
244 // We need to clean up the resources after our test
248 it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
249 const pool
= new DynamicThreadPool(
252 './tests/worker-files/thread/testWorker.js',
253 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
255 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
256 const promises
= new Set()
257 const maxMultiplier
= 2
258 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
259 promises
.add(pool
.execute())
261 await Promise
.all(promises
)
262 for (const workerNode
of pool
.workerNodes
) {
263 expect(workerNode
.usage
).toStrictEqual({
265 executed
: expect
.any(Number
),
273 history
: expect
.any(CircularArray
)
276 history
: expect
.any(CircularArray
)
280 history
: expect
.any(CircularArray
)
283 history
: expect
.any(CircularArray
)
287 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
288 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
293 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
294 WorkerChoiceStrategies
.ROUND_ROBIN
297 // We need to clean up the resources after our test
301 it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
302 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
303 let pool
= new FixedClusterPool(
305 './tests/worker-files/cluster/testWorker.js',
306 { workerChoiceStrategy
}
308 let results
= new Set()
309 for (let i
= 0; i
< max
; i
++) {
310 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.id
)
312 expect(results
.size
).toBe(max
)
314 pool
= new FixedThreadPool(
316 './tests/worker-files/thread/testWorker.js',
317 { workerChoiceStrategy
}
320 for (let i
= 0; i
< max
; i
++) {
321 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.threadId
)
323 expect(results
.size
).toBe(max
)
327 it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
328 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
329 let pool
= new FixedThreadPool(
331 './tests/worker-files/thread/testWorker.js',
332 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
335 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
339 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
341 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
342 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
346 pool
= new DynamicThreadPool(
349 './tests/worker-files/thread/testWorker.js',
350 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
353 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
357 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
359 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
360 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
363 // We need to clean up the resources after our test
367 it('Verify LEAST_USED strategy default policy', async () => {
368 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
369 let pool
= new FixedThreadPool(
371 './tests/worker-files/thread/testWorker.js',
372 { workerChoiceStrategy
}
374 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
375 dynamicWorkerUsage
: false,
376 dynamicWorkerReady
: true
379 pool
= new DynamicThreadPool(
382 './tests/worker-files/thread/testWorker.js',
383 { workerChoiceStrategy
}
385 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
386 dynamicWorkerUsage
: false,
387 dynamicWorkerReady
: true
389 // We need to clean up the resources after our test
393 it('Verify LEAST_USED strategy default tasks statistics requirements', async () => {
394 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
395 let pool
= new FixedThreadPool(
397 './tests/worker-files/thread/testWorker.js',
398 { workerChoiceStrategy
}
401 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
420 pool
= new DynamicThreadPool(
423 './tests/worker-files/thread/testWorker.js',
424 { workerChoiceStrategy
}
427 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
445 // We need to clean up the resources after our test
449 it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
450 const pool
= new FixedThreadPool(
452 './tests/worker-files/thread/testWorker.js',
453 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
455 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
456 const promises
= new Set()
457 const maxMultiplier
= 2
458 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
459 promises
.add(pool
.execute())
461 await Promise
.all(promises
)
462 for (const workerNode
of pool
.workerNodes
) {
463 expect(workerNode
.usage
).toStrictEqual({
465 executed
: expect
.any(Number
),
473 history
: expect
.any(CircularArray
)
476 history
: expect
.any(CircularArray
)
480 history
: expect
.any(CircularArray
)
483 history
: expect
.any(CircularArray
)
487 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
488 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
492 // We need to clean up the resources after our test
496 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
497 const pool
= new DynamicThreadPool(
500 './tests/worker-files/thread/testWorker.js',
501 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
503 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
504 const promises
= new Set()
505 const maxMultiplier
= 2
506 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
507 promises
.add(pool
.execute())
509 await Promise
.all(promises
)
510 for (const workerNode
of pool
.workerNodes
) {
511 expect(workerNode
.usage
).toStrictEqual({
513 executed
: expect
.any(Number
),
521 history
: expect
.any(CircularArray
)
524 history
: expect
.any(CircularArray
)
528 history
: expect
.any(CircularArray
)
531 history
: expect
.any(CircularArray
)
535 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
536 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
540 // We need to clean up the resources after our test
544 it('Verify LEAST_BUSY strategy default policy', async () => {
545 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
546 let pool
= new FixedThreadPool(
548 './tests/worker-files/thread/testWorker.js',
549 { workerChoiceStrategy
}
551 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
552 dynamicWorkerUsage
: false,
553 dynamicWorkerReady
: true
556 pool
= new DynamicThreadPool(
559 './tests/worker-files/thread/testWorker.js',
560 { workerChoiceStrategy
}
562 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
563 dynamicWorkerUsage
: false,
564 dynamicWorkerReady
: true
566 // We need to clean up the resources after our test
570 it('Verify LEAST_BUSY strategy default tasks statistics requirements', async () => {
571 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
572 let pool
= new FixedThreadPool(
574 './tests/worker-files/thread/testWorker.js',
575 { workerChoiceStrategy
}
578 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
597 pool
= new DynamicThreadPool(
600 './tests/worker-files/thread/testWorker.js',
601 { workerChoiceStrategy
}
604 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
622 // We need to clean up the resources after our test
626 it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
627 const pool
= new FixedThreadPool(
629 './tests/worker-files/thread/testWorker.js',
630 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
632 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
633 const promises
= new Set()
634 const maxMultiplier
= 2
635 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
636 promises
.add(pool
.execute())
638 await Promise
.all(promises
)
639 for (const workerNode
of pool
.workerNodes
) {
640 expect(workerNode
.usage
).toMatchObject({
642 executed
: expect
.any(Number
),
650 history
: expect
.any(CircularArray
)
653 history
: expect
.any(CircularArray
)
657 history
: expect
.any(CircularArray
)
660 history
: expect
.any(CircularArray
)
664 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
665 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
668 if (workerNode
.usage
.runTime
.aggregate
== null) {
669 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
671 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
673 if (workerNode
.usage
.waitTime
.aggregate
== null) {
674 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
676 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
679 // We need to clean up the resources after our test
683 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
684 const pool
= new DynamicThreadPool(
687 './tests/worker-files/thread/testWorker.js',
688 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
690 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
691 const promises
= new Set()
692 const maxMultiplier
= 2
693 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
694 promises
.add(pool
.execute())
696 await Promise
.all(promises
)
697 for (const workerNode
of pool
.workerNodes
) {
698 expect(workerNode
.usage
).toMatchObject({
700 executed
: expect
.any(Number
),
708 history
: expect
.any(CircularArray
)
711 history
: expect
.any(CircularArray
)
715 history
: expect
.any(CircularArray
)
718 history
: expect
.any(CircularArray
)
722 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
723 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
726 if (workerNode
.usage
.runTime
.aggregate
== null) {
727 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
729 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
731 if (workerNode
.usage
.waitTime
.aggregate
== null) {
732 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
734 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
737 // We need to clean up the resources after our test
741 it('Verify LEAST_ELU strategy default policy', async () => {
742 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
743 let pool
= new FixedThreadPool(
745 './tests/worker-files/thread/testWorker.js',
746 { workerChoiceStrategy
}
748 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
749 dynamicWorkerUsage
: false,
750 dynamicWorkerReady
: true
753 pool
= new DynamicThreadPool(
756 './tests/worker-files/thread/testWorker.js',
757 { workerChoiceStrategy
}
759 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
760 dynamicWorkerUsage
: false,
761 dynamicWorkerReady
: true
763 // We need to clean up the resources after our test
767 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
768 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
769 let pool
= new FixedThreadPool(
771 './tests/worker-files/thread/testWorker.js',
772 { workerChoiceStrategy
}
775 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
794 pool
= new DynamicThreadPool(
797 './tests/worker-files/thread/testWorker.js',
798 { workerChoiceStrategy
}
801 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
819 // We need to clean up the resources after our test
823 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
824 const pool
= new FixedThreadPool(
826 './tests/worker-files/thread/testWorker.js',
827 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
829 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
830 const promises
= new Set()
831 const maxMultiplier
= 2
832 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
833 promises
.add(pool
.execute())
835 await Promise
.all(promises
)
836 for (const workerNode
of pool
.workerNodes
) {
837 expect(workerNode
.usage
).toMatchObject({
839 executed
: expect
.any(Number
),
847 history
: expect
.any(CircularArray
)
850 history
: expect
.any(CircularArray
)
854 history
: expect
.any(CircularArray
)
857 history
: expect
.any(CircularArray
)
861 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
862 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
865 if (workerNode
.usage
.elu
.utilization
== null) {
866 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
868 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
869 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
872 // We need to clean up the resources after our test
876 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
877 const pool
= new DynamicThreadPool(
880 './tests/worker-files/thread/testWorker.js',
881 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
883 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
884 const promises
= new Set()
885 const maxMultiplier
= 2
886 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
887 promises
.add(pool
.execute())
889 await Promise
.all(promises
)
890 for (const workerNode
of pool
.workerNodes
) {
891 expect(workerNode
.usage
).toMatchObject({
893 executed
: expect
.any(Number
),
901 history
: expect
.any(CircularArray
)
904 history
: expect
.any(CircularArray
)
908 history
: expect
.any(CircularArray
)
911 history
: expect
.any(CircularArray
)
915 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
916 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
919 if (workerNode
.usage
.elu
.utilization
== null) {
920 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
922 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
923 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
926 // We need to clean up the resources after our test
930 it('Verify FAIR_SHARE strategy default policy', async () => {
931 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
932 let pool
= new FixedThreadPool(
934 './tests/worker-files/thread/testWorker.js',
935 { workerChoiceStrategy
}
937 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
938 dynamicWorkerUsage
: false,
939 dynamicWorkerReady
: true
942 pool
= new DynamicThreadPool(
945 './tests/worker-files/thread/testWorker.js',
946 { workerChoiceStrategy
}
948 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
949 dynamicWorkerUsage
: false,
950 dynamicWorkerReady
: true
952 // We need to clean up the resources after our test
956 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
957 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
958 let pool
= new FixedThreadPool(
960 './tests/worker-files/thread/testWorker.js',
961 { workerChoiceStrategy
}
964 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
983 pool
= new DynamicThreadPool(
986 './tests/worker-files/thread/testWorker.js',
987 { workerChoiceStrategy
}
990 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1008 // We need to clean up the resources after our test
1009 await pool
.destroy()
1012 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
1013 const pool
= new FixedThreadPool(
1015 './tests/worker-files/thread/testWorker.js',
1016 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1018 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1019 const promises
= new Set()
1020 const maxMultiplier
= 2
1021 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1022 promises
.add(pool
.execute())
1024 await Promise
.all(promises
)
1025 for (const workerNode
of pool
.workerNodes
) {
1026 expect(workerNode
.usage
).toMatchObject({
1028 executed
: expect
.any(Number
),
1036 history
: expect
.any(CircularArray
)
1039 history
: expect
.any(CircularArray
)
1043 history
: expect
.any(CircularArray
)
1046 history
: expect
.any(CircularArray
)
1050 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1051 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1054 if (workerNode
.usage
.runTime
.aggregate
== null) {
1055 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1057 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1059 if (workerNode
.usage
.runTime
.average
== null) {
1060 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1062 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1064 if (workerNode
.usage
.elu
.utilization
== null) {
1065 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1067 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1068 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1072 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1073 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1074 ).workersVirtualTaskEndTimestamp
.length
1075 ).toBe(pool
.workerNodes
.length
)
1076 // We need to clean up the resources after our test
1077 await pool
.destroy()
1080 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1081 const pool
= new DynamicThreadPool(
1084 './tests/worker-files/thread/testWorker.js',
1085 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1087 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1088 const promises
= new Set()
1089 const maxMultiplier
= 2
1090 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1091 promises
.add(pool
.execute())
1093 await Promise
.all(promises
)
1094 for (const workerNode
of pool
.workerNodes
) {
1095 expect(workerNode
.usage
).toMatchObject({
1097 executed
: expect
.any(Number
),
1105 history
: expect
.any(CircularArray
)
1108 history
: expect
.any(CircularArray
)
1112 history
: expect
.any(CircularArray
)
1115 history
: expect
.any(CircularArray
)
1119 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1120 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1123 if (workerNode
.usage
.runTime
.aggregate
== null) {
1124 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1126 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1128 if (workerNode
.usage
.runTime
.average
== null) {
1129 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1131 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1133 if (workerNode
.usage
.elu
.utilization
== null) {
1134 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1136 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1137 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1141 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1142 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1143 ).workersVirtualTaskEndTimestamp
.length
1144 ).toBe(pool
.workerNodes
.length
)
1145 // We need to clean up the resources after our test
1146 await pool
.destroy()
1149 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1150 const pool
= new DynamicThreadPool(
1153 './tests/worker-files/thread/testWorker.js',
1155 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1156 workerChoiceStrategyOptions
: {
1157 runTime
: { median
: true }
1161 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1162 const promises
= new Set()
1163 const maxMultiplier
= 2
1164 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1165 promises
.add(pool
.execute())
1167 await Promise
.all(promises
)
1168 for (const workerNode
of pool
.workerNodes
) {
1169 expect(workerNode
.usage
).toMatchObject({
1171 executed
: expect
.any(Number
),
1179 history
: expect
.any(CircularArray
)
1182 history
: expect
.any(CircularArray
)
1186 history
: expect
.any(CircularArray
)
1189 history
: expect
.any(CircularArray
)
1193 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1194 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1197 if (workerNode
.usage
.runTime
.aggregate
== null) {
1198 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1200 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1202 if (workerNode
.usage
.runTime
.median
== null) {
1203 expect(workerNode
.usage
.runTime
.median
).toBeUndefined()
1205 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1207 if (workerNode
.usage
.elu
.utilization
== null) {
1208 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1210 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1211 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1215 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1216 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1217 ).workersVirtualTaskEndTimestamp
.length
1218 ).toBe(pool
.workerNodes
.length
)
1219 // We need to clean up the resources after our test
1220 await pool
.destroy()
1223 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1224 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1225 let pool
= new FixedThreadPool(
1227 './tests/worker-files/thread/testWorker.js'
1230 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1231 workerChoiceStrategy
1232 ).workersVirtualTaskEndTimestamp
1233 ).toBeInstanceOf(Array
)
1235 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1236 workerChoiceStrategy
1237 ).workersVirtualTaskEndTimestamp
.length
1239 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1240 workerChoiceStrategy
1241 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1243 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1244 workerChoiceStrategy
1245 ).workersVirtualTaskEndTimestamp
.length
1247 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1249 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1250 workerChoiceStrategy
1251 ).workersVirtualTaskEndTimestamp
1252 ).toBeInstanceOf(Array
)
1254 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1255 workerChoiceStrategy
1256 ).workersVirtualTaskEndTimestamp
.length
1258 await pool
.destroy()
1259 pool
= new DynamicThreadPool(
1262 './tests/worker-files/thread/testWorker.js'
1265 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1266 workerChoiceStrategy
1267 ).workersVirtualTaskEndTimestamp
1268 ).toBeInstanceOf(Array
)
1270 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1271 workerChoiceStrategy
1272 ).workersVirtualTaskEndTimestamp
.length
1274 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1275 workerChoiceStrategy
1276 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1278 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1279 workerChoiceStrategy
1280 ).workersVirtualTaskEndTimestamp
.length
1282 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1284 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1285 workerChoiceStrategy
1286 ).workersVirtualTaskEndTimestamp
1287 ).toBeInstanceOf(Array
)
1289 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1290 workerChoiceStrategy
1291 ).workersVirtualTaskEndTimestamp
.length
1293 // We need to clean up the resources after our test
1294 await pool
.destroy()
1297 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1298 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1299 let pool
= new FixedThreadPool(
1301 './tests/worker-files/thread/testWorker.js',
1302 { workerChoiceStrategy
}
1304 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1305 dynamicWorkerUsage
: false,
1306 dynamicWorkerReady
: true
1308 await pool
.destroy()
1309 pool
= new DynamicThreadPool(
1312 './tests/worker-files/thread/testWorker.js',
1313 { workerChoiceStrategy
}
1315 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1316 dynamicWorkerUsage
: false,
1317 dynamicWorkerReady
: true
1319 // We need to clean up the resources after our test
1320 await pool
.destroy()
1323 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1324 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1325 let pool
= new FixedThreadPool(
1327 './tests/worker-files/thread/testWorker.js',
1328 { workerChoiceStrategy
}
1331 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1349 await pool
.destroy()
1350 pool
= new DynamicThreadPool(
1353 './tests/worker-files/thread/testWorker.js',
1354 { workerChoiceStrategy
}
1357 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1375 // We need to clean up the resources after our test
1376 await pool
.destroy()
1379 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1380 const pool
= new FixedThreadPool(
1382 './tests/worker-files/thread/testWorker.js',
1383 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1385 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1386 const promises
= new Set()
1387 const maxMultiplier
= 2
1388 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1389 promises
.add(pool
.execute())
1391 await Promise
.all(promises
)
1392 for (const workerNode
of pool
.workerNodes
) {
1393 expect(workerNode
.usage
).toStrictEqual({
1395 executed
: expect
.any(Number
),
1402 runTime
: expect
.objectContaining({
1403 history
: expect
.any(CircularArray
)
1406 history
: expect
.any(CircularArray
)
1410 history
: expect
.any(CircularArray
)
1413 history
: expect
.any(CircularArray
)
1417 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1418 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1421 if (workerNode
.usage
.runTime
.aggregate
== null) {
1422 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1424 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1426 if (workerNode
.usage
.runTime
.average
== null) {
1427 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1429 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1433 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1434 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1435 ).defaultWorkerWeight
1436 ).toBeGreaterThan(0)
1438 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1439 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1440 ).workerVirtualTaskRunTime
1441 ).toBeGreaterThanOrEqual(0)
1442 // We need to clean up the resources after our test
1443 await pool
.destroy()
1446 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1447 const pool
= new DynamicThreadPool(
1450 './tests/worker-files/thread/testWorker.js',
1451 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1453 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1454 const promises
= new Set()
1455 const maxMultiplier
= 2
1456 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1457 promises
.add(pool
.execute())
1459 await Promise
.all(promises
)
1460 for (const workerNode
of pool
.workerNodes
) {
1461 expect(workerNode
.usage
).toStrictEqual({
1463 executed
: expect
.any(Number
),
1470 runTime
: expect
.objectContaining({
1471 history
: expect
.any(CircularArray
)
1474 history
: expect
.any(CircularArray
)
1478 history
: expect
.any(CircularArray
)
1481 history
: expect
.any(CircularArray
)
1485 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1486 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1489 if (workerNode
.usage
.runTime
.aggregate
== null) {
1490 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1492 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1494 if (workerNode
.usage
.runTime
.average
== null) {
1495 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1497 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1501 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1502 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1503 ).defaultWorkerWeight
1504 ).toBeGreaterThan(0)
1506 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1507 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1508 ).workerVirtualTaskRunTime
1509 ).toBeGreaterThanOrEqual(0)
1510 // We need to clean up the resources after our test
1511 await pool
.destroy()
1514 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1515 const pool
= new DynamicThreadPool(
1518 './tests/worker-files/thread/testWorker.js',
1520 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1521 workerChoiceStrategyOptions
: {
1522 runTime
: { median
: true }
1526 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1527 const promises
= new Set()
1528 const maxMultiplier
= 2
1529 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1530 promises
.add(pool
.execute())
1532 await Promise
.all(promises
)
1533 for (const workerNode
of pool
.workerNodes
) {
1534 expect(workerNode
.usage
).toStrictEqual({
1536 executed
: expect
.any(Number
),
1543 runTime
: expect
.objectContaining({
1544 history
: expect
.any(CircularArray
)
1547 history
: expect
.any(CircularArray
)
1551 history
: expect
.any(CircularArray
)
1554 history
: expect
.any(CircularArray
)
1558 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1559 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1562 if (workerNode
.usage
.runTime
.aggregate
== null) {
1563 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1565 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1567 if (workerNode
.usage
.runTime
.median
== null) {
1568 expect(workerNode
.usage
.runTime
.median
).toBeUndefined()
1570 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1574 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1575 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1576 ).defaultWorkerWeight
1577 ).toBeGreaterThan(0)
1579 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1580 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1581 ).workerVirtualTaskRunTime
1582 ).toBeGreaterThanOrEqual(0)
1583 // We need to clean up the resources after our test
1584 await pool
.destroy()
1587 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1588 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1589 let pool
= new FixedThreadPool(
1591 './tests/worker-files/thread/testWorker.js'
1594 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1595 workerChoiceStrategy
1599 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1600 workerChoiceStrategy
1601 ).defaultWorkerWeight
1604 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1605 workerChoiceStrategy
1606 ).workerVirtualTaskRunTime
1608 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1610 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1611 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1615 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1616 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1617 ).defaultWorkerWeight
1618 ).toBeGreaterThan(0)
1620 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1621 workerChoiceStrategy
1622 ).workerVirtualTaskRunTime
1624 await pool
.destroy()
1625 pool
= new DynamicThreadPool(
1628 './tests/worker-files/thread/testWorker.js'
1631 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1632 workerChoiceStrategy
1636 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1637 workerChoiceStrategy
1638 ).defaultWorkerWeight
1641 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1642 workerChoiceStrategy
1643 ).workerVirtualTaskRunTime
1645 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1647 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1648 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1652 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1653 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1654 ).defaultWorkerWeight
1655 ).toBeGreaterThan(0)
1657 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1658 workerChoiceStrategy
1659 ).workerVirtualTaskRunTime
1661 // We need to clean up the resources after our test
1662 await pool
.destroy()
1665 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1666 const workerChoiceStrategy
=
1667 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1668 let pool
= new FixedThreadPool(
1670 './tests/worker-files/thread/testWorker.js',
1671 { workerChoiceStrategy
}
1673 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1674 dynamicWorkerUsage
: false,
1675 dynamicWorkerReady
: true
1677 await pool
.destroy()
1678 pool
= new DynamicThreadPool(
1681 './tests/worker-files/thread/testWorker.js',
1682 { workerChoiceStrategy
}
1684 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1685 dynamicWorkerUsage
: false,
1686 dynamicWorkerReady
: true
1688 // We need to clean up the resources after our test
1689 await pool
.destroy()
1692 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1693 const workerChoiceStrategy
=
1694 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1695 let pool
= new FixedThreadPool(
1697 './tests/worker-files/thread/testWorker.js',
1698 { workerChoiceStrategy
}
1701 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1719 await pool
.destroy()
1720 pool
= new DynamicThreadPool(
1723 './tests/worker-files/thread/testWorker.js',
1724 { workerChoiceStrategy
}
1727 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1745 // We need to clean up the resources after our test
1746 await pool
.destroy()
1749 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1750 const pool
= new FixedThreadPool(
1752 './tests/worker-files/thread/testWorker.js',
1754 workerChoiceStrategy
:
1755 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1758 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1759 const promises
= new Set()
1760 const maxMultiplier
= 2
1761 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1762 promises
.add(pool
.execute())
1764 await Promise
.all(promises
)
1765 for (const workerNode
of pool
.workerNodes
) {
1766 expect(workerNode
.usage
).toStrictEqual({
1768 executed
: maxMultiplier
,
1776 history
: expect
.any(CircularArray
)
1779 history
: expect
.any(CircularArray
)
1783 history
: expect
.any(CircularArray
)
1786 history
: expect
.any(CircularArray
)
1792 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1793 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1794 ).defaultWorkerWeight
1795 ).toBeGreaterThan(0)
1797 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1798 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1802 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1803 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1807 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1808 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1811 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1812 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1813 ).defaultWorkerWeight
1815 // We need to clean up the resources after our test
1816 await pool
.destroy()
1819 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1820 const pool
= new DynamicThreadPool(
1823 './tests/worker-files/thread/testWorker.js',
1825 workerChoiceStrategy
:
1826 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1829 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1830 const promises
= new Set()
1831 const maxMultiplier
= 2
1832 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1833 promises
.add(pool
.execute())
1835 await Promise
.all(promises
)
1836 for (const workerNode
of pool
.workerNodes
) {
1837 expect(workerNode
.usage
).toStrictEqual({
1839 executed
: expect
.any(Number
),
1847 history
: expect
.any(CircularArray
)
1850 history
: expect
.any(CircularArray
)
1854 history
: expect
.any(CircularArray
)
1857 history
: expect
.any(CircularArray
)
1861 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1862 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1867 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1868 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1869 ).defaultWorkerWeight
1870 ).toBeGreaterThan(0)
1872 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1873 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1877 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1878 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1882 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1883 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1886 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1887 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1888 ).defaultWorkerWeight
1890 // We need to clean up the resources after our test
1891 await pool
.destroy()
1894 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1895 const workerChoiceStrategy
=
1896 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1897 let pool
= new FixedThreadPool(
1899 './tests/worker-files/thread/testWorker.js'
1902 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1903 workerChoiceStrategy
1907 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1908 workerChoiceStrategy
1912 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1913 workerChoiceStrategy
1914 ).defaultWorkerWeight
1917 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1918 workerChoiceStrategy
1921 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1923 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1924 workerChoiceStrategy
1928 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1929 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1933 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1934 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1935 ).defaultWorkerWeight
1936 ).toBeGreaterThan(0)
1938 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1939 workerChoiceStrategy
1942 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1943 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1944 ).defaultWorkerWeight
1946 await pool
.destroy()
1947 pool
= new DynamicThreadPool(
1950 './tests/worker-files/thread/testWorker.js'
1953 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1954 workerChoiceStrategy
1958 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1959 workerChoiceStrategy
1963 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1964 workerChoiceStrategy
1965 ).defaultWorkerWeight
1968 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1969 workerChoiceStrategy
1972 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1974 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1975 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1979 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1980 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1981 ).defaultWorkerWeight
1982 ).toBeGreaterThan(0)
1984 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1985 workerChoiceStrategy
1988 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1989 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1990 ).defaultWorkerWeight
1992 // We need to clean up the resources after our test
1993 await pool
.destroy()
1996 it('Verify unknown strategy throw error', () => {
1999 new DynamicThreadPool(
2002 './tests/worker-files/thread/testWorker.js',
2003 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
2005 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")