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
,
224 history
: expect
.any(CircularArray
)
230 history
: expect
.any(CircularArray
)
237 history
: expect
.any(CircularArray
)
243 history
: expect
.any(CircularArray
)
250 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
251 WorkerChoiceStrategies
.ROUND_ROBIN
254 // We need to clean up the resources after our test
258 it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
259 const pool
= new DynamicThreadPool(
262 './tests/worker-files/thread/testWorker.js',
263 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
265 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
266 const promises
= new Set()
267 const maxMultiplier
= 2
268 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
269 promises
.add(pool
.execute())
271 await Promise
.all(promises
)
272 for (const workerNode
of pool
.workerNodes
) {
273 expect(workerNode
.workerUsage
).toStrictEqual({
275 executed
: maxMultiplier
,
285 history
: expect
.any(CircularArray
)
291 history
: expect
.any(CircularArray
)
298 history
: expect
.any(CircularArray
)
304 history
: expect
.any(CircularArray
)
311 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
312 WorkerChoiceStrategies
.ROUND_ROBIN
315 // We need to clean up the resources after our test
319 it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
320 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
321 let pool
= new FixedClusterPool(
323 './tests/worker-files/cluster/testWorker.js',
324 { workerChoiceStrategy
}
326 let results
= new Set()
327 for (let i
= 0; i
< max
; i
++) {
328 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.id
)
330 expect(results
.size
).toBe(max
)
332 pool
= new FixedThreadPool(
334 './tests/worker-files/thread/testWorker.js',
335 { workerChoiceStrategy
}
338 for (let i
= 0; i
< max
; i
++) {
339 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.threadId
)
341 expect(results
.size
).toBe(max
)
345 it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
346 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
347 let pool
= new FixedThreadPool(
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
364 pool
= new DynamicThreadPool(
367 './tests/worker-files/thread/testWorker.js',
368 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
371 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
375 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
377 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
378 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
381 // We need to clean up the resources after our test
385 it('Verify LEAST_USED strategy default policy', async () => {
386 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
387 let pool
= new FixedThreadPool(
389 './tests/worker-files/thread/testWorker.js',
390 { workerChoiceStrategy
}
392 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
393 useDynamicWorker
: false
396 pool
= new DynamicThreadPool(
399 './tests/worker-files/thread/testWorker.js',
400 { workerChoiceStrategy
}
402 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
403 useDynamicWorker
: false
405 // We need to clean up the resources after our test
409 it('Verify LEAST_USED strategy default tasks statistics requirements', async () => {
410 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
411 let pool
= new FixedThreadPool(
413 './tests/worker-files/thread/testWorker.js',
414 { workerChoiceStrategy
}
417 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
436 pool
= new DynamicThreadPool(
439 './tests/worker-files/thread/testWorker.js',
440 { workerChoiceStrategy
}
443 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
461 // We need to clean up the resources after our test
465 it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
466 const pool
= new FixedThreadPool(
468 './tests/worker-files/thread/testWorker.js',
469 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
471 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
472 const promises
= new Set()
473 const maxMultiplier
= 2
474 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
475 promises
.add(pool
.execute())
477 await Promise
.all(promises
)
478 for (const workerNode
of pool
.workerNodes
) {
479 expect(workerNode
.workerUsage
).toStrictEqual({
481 executed
: expect
.any(Number
),
491 history
: expect
.any(CircularArray
)
497 history
: expect
.any(CircularArray
)
504 history
: expect
.any(CircularArray
)
510 history
: expect
.any(CircularArray
)
515 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
516 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
520 // We need to clean up the resources after our test
524 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
525 const pool
= new DynamicThreadPool(
528 './tests/worker-files/thread/testWorker.js',
529 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
531 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
532 const promises
= new Set()
533 const maxMultiplier
= 2
534 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
535 promises
.add(pool
.execute())
537 await Promise
.all(promises
)
538 for (const workerNode
of pool
.workerNodes
) {
539 expect(workerNode
.workerUsage
).toStrictEqual({
541 executed
: expect
.any(Number
),
551 history
: expect
.any(CircularArray
)
557 history
: expect
.any(CircularArray
)
564 history
: expect
.any(CircularArray
)
570 history
: expect
.any(CircularArray
)
575 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
576 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
580 // We need to clean up the resources after our test
584 it('Verify LEAST_BUSY strategy default policy', async () => {
585 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
586 let pool
= new FixedThreadPool(
588 './tests/worker-files/thread/testWorker.js',
589 { workerChoiceStrategy
}
591 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
592 useDynamicWorker
: false
595 pool
= new DynamicThreadPool(
598 './tests/worker-files/thread/testWorker.js',
599 { workerChoiceStrategy
}
601 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
602 useDynamicWorker
: false
604 // We need to clean up the resources after our test
608 it('Verify LEAST_BUSY strategy default tasks statistics requirements', async () => {
609 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
610 let pool
= new FixedThreadPool(
612 './tests/worker-files/thread/testWorker.js',
613 { workerChoiceStrategy
}
616 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
635 pool
= new DynamicThreadPool(
638 './tests/worker-files/thread/testWorker.js',
639 { workerChoiceStrategy
}
642 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
660 // We need to clean up the resources after our test
664 it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
665 const pool
= new FixedThreadPool(
667 './tests/worker-files/thread/testWorker.js',
668 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
670 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
671 const promises
= new Set()
672 const maxMultiplier
= 2
673 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
674 promises
.add(pool
.execute())
676 await Promise
.all(promises
)
677 for (const workerNode
of pool
.workerNodes
) {
678 expect(workerNode
.workerUsage
).toStrictEqual({
680 executed
: expect
.any(Number
),
687 aggregate
: expect
.any(Number
),
690 history
: expect
.any(CircularArray
)
693 aggregate
: expect
.any(Number
),
696 history
: expect
.any(CircularArray
)
703 history
: expect
.any(CircularArray
)
709 history
: expect
.any(CircularArray
)
714 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
715 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
718 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
719 expect(workerNode
.workerUsage
.waitTime
.aggregate
).toBeGreaterThanOrEqual(
723 // We need to clean up the resources after our test
727 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
728 const pool
= new DynamicThreadPool(
731 './tests/worker-files/thread/testWorker.js',
732 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
734 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
735 const promises
= new Set()
736 const maxMultiplier
= 2
737 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
738 promises
.add(pool
.execute())
740 await Promise
.all(promises
)
741 for (const workerNode
of pool
.workerNodes
) {
742 expect(workerNode
.workerUsage
).toStrictEqual({
744 executed
: expect
.any(Number
),
751 aggregate
: expect
.any(Number
),
754 history
: expect
.any(CircularArray
)
757 aggregate
: expect
.any(Number
),
760 history
: expect
.any(CircularArray
)
767 history
: expect
.any(CircularArray
)
773 history
: expect
.any(CircularArray
)
778 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
779 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
782 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
783 expect(workerNode
.workerUsage
.waitTime
.aggregate
).toBeGreaterThanOrEqual(
787 // We need to clean up the resources after our test
791 it('Verify LEAST_ELU strategy default policy', async () => {
792 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
793 let pool
= new FixedThreadPool(
795 './tests/worker-files/thread/testWorker.js',
796 { workerChoiceStrategy
}
798 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
799 useDynamicWorker
: false
802 pool
= new DynamicThreadPool(
805 './tests/worker-files/thread/testWorker.js',
806 { workerChoiceStrategy
}
808 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
809 useDynamicWorker
: false
811 // We need to clean up the resources after our test
815 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
816 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
817 let pool
= new FixedThreadPool(
819 './tests/worker-files/thread/testWorker.js',
820 { workerChoiceStrategy
}
823 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
842 pool
= new DynamicThreadPool(
845 './tests/worker-files/thread/testWorker.js',
846 { workerChoiceStrategy
}
849 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
867 // We need to clean up the resources after our test
871 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
872 const pool
= new FixedThreadPool(
874 './tests/worker-files/thread/testWorker.js',
875 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
877 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
878 const promises
= new Set()
879 const maxMultiplier
= 2
880 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
881 promises
.add(pool
.execute())
883 await Promise
.all(promises
)
884 for (const workerNode
of pool
.workerNodes
) {
885 expect(workerNode
.workerUsage
).toStrictEqual({
887 executed
: expect
.any(Number
),
897 history
: expect
.any(CircularArray
)
903 history
: expect
.any(CircularArray
)
910 history
: expect
.any(CircularArray
)
913 aggregate
: expect
.any(Number
),
916 history
: expect
.any(CircularArray
)
918 utilization
: expect
.any(Number
)
921 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
922 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
925 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
926 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
928 // We need to clean up the resources after our test
932 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
933 const pool
= new DynamicThreadPool(
936 './tests/worker-files/thread/testWorker.js',
937 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
939 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
940 const promises
= new Set()
941 const maxMultiplier
= 2
942 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
943 promises
.add(pool
.execute())
945 await Promise
.all(promises
)
946 for (const workerNode
of pool
.workerNodes
) {
947 expect(workerNode
.workerUsage
).toStrictEqual({
949 executed
: expect
.any(Number
),
959 history
: expect
.any(CircularArray
)
965 history
: expect
.any(CircularArray
)
972 history
: expect
.any(CircularArray
)
975 aggregate
: expect
.any(Number
),
978 history
: expect
.any(CircularArray
)
980 utilization
: expect
.any(Number
)
983 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
984 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
987 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
988 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
990 // We need to clean up the resources after our test
994 it('Verify FAIR_SHARE strategy default policy', async () => {
995 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
996 let pool
= new FixedThreadPool(
998 './tests/worker-files/thread/testWorker.js',
999 { workerChoiceStrategy
}
1001 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1002 useDynamicWorker
: false
1004 await pool
.destroy()
1005 pool
= new DynamicThreadPool(
1008 './tests/worker-files/thread/testWorker.js',
1009 { workerChoiceStrategy
}
1011 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1012 useDynamicWorker
: false
1014 // We need to clean up the resources after our test
1015 await pool
.destroy()
1018 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
1019 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1020 let pool
= new FixedThreadPool(
1022 './tests/worker-files/thread/testWorker.js',
1023 { workerChoiceStrategy
}
1026 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1044 await pool
.destroy()
1045 pool
= new DynamicThreadPool(
1048 './tests/worker-files/thread/testWorker.js',
1049 { workerChoiceStrategy
}
1052 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1070 // We need to clean up the resources after our test
1071 await pool
.destroy()
1074 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
1075 const pool
= new FixedThreadPool(
1077 './tests/worker-files/thread/testWorker.js',
1078 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1080 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1081 const promises
= new Set()
1082 const maxMultiplier
= 2
1083 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1084 promises
.add(pool
.execute())
1086 await Promise
.all(promises
)
1087 for (const workerNode
of pool
.workerNodes
) {
1088 expect(workerNode
.workerUsage
).toStrictEqual({
1090 executed
: expect
.any(Number
),
1097 aggregate
: expect
.any(Number
),
1098 average
: expect
.any(Number
),
1100 history
: expect
.any(CircularArray
)
1106 history
: expect
.any(CircularArray
)
1113 history
: expect
.any(CircularArray
)
1116 aggregate
: expect
.any(Number
),
1117 average
: expect
.any(Number
),
1119 history
: expect
.any(CircularArray
)
1121 utilization
: expect
.any(Number
)
1124 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1125 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1128 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1129 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1130 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1131 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
1134 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1135 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1136 ).workersVirtualTaskEndTimestamp
.length
1137 ).toBe(pool
.workerNodes
.length
)
1138 // We need to clean up the resources after our test
1139 await pool
.destroy()
1142 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1143 const pool
= new DynamicThreadPool(
1146 './tests/worker-files/thread/testWorker.js',
1147 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1149 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1150 const promises
= new Set()
1151 const maxMultiplier
= 2
1152 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1153 promises
.add(pool
.execute())
1155 await Promise
.all(promises
)
1156 for (const workerNode
of pool
.workerNodes
) {
1157 expect(workerNode
.workerUsage
).toStrictEqual({
1159 executed
: expect
.any(Number
),
1166 aggregate
: expect
.any(Number
),
1167 average
: expect
.any(Number
),
1169 history
: expect
.any(CircularArray
)
1175 history
: expect
.any(CircularArray
)
1182 history
: expect
.any(CircularArray
)
1185 aggregate
: expect
.any(Number
),
1186 average
: expect
.any(Number
),
1188 history
: expect
.any(CircularArray
)
1190 utilization
: expect
.any(Number
)
1193 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1194 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1197 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1198 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1199 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1200 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
1203 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1204 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1205 ).workersVirtualTaskEndTimestamp
.length
1206 ).toBe(pool
.workerNodes
.length
)
1207 // We need to clean up the resources after our test
1208 await pool
.destroy()
1211 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1212 const pool
= new DynamicThreadPool(
1215 './tests/worker-files/thread/testWorker.js',
1217 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1218 workerChoiceStrategyOptions
: {
1219 runTime
: { median
: true }
1223 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1224 const promises
= new Set()
1225 const maxMultiplier
= 2
1226 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1227 promises
.add(pool
.execute())
1229 await Promise
.all(promises
)
1230 for (const workerNode
of pool
.workerNodes
) {
1231 expect(workerNode
.workerUsage
).toStrictEqual({
1233 executed
: expect
.any(Number
),
1240 aggregate
: expect
.any(Number
),
1242 median
: expect
.any(Number
),
1243 history
: expect
.any(CircularArray
)
1249 history
: expect
.any(CircularArray
)
1256 history
: expect
.any(CircularArray
)
1259 aggregate
: expect
.any(Number
),
1260 average
: expect
.any(Number
),
1262 history
: expect
.any(CircularArray
)
1264 utilization
: expect
.any(Number
)
1267 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1268 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1271 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1272 expect(workerNode
.workerUsage
.runTime
.median
).toBeGreaterThanOrEqual(0)
1273 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1274 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
1277 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1278 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1279 ).workersVirtualTaskEndTimestamp
.length
1280 ).toBe(pool
.workerNodes
.length
)
1281 // We need to clean up the resources after our test
1282 await pool
.destroy()
1285 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1286 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1287 let pool
= new FixedThreadPool(
1289 './tests/worker-files/thread/testWorker.js'
1292 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1293 workerChoiceStrategy
1294 ).workersVirtualTaskEndTimestamp
1295 ).toBeInstanceOf(Array
)
1297 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1298 workerChoiceStrategy
1299 ).workersVirtualTaskEndTimestamp
.length
1301 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1302 workerChoiceStrategy
1303 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1305 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1306 workerChoiceStrategy
1307 ).workersVirtualTaskEndTimestamp
.length
1309 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1311 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1312 workerChoiceStrategy
1313 ).workersVirtualTaskEndTimestamp
1314 ).toBeInstanceOf(Array
)
1316 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1317 workerChoiceStrategy
1318 ).workersVirtualTaskEndTimestamp
.length
1320 await pool
.destroy()
1321 pool
= new DynamicThreadPool(
1324 './tests/worker-files/thread/testWorker.js'
1327 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1328 workerChoiceStrategy
1329 ).workersVirtualTaskEndTimestamp
1330 ).toBeInstanceOf(Array
)
1332 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1333 workerChoiceStrategy
1334 ).workersVirtualTaskEndTimestamp
.length
1336 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1337 workerChoiceStrategy
1338 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1340 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1341 workerChoiceStrategy
1342 ).workersVirtualTaskEndTimestamp
.length
1344 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1346 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1347 workerChoiceStrategy
1348 ).workersVirtualTaskEndTimestamp
1349 ).toBeInstanceOf(Array
)
1351 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1352 workerChoiceStrategy
1353 ).workersVirtualTaskEndTimestamp
.length
1355 // We need to clean up the resources after our test
1356 await pool
.destroy()
1359 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1360 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1361 let pool
= new FixedThreadPool(
1363 './tests/worker-files/thread/testWorker.js',
1364 { workerChoiceStrategy
}
1366 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1367 useDynamicWorker
: true
1369 await pool
.destroy()
1370 pool
= new DynamicThreadPool(
1373 './tests/worker-files/thread/testWorker.js',
1374 { workerChoiceStrategy
}
1376 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1377 useDynamicWorker
: true
1379 // We need to clean up the resources after our test
1380 await pool
.destroy()
1383 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1384 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1385 let pool
= new FixedThreadPool(
1387 './tests/worker-files/thread/testWorker.js',
1388 { workerChoiceStrategy
}
1391 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1409 await pool
.destroy()
1410 pool
= new DynamicThreadPool(
1413 './tests/worker-files/thread/testWorker.js',
1414 { workerChoiceStrategy
}
1417 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1435 // We need to clean up the resources after our test
1436 await pool
.destroy()
1439 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1440 const pool
= new FixedThreadPool(
1442 './tests/worker-files/thread/testWorker.js',
1443 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1445 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1446 const promises
= new Set()
1447 const maxMultiplier
= 2
1448 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1449 promises
.add(pool
.execute())
1451 await Promise
.all(promises
)
1452 for (const workerNode
of pool
.workerNodes
) {
1453 expect(workerNode
.workerUsage
).toStrictEqual({
1455 executed
: expect
.any(Number
),
1462 aggregate
: expect
.any(Number
),
1463 average
: expect
.any(Number
),
1465 history
: expect
.any(CircularArray
)
1471 history
: expect
.any(CircularArray
)
1478 history
: expect
.any(CircularArray
)
1484 history
: expect
.any(CircularArray
)
1489 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1490 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1493 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1494 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1497 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1498 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1499 ).defaultWorkerWeight
1500 ).toBeGreaterThan(0)
1502 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1503 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1504 ).workerVirtualTaskRunTime
1505 ).toBeGreaterThanOrEqual(0)
1506 // We need to clean up the resources after our test
1507 await pool
.destroy()
1510 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1511 const pool
= new DynamicThreadPool(
1514 './tests/worker-files/thread/testWorker.js',
1515 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1517 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1518 const promises
= new Set()
1519 const maxMultiplier
= 2
1520 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1521 promises
.add(pool
.execute())
1523 await Promise
.all(promises
)
1524 for (const workerNode
of pool
.workerNodes
) {
1525 expect(workerNode
.workerUsage
).toStrictEqual({
1527 executed
: expect
.any(Number
),
1534 aggregate
: expect
.any(Number
),
1535 average
: expect
.any(Number
),
1537 history
: expect
.any(CircularArray
)
1543 history
: expect
.any(CircularArray
)
1550 history
: expect
.any(CircularArray
)
1556 history
: expect
.any(CircularArray
)
1561 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1562 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1565 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThan(0)
1566 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThan(0)
1569 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1570 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1571 ).defaultWorkerWeight
1572 ).toBeGreaterThan(0)
1574 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1575 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1576 ).workerVirtualTaskRunTime
1577 ).toBeGreaterThanOrEqual(0)
1578 // We need to clean up the resources after our test
1579 await pool
.destroy()
1582 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1583 const pool
= new DynamicThreadPool(
1586 './tests/worker-files/thread/testWorker.js',
1588 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1589 workerChoiceStrategyOptions
: {
1590 runTime
: { median
: true }
1594 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1595 const promises
= new Set()
1596 const maxMultiplier
= 2
1597 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1598 promises
.add(pool
.execute())
1600 await Promise
.all(promises
)
1601 for (const workerNode
of pool
.workerNodes
) {
1602 expect(workerNode
.workerUsage
).toStrictEqual({
1604 executed
: expect
.any(Number
),
1611 aggregate
: expect
.any(Number
),
1613 median
: expect
.any(Number
),
1614 history
: expect
.any(CircularArray
)
1620 history
: expect
.any(CircularArray
)
1627 history
: expect
.any(CircularArray
)
1633 history
: expect
.any(CircularArray
)
1638 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1639 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1642 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThan(0)
1643 expect(workerNode
.workerUsage
.runTime
.median
).toBeGreaterThan(0)
1646 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1647 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1648 ).defaultWorkerWeight
1649 ).toBeGreaterThan(0)
1651 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1652 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1653 ).workerVirtualTaskRunTime
1654 ).toBeGreaterThanOrEqual(0)
1655 // We need to clean up the resources after our test
1656 await pool
.destroy()
1659 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1660 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1661 let pool
= new FixedThreadPool(
1663 './tests/worker-files/thread/testWorker.js'
1666 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1667 workerChoiceStrategy
1671 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1672 workerChoiceStrategy
1673 ).defaultWorkerWeight
1676 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1677 workerChoiceStrategy
1678 ).workerVirtualTaskRunTime
1680 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1682 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1683 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1687 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1688 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1689 ).defaultWorkerWeight
1690 ).toBeGreaterThan(0)
1692 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1693 workerChoiceStrategy
1694 ).workerVirtualTaskRunTime
1696 await pool
.destroy()
1697 pool
= new DynamicThreadPool(
1700 './tests/worker-files/thread/testWorker.js'
1703 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1704 workerChoiceStrategy
1708 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1709 workerChoiceStrategy
1710 ).defaultWorkerWeight
1713 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1714 workerChoiceStrategy
1715 ).workerVirtualTaskRunTime
1717 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1719 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1720 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1724 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1725 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1726 ).defaultWorkerWeight
1727 ).toBeGreaterThan(0)
1729 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1730 workerChoiceStrategy
1731 ).workerVirtualTaskRunTime
1733 // We need to clean up the resources after our test
1734 await pool
.destroy()
1737 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1738 const workerChoiceStrategy
=
1739 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1740 let pool
= new FixedThreadPool(
1742 './tests/worker-files/thread/testWorker.js',
1743 { workerChoiceStrategy
}
1745 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1746 useDynamicWorker
: true
1748 await pool
.destroy()
1749 pool
= new DynamicThreadPool(
1752 './tests/worker-files/thread/testWorker.js',
1753 { workerChoiceStrategy
}
1755 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1756 useDynamicWorker
: true
1758 // We need to clean up the resources after our test
1759 await pool
.destroy()
1762 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1763 const workerChoiceStrategy
=
1764 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1765 let pool
= new FixedThreadPool(
1767 './tests/worker-files/thread/testWorker.js',
1768 { workerChoiceStrategy
}
1771 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1789 await pool
.destroy()
1790 pool
= new DynamicThreadPool(
1793 './tests/worker-files/thread/testWorker.js',
1794 { workerChoiceStrategy
}
1797 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
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 fixed pool', async () => {
1820 const pool
= new FixedThreadPool(
1822 './tests/worker-files/thread/testWorker.js',
1824 workerChoiceStrategy
:
1825 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1828 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1829 const promises
= new Set()
1830 const maxMultiplier
= 2
1831 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1832 promises
.add(pool
.execute())
1834 await Promise
.all(promises
)
1835 for (const workerNode
of pool
.workerNodes
) {
1836 expect(workerNode
.workerUsage
).toStrictEqual({
1838 executed
: maxMultiplier
,
1848 history
: expect
.any(CircularArray
)
1854 history
: expect
.any(CircularArray
)
1861 history
: expect
.any(CircularArray
)
1867 history
: expect
.any(CircularArray
)
1874 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1875 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1876 ).defaultWorkerWeight
1877 ).toBeGreaterThan(0)
1879 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1880 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1884 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1885 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1889 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1890 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1893 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1894 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1895 ).defaultWorkerWeight
1897 // We need to clean up the resources after our test
1898 await pool
.destroy()
1901 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1902 const pool
= new DynamicThreadPool(
1905 './tests/worker-files/thread/testWorker.js',
1907 workerChoiceStrategy
:
1908 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1911 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1912 const promises
= new Set()
1913 const maxMultiplier
= 2
1914 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1915 promises
.add(pool
.execute())
1917 await Promise
.all(promises
)
1918 for (const workerNode
of pool
.workerNodes
) {
1919 expect(workerNode
.workerUsage
).toStrictEqual({
1921 executed
: maxMultiplier
,
1931 history
: expect
.any(CircularArray
)
1937 history
: expect
.any(CircularArray
)
1944 history
: expect
.any(CircularArray
)
1950 history
: expect
.any(CircularArray
)
1957 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1958 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1959 ).defaultWorkerWeight
1960 ).toBeGreaterThan(0)
1962 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1963 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1967 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1968 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1972 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1973 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1976 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1977 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1978 ).defaultWorkerWeight
1980 // We need to clean up the resources after our test
1981 await pool
.destroy()
1984 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1985 const workerChoiceStrategy
=
1986 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1987 let pool
= new FixedThreadPool(
1989 './tests/worker-files/thread/testWorker.js'
1992 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1993 workerChoiceStrategy
1997 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1998 workerChoiceStrategy
2002 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2003 workerChoiceStrategy
2004 ).defaultWorkerWeight
2007 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2008 workerChoiceStrategy
2011 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
2013 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2014 workerChoiceStrategy
2018 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2019 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2023 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2024 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2025 ).defaultWorkerWeight
2026 ).toBeGreaterThan(0)
2028 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2029 workerChoiceStrategy
2032 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2033 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2034 ).defaultWorkerWeight
2036 await pool
.destroy()
2037 pool
= new DynamicThreadPool(
2040 './tests/worker-files/thread/testWorker.js'
2043 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2044 workerChoiceStrategy
2048 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2049 workerChoiceStrategy
2053 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2054 workerChoiceStrategy
2055 ).defaultWorkerWeight
2058 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2059 workerChoiceStrategy
2062 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
2064 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2065 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2069 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2070 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2071 ).defaultWorkerWeight
2072 ).toBeGreaterThan(0)
2074 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2075 workerChoiceStrategy
2078 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2079 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2080 ).defaultWorkerWeight
2082 // We need to clean up the resources after our test
2083 await pool
.destroy()
2086 it('Verify unknown strategy throw error', () => {
2089 new DynamicThreadPool(
2092 './tests/worker-files/thread/testWorker.js',
2093 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
2095 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")