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
: maxMultiplier
,
488 history
: expect
.any(CircularArray
)
494 history
: expect
.any(CircularArray
)
501 history
: expect
.any(CircularArray
)
507 history
: expect
.any(CircularArray
)
513 // We need to clean up the resources after our test
517 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
518 const pool
= new DynamicThreadPool(
521 './tests/worker-files/thread/testWorker.js',
522 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
524 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
525 const promises
= new Set()
526 const maxMultiplier
= 2
527 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
528 promises
.add(pool
.execute())
530 await Promise
.all(promises
)
531 for (const workerNode
of pool
.workerNodes
) {
532 expect(workerNode
.workerUsage
).toStrictEqual({
534 executed
: maxMultiplier
,
543 history
: expect
.any(CircularArray
)
549 history
: expect
.any(CircularArray
)
556 history
: expect
.any(CircularArray
)
562 history
: expect
.any(CircularArray
)
568 // We need to clean up the resources after our test
572 it('Verify LEAST_BUSY strategy default policy', async () => {
573 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
574 let pool
= new FixedThreadPool(
576 './tests/worker-files/thread/testWorker.js',
577 { workerChoiceStrategy
}
579 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
580 useDynamicWorker
: false
583 pool
= new DynamicThreadPool(
586 './tests/worker-files/thread/testWorker.js',
587 { workerChoiceStrategy
}
589 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
590 useDynamicWorker
: false
592 // We need to clean up the resources after our test
596 it('Verify LEAST_BUSY strategy default tasks statistics requirements', async () => {
597 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
598 let pool
= new FixedThreadPool(
600 './tests/worker-files/thread/testWorker.js',
601 { workerChoiceStrategy
}
604 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
623 pool
= new DynamicThreadPool(
626 './tests/worker-files/thread/testWorker.js',
627 { workerChoiceStrategy
}
630 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
648 // We need to clean up the resources after our test
652 it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
653 const pool
= new FixedThreadPool(
655 './tests/worker-files/thread/testWorker.js',
656 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
658 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
659 const promises
= new Set()
660 const maxMultiplier
= 2
661 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
662 promises
.add(pool
.execute())
664 await Promise
.all(promises
)
665 for (const workerNode
of pool
.workerNodes
) {
666 expect(workerNode
.workerUsage
).toStrictEqual({
668 executed
: expect
.any(Number
),
674 aggregate
: expect
.any(Number
),
677 history
: expect
.any(CircularArray
)
680 aggregate
: expect
.any(Number
),
683 history
: expect
.any(CircularArray
)
690 history
: expect
.any(CircularArray
)
696 history
: expect
.any(CircularArray
)
701 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThan(0)
702 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
705 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
706 expect(workerNode
.workerUsage
.waitTime
.aggregate
).toBeGreaterThanOrEqual(
710 // We need to clean up the resources after our test
714 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
715 const pool
= new DynamicThreadPool(
718 './tests/worker-files/thread/testWorker.js',
719 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
721 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
722 const promises
= new Set()
723 const maxMultiplier
= 2
724 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
725 promises
.add(pool
.execute())
727 await Promise
.all(promises
)
728 for (const workerNode
of pool
.workerNodes
) {
729 expect(workerNode
.workerUsage
).toStrictEqual({
731 executed
: expect
.any(Number
),
737 aggregate
: expect
.any(Number
),
740 history
: expect
.any(CircularArray
)
743 aggregate
: expect
.any(Number
),
746 history
: expect
.any(CircularArray
)
753 history
: expect
.any(CircularArray
)
759 history
: expect
.any(CircularArray
)
764 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThan(0)
765 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
768 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThan(0)
769 expect(workerNode
.workerUsage
.waitTime
.aggregate
).toBeGreaterThan(0)
771 // We need to clean up the resources after our test
775 it('Verify LEAST_ELU strategy default policy', async () => {
776 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
777 let pool
= new FixedThreadPool(
779 './tests/worker-files/thread/testWorker.js',
780 { workerChoiceStrategy
}
782 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
783 useDynamicWorker
: false
786 pool
= new DynamicThreadPool(
789 './tests/worker-files/thread/testWorker.js',
790 { workerChoiceStrategy
}
792 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
793 useDynamicWorker
: false
795 // We need to clean up the resources after our test
799 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
800 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
801 let pool
= new FixedThreadPool(
803 './tests/worker-files/thread/testWorker.js',
804 { workerChoiceStrategy
}
807 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
826 pool
= new DynamicThreadPool(
829 './tests/worker-files/thread/testWorker.js',
830 { workerChoiceStrategy
}
833 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
851 // We need to clean up the resources after our test
855 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
856 const pool
= new FixedThreadPool(
858 './tests/worker-files/thread/testWorker.js',
859 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
861 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
862 const promises
= new Set()
863 const maxMultiplier
= 2
864 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
865 promises
.add(pool
.execute())
867 await Promise
.all(promises
)
868 for (const workerNode
of pool
.workerNodes
) {
869 expect(workerNode
.workerUsage
).toStrictEqual({
871 executed
: expect
.any(Number
),
880 history
: expect
.any(CircularArray
)
886 history
: expect
.any(CircularArray
)
893 history
: expect
.any(CircularArray
)
896 aggregate
: expect
.any(Number
),
899 history
: expect
.any(CircularArray
)
901 utilization
: expect
.any(Number
)
904 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
905 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
908 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
909 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
911 // We need to clean up the resources after our test
915 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
916 const pool
= new DynamicThreadPool(
919 './tests/worker-files/thread/testWorker.js',
920 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
922 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
923 const promises
= new Set()
924 const maxMultiplier
= 2
925 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
926 promises
.add(pool
.execute())
928 await Promise
.all(promises
)
929 for (const workerNode
of pool
.workerNodes
) {
930 expect(workerNode
.workerUsage
).toStrictEqual({
932 executed
: expect
.any(Number
),
941 history
: expect
.any(CircularArray
)
947 history
: expect
.any(CircularArray
)
954 history
: expect
.any(CircularArray
)
957 aggregate
: expect
.any(Number
),
960 history
: expect
.any(CircularArray
)
962 utilization
: expect
.any(Number
)
965 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
966 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
969 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
970 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
972 // We need to clean up the resources after our test
976 it('Verify FAIR_SHARE strategy default policy', async () => {
977 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
978 let pool
= new FixedThreadPool(
980 './tests/worker-files/thread/testWorker.js',
981 { workerChoiceStrategy
}
983 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
984 useDynamicWorker
: false
987 pool
= new DynamicThreadPool(
990 './tests/worker-files/thread/testWorker.js',
991 { workerChoiceStrategy
}
993 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
994 useDynamicWorker
: false
996 // We need to clean up the resources after our test
1000 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
1001 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1002 let pool
= new FixedThreadPool(
1004 './tests/worker-files/thread/testWorker.js',
1005 { workerChoiceStrategy
}
1008 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1026 await pool
.destroy()
1027 pool
= new DynamicThreadPool(
1030 './tests/worker-files/thread/testWorker.js',
1031 { workerChoiceStrategy
}
1034 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1052 // We need to clean up the resources after our test
1053 await pool
.destroy()
1056 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
1057 const pool
= new FixedThreadPool(
1059 './tests/worker-files/thread/testWorker.js',
1060 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1062 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1063 const promises
= new Set()
1064 const maxMultiplier
= 2
1065 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1066 promises
.add(pool
.execute())
1068 await Promise
.all(promises
)
1069 for (const workerNode
of pool
.workerNodes
) {
1070 expect(workerNode
.workerUsage
).toStrictEqual({
1072 executed
: expect
.any(Number
),
1078 aggregate
: expect
.any(Number
),
1079 average
: expect
.any(Number
),
1081 history
: expect
.any(CircularArray
)
1087 history
: expect
.any(CircularArray
)
1094 history
: expect
.any(CircularArray
)
1097 aggregate
: expect
.any(Number
),
1098 average
: expect
.any(Number
),
1100 history
: expect
.any(CircularArray
)
1102 utilization
: expect
.any(Number
)
1105 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1106 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1109 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThan(0)
1110 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThan(0)
1111 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1112 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
1115 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1116 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1117 ).workersVirtualTaskEndTimestamp
.length
1118 ).toBe(pool
.workerNodes
.length
)
1119 // We need to clean up the resources after our test
1120 await pool
.destroy()
1123 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1124 const pool
= new DynamicThreadPool(
1127 './tests/worker-files/thread/testWorker.js',
1128 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1130 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1131 const promises
= new Set()
1132 const maxMultiplier
= 2
1133 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1134 promises
.add(pool
.execute())
1136 await Promise
.all(promises
)
1137 for (const workerNode
of pool
.workerNodes
) {
1138 expect(workerNode
.workerUsage
).toStrictEqual({
1140 executed
: expect
.any(Number
),
1146 aggregate
: expect
.any(Number
),
1147 average
: expect
.any(Number
),
1149 history
: expect
.any(CircularArray
)
1155 history
: expect
.any(CircularArray
)
1162 history
: expect
.any(CircularArray
)
1165 aggregate
: expect
.any(Number
),
1166 average
: expect
.any(Number
),
1168 history
: expect
.any(CircularArray
)
1170 utilization
: expect
.any(Number
)
1173 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1174 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1177 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1178 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1179 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1180 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
1183 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1184 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1185 ).workersVirtualTaskEndTimestamp
.length
1186 ).toBe(pool
.workerNodes
.length
)
1187 // We need to clean up the resources after our test
1188 await pool
.destroy()
1191 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1192 const pool
= new DynamicThreadPool(
1195 './tests/worker-files/thread/testWorker.js',
1197 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1198 workerChoiceStrategyOptions
: {
1199 runTime
: { median
: true }
1203 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1204 const promises
= new Set()
1205 const maxMultiplier
= 2
1206 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1207 promises
.add(pool
.execute())
1209 await Promise
.all(promises
)
1210 for (const workerNode
of pool
.workerNodes
) {
1211 expect(workerNode
.workerUsage
).toStrictEqual({
1213 executed
: expect
.any(Number
),
1219 aggregate
: expect
.any(Number
),
1221 median
: expect
.any(Number
),
1222 history
: expect
.any(CircularArray
)
1228 history
: expect
.any(CircularArray
)
1235 history
: expect
.any(CircularArray
)
1238 aggregate
: expect
.any(Number
),
1239 average
: expect
.any(Number
),
1241 history
: expect
.any(CircularArray
)
1243 utilization
: expect
.any(Number
)
1246 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1247 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1250 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1251 expect(workerNode
.workerUsage
.runTime
.median
).toBeGreaterThanOrEqual(0)
1252 expect(workerNode
.workerUsage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1253 expect(workerNode
.workerUsage
.elu
.utilization
).toBeLessThanOrEqual(1)
1256 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1257 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1258 ).workersVirtualTaskEndTimestamp
.length
1259 ).toBe(pool
.workerNodes
.length
)
1260 // We need to clean up the resources after our test
1261 await pool
.destroy()
1264 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1265 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1266 let pool
= new FixedThreadPool(
1268 './tests/worker-files/thread/testWorker.js'
1271 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1272 workerChoiceStrategy
1273 ).workersVirtualTaskEndTimestamp
1274 ).toBeInstanceOf(Array
)
1276 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1277 workerChoiceStrategy
1278 ).workersVirtualTaskEndTimestamp
.length
1280 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1281 workerChoiceStrategy
1282 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1284 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1285 workerChoiceStrategy
1286 ).workersVirtualTaskEndTimestamp
.length
1288 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1290 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1291 workerChoiceStrategy
1292 ).workersVirtualTaskEndTimestamp
1293 ).toBeInstanceOf(Array
)
1295 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1296 workerChoiceStrategy
1297 ).workersVirtualTaskEndTimestamp
.length
1299 await pool
.destroy()
1300 pool
= new DynamicThreadPool(
1303 './tests/worker-files/thread/testWorker.js'
1306 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1307 workerChoiceStrategy
1308 ).workersVirtualTaskEndTimestamp
1309 ).toBeInstanceOf(Array
)
1311 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1312 workerChoiceStrategy
1313 ).workersVirtualTaskEndTimestamp
.length
1315 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1316 workerChoiceStrategy
1317 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1319 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1320 workerChoiceStrategy
1321 ).workersVirtualTaskEndTimestamp
.length
1323 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1325 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1326 workerChoiceStrategy
1327 ).workersVirtualTaskEndTimestamp
1328 ).toBeInstanceOf(Array
)
1330 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1331 workerChoiceStrategy
1332 ).workersVirtualTaskEndTimestamp
.length
1334 // We need to clean up the resources after our test
1335 await pool
.destroy()
1338 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1339 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1340 let pool
= new FixedThreadPool(
1342 './tests/worker-files/thread/testWorker.js',
1343 { workerChoiceStrategy
}
1345 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1346 useDynamicWorker
: true
1348 await pool
.destroy()
1349 pool
= new DynamicThreadPool(
1352 './tests/worker-files/thread/testWorker.js',
1353 { workerChoiceStrategy
}
1355 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1356 useDynamicWorker
: true
1358 // We need to clean up the resources after our test
1359 await pool
.destroy()
1362 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1363 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1364 let pool
= new FixedThreadPool(
1366 './tests/worker-files/thread/testWorker.js',
1367 { workerChoiceStrategy
}
1370 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1388 await pool
.destroy()
1389 pool
= new DynamicThreadPool(
1392 './tests/worker-files/thread/testWorker.js',
1393 { workerChoiceStrategy
}
1396 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1414 // We need to clean up the resources after our test
1415 await pool
.destroy()
1418 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1419 const pool
= new FixedThreadPool(
1421 './tests/worker-files/thread/testWorker.js',
1422 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1424 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1425 const promises
= new Set()
1426 const maxMultiplier
= 2
1427 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1428 promises
.add(pool
.execute())
1430 await Promise
.all(promises
)
1431 for (const workerNode
of pool
.workerNodes
) {
1432 expect(workerNode
.workerUsage
).toStrictEqual({
1434 executed
: expect
.any(Number
),
1440 aggregate
: expect
.any(Number
),
1441 average
: expect
.any(Number
),
1443 history
: expect
.any(CircularArray
)
1449 history
: expect
.any(CircularArray
)
1456 history
: expect
.any(CircularArray
)
1462 history
: expect
.any(CircularArray
)
1467 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1468 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1471 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThanOrEqual(0)
1472 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThanOrEqual(0)
1475 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1476 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1477 ).defaultWorkerWeight
1478 ).toBeGreaterThan(0)
1480 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1481 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1482 ).workerVirtualTaskRunTime
1483 ).toBeGreaterThanOrEqual(0)
1484 // We need to clean up the resources after our test
1485 await pool
.destroy()
1488 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1489 const pool
= new DynamicThreadPool(
1492 './tests/worker-files/thread/testWorker.js',
1493 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1495 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1496 const promises
= new Set()
1497 const maxMultiplier
= 2
1498 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1499 promises
.add(pool
.execute())
1501 await Promise
.all(promises
)
1502 for (const workerNode
of pool
.workerNodes
) {
1503 expect(workerNode
.workerUsage
).toStrictEqual({
1505 executed
: expect
.any(Number
),
1511 aggregate
: expect
.any(Number
),
1512 average
: expect
.any(Number
),
1514 history
: expect
.any(CircularArray
)
1520 history
: expect
.any(CircularArray
)
1527 history
: expect
.any(CircularArray
)
1533 history
: expect
.any(CircularArray
)
1538 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1539 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1542 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThan(0)
1543 expect(workerNode
.workerUsage
.runTime
.average
).toBeGreaterThan(0)
1546 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1547 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1548 ).defaultWorkerWeight
1549 ).toBeGreaterThan(0)
1551 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1552 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1553 ).workerVirtualTaskRunTime
1554 ).toBeGreaterThanOrEqual(0)
1555 // We need to clean up the resources after our test
1556 await pool
.destroy()
1559 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1560 const pool
= new DynamicThreadPool(
1563 './tests/worker-files/thread/testWorker.js',
1565 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1566 workerChoiceStrategyOptions
: {
1567 runTime
: { median
: true }
1571 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1572 const promises
= new Set()
1573 const maxMultiplier
= 2
1574 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1575 promises
.add(pool
.execute())
1577 await Promise
.all(promises
)
1578 for (const workerNode
of pool
.workerNodes
) {
1579 expect(workerNode
.workerUsage
).toStrictEqual({
1581 executed
: expect
.any(Number
),
1587 aggregate
: expect
.any(Number
),
1589 median
: expect
.any(Number
),
1590 history
: expect
.any(CircularArray
)
1596 history
: expect
.any(CircularArray
)
1603 history
: expect
.any(CircularArray
)
1609 history
: expect
.any(CircularArray
)
1614 expect(workerNode
.workerUsage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1615 expect(workerNode
.workerUsage
.tasks
.executed
).toBeLessThanOrEqual(
1618 expect(workerNode
.workerUsage
.runTime
.aggregate
).toBeGreaterThan(0)
1619 expect(workerNode
.workerUsage
.runTime
.median
).toBeGreaterThan(0)
1622 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1623 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1624 ).defaultWorkerWeight
1625 ).toBeGreaterThan(0)
1627 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1628 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1629 ).workerVirtualTaskRunTime
1630 ).toBeGreaterThanOrEqual(0)
1631 // We need to clean up the resources after our test
1632 await pool
.destroy()
1635 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1636 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1637 let pool
= new FixedThreadPool(
1639 './tests/worker-files/thread/testWorker.js'
1642 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1643 workerChoiceStrategy
1647 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1648 workerChoiceStrategy
1649 ).defaultWorkerWeight
1652 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1653 workerChoiceStrategy
1654 ).workerVirtualTaskRunTime
1656 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1658 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1659 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1663 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1664 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1665 ).defaultWorkerWeight
1666 ).toBeGreaterThan(0)
1668 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1669 workerChoiceStrategy
1670 ).workerVirtualTaskRunTime
1672 await pool
.destroy()
1673 pool
= new DynamicThreadPool(
1676 './tests/worker-files/thread/testWorker.js'
1679 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1680 workerChoiceStrategy
1684 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1685 workerChoiceStrategy
1686 ).defaultWorkerWeight
1689 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1690 workerChoiceStrategy
1691 ).workerVirtualTaskRunTime
1693 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1695 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1696 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1700 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1701 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1702 ).defaultWorkerWeight
1703 ).toBeGreaterThan(0)
1705 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1706 workerChoiceStrategy
1707 ).workerVirtualTaskRunTime
1709 // We need to clean up the resources after our test
1710 await pool
.destroy()
1713 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1714 const workerChoiceStrategy
=
1715 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1716 let pool
= new FixedThreadPool(
1718 './tests/worker-files/thread/testWorker.js',
1719 { workerChoiceStrategy
}
1721 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1722 useDynamicWorker
: true
1724 await pool
.destroy()
1725 pool
= new DynamicThreadPool(
1728 './tests/worker-files/thread/testWorker.js',
1729 { workerChoiceStrategy
}
1731 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1732 useDynamicWorker
: true
1734 // We need to clean up the resources after our test
1735 await pool
.destroy()
1738 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1739 const workerChoiceStrategy
=
1740 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1741 let pool
= new FixedThreadPool(
1743 './tests/worker-files/thread/testWorker.js',
1744 { workerChoiceStrategy
}
1747 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1765 await pool
.destroy()
1766 pool
= new DynamicThreadPool(
1769 './tests/worker-files/thread/testWorker.js',
1770 { workerChoiceStrategy
}
1773 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1791 // We need to clean up the resources after our test
1792 await pool
.destroy()
1795 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1796 const pool
= new FixedThreadPool(
1798 './tests/worker-files/thread/testWorker.js',
1800 workerChoiceStrategy
:
1801 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1804 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1805 const promises
= new Set()
1806 const maxMultiplier
= 2
1807 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1808 promises
.add(pool
.execute())
1810 await Promise
.all(promises
)
1811 for (const workerNode
of pool
.workerNodes
) {
1812 expect(workerNode
.workerUsage
).toStrictEqual({
1814 executed
: maxMultiplier
,
1823 history
: expect
.any(CircularArray
)
1829 history
: expect
.any(CircularArray
)
1836 history
: expect
.any(CircularArray
)
1842 history
: expect
.any(CircularArray
)
1849 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1850 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1851 ).defaultWorkerWeight
1852 ).toBeGreaterThan(0)
1854 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1855 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1859 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1860 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1864 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1865 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1868 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1869 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1870 ).defaultWorkerWeight
1872 // We need to clean up the resources after our test
1873 await pool
.destroy()
1876 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1877 const pool
= new DynamicThreadPool(
1880 './tests/worker-files/thread/testWorker.js',
1882 workerChoiceStrategy
:
1883 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1886 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1887 const promises
= new Set()
1888 const maxMultiplier
= 2
1889 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1890 promises
.add(pool
.execute())
1892 await Promise
.all(promises
)
1893 for (const workerNode
of pool
.workerNodes
) {
1894 expect(workerNode
.workerUsage
).toStrictEqual({
1896 executed
: maxMultiplier
,
1905 history
: expect
.any(CircularArray
)
1911 history
: expect
.any(CircularArray
)
1918 history
: expect
.any(CircularArray
)
1924 history
: expect
.any(CircularArray
)
1931 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1932 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1933 ).defaultWorkerWeight
1934 ).toBeGreaterThan(0)
1936 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1937 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1941 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1942 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1946 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1947 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1950 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1951 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1952 ).defaultWorkerWeight
1954 // We need to clean up the resources after our test
1955 await pool
.destroy()
1958 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1959 const workerChoiceStrategy
=
1960 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1961 let pool
= new FixedThreadPool(
1963 './tests/worker-files/thread/testWorker.js'
1966 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1967 workerChoiceStrategy
1971 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1972 workerChoiceStrategy
1976 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1977 workerChoiceStrategy
1978 ).defaultWorkerWeight
1981 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1982 workerChoiceStrategy
1985 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1987 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1988 workerChoiceStrategy
1992 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1993 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1997 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1998 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1999 ).defaultWorkerWeight
2000 ).toBeGreaterThan(0)
2002 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2003 workerChoiceStrategy
2006 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2007 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2008 ).defaultWorkerWeight
2010 await pool
.destroy()
2011 pool
= new DynamicThreadPool(
2014 './tests/worker-files/thread/testWorker.js'
2017 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2018 workerChoiceStrategy
2022 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2023 workerChoiceStrategy
2027 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2028 workerChoiceStrategy
2029 ).defaultWorkerWeight
2032 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2033 workerChoiceStrategy
2036 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
2038 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2039 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2043 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2044 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2045 ).defaultWorkerWeight
2046 ).toBeGreaterThan(0)
2048 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2049 workerChoiceStrategy
2052 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2053 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2054 ).defaultWorkerWeight
2056 // We need to clean up the resources after our test
2057 await pool
.destroy()
2060 it('Verify unknown strategy throw error', () => {
2063 new DynamicThreadPool(
2066 './tests/worker-files/thread/testWorker.js',
2067 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
2069 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")