1 const { expect
} = require('expect')
8 } = require('../../../lib')
9 const { CircularArray
} = require('../../../lib/circular-array')
11 describe('Selection strategies test suite', () => {
15 it('Verify that WorkerChoiceStrategies enumeration provides string values', () => {
16 expect(WorkerChoiceStrategies
.ROUND_ROBIN
).toBe('ROUND_ROBIN')
17 expect(WorkerChoiceStrategies
.LEAST_USED
).toBe('LEAST_USED')
18 expect(WorkerChoiceStrategies
.LEAST_BUSY
).toBe('LEAST_BUSY')
19 expect(WorkerChoiceStrategies
.LEAST_ELU
).toBe('LEAST_ELU')
20 expect(WorkerChoiceStrategies
.FAIR_SHARE
).toBe('FAIR_SHARE')
21 expect(WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
).toBe(
22 'WEIGHTED_ROUND_ROBIN'
24 expect(WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
).toBe(
25 'INTERLEAVED_WEIGHTED_ROUND_ROBIN'
29 it('Verify ROUND_ROBIN strategy is the default at pool creation', async () => {
30 const pool
= new DynamicThreadPool(
33 './tests/worker-files/thread/testWorker.js'
35 expect(pool
.opts
.workerChoiceStrategy
).toBe(
36 WorkerChoiceStrategies
.ROUND_ROBIN
38 // We need to clean up the resources after our test
42 it('Verify available strategies are taken at pool creation', async () => {
43 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
44 const pool
= new FixedThreadPool(
46 './tests/worker-files/thread/testWorker.js',
47 { workerChoiceStrategy
}
49 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
50 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
57 it('Verify available strategies can be set after pool creation', async () => {
58 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
59 const pool
= new DynamicThreadPool(
62 './tests/worker-files/thread/testWorker.js'
64 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
65 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
66 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
69 expect(pool
.opts
.workerChoiceStrategyOptions
).toStrictEqual({
71 runTime
: { median
: false },
72 waitTime
: { median
: false },
73 elu
: { median
: false }
75 expect(pool
.workerChoiceStrategyContext
.opts
).toStrictEqual({
77 runTime
: { median
: false },
78 waitTime
: { median
: false },
79 elu
: { median
: false }
83 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
84 const pool
= new DynamicClusterPool(
87 './tests/worker-files/cluster/testWorker.js'
89 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
, { retries
: 3 })
90 expect(pool
.opts
.workerChoiceStrategy
).toBe(workerChoiceStrategy
)
91 expect(pool
.workerChoiceStrategyContext
.workerChoiceStrategy
).toBe(
94 expect(pool
.opts
.workerChoiceStrategyOptions
).toStrictEqual({
96 runTime
: { median
: false },
97 waitTime
: { median
: false },
98 elu
: { median
: false }
100 expect(pool
.workerChoiceStrategyContext
.opts
).toStrictEqual({
102 runTime
: { median
: false },
103 waitTime
: { median
: false },
104 elu
: { median
: false }
110 it('Verify available strategies default internals at pool creation', async () => {
111 const pool
= new FixedThreadPool(
113 './tests/worker-files/thread/testWorker.js'
115 for (const workerChoiceStrategy
of Object
.values(WorkerChoiceStrategies
)) {
116 if (workerChoiceStrategy
=== WorkerChoiceStrategies
.ROUND_ROBIN
) {
118 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
122 } else if (workerChoiceStrategy
=== WorkerChoiceStrategies
.FAIR_SHARE
) {
124 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
126 ).workersVirtualTaskEndTimestamp
127 ).toBeInstanceOf(Array
)
129 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
131 ).workersVirtualTaskEndTimestamp
.length
134 workerChoiceStrategy
=== WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
137 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
142 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
144 ).defaultWorkerWeight
147 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
149 ).workerVirtualTaskRunTime
156 it('Verify ROUND_ROBIN strategy default policy', async () => {
157 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
158 let pool
= new FixedThreadPool(
160 './tests/worker-files/thread/testWorker.js',
161 { workerChoiceStrategy
}
163 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
164 dynamicWorkerUsage
: false,
165 dynamicWorkerReady
: true
168 pool
= new DynamicThreadPool(
171 './tests/worker-files/thread/testWorker.js',
172 { workerChoiceStrategy
}
174 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
175 dynamicWorkerUsage
: false,
176 dynamicWorkerReady
: true
178 // We need to clean up the resources after our test
182 it('Verify ROUND_ROBIN strategy default tasks statistics requirements', async () => {
183 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
184 let pool
= new FixedThreadPool(
186 './tests/worker-files/thread/testWorker.js',
187 { workerChoiceStrategy
}
190 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
209 pool
= new DynamicThreadPool(
212 './tests/worker-files/thread/testWorker.js',
213 { workerChoiceStrategy
}
216 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
234 // We need to clean up the resources after our test
238 it('Verify ROUND_ROBIN strategy can be run in a fixed pool', async () => {
239 const pool
= new FixedThreadPool(
241 './tests/worker-files/thread/testWorker.js',
242 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
244 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
245 const promises
= new Set()
246 const maxMultiplier
= 2
247 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
248 promises
.add(pool
.execute())
250 await Promise
.all(promises
)
251 for (const workerNode
of pool
.workerNodes
) {
252 expect(workerNode
.usage
).toStrictEqual({
254 executed
: maxMultiplier
,
262 history
: expect
.any(CircularArray
)
265 history
: expect
.any(CircularArray
)
269 history
: expect
.any(CircularArray
)
272 history
: expect
.any(CircularArray
)
278 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
279 WorkerChoiceStrategies
.ROUND_ROBIN
282 // We need to clean up the resources after our test
286 it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
287 const pool
= new DynamicThreadPool(
290 './tests/worker-files/thread/testWorker.js',
291 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
293 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
294 const promises
= new Set()
295 const maxMultiplier
= 2
296 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
297 promises
.add(pool
.execute())
299 await Promise
.all(promises
)
300 for (const workerNode
of pool
.workerNodes
) {
301 expect(workerNode
.usage
).toStrictEqual({
303 executed
: expect
.any(Number
),
311 history
: expect
.any(CircularArray
)
314 history
: expect
.any(CircularArray
)
318 history
: expect
.any(CircularArray
)
321 history
: expect
.any(CircularArray
)
325 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
326 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
331 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
332 WorkerChoiceStrategies
.ROUND_ROBIN
335 // We need to clean up the resources after our test
339 it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
340 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
341 let pool
= new FixedClusterPool(
343 './tests/worker-files/cluster/testWorker.js',
344 { workerChoiceStrategy
}
346 let results
= new Set()
347 for (let i
= 0; i
< max
; i
++) {
348 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.id
)
350 expect(results
.size
).toBe(max
)
352 pool
= new FixedThreadPool(
354 './tests/worker-files/thread/testWorker.js',
355 { workerChoiceStrategy
}
358 for (let i
= 0; i
< max
; i
++) {
359 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.threadId
)
361 expect(results
.size
).toBe(max
)
365 it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
366 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
367 let pool
= new FixedThreadPool(
369 './tests/worker-files/thread/testWorker.js',
370 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
373 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
377 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
379 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
380 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
384 pool
= new DynamicThreadPool(
387 './tests/worker-files/thread/testWorker.js',
388 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
391 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
395 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
397 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
398 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
401 // We need to clean up the resources after our test
405 it('Verify LEAST_USED strategy default policy', async () => {
406 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
407 let pool
= new FixedThreadPool(
409 './tests/worker-files/thread/testWorker.js',
410 { workerChoiceStrategy
}
412 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
413 dynamicWorkerUsage
: false,
414 dynamicWorkerReady
: true
417 pool
= new DynamicThreadPool(
420 './tests/worker-files/thread/testWorker.js',
421 { workerChoiceStrategy
}
423 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
424 dynamicWorkerUsage
: false,
425 dynamicWorkerReady
: true
427 // We need to clean up the resources after our test
431 it('Verify LEAST_USED strategy default tasks statistics requirements', async () => {
432 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
433 let pool
= new FixedThreadPool(
435 './tests/worker-files/thread/testWorker.js',
436 { workerChoiceStrategy
}
439 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
458 pool
= new DynamicThreadPool(
461 './tests/worker-files/thread/testWorker.js',
462 { workerChoiceStrategy
}
465 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
483 // We need to clean up the resources after our test
487 it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
488 const pool
= new FixedThreadPool(
490 './tests/worker-files/thread/testWorker.js',
491 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
493 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
494 const promises
= new Set()
495 const maxMultiplier
= 2
496 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
497 promises
.add(pool
.execute())
499 await Promise
.all(promises
)
500 for (const workerNode
of pool
.workerNodes
) {
501 expect(workerNode
.usage
).toStrictEqual({
503 executed
: expect
.any(Number
),
511 history
: expect
.any(CircularArray
)
514 history
: expect
.any(CircularArray
)
518 history
: expect
.any(CircularArray
)
521 history
: expect
.any(CircularArray
)
525 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
526 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
530 // We need to clean up the resources after our test
534 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
535 const pool
= new DynamicThreadPool(
538 './tests/worker-files/thread/testWorker.js',
539 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
541 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
542 const promises
= new Set()
543 const maxMultiplier
= 2
544 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
545 promises
.add(pool
.execute())
547 await Promise
.all(promises
)
548 for (const workerNode
of pool
.workerNodes
) {
549 expect(workerNode
.usage
).toStrictEqual({
551 executed
: expect
.any(Number
),
559 history
: expect
.any(CircularArray
)
562 history
: expect
.any(CircularArray
)
566 history
: expect
.any(CircularArray
)
569 history
: expect
.any(CircularArray
)
573 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
574 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
578 // We need to clean up the resources after our test
582 it('Verify LEAST_BUSY strategy default policy', async () => {
583 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
584 let pool
= new FixedThreadPool(
586 './tests/worker-files/thread/testWorker.js',
587 { workerChoiceStrategy
}
589 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
590 dynamicWorkerUsage
: false,
591 dynamicWorkerReady
: true
594 pool
= new DynamicThreadPool(
597 './tests/worker-files/thread/testWorker.js',
598 { workerChoiceStrategy
}
600 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
601 dynamicWorkerUsage
: false,
602 dynamicWorkerReady
: true
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
).toMatchObject({
680 executed
: expect
.any(Number
),
688 history
: expect
.any(CircularArray
)
691 history
: expect
.any(CircularArray
)
695 history
: expect
.any(CircularArray
)
698 history
: expect
.any(CircularArray
)
702 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
703 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
706 if (workerNode
.usage
.runTime
.aggregate
== null) {
707 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
709 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
711 if (workerNode
.usage
.waitTime
.aggregate
== null) {
712 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
714 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
717 // We need to clean up the resources after our test
721 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
722 const pool
= new DynamicThreadPool(
725 './tests/worker-files/thread/testWorker.js',
726 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
728 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
729 const promises
= new Set()
730 const maxMultiplier
= 2
731 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
732 promises
.add(pool
.execute())
734 await Promise
.all(promises
)
735 for (const workerNode
of pool
.workerNodes
) {
736 expect(workerNode
.usage
).toMatchObject({
738 executed
: expect
.any(Number
),
746 history
: expect
.any(CircularArray
)
749 history
: expect
.any(CircularArray
)
753 history
: expect
.any(CircularArray
)
756 history
: expect
.any(CircularArray
)
760 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
761 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
764 if (workerNode
.usage
.runTime
.aggregate
== null) {
765 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
767 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
769 if (workerNode
.usage
.waitTime
.aggregate
== null) {
770 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
772 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
775 // We need to clean up the resources after our test
779 it('Verify LEAST_ELU strategy default policy', async () => {
780 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
781 let pool
= new FixedThreadPool(
783 './tests/worker-files/thread/testWorker.js',
784 { workerChoiceStrategy
}
786 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
787 dynamicWorkerUsage
: false,
788 dynamicWorkerReady
: true
791 pool
= new DynamicThreadPool(
794 './tests/worker-files/thread/testWorker.js',
795 { workerChoiceStrategy
}
797 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
798 dynamicWorkerUsage
: false,
799 dynamicWorkerReady
: true
801 // We need to clean up the resources after our test
805 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
806 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
807 let pool
= new FixedThreadPool(
809 './tests/worker-files/thread/testWorker.js',
810 { workerChoiceStrategy
}
813 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
832 pool
= new DynamicThreadPool(
835 './tests/worker-files/thread/testWorker.js',
836 { workerChoiceStrategy
}
839 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
857 // We need to clean up the resources after our test
861 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
862 const pool
= new FixedThreadPool(
864 './tests/worker-files/thread/testWorker.js',
865 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
867 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
868 const promises
= new Set()
869 const maxMultiplier
= 2
870 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
871 promises
.add(pool
.execute())
873 await Promise
.all(promises
)
874 for (const workerNode
of pool
.workerNodes
) {
875 expect(workerNode
.usage
).toMatchObject({
877 executed
: expect
.any(Number
),
885 history
: expect
.any(CircularArray
)
888 history
: expect
.any(CircularArray
)
892 history
: expect
.any(CircularArray
)
895 history
: expect
.any(CircularArray
)
899 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
900 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
903 if (workerNode
.usage
.elu
.utilization
== null) {
904 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
906 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
907 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
910 // We need to clean up the resources after our test
914 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
915 const pool
= new DynamicThreadPool(
918 './tests/worker-files/thread/testWorker.js',
919 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
921 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
922 const promises
= new Set()
923 const maxMultiplier
= 2
924 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
925 promises
.add(pool
.execute())
927 await Promise
.all(promises
)
928 for (const workerNode
of pool
.workerNodes
) {
929 expect(workerNode
.usage
).toMatchObject({
931 executed
: expect
.any(Number
),
939 history
: expect
.any(CircularArray
)
942 history
: expect
.any(CircularArray
)
946 history
: expect
.any(CircularArray
)
949 history
: expect
.any(CircularArray
)
953 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
954 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
957 if (workerNode
.usage
.elu
.utilization
== null) {
958 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
960 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
961 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
964 // We need to clean up the resources after our test
968 it('Verify FAIR_SHARE strategy default policy', async () => {
969 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
970 let pool
= new FixedThreadPool(
972 './tests/worker-files/thread/testWorker.js',
973 { workerChoiceStrategy
}
975 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
976 dynamicWorkerUsage
: false,
977 dynamicWorkerReady
: true
980 pool
= new DynamicThreadPool(
983 './tests/worker-files/thread/testWorker.js',
984 { workerChoiceStrategy
}
986 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
987 dynamicWorkerUsage
: false,
988 dynamicWorkerReady
: true
990 // We need to clean up the resources after our test
994 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
995 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
996 let pool
= new FixedThreadPool(
998 './tests/worker-files/thread/testWorker.js',
999 { workerChoiceStrategy
}
1002 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1020 await pool
.destroy()
1021 pool
= new DynamicThreadPool(
1024 './tests/worker-files/thread/testWorker.js',
1025 { workerChoiceStrategy
}
1028 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1046 // We need to clean up the resources after our test
1047 await pool
.destroy()
1050 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
1051 const pool
= new FixedThreadPool(
1053 './tests/worker-files/thread/testWorker.js',
1054 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1056 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1057 const promises
= new Set()
1058 const maxMultiplier
= 2
1059 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1060 promises
.add(pool
.execute())
1062 await Promise
.all(promises
)
1063 for (const workerNode
of pool
.workerNodes
) {
1064 expect(workerNode
.usage
).toMatchObject({
1066 executed
: expect
.any(Number
),
1074 history
: expect
.any(CircularArray
)
1077 history
: expect
.any(CircularArray
)
1081 history
: expect
.any(CircularArray
)
1084 history
: expect
.any(CircularArray
)
1088 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1089 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1092 if (workerNode
.usage
.runTime
.aggregate
== null) {
1093 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1095 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1097 if (workerNode
.usage
.runTime
.average
== null) {
1098 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1100 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1102 if (workerNode
.usage
.elu
.utilization
== null) {
1103 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1105 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1106 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1110 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1111 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1112 ).workersVirtualTaskEndTimestamp
.length
1113 ).toBe(pool
.workerNodes
.length
)
1114 // We need to clean up the resources after our test
1115 await pool
.destroy()
1118 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1119 const pool
= new DynamicThreadPool(
1122 './tests/worker-files/thread/testWorker.js',
1123 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1125 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1126 const promises
= new Set()
1127 const maxMultiplier
= 2
1128 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1129 promises
.add(pool
.execute())
1131 await Promise
.all(promises
)
1132 for (const workerNode
of pool
.workerNodes
) {
1133 expect(workerNode
.usage
).toMatchObject({
1135 executed
: expect
.any(Number
),
1143 history
: expect
.any(CircularArray
)
1146 history
: expect
.any(CircularArray
)
1150 history
: expect
.any(CircularArray
)
1153 history
: expect
.any(CircularArray
)
1157 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1158 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1161 if (workerNode
.usage
.runTime
.aggregate
== null) {
1162 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1164 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1166 if (workerNode
.usage
.runTime
.average
== null) {
1167 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1169 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1171 if (workerNode
.usage
.elu
.utilization
== null) {
1172 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1174 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1175 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1179 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1180 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1181 ).workersVirtualTaskEndTimestamp
.length
1182 ).toBe(pool
.workerNodes
.length
)
1183 // We need to clean up the resources after our test
1184 await pool
.destroy()
1187 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1188 const pool
= new DynamicThreadPool(
1191 './tests/worker-files/thread/testWorker.js',
1193 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1194 workerChoiceStrategyOptions
: {
1195 runTime
: { median
: true }
1199 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1200 const promises
= new Set()
1201 const maxMultiplier
= 2
1202 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1203 promises
.add(pool
.execute())
1205 await Promise
.all(promises
)
1206 for (const workerNode
of pool
.workerNodes
) {
1207 expect(workerNode
.usage
).toMatchObject({
1209 executed
: expect
.any(Number
),
1217 history
: expect
.any(CircularArray
)
1220 history
: expect
.any(CircularArray
)
1224 history
: expect
.any(CircularArray
)
1227 history
: expect
.any(CircularArray
)
1231 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1232 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1235 if (workerNode
.usage
.runTime
.aggregate
== null) {
1236 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1238 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1240 if (workerNode
.usage
.runTime
.median
== null) {
1241 expect(workerNode
.usage
.runTime
.median
).toBeUndefined()
1243 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1245 if (workerNode
.usage
.elu
.utilization
== null) {
1246 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1248 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1249 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1253 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1254 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1255 ).workersVirtualTaskEndTimestamp
.length
1256 ).toBe(pool
.workerNodes
.length
)
1257 // We need to clean up the resources after our test
1258 await pool
.destroy()
1261 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1262 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1263 let pool
= new FixedThreadPool(
1265 './tests/worker-files/thread/testWorker.js'
1268 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1269 workerChoiceStrategy
1270 ).workersVirtualTaskEndTimestamp
1271 ).toBeInstanceOf(Array
)
1273 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1274 workerChoiceStrategy
1275 ).workersVirtualTaskEndTimestamp
.length
1277 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1278 workerChoiceStrategy
1279 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1281 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1282 workerChoiceStrategy
1283 ).workersVirtualTaskEndTimestamp
.length
1285 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1287 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1288 workerChoiceStrategy
1289 ).workersVirtualTaskEndTimestamp
1290 ).toBeInstanceOf(Array
)
1292 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1293 workerChoiceStrategy
1294 ).workersVirtualTaskEndTimestamp
.length
1296 await pool
.destroy()
1297 pool
= new DynamicThreadPool(
1300 './tests/worker-files/thread/testWorker.js'
1303 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1304 workerChoiceStrategy
1305 ).workersVirtualTaskEndTimestamp
1306 ).toBeInstanceOf(Array
)
1308 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1309 workerChoiceStrategy
1310 ).workersVirtualTaskEndTimestamp
.length
1312 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1313 workerChoiceStrategy
1314 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1316 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1317 workerChoiceStrategy
1318 ).workersVirtualTaskEndTimestamp
.length
1320 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1322 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1323 workerChoiceStrategy
1324 ).workersVirtualTaskEndTimestamp
1325 ).toBeInstanceOf(Array
)
1327 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1328 workerChoiceStrategy
1329 ).workersVirtualTaskEndTimestamp
.length
1331 // We need to clean up the resources after our test
1332 await pool
.destroy()
1335 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1336 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1337 let pool
= new FixedThreadPool(
1339 './tests/worker-files/thread/testWorker.js',
1340 { workerChoiceStrategy
}
1342 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1343 dynamicWorkerUsage
: false,
1344 dynamicWorkerReady
: true
1346 await pool
.destroy()
1347 pool
= new DynamicThreadPool(
1350 './tests/worker-files/thread/testWorker.js',
1351 { workerChoiceStrategy
}
1353 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1354 dynamicWorkerUsage
: false,
1355 dynamicWorkerReady
: true
1357 // We need to clean up the resources after our test
1358 await pool
.destroy()
1361 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1362 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1363 let pool
= new FixedThreadPool(
1365 './tests/worker-files/thread/testWorker.js',
1366 { workerChoiceStrategy
}
1369 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1387 await pool
.destroy()
1388 pool
= new DynamicThreadPool(
1391 './tests/worker-files/thread/testWorker.js',
1392 { workerChoiceStrategy
}
1395 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1413 // We need to clean up the resources after our test
1414 await pool
.destroy()
1417 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1418 const pool
= new FixedThreadPool(
1420 './tests/worker-files/thread/testWorker.js',
1421 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1423 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1424 const promises
= new Set()
1425 const maxMultiplier
= 2
1426 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1427 promises
.add(pool
.execute())
1429 await Promise
.all(promises
)
1430 for (const workerNode
of pool
.workerNodes
) {
1431 expect(workerNode
.usage
).toStrictEqual({
1433 executed
: expect
.any(Number
),
1440 runTime
: expect
.objectContaining({
1441 history
: expect
.any(CircularArray
)
1444 history
: expect
.any(CircularArray
)
1448 history
: expect
.any(CircularArray
)
1451 history
: expect
.any(CircularArray
)
1455 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1456 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1459 if (workerNode
.usage
.runTime
.aggregate
== null) {
1460 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1462 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1464 if (workerNode
.usage
.runTime
.average
== null) {
1465 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1467 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1471 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1472 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1473 ).defaultWorkerWeight
1474 ).toBeGreaterThan(0)
1476 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1477 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1478 ).workerVirtualTaskRunTime
1479 ).toBeGreaterThanOrEqual(0)
1480 // We need to clean up the resources after our test
1481 await pool
.destroy()
1484 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1485 const pool
= new DynamicThreadPool(
1488 './tests/worker-files/thread/testWorker.js',
1489 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1491 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1492 const promises
= new Set()
1493 const maxMultiplier
= 2
1494 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1495 promises
.add(pool
.execute())
1497 await Promise
.all(promises
)
1498 for (const workerNode
of pool
.workerNodes
) {
1499 expect(workerNode
.usage
).toStrictEqual({
1501 executed
: expect
.any(Number
),
1508 runTime
: expect
.objectContaining({
1509 history
: expect
.any(CircularArray
)
1512 history
: expect
.any(CircularArray
)
1516 history
: expect
.any(CircularArray
)
1519 history
: expect
.any(CircularArray
)
1523 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1524 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1527 if (workerNode
.usage
.runTime
.aggregate
== null) {
1528 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1530 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1532 if (workerNode
.usage
.runTime
.average
== null) {
1533 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1535 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1539 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1540 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1541 ).defaultWorkerWeight
1542 ).toBeGreaterThan(0)
1544 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1545 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1546 ).workerVirtualTaskRunTime
1547 ).toBeGreaterThanOrEqual(0)
1548 // We need to clean up the resources after our test
1549 await pool
.destroy()
1552 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1553 const pool
= new DynamicThreadPool(
1556 './tests/worker-files/thread/testWorker.js',
1558 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1559 workerChoiceStrategyOptions
: {
1560 runTime
: { median
: true }
1564 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1565 const promises
= new Set()
1566 const maxMultiplier
= 2
1567 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1568 promises
.add(pool
.execute())
1570 await Promise
.all(promises
)
1571 for (const workerNode
of pool
.workerNodes
) {
1572 expect(workerNode
.usage
).toStrictEqual({
1574 executed
: expect
.any(Number
),
1581 runTime
: expect
.objectContaining({
1582 history
: expect
.any(CircularArray
)
1585 history
: expect
.any(CircularArray
)
1589 history
: expect
.any(CircularArray
)
1592 history
: expect
.any(CircularArray
)
1596 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1597 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1600 if (workerNode
.usage
.runTime
.aggregate
== null) {
1601 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1603 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1605 if (workerNode
.usage
.runTime
.median
== null) {
1606 expect(workerNode
.usage
.runTime
.median
).toBeUndefined()
1608 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1612 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1613 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1614 ).defaultWorkerWeight
1615 ).toBeGreaterThan(0)
1617 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1618 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1619 ).workerVirtualTaskRunTime
1620 ).toBeGreaterThanOrEqual(0)
1621 // We need to clean up the resources after our test
1622 await pool
.destroy()
1625 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1626 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1627 let pool
= new FixedThreadPool(
1629 './tests/worker-files/thread/testWorker.js'
1632 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1633 workerChoiceStrategy
1637 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1638 workerChoiceStrategy
1639 ).defaultWorkerWeight
1642 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1643 workerChoiceStrategy
1644 ).workerVirtualTaskRunTime
1646 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1648 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1649 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1653 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1654 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1655 ).defaultWorkerWeight
1656 ).toBeGreaterThan(0)
1658 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1659 workerChoiceStrategy
1660 ).workerVirtualTaskRunTime
1662 await pool
.destroy()
1663 pool
= new DynamicThreadPool(
1666 './tests/worker-files/thread/testWorker.js'
1669 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1670 workerChoiceStrategy
1674 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1675 workerChoiceStrategy
1676 ).defaultWorkerWeight
1679 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1680 workerChoiceStrategy
1681 ).workerVirtualTaskRunTime
1683 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1685 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1686 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1690 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1691 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1692 ).defaultWorkerWeight
1693 ).toBeGreaterThan(0)
1695 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1696 workerChoiceStrategy
1697 ).workerVirtualTaskRunTime
1699 // We need to clean up the resources after our test
1700 await pool
.destroy()
1703 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1704 const workerChoiceStrategy
=
1705 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1706 let pool
= new FixedThreadPool(
1708 './tests/worker-files/thread/testWorker.js',
1709 { workerChoiceStrategy
}
1711 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1712 dynamicWorkerUsage
: false,
1713 dynamicWorkerReady
: true
1715 await pool
.destroy()
1716 pool
= new DynamicThreadPool(
1719 './tests/worker-files/thread/testWorker.js',
1720 { workerChoiceStrategy
}
1722 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1723 dynamicWorkerUsage
: false,
1724 dynamicWorkerReady
: true
1726 // We need to clean up the resources after our test
1727 await pool
.destroy()
1730 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1731 const workerChoiceStrategy
=
1732 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1733 let pool
= new FixedThreadPool(
1735 './tests/worker-files/thread/testWorker.js',
1736 { workerChoiceStrategy
}
1739 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1757 await pool
.destroy()
1758 pool
= new DynamicThreadPool(
1761 './tests/worker-files/thread/testWorker.js',
1762 { workerChoiceStrategy
}
1765 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1783 // We need to clean up the resources after our test
1784 await pool
.destroy()
1787 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1788 const pool
= new FixedThreadPool(
1790 './tests/worker-files/thread/testWorker.js',
1792 workerChoiceStrategy
:
1793 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1796 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1797 const promises
= new Set()
1798 const maxMultiplier
= 2
1799 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1800 promises
.add(pool
.execute())
1802 await Promise
.all(promises
)
1803 for (const workerNode
of pool
.workerNodes
) {
1804 expect(workerNode
.usage
).toStrictEqual({
1806 executed
: maxMultiplier
,
1814 history
: expect
.any(CircularArray
)
1817 history
: expect
.any(CircularArray
)
1821 history
: expect
.any(CircularArray
)
1824 history
: expect
.any(CircularArray
)
1830 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1831 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1832 ).defaultWorkerWeight
1833 ).toBeGreaterThan(0)
1835 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1836 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1840 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1841 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1845 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1846 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1849 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1850 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1851 ).defaultWorkerWeight
1853 // We need to clean up the resources after our test
1854 await pool
.destroy()
1857 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1858 const pool
= new DynamicThreadPool(
1861 './tests/worker-files/thread/testWorker.js',
1863 workerChoiceStrategy
:
1864 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1867 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1868 const promises
= new Set()
1869 const maxMultiplier
= 2
1870 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1871 promises
.add(pool
.execute())
1873 await Promise
.all(promises
)
1874 for (const workerNode
of pool
.workerNodes
) {
1875 expect(workerNode
.usage
).toStrictEqual({
1877 executed
: expect
.any(Number
),
1885 history
: expect
.any(CircularArray
)
1888 history
: expect
.any(CircularArray
)
1892 history
: expect
.any(CircularArray
)
1895 history
: expect
.any(CircularArray
)
1899 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1900 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1905 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1906 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1907 ).defaultWorkerWeight
1908 ).toBeGreaterThan(0)
1910 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1911 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1915 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1916 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1920 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1921 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1924 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1925 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1926 ).defaultWorkerWeight
1928 // We need to clean up the resources after our test
1929 await pool
.destroy()
1932 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1933 const workerChoiceStrategy
=
1934 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1935 let pool
= new FixedThreadPool(
1937 './tests/worker-files/thread/testWorker.js'
1940 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1941 workerChoiceStrategy
1945 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1946 workerChoiceStrategy
1950 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1951 workerChoiceStrategy
1952 ).defaultWorkerWeight
1955 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1956 workerChoiceStrategy
1959 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1961 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1962 workerChoiceStrategy
1966 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1967 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1971 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1972 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1973 ).defaultWorkerWeight
1974 ).toBeGreaterThan(0)
1976 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1977 workerChoiceStrategy
1980 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1981 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1982 ).defaultWorkerWeight
1984 await pool
.destroy()
1985 pool
= new DynamicThreadPool(
1988 './tests/worker-files/thread/testWorker.js'
1991 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1992 workerChoiceStrategy
1996 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1997 workerChoiceStrategy
2001 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2002 workerChoiceStrategy
2003 ).defaultWorkerWeight
2006 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2007 workerChoiceStrategy
2010 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
2012 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2013 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2017 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2018 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2019 ).defaultWorkerWeight
2020 ).toBeGreaterThan(0)
2022 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2023 workerChoiceStrategy
2026 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
2027 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
2028 ).defaultWorkerWeight
2030 // We need to clean up the resources after our test
2031 await pool
.destroy()
2034 it('Verify unknown strategy throw error', () => {
2037 new DynamicThreadPool(
2040 './tests/worker-files/thread/testWorker.js',
2041 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
2043 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")