1 const { expect
} = require('expect')
3 WorkerChoiceStrategies
,
7 } = require('../../../lib')
8 const { CircularArray
} = require('../../../lib/circular-array')
10 describe('Selection strategies test suite', () => {
14 it('Verify that WorkerChoiceStrategies enumeration provides string values', () => {
15 expect(WorkerChoiceStrategies
.ROUND_ROBIN
).toBe('ROUND_ROBIN')
16 expect(WorkerChoiceStrategies
.LEAST_USED
).toBe('LEAST_USED')
17 expect(WorkerChoiceStrategies
.LEAST_BUSY
).toBe('LEAST_BUSY')
18 expect(WorkerChoiceStrategies
.LEAST_ELU
).toBe('LEAST_ELU')
19 expect(WorkerChoiceStrategies
.FAIR_SHARE
).toBe('FAIR_SHARE')
20 expect(WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
).toBe(
21 'WEIGHTED_ROUND_ROBIN'
23 expect(WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
).toBe(
24 'INTERLEAVED_WEIGHTED_ROUND_ROBIN'
28 it('Verify ROUND_ROBIN strategy is the default at pool creation', async () => {
29 const pool
= new DynamicThreadPool(
32 './tests/worker-files/thread/testWorker.js'
34 expect(pool
.opts
.workerChoiceStrategy
).toBe(
35 WorkerChoiceStrategies
.ROUND_ROBIN
37 // We need to clean up the resources after our test
41 it('Verify available strategies are taken at pool creation', async () => {
42 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
43 const pool
= new FixedThreadPool(
45 './tests/worker-files/thread/testWorker.js',
46 { workerChoiceStrategy
}
48 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
49 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
56 it('Verify available strategies can be set after pool creation', async () => {
57 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
58 const pool
= new DynamicThreadPool(
61 './tests/worker-files/thread/testWorker.js'
63 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
64 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
65 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
72 it('Verify available strategies default internals at pool creation', async () => {
73 const pool
= new FixedThreadPool(
75 './tests/worker-files/thread/testWorker.js'
77 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
78 if (workerChoiceStrategy
=== WorkerChoiceStrategies
.ROUND_ROBIN
) {
80 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
84 } else if (workerChoiceStrategy
=== WorkerChoiceStrategies
.FAIR_SHARE
) {
86 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
88 ).workersVirtualTaskEndTimestamp
89 ).toBeInstanceOf(Array
)
91 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
93 ).workersVirtualTaskEndTimestamp
.length
96 workerChoiceStrategy
=== WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
99 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
104 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
106 ).defaultWorkerWeight
109 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
111 ).workerVirtualTaskRunTime
118 it('Verify ROUND_ROBIN strategy default policy', async () => {
119 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
120 let pool
= new FixedThreadPool(
122 './tests/worker-files/thread/testWorker.js',
123 { workerChoiceStrategy
}
125 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
126 useDynamicWorker
: true
129 pool
= new DynamicThreadPool(
132 './tests/worker-files/thread/testWorker.js',
133 { workerChoiceStrategy
}
135 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
136 useDynamicWorker
: true
138 // We need to clean up the resources after our test
142 it('Verify ROUND_ROBIN strategy default tasks statistics requirements', async () => {
143 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
144 let pool
= new FixedThreadPool(
146 './tests/worker-files/thread/testWorker.js',
147 { workerChoiceStrategy
}
150 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
169 pool
= new DynamicThreadPool(
172 './tests/worker-files/thread/testWorker.js',
173 { workerChoiceStrategy
}
176 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
194 // We need to clean up the resources after our test
198 it('Verify ROUND_ROBIN strategy can be run in a fixed pool', async () => {
199 const pool
= new FixedThreadPool(
201 './tests/worker-files/thread/testWorker.js',
202 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
204 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
205 const promises
= new Set()
206 const maxMultiplier
= 2
207 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
208 promises
.add(pool
.execute())
210 await Promise
.all(promises
)
211 for (const workerNode
of pool
.workerNodes
) {
212 expect(workerNode
.usage
).toStrictEqual({
214 executed
: maxMultiplier
,
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
.usage
).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
.usage
).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
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
516 expect(workerNode
.usage
.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
.usage
).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
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
576 expect(workerNode
.usage
.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
.usage
).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
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
715 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
718 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
719 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThanOrEqual(0)
721 // We need to clean up the resources after our test
725 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
726 const pool
= new DynamicThreadPool(
729 './tests/worker-files/thread/testWorker.js',
730 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
732 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
733 const promises
= new Set()
734 const maxMultiplier
= 2
735 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
736 promises
.add(pool
.execute())
738 await Promise
.all(promises
)
739 for (const workerNode
of pool
.workerNodes
) {
740 expect(workerNode
.usage
).toStrictEqual({
742 executed
: expect
.any(Number
),
749 aggregate
: expect
.any(Number
),
752 history
: expect
.any(CircularArray
)
755 aggregate
: expect
.any(Number
),
758 history
: expect
.any(CircularArray
)
765 history
: expect
.any(CircularArray
)
771 history
: expect
.any(CircularArray
)
776 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
777 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
780 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
781 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThanOrEqual(0)
783 // We need to clean up the resources after our test
787 it('Verify LEAST_ELU strategy default policy', async () => {
788 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
789 let pool
= new FixedThreadPool(
791 './tests/worker-files/thread/testWorker.js',
792 { workerChoiceStrategy
}
794 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
795 useDynamicWorker
: false
798 pool
= new DynamicThreadPool(
801 './tests/worker-files/thread/testWorker.js',
802 { workerChoiceStrategy
}
804 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
805 useDynamicWorker
: false
807 // We need to clean up the resources after our test
811 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
812 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
813 let pool
= new FixedThreadPool(
815 './tests/worker-files/thread/testWorker.js',
816 { workerChoiceStrategy
}
819 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
838 pool
= new DynamicThreadPool(
841 './tests/worker-files/thread/testWorker.js',
842 { workerChoiceStrategy
}
845 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
863 // We need to clean up the resources after our test
867 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
868 const pool
= new FixedThreadPool(
870 './tests/worker-files/thread/testWorker.js',
871 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
873 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
874 const promises
= new Set()
875 const maxMultiplier
= 2
876 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
877 promises
.add(pool
.execute())
879 await Promise
.all(promises
)
880 for (const workerNode
of pool
.workerNodes
) {
881 expect(workerNode
.usage
).toStrictEqual({
883 executed
: expect
.any(Number
),
893 history
: expect
.any(CircularArray
)
899 history
: expect
.any(CircularArray
)
906 history
: expect
.any(CircularArray
)
909 aggregate
: expect
.any(Number
),
912 history
: expect
.any(CircularArray
)
914 utilization
: expect
.any(Number
)
917 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
918 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
921 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
922 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
924 // We need to clean up the resources after our test
928 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
929 const pool
= new DynamicThreadPool(
932 './tests/worker-files/thread/testWorker.js',
933 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
935 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
936 const promises
= new Set()
937 const maxMultiplier
= 2
938 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
939 promises
.add(pool
.execute())
941 await Promise
.all(promises
)
942 for (const workerNode
of pool
.workerNodes
) {
943 expect(workerNode
.usage
).toStrictEqual({
945 executed
: expect
.any(Number
),
955 history
: expect
.any(CircularArray
)
961 history
: expect
.any(CircularArray
)
968 history
: expect
.any(CircularArray
)
971 aggregate
: expect
.any(Number
),
974 history
: expect
.any(CircularArray
)
976 utilization
: expect
.any(Number
)
979 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
980 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
983 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
984 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
986 // We need to clean up the resources after our test
990 it('Verify FAIR_SHARE strategy default policy', async () => {
991 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
992 let pool
= new FixedThreadPool(
994 './tests/worker-files/thread/testWorker.js',
995 { workerChoiceStrategy
}
997 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
998 useDynamicWorker
: false
1000 await pool
.destroy()
1001 pool
= new DynamicThreadPool(
1004 './tests/worker-files/thread/testWorker.js',
1005 { workerChoiceStrategy
}
1007 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1008 useDynamicWorker
: false
1010 // We need to clean up the resources after our test
1011 await pool
.destroy()
1014 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
1015 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1016 let pool
= new FixedThreadPool(
1018 './tests/worker-files/thread/testWorker.js',
1019 { workerChoiceStrategy
}
1022 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1040 await pool
.destroy()
1041 pool
= new DynamicThreadPool(
1044 './tests/worker-files/thread/testWorker.js',
1045 { workerChoiceStrategy
}
1048 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1066 // We need to clean up the resources after our test
1067 await pool
.destroy()
1070 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
1071 const pool
= new FixedThreadPool(
1073 './tests/worker-files/thread/testWorker.js',
1074 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1076 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1077 const promises
= new Set()
1078 const maxMultiplier
= 2
1079 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1080 promises
.add(pool
.execute())
1082 await Promise
.all(promises
)
1083 for (const workerNode
of pool
.workerNodes
) {
1084 expect(workerNode
.usage
).toStrictEqual({
1086 executed
: expect
.any(Number
),
1093 aggregate
: expect
.any(Number
),
1094 average
: expect
.any(Number
),
1096 history
: expect
.any(CircularArray
)
1102 history
: expect
.any(CircularArray
)
1109 history
: expect
.any(CircularArray
)
1112 aggregate
: expect
.any(Number
),
1113 average
: expect
.any(Number
),
1115 history
: expect
.any(CircularArray
)
1117 utilization
: expect
.any(Number
)
1120 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1121 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1124 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1125 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1126 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1127 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1130 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1131 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1132 ).workersVirtualTaskEndTimestamp
.length
1133 ).toBe(pool
.workerNodes
.length
)
1134 // We need to clean up the resources after our test
1135 await pool
.destroy()
1138 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1139 const pool
= new DynamicThreadPool(
1142 './tests/worker-files/thread/testWorker.js',
1143 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1145 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1146 const promises
= new Set()
1147 const maxMultiplier
= 2
1148 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1149 promises
.add(pool
.execute())
1151 await Promise
.all(promises
)
1152 for (const workerNode
of pool
.workerNodes
) {
1153 expect(workerNode
.usage
).toStrictEqual({
1155 executed
: expect
.any(Number
),
1162 aggregate
: expect
.any(Number
),
1163 average
: expect
.any(Number
),
1165 history
: expect
.any(CircularArray
)
1171 history
: expect
.any(CircularArray
)
1178 history
: expect
.any(CircularArray
)
1181 aggregate
: expect
.any(Number
),
1182 average
: expect
.any(Number
),
1184 history
: expect
.any(CircularArray
)
1186 utilization
: expect
.any(Number
)
1189 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1190 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1193 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1194 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1195 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1196 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1199 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1200 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1201 ).workersVirtualTaskEndTimestamp
.length
1202 ).toBe(pool
.workerNodes
.length
)
1203 // We need to clean up the resources after our test
1204 await pool
.destroy()
1207 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1208 const pool
= new DynamicThreadPool(
1211 './tests/worker-files/thread/testWorker.js',
1213 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1214 workerChoiceStrategyOptions
: {
1215 runTime
: { median
: true }
1219 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1220 const promises
= new Set()
1221 const maxMultiplier
= 2
1222 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1223 promises
.add(pool
.execute())
1225 await Promise
.all(promises
)
1226 for (const workerNode
of pool
.workerNodes
) {
1227 expect(workerNode
.usage
).toStrictEqual({
1229 executed
: expect
.any(Number
),
1236 aggregate
: expect
.any(Number
),
1238 median
: expect
.any(Number
),
1239 history
: expect
.any(CircularArray
)
1245 history
: expect
.any(CircularArray
)
1252 history
: expect
.any(CircularArray
)
1255 aggregate
: expect
.any(Number
),
1256 average
: expect
.any(Number
),
1258 history
: expect
.any(CircularArray
)
1260 utilization
: expect
.any(Number
)
1263 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1264 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1267 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1268 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThanOrEqual(0)
1269 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1270 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1273 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1274 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1275 ).workersVirtualTaskEndTimestamp
.length
1276 ).toBe(pool
.workerNodes
.length
)
1277 // We need to clean up the resources after our test
1278 await pool
.destroy()
1281 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1282 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1283 let pool
= new FixedThreadPool(
1285 './tests/worker-files/thread/testWorker.js'
1288 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1289 workerChoiceStrategy
1290 ).workersVirtualTaskEndTimestamp
1291 ).toBeInstanceOf(Array
)
1293 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1294 workerChoiceStrategy
1295 ).workersVirtualTaskEndTimestamp
.length
1297 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1298 workerChoiceStrategy
1299 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1301 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1302 workerChoiceStrategy
1303 ).workersVirtualTaskEndTimestamp
.length
1305 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1307 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1308 workerChoiceStrategy
1309 ).workersVirtualTaskEndTimestamp
1310 ).toBeInstanceOf(Array
)
1312 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1313 workerChoiceStrategy
1314 ).workersVirtualTaskEndTimestamp
.length
1316 await pool
.destroy()
1317 pool
= new DynamicThreadPool(
1320 './tests/worker-files/thread/testWorker.js'
1323 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1324 workerChoiceStrategy
1325 ).workersVirtualTaskEndTimestamp
1326 ).toBeInstanceOf(Array
)
1328 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1329 workerChoiceStrategy
1330 ).workersVirtualTaskEndTimestamp
.length
1332 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1333 workerChoiceStrategy
1334 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1336 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1337 workerChoiceStrategy
1338 ).workersVirtualTaskEndTimestamp
.length
1340 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1342 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1343 workerChoiceStrategy
1344 ).workersVirtualTaskEndTimestamp
1345 ).toBeInstanceOf(Array
)
1347 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1348 workerChoiceStrategy
1349 ).workersVirtualTaskEndTimestamp
.length
1351 // We need to clean up the resources after our test
1352 await pool
.destroy()
1355 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1356 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1357 let pool
= new FixedThreadPool(
1359 './tests/worker-files/thread/testWorker.js',
1360 { workerChoiceStrategy
}
1362 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1363 useDynamicWorker
: true
1365 await pool
.destroy()
1366 pool
= new DynamicThreadPool(
1369 './tests/worker-files/thread/testWorker.js',
1370 { workerChoiceStrategy
}
1372 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1373 useDynamicWorker
: true
1375 // We need to clean up the resources after our test
1376 await pool
.destroy()
1379 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1380 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1381 let pool
= new FixedThreadPool(
1383 './tests/worker-files/thread/testWorker.js',
1384 { workerChoiceStrategy
}
1387 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1405 await pool
.destroy()
1406 pool
= new DynamicThreadPool(
1409 './tests/worker-files/thread/testWorker.js',
1410 { workerChoiceStrategy
}
1413 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1431 // We need to clean up the resources after our test
1432 await pool
.destroy()
1435 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1436 const pool
= new FixedThreadPool(
1438 './tests/worker-files/thread/testWorker.js',
1439 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1441 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1442 const promises
= new Set()
1443 const maxMultiplier
= 2
1444 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1445 promises
.add(pool
.execute())
1447 await Promise
.all(promises
)
1448 for (const workerNode
of pool
.workerNodes
) {
1449 expect(workerNode
.usage
).toStrictEqual({
1451 executed
: expect
.any(Number
),
1458 aggregate
: expect
.any(Number
),
1459 average
: expect
.any(Number
),
1461 history
: expect
.any(CircularArray
)
1467 history
: expect
.any(CircularArray
)
1474 history
: expect
.any(CircularArray
)
1480 history
: expect
.any(CircularArray
)
1485 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1486 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1489 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1490 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1493 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1494 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1495 ).defaultWorkerWeight
1496 ).toBeGreaterThan(0)
1498 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1499 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1500 ).workerVirtualTaskRunTime
1501 ).toBeGreaterThanOrEqual(0)
1502 // We need to clean up the resources after our test
1503 await pool
.destroy()
1506 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1507 const pool
= new DynamicThreadPool(
1510 './tests/worker-files/thread/testWorker.js',
1511 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1513 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1514 const promises
= new Set()
1515 const maxMultiplier
= 2
1516 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1517 promises
.add(pool
.execute())
1519 await Promise
.all(promises
)
1520 for (const workerNode
of pool
.workerNodes
) {
1521 expect(workerNode
.usage
).toStrictEqual({
1523 executed
: expect
.any(Number
),
1530 aggregate
: expect
.any(Number
),
1531 average
: expect
.any(Number
),
1533 history
: expect
.any(CircularArray
)
1539 history
: expect
.any(CircularArray
)
1546 history
: expect
.any(CircularArray
)
1552 history
: expect
.any(CircularArray
)
1557 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1558 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1561 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1562 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1565 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1566 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1567 ).defaultWorkerWeight
1568 ).toBeGreaterThan(0)
1570 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1571 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1572 ).workerVirtualTaskRunTime
1573 ).toBeGreaterThanOrEqual(0)
1574 // We need to clean up the resources after our test
1575 await pool
.destroy()
1578 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1579 const pool
= new DynamicThreadPool(
1582 './tests/worker-files/thread/testWorker.js',
1584 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1585 workerChoiceStrategyOptions
: {
1586 runTime
: { median
: true }
1590 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1591 const promises
= new Set()
1592 const maxMultiplier
= 2
1593 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1594 promises
.add(pool
.execute())
1596 await Promise
.all(promises
)
1597 for (const workerNode
of pool
.workerNodes
) {
1598 expect(workerNode
.usage
).toStrictEqual({
1600 executed
: expect
.any(Number
),
1607 aggregate
: expect
.any(Number
),
1609 median
: expect
.any(Number
),
1610 history
: expect
.any(CircularArray
)
1616 history
: expect
.any(CircularArray
)
1623 history
: expect
.any(CircularArray
)
1629 history
: expect
.any(CircularArray
)
1634 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1635 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1638 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1639 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1642 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1643 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1644 ).defaultWorkerWeight
1645 ).toBeGreaterThan(0)
1647 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1648 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1649 ).workerVirtualTaskRunTime
1650 ).toBeGreaterThanOrEqual(0)
1651 // We need to clean up the resources after our test
1652 await pool
.destroy()
1655 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1656 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1657 let pool
= new FixedThreadPool(
1659 './tests/worker-files/thread/testWorker.js'
1662 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1663 workerChoiceStrategy
1667 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1668 workerChoiceStrategy
1669 ).defaultWorkerWeight
1672 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1673 workerChoiceStrategy
1674 ).workerVirtualTaskRunTime
1676 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1678 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1679 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1683 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1684 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1685 ).defaultWorkerWeight
1686 ).toBeGreaterThan(0)
1688 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1689 workerChoiceStrategy
1690 ).workerVirtualTaskRunTime
1692 await pool
.destroy()
1693 pool
= new DynamicThreadPool(
1696 './tests/worker-files/thread/testWorker.js'
1699 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1700 workerChoiceStrategy
1704 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1705 workerChoiceStrategy
1706 ).defaultWorkerWeight
1709 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1710 workerChoiceStrategy
1711 ).workerVirtualTaskRunTime
1713 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1715 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1716 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1720 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1721 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1722 ).defaultWorkerWeight
1723 ).toBeGreaterThan(0)
1725 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1726 workerChoiceStrategy
1727 ).workerVirtualTaskRunTime
1729 // We need to clean up the resources after our test
1730 await pool
.destroy()
1733 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1734 const workerChoiceStrategy
=
1735 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1736 let pool
= new FixedThreadPool(
1738 './tests/worker-files/thread/testWorker.js',
1739 { workerChoiceStrategy
}
1741 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1742 useDynamicWorker
: true
1744 await pool
.destroy()
1745 pool
= new DynamicThreadPool(
1748 './tests/worker-files/thread/testWorker.js',
1749 { workerChoiceStrategy
}
1751 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1752 useDynamicWorker
: true
1754 // We need to clean up the resources after our test
1755 await pool
.destroy()
1758 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1759 const workerChoiceStrategy
=
1760 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1761 let pool
= new FixedThreadPool(
1763 './tests/worker-files/thread/testWorker.js',
1764 { workerChoiceStrategy
}
1767 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1785 await pool
.destroy()
1786 pool
= new DynamicThreadPool(
1789 './tests/worker-files/thread/testWorker.js',
1790 { workerChoiceStrategy
}
1793 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1811 // We need to clean up the resources after our test
1812 await pool
.destroy()
1815 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1816 const pool
= new FixedThreadPool(
1818 './tests/worker-files/thread/testWorker.js',
1820 workerChoiceStrategy
:
1821 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1824 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1825 const promises
= new Set()
1826 const maxMultiplier
= 2
1827 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1828 promises
.add(pool
.execute())
1830 await Promise
.all(promises
)
1831 for (const workerNode
of pool
.workerNodes
) {
1832 expect(workerNode
.usage
).toStrictEqual({
1834 executed
: maxMultiplier
,
1844 history
: expect
.any(CircularArray
)
1850 history
: expect
.any(CircularArray
)
1857 history
: expect
.any(CircularArray
)
1863 history
: expect
.any(CircularArray
)
1870 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1871 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1872 ).defaultWorkerWeight
1873 ).toBeGreaterThan(0)
1875 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1876 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1880 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1881 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1885 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1886 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1889 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1890 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1891 ).defaultWorkerWeight
1893 // We need to clean up the resources after our test
1894 await pool
.destroy()
1897 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1898 const pool
= new DynamicThreadPool(
1901 './tests/worker-files/thread/testWorker.js',
1903 workerChoiceStrategy
:
1904 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1907 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1908 const promises
= new Set()
1909 const maxMultiplier
= 2
1910 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1911 promises
.add(pool
.execute())
1913 await Promise
.all(promises
)
1914 for (const workerNode
of pool
.workerNodes
) {
1915 expect(workerNode
.usage
).toStrictEqual({
1917 executed
: maxMultiplier
,
1927 history
: expect
.any(CircularArray
)
1933 history
: expect
.any(CircularArray
)
1940 history
: expect
.any(CircularArray
)
1946 history
: expect
.any(CircularArray
)
1953 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1954 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1955 ).defaultWorkerWeight
1956 ).toBeGreaterThan(0)
1958 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1959 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1963 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1964 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1968 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1969 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1972 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1973 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1974 ).defaultWorkerWeight
1976 // We need to clean up the resources after our test
1977 await pool
.destroy()
1980 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1981 const workerChoiceStrategy
=
1982 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1983 let pool
= new FixedThreadPool(
1985 './tests/worker-files/thread/testWorker.js'
1988 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1989 workerChoiceStrategy
1993 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1994 workerChoiceStrategy
1998 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1999 workerChoiceStrategy
2000 ).defaultWorkerWeight
2003 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2004 workerChoiceStrategy
2007 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
2009 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2010 workerChoiceStrategy
2014 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2015 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2019 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2020 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2021 ).defaultWorkerWeight
2022 ).toBeGreaterThan(0)
2024 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2025 workerChoiceStrategy
2028 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2029 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2030 ).defaultWorkerWeight
2032 await pool
.destroy()
2033 pool
= new DynamicThreadPool(
2036 './tests/worker-files/thread/testWorker.js'
2039 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2040 workerChoiceStrategy
2044 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2045 workerChoiceStrategy
2049 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2050 workerChoiceStrategy
2051 ).defaultWorkerWeight
2054 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2055 workerChoiceStrategy
2058 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
2060 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2061 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2065 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2066 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2067 ).defaultWorkerWeight
2068 ).toBeGreaterThan(0)
2070 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2071 workerChoiceStrategy
2074 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2075 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2076 ).defaultWorkerWeight
2078 // We need to clean up the resources after our test
2079 await pool
.destroy()
2082 it('Verify unknown strategy throw error', () => {
2085 new DynamicThreadPool(
2088 './tests/worker-files/thread/testWorker.js',
2089 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
2091 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")