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
.workerUsage
).toStrictEqual({
214 executed
: maxMultiplier
,
223 history
: expect
.any(CircularArray
)
229 history
: expect
.any(CircularArray
)
236 history
: expect
.any(CircularArray
)
242 history
: expect
.any(CircularArray
)
249 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
250 WorkerChoiceStrategies
.ROUND_ROBIN
253 // We need to clean up the resources after our test
257 it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
258 const pool
= new DynamicThreadPool(
261 './tests/worker-files/thread/testWorker.js',
262 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
264 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
265 const promises
= new Set()
266 const maxMultiplier
= 2
267 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
268 promises
.add(pool
.execute())
270 await Promise
.all(promises
)
271 for (const workerNode
of pool
.workerNodes
) {
272 expect(workerNode
.workerUsage
).toStrictEqual({
274 executed
: maxMultiplier
,
283 history
: expect
.any(CircularArray
)
289 history
: expect
.any(CircularArray
)
296 history
: expect
.any(CircularArray
)
302 history
: expect
.any(CircularArray
)
309 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
310 WorkerChoiceStrategies
.ROUND_ROBIN
313 // We need to clean up the resources after our test
317 it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
318 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
319 let pool
= new FixedClusterPool(
321 './tests/worker-files/cluster/testWorker.js',
322 { workerChoiceStrategy
}
324 let results
= new Set()
325 for (let i
= 0; i
< max
; i
++) {
326 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.id
)
328 expect(results
.size
).toBe(max
)
330 pool
= new FixedThreadPool(
332 './tests/worker-files/thread/testWorker.js',
333 { workerChoiceStrategy
}
336 for (let i
= 0; i
< max
; i
++) {
337 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.threadId
)
339 expect(results
.size
).toBe(max
)
343 it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
344 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
345 let pool
= new FixedThreadPool(
347 './tests/worker-files/thread/testWorker.js',
348 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
351 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
355 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
357 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
358 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
362 pool
= new DynamicThreadPool(
365 './tests/worker-files/thread/testWorker.js',
366 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
369 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
373 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
375 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
376 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
379 // We need to clean up the resources after our test
383 it('Verify LEAST_USED strategy default policy', async () => {
384 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
385 let pool
= new FixedThreadPool(
387 './tests/worker-files/thread/testWorker.js',
388 { workerChoiceStrategy
}
390 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
391 useDynamicWorker
: false
394 pool
= new DynamicThreadPool(
397 './tests/worker-files/thread/testWorker.js',
398 { workerChoiceStrategy
}
400 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
401 useDynamicWorker
: false
403 // We need to clean up the resources after our test
407 it('Verify LEAST_USED strategy default tasks statistics requirements', async () => {
408 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
409 let pool
= new FixedThreadPool(
411 './tests/worker-files/thread/testWorker.js',
412 { workerChoiceStrategy
}
415 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
434 pool
= new DynamicThreadPool(
437 './tests/worker-files/thread/testWorker.js',
438 { workerChoiceStrategy
}
441 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
459 // We need to clean up the resources after our test
463 it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
464 const pool
= new FixedThreadPool(
466 './tests/worker-files/thread/testWorker.js',
467 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
469 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
470 const promises
= new Set()
471 const maxMultiplier
= 2
472 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
473 promises
.add(pool
.execute())
475 await Promise
.all(promises
)
476 for (const workerNode
of pool
.workerNodes
) {
477 expect(workerNode
.workerUsage
).toStrictEqual({
479 executed
: expect
.any(Number
),
488 history
: expect
.any(CircularArray
)
494 history
: expect
.any(CircularArray
)
501 history
: expect
.any(CircularArray
)
507 history
: expect
.any(CircularArray
)
512 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
513 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
517 // We need to clean up the resources after our test
521 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
522 const pool
= new DynamicThreadPool(
525 './tests/worker-files/thread/testWorker.js',
526 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
528 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
529 const promises
= new Set()
530 const maxMultiplier
= 2
531 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
532 promises
.add(pool
.execute())
534 await Promise
.all(promises
)
535 for (const workerNode
of pool
.workerNodes
) {
536 expect(workerNode
.workerUsage
).toStrictEqual({
538 executed
: expect
.any(Number
),
547 history
: expect
.any(CircularArray
)
553 history
: expect
.any(CircularArray
)
560 history
: expect
.any(CircularArray
)
566 history
: expect
.any(CircularArray
)
571 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
572 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
576 // We need to clean up the resources after our test
580 it('Verify LEAST_BUSY strategy default policy', async () => {
581 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
582 let pool
= new FixedThreadPool(
584 './tests/worker-files/thread/testWorker.js',
585 { workerChoiceStrategy
}
587 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
588 useDynamicWorker
: false
591 pool
= new DynamicThreadPool(
594 './tests/worker-files/thread/testWorker.js',
595 { workerChoiceStrategy
}
597 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
598 useDynamicWorker
: false
600 // We need to clean up the resources after our test
604 it('Verify LEAST_BUSY strategy default tasks statistics requirements', async () => {
605 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
606 let pool
= new FixedThreadPool(
608 './tests/worker-files/thread/testWorker.js',
609 { workerChoiceStrategy
}
612 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
631 pool
= new DynamicThreadPool(
634 './tests/worker-files/thread/testWorker.js',
635 { workerChoiceStrategy
}
638 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
656 // We need to clean up the resources after our test
660 it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
661 const pool
= new FixedThreadPool(
663 './tests/worker-files/thread/testWorker.js',
664 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
666 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
667 const promises
= new Set()
668 const maxMultiplier
= 2
669 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
670 promises
.add(pool
.execute())
672 await Promise
.all(promises
)
673 for (const workerNode
of pool
.workerNodes
) {
674 expect(workerNode
.workerUsage
).toStrictEqual({
676 executed
: expect
.any(Number
),
682 aggregate
: expect
.any(Number
),
685 history
: expect
.any(CircularArray
)
688 aggregate
: expect
.any(Number
),
691 history
: expect
.any(CircularArray
)
698 history
: expect
.any(CircularArray
)
704 history
: expect
.any(CircularArray
)
709 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
710 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
713 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
714 expect(workerNode
.workerUsage
.waitTime
.aggregate
).toBeGreaterThanOrEqual(
718 // We need to clean up the resources after our test
722 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
723 const pool
= new DynamicThreadPool(
726 './tests/worker-files/thread/testWorker.js',
727 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
729 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
730 const promises
= new Set()
731 const maxMultiplier
= 2
732 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
733 promises
.add(pool
.execute())
735 await Promise
.all(promises
)
736 for (const workerNode
of pool
.workerNodes
) {
737 expect(workerNode
.workerUsage
).toStrictEqual({
739 executed
: expect
.any(Number
),
745 aggregate
: expect
.any(Number
),
748 history
: expect
.any(CircularArray
)
751 aggregate
: expect
.any(Number
),
754 history
: expect
.any(CircularArray
)
761 history
: expect
.any(CircularArray
)
767 history
: expect
.any(CircularArray
)
772 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
773 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
776 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
777 expect(workerNode
.workerUsage
.waitTime
.aggregate
).toBeGreaterThanOrEqual(
781 // We need to clean up the resources after our test
785 it('Verify LEAST_ELU strategy default policy', async () => {
786 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
787 let pool
= new FixedThreadPool(
789 './tests/worker-files/thread/testWorker.js',
790 { workerChoiceStrategy
}
792 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
793 useDynamicWorker
: false
796 pool
= new DynamicThreadPool(
799 './tests/worker-files/thread/testWorker.js',
800 { workerChoiceStrategy
}
802 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
803 useDynamicWorker
: false
805 // We need to clean up the resources after our test
809 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
810 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
811 let pool
= new FixedThreadPool(
813 './tests/worker-files/thread/testWorker.js',
814 { workerChoiceStrategy
}
817 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
836 pool
= new DynamicThreadPool(
839 './tests/worker-files/thread/testWorker.js',
840 { workerChoiceStrategy
}
843 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
861 // We need to clean up the resources after our test
865 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
866 const pool
= new FixedThreadPool(
868 './tests/worker-files/thread/testWorker.js',
869 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
871 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
872 const promises
= new Set()
873 const maxMultiplier
= 2
874 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
875 promises
.add(pool
.execute())
877 await Promise
.all(promises
)
878 for (const workerNode
of pool
.workerNodes
) {
879 expect(workerNode
.workerUsage
).toStrictEqual({
881 executed
: expect
.any(Number
),
890 history
: expect
.any(CircularArray
)
896 history
: expect
.any(CircularArray
)
903 history
: expect
.any(CircularArray
)
906 aggregate
: expect
.any(Number
),
909 history
: expect
.any(CircularArray
)
911 utilization
: expect
.any(Number
)
914 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
915 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
918 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
919 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
921 // We need to clean up the resources after our test
925 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
926 const pool
= new DynamicThreadPool(
929 './tests/worker-files/thread/testWorker.js',
930 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
932 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
933 const promises
= new Set()
934 const maxMultiplier
= 2
935 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
936 promises
.add(pool
.execute())
938 await Promise
.all(promises
)
939 for (const workerNode
of pool
.workerNodes
) {
940 expect(workerNode
.workerUsage
).toStrictEqual({
942 executed
: expect
.any(Number
),
951 history
: expect
.any(CircularArray
)
957 history
: expect
.any(CircularArray
)
964 history
: expect
.any(CircularArray
)
967 aggregate
: expect
.any(Number
),
970 history
: expect
.any(CircularArray
)
972 utilization
: expect
.any(Number
)
975 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
976 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
979 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
980 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
982 // We need to clean up the resources after our test
986 it('Verify FAIR_SHARE strategy default policy', async () => {
987 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
988 let pool
= new FixedThreadPool(
990 './tests/worker-files/thread/testWorker.js',
991 { workerChoiceStrategy
}
993 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
994 useDynamicWorker
: false
997 pool
= new DynamicThreadPool(
1000 './tests/worker-files/thread/testWorker.js',
1001 { workerChoiceStrategy
}
1003 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1004 useDynamicWorker
: false
1006 // We need to clean up the resources after our test
1007 await pool
.destroy()
1010 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
1011 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1012 let pool
= new FixedThreadPool(
1014 './tests/worker-files/thread/testWorker.js',
1015 { workerChoiceStrategy
}
1018 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1036 await pool
.destroy()
1037 pool
= new DynamicThreadPool(
1040 './tests/worker-files/thread/testWorker.js',
1041 { workerChoiceStrategy
}
1044 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1062 // We need to clean up the resources after our test
1063 await pool
.destroy()
1066 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
1067 const pool
= new FixedThreadPool(
1069 './tests/worker-files/thread/testWorker.js',
1070 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1072 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1073 const promises
= new Set()
1074 const maxMultiplier
= 2
1075 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1076 promises
.add(pool
.execute())
1078 await Promise
.all(promises
)
1079 for (const workerNode
of pool
.workerNodes
) {
1080 expect(workerNode
.workerUsage
).toStrictEqual({
1082 executed
: expect
.any(Number
),
1088 aggregate
: expect
.any(Number
),
1089 average
: expect
.any(Number
),
1091 history
: expect
.any(CircularArray
)
1097 history
: expect
.any(CircularArray
)
1104 history
: expect
.any(CircularArray
)
1107 aggregate
: expect
.any(Number
),
1108 average
: expect
.any(Number
),
1110 history
: expect
.any(CircularArray
)
1112 utilization
: expect
.any(Number
)
1115 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1116 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1119 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1120 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1121 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1122 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
1125 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1126 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1127 ).workersVirtualTaskEndTimestamp
.length
1128 ).toBe(pool
.workerNodes
.length
)
1129 // We need to clean up the resources after our test
1130 await pool
.destroy()
1133 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1134 const pool
= new DynamicThreadPool(
1137 './tests/worker-files/thread/testWorker.js',
1138 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1140 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1141 const promises
= new Set()
1142 const maxMultiplier
= 2
1143 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1144 promises
.add(pool
.execute())
1146 await Promise
.all(promises
)
1147 for (const workerNode
of pool
.workerNodes
) {
1148 expect(workerNode
.workerUsage
).toStrictEqual({
1150 executed
: expect
.any(Number
),
1156 aggregate
: expect
.any(Number
),
1157 average
: expect
.any(Number
),
1159 history
: expect
.any(CircularArray
)
1165 history
: expect
.any(CircularArray
)
1172 history
: expect
.any(CircularArray
)
1175 aggregate
: expect
.any(Number
),
1176 average
: expect
.any(Number
),
1178 history
: expect
.any(CircularArray
)
1180 utilization
: expect
.any(Number
)
1183 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1184 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1187 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1188 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1189 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1190 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
1193 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1194 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1195 ).workersVirtualTaskEndTimestamp
.length
1196 ).toBe(pool
.workerNodes
.length
)
1197 // We need to clean up the resources after our test
1198 await pool
.destroy()
1201 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1202 const pool
= new DynamicThreadPool(
1205 './tests/worker-files/thread/testWorker.js',
1207 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1208 workerChoiceStrategyOptions
: {
1209 runTime
: { median
: true }
1213 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1214 const promises
= new Set()
1215 const maxMultiplier
= 2
1216 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1217 promises
.add(pool
.execute())
1219 await Promise
.all(promises
)
1220 for (const workerNode
of pool
.workerNodes
) {
1221 expect(workerNode
.workerUsage
).toStrictEqual({
1223 executed
: expect
.any(Number
),
1229 aggregate
: expect
.any(Number
),
1231 median
: expect
.any(Number
),
1232 history
: expect
.any(CircularArray
)
1238 history
: expect
.any(CircularArray
)
1245 history
: expect
.any(CircularArray
)
1248 aggregate
: expect
.any(Number
),
1249 average
: expect
.any(Number
),
1251 history
: expect
.any(CircularArray
)
1253 utilization
: expect
.any(Number
)
1256 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1257 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1260 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1261 expect(workerNode
.workerUsage
.runTime
.median
).toBeGreaterThanOrEqual(0)
1262 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1263 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
1266 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1267 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1268 ).workersVirtualTaskEndTimestamp
.length
1269 ).toBe(pool
.workerNodes
.length
)
1270 // We need to clean up the resources after our test
1271 await pool
.destroy()
1274 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1275 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1276 let pool
= new FixedThreadPool(
1278 './tests/worker-files/thread/testWorker.js'
1281 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1282 workerChoiceStrategy
1283 ).workersVirtualTaskEndTimestamp
1284 ).toBeInstanceOf(Array
)
1286 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1287 workerChoiceStrategy
1288 ).workersVirtualTaskEndTimestamp
.length
1290 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1291 workerChoiceStrategy
1292 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1294 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1295 workerChoiceStrategy
1296 ).workersVirtualTaskEndTimestamp
.length
1298 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1300 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1301 workerChoiceStrategy
1302 ).workersVirtualTaskEndTimestamp
1303 ).toBeInstanceOf(Array
)
1305 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1306 workerChoiceStrategy
1307 ).workersVirtualTaskEndTimestamp
.length
1309 await pool
.destroy()
1310 pool
= new DynamicThreadPool(
1313 './tests/worker-files/thread/testWorker.js'
1316 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1317 workerChoiceStrategy
1318 ).workersVirtualTaskEndTimestamp
1319 ).toBeInstanceOf(Array
)
1321 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1322 workerChoiceStrategy
1323 ).workersVirtualTaskEndTimestamp
.length
1325 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1326 workerChoiceStrategy
1327 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1329 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1330 workerChoiceStrategy
1331 ).workersVirtualTaskEndTimestamp
.length
1333 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1335 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1336 workerChoiceStrategy
1337 ).workersVirtualTaskEndTimestamp
1338 ).toBeInstanceOf(Array
)
1340 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1341 workerChoiceStrategy
1342 ).workersVirtualTaskEndTimestamp
.length
1344 // We need to clean up the resources after our test
1345 await pool
.destroy()
1348 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1349 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1350 let pool
= new FixedThreadPool(
1352 './tests/worker-files/thread/testWorker.js',
1353 { workerChoiceStrategy
}
1355 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1356 useDynamicWorker
: true
1358 await pool
.destroy()
1359 pool
= new DynamicThreadPool(
1362 './tests/worker-files/thread/testWorker.js',
1363 { workerChoiceStrategy
}
1365 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1366 useDynamicWorker
: true
1368 // We need to clean up the resources after our test
1369 await pool
.destroy()
1372 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1373 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1374 let pool
= new FixedThreadPool(
1376 './tests/worker-files/thread/testWorker.js',
1377 { workerChoiceStrategy
}
1380 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1398 await pool
.destroy()
1399 pool
= new DynamicThreadPool(
1402 './tests/worker-files/thread/testWorker.js',
1403 { workerChoiceStrategy
}
1406 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1424 // We need to clean up the resources after our test
1425 await pool
.destroy()
1428 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1429 const pool
= new FixedThreadPool(
1431 './tests/worker-files/thread/testWorker.js',
1432 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1434 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1435 const promises
= new Set()
1436 const maxMultiplier
= 2
1437 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1438 promises
.add(pool
.execute())
1440 await Promise
.all(promises
)
1441 for (const workerNode
of pool
.workerNodes
) {
1442 expect(workerNode
.workerUsage
).toStrictEqual({
1444 executed
: expect
.any(Number
),
1450 aggregate
: expect
.any(Number
),
1451 average
: expect
.any(Number
),
1453 history
: expect
.any(CircularArray
)
1459 history
: expect
.any(CircularArray
)
1466 history
: expect
.any(CircularArray
)
1472 history
: expect
.any(CircularArray
)
1477 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1478 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1481 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1482 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1485 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1486 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1487 ).defaultWorkerWeight
1488 ).toBeGreaterThan(0)
1490 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1491 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1492 ).workerVirtualTaskRunTime
1493 ).toBeGreaterThanOrEqual(0)
1494 // We need to clean up the resources after our test
1495 await pool
.destroy()
1498 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1499 const pool
= new DynamicThreadPool(
1502 './tests/worker-files/thread/testWorker.js',
1503 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1505 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1506 const promises
= new Set()
1507 const maxMultiplier
= 2
1508 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1509 promises
.add(pool
.execute())
1511 await Promise
.all(promises
)
1512 for (const workerNode
of pool
.workerNodes
) {
1513 expect(workerNode
.workerUsage
).toStrictEqual({
1515 executed
: expect
.any(Number
),
1521 aggregate
: expect
.any(Number
),
1522 average
: expect
.any(Number
),
1524 history
: expect
.any(CircularArray
)
1530 history
: expect
.any(CircularArray
)
1537 history
: expect
.any(CircularArray
)
1543 history
: expect
.any(CircularArray
)
1548 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1549 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1552 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThan(0)
1553 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThan(0)
1556 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1557 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1558 ).defaultWorkerWeight
1559 ).toBeGreaterThan(0)
1561 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1562 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1563 ).workerVirtualTaskRunTime
1564 ).toBeGreaterThanOrEqual(0)
1565 // We need to clean up the resources after our test
1566 await pool
.destroy()
1569 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1570 const pool
= new DynamicThreadPool(
1573 './tests/worker-files/thread/testWorker.js',
1575 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1576 workerChoiceStrategyOptions
: {
1577 runTime
: { median
: true }
1581 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1582 const promises
= new Set()
1583 const maxMultiplier
= 2
1584 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1585 promises
.add(pool
.execute())
1587 await Promise
.all(promises
)
1588 for (const workerNode
of pool
.workerNodes
) {
1589 expect(workerNode
.workerUsage
).toStrictEqual({
1591 executed
: expect
.any(Number
),
1597 aggregate
: expect
.any(Number
),
1599 median
: expect
.any(Number
),
1600 history
: expect
.any(CircularArray
)
1606 history
: expect
.any(CircularArray
)
1613 history
: expect
.any(CircularArray
)
1619 history
: expect
.any(CircularArray
)
1624 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1625 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1628 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThan(0)
1629 expect(workerNode
.workerUsage
.runTime
.median
).toBeGreaterThan(0)
1632 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1633 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1634 ).defaultWorkerWeight
1635 ).toBeGreaterThan(0)
1637 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1638 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1639 ).workerVirtualTaskRunTime
1640 ).toBeGreaterThanOrEqual(0)
1641 // We need to clean up the resources after our test
1642 await pool
.destroy()
1645 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1646 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1647 let pool
= new FixedThreadPool(
1649 './tests/worker-files/thread/testWorker.js'
1652 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1653 workerChoiceStrategy
1657 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1658 workerChoiceStrategy
1659 ).defaultWorkerWeight
1662 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1663 workerChoiceStrategy
1664 ).workerVirtualTaskRunTime
1666 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1668 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1669 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1673 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1674 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1675 ).defaultWorkerWeight
1676 ).toBeGreaterThan(0)
1678 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1679 workerChoiceStrategy
1680 ).workerVirtualTaskRunTime
1682 await pool
.destroy()
1683 pool
= new DynamicThreadPool(
1686 './tests/worker-files/thread/testWorker.js'
1689 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1690 workerChoiceStrategy
1694 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1695 workerChoiceStrategy
1696 ).defaultWorkerWeight
1699 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1700 workerChoiceStrategy
1701 ).workerVirtualTaskRunTime
1703 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1705 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1706 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1710 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1711 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1712 ).defaultWorkerWeight
1713 ).toBeGreaterThan(0)
1715 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1716 workerChoiceStrategy
1717 ).workerVirtualTaskRunTime
1719 // We need to clean up the resources after our test
1720 await pool
.destroy()
1723 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1724 const workerChoiceStrategy
=
1725 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1726 let pool
= new FixedThreadPool(
1728 './tests/worker-files/thread/testWorker.js',
1729 { workerChoiceStrategy
}
1731 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1732 useDynamicWorker
: true
1734 await pool
.destroy()
1735 pool
= new DynamicThreadPool(
1738 './tests/worker-files/thread/testWorker.js',
1739 { workerChoiceStrategy
}
1741 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1742 useDynamicWorker
: true
1744 // We need to clean up the resources after our test
1745 await pool
.destroy()
1748 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1749 const workerChoiceStrategy
=
1750 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1751 let pool
= new FixedThreadPool(
1753 './tests/worker-files/thread/testWorker.js',
1754 { workerChoiceStrategy
}
1757 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1775 await pool
.destroy()
1776 pool
= new DynamicThreadPool(
1779 './tests/worker-files/thread/testWorker.js',
1780 { workerChoiceStrategy
}
1783 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1801 // We need to clean up the resources after our test
1802 await pool
.destroy()
1805 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1806 const pool
= new FixedThreadPool(
1808 './tests/worker-files/thread/testWorker.js',
1810 workerChoiceStrategy
:
1811 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1814 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1815 const promises
= new Set()
1816 const maxMultiplier
= 2
1817 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1818 promises
.add(pool
.execute())
1820 await Promise
.all(promises
)
1821 for (const workerNode
of pool
.workerNodes
) {
1822 expect(workerNode
.workerUsage
).toStrictEqual({
1824 executed
: maxMultiplier
,
1833 history
: expect
.any(CircularArray
)
1839 history
: expect
.any(CircularArray
)
1846 history
: expect
.any(CircularArray
)
1852 history
: expect
.any(CircularArray
)
1859 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1860 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1861 ).defaultWorkerWeight
1862 ).toBeGreaterThan(0)
1864 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1865 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1869 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1870 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1874 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1875 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1878 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1879 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1880 ).defaultWorkerWeight
1882 // We need to clean up the resources after our test
1883 await pool
.destroy()
1886 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1887 const pool
= new DynamicThreadPool(
1890 './tests/worker-files/thread/testWorker.js',
1892 workerChoiceStrategy
:
1893 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1896 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1897 const promises
= new Set()
1898 const maxMultiplier
= 2
1899 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1900 promises
.add(pool
.execute())
1902 await Promise
.all(promises
)
1903 for (const workerNode
of pool
.workerNodes
) {
1904 expect(workerNode
.workerUsage
).toStrictEqual({
1906 executed
: maxMultiplier
,
1915 history
: expect
.any(CircularArray
)
1921 history
: expect
.any(CircularArray
)
1928 history
: expect
.any(CircularArray
)
1934 history
: expect
.any(CircularArray
)
1941 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1942 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1943 ).defaultWorkerWeight
1944 ).toBeGreaterThan(0)
1946 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1947 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1951 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1952 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1956 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1957 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1960 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1961 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1962 ).defaultWorkerWeight
1964 // We need to clean up the resources after our test
1965 await pool
.destroy()
1968 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1969 const workerChoiceStrategy
=
1970 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1971 let pool
= new FixedThreadPool(
1973 './tests/worker-files/thread/testWorker.js'
1976 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1977 workerChoiceStrategy
1981 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1982 workerChoiceStrategy
1986 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1987 workerChoiceStrategy
1988 ).defaultWorkerWeight
1991 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1992 workerChoiceStrategy
1995 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1997 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1998 workerChoiceStrategy
2002 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2003 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2007 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2008 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2009 ).defaultWorkerWeight
2010 ).toBeGreaterThan(0)
2012 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2013 workerChoiceStrategy
2016 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2017 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2018 ).defaultWorkerWeight
2020 await pool
.destroy()
2021 pool
= new DynamicThreadPool(
2024 './tests/worker-files/thread/testWorker.js'
2027 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2028 workerChoiceStrategy
2032 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2033 workerChoiceStrategy
2037 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2038 workerChoiceStrategy
2039 ).defaultWorkerWeight
2042 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2043 workerChoiceStrategy
2046 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
2048 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2049 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2053 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2054 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2055 ).defaultWorkerWeight
2056 ).toBeGreaterThan(0)
2058 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2059 workerChoiceStrategy
2062 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2063 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2064 ).defaultWorkerWeight
2066 // We need to clean up the resources after our test
2067 await pool
.destroy()
2070 it('Verify unknown strategy throw error', () => {
2073 new DynamicThreadPool(
2076 './tests/worker-files/thread/testWorker.js',
2077 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
2079 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")