1 const { expect
} = require('expect')
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
,
221 history
: expect
.any(CircularArray
)
224 history
: expect
.any(CircularArray
)
228 history
: expect
.any(CircularArray
)
231 history
: expect
.any(CircularArray
)
237 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
238 WorkerChoiceStrategies
.ROUND_ROBIN
241 // We need to clean up the resources after our test
245 it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
246 const pool
= new DynamicThreadPool(
249 './tests/worker-files/thread/testWorker.js',
250 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
252 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
253 const promises
= new Set()
254 const maxMultiplier
= 2
255 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
256 promises
.add(pool
.execute())
258 await Promise
.all(promises
)
259 for (const workerNode
of pool
.workerNodes
) {
260 expect(workerNode
.usage
).toStrictEqual({
262 executed
: maxMultiplier
,
269 history
: expect
.any(CircularArray
)
272 history
: expect
.any(CircularArray
)
276 history
: expect
.any(CircularArray
)
279 history
: expect
.any(CircularArray
)
285 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
286 WorkerChoiceStrategies
.ROUND_ROBIN
289 // We need to clean up the resources after our test
293 it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
294 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
295 let pool
= new FixedClusterPool(
297 './tests/worker-files/cluster/testWorker.js',
298 { workerChoiceStrategy
}
300 let results
= new Set()
301 for (let i
= 0; i
< max
; i
++) {
302 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.id
)
304 expect(results
.size
).toBe(max
)
306 pool
= new FixedThreadPool(
308 './tests/worker-files/thread/testWorker.js',
309 { workerChoiceStrategy
}
312 for (let i
= 0; i
< max
; i
++) {
313 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.threadId
)
315 expect(results
.size
).toBe(max
)
319 it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
320 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
321 let pool
= new FixedThreadPool(
323 './tests/worker-files/thread/testWorker.js',
324 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
327 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
331 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
333 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
334 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
338 pool
= new DynamicThreadPool(
341 './tests/worker-files/thread/testWorker.js',
342 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
345 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
349 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
351 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
352 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
355 // We need to clean up the resources after our test
359 it('Verify LEAST_USED strategy default policy', async () => {
360 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
361 let pool
= new FixedThreadPool(
363 './tests/worker-files/thread/testWorker.js',
364 { workerChoiceStrategy
}
366 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
367 useDynamicWorker
: false
370 pool
= new DynamicThreadPool(
373 './tests/worker-files/thread/testWorker.js',
374 { workerChoiceStrategy
}
376 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
377 useDynamicWorker
: false
379 // We need to clean up the resources after our test
383 it('Verify LEAST_USED strategy default tasks statistics requirements', async () => {
384 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
385 let pool
= new FixedThreadPool(
387 './tests/worker-files/thread/testWorker.js',
388 { workerChoiceStrategy
}
391 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
410 pool
= new DynamicThreadPool(
413 './tests/worker-files/thread/testWorker.js',
414 { workerChoiceStrategy
}
417 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
435 // We need to clean up the resources after our test
439 it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
440 const pool
= new FixedThreadPool(
442 './tests/worker-files/thread/testWorker.js',
443 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
445 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
446 const promises
= new Set()
447 const maxMultiplier
= 2
448 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
449 promises
.add(pool
.execute())
451 await Promise
.all(promises
)
452 for (const workerNode
of pool
.workerNodes
) {
453 expect(workerNode
.usage
).toStrictEqual({
455 executed
: expect
.any(Number
),
462 history
: expect
.any(CircularArray
)
465 history
: expect
.any(CircularArray
)
469 history
: expect
.any(CircularArray
)
472 history
: expect
.any(CircularArray
)
476 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
477 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
481 // We need to clean up the resources after our test
485 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
486 const pool
= new DynamicThreadPool(
489 './tests/worker-files/thread/testWorker.js',
490 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
492 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
493 const promises
= new Set()
494 const maxMultiplier
= 2
495 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
496 promises
.add(pool
.execute())
498 await Promise
.all(promises
)
499 for (const workerNode
of pool
.workerNodes
) {
500 expect(workerNode
.usage
).toStrictEqual({
502 executed
: expect
.any(Number
),
509 history
: expect
.any(CircularArray
)
512 history
: expect
.any(CircularArray
)
516 history
: expect
.any(CircularArray
)
519 history
: expect
.any(CircularArray
)
523 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
524 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
528 // We need to clean up the resources after our test
532 it('Verify LEAST_BUSY strategy default policy', async () => {
533 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
534 let pool
= new FixedThreadPool(
536 './tests/worker-files/thread/testWorker.js',
537 { workerChoiceStrategy
}
539 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
540 useDynamicWorker
: false
543 pool
= new DynamicThreadPool(
546 './tests/worker-files/thread/testWorker.js',
547 { workerChoiceStrategy
}
549 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
550 useDynamicWorker
: false
552 // We need to clean up the resources after our test
556 it('Verify LEAST_BUSY strategy default tasks statistics requirements', async () => {
557 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
558 let pool
= new FixedThreadPool(
560 './tests/worker-files/thread/testWorker.js',
561 { workerChoiceStrategy
}
564 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
583 pool
= new DynamicThreadPool(
586 './tests/worker-files/thread/testWorker.js',
587 { workerChoiceStrategy
}
590 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
608 // We need to clean up the resources after our test
612 it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
613 const pool
= new FixedThreadPool(
615 './tests/worker-files/thread/testWorker.js',
616 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
618 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
619 const promises
= new Set()
620 const maxMultiplier
= 2
621 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
622 promises
.add(pool
.execute())
624 await Promise
.all(promises
)
625 for (const workerNode
of pool
.workerNodes
) {
626 expect(workerNode
.usage
).toMatchObject({
628 executed
: expect
.any(Number
),
635 history
: expect
.any(CircularArray
)
638 history
: expect
.any(CircularArray
)
642 history
: expect
.any(CircularArray
)
645 history
: expect
.any(CircularArray
)
649 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
650 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
653 if (workerNode
.usage
.runTime
.aggregate
== null) {
654 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
656 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
658 if (workerNode
.usage
.waitTime
.aggregate
== null) {
659 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
661 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
664 // We need to clean up the resources after our test
668 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
669 const pool
= new DynamicThreadPool(
672 './tests/worker-files/thread/testWorker.js',
673 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
675 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
676 const promises
= new Set()
677 const maxMultiplier
= 2
678 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
679 promises
.add(pool
.execute())
681 await Promise
.all(promises
)
682 for (const workerNode
of pool
.workerNodes
) {
683 expect(workerNode
.usage
).toMatchObject({
685 executed
: expect
.any(Number
),
692 history
: expect
.any(CircularArray
)
695 history
: expect
.any(CircularArray
)
699 history
: expect
.any(CircularArray
)
702 history
: expect
.any(CircularArray
)
706 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
707 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
710 if (workerNode
.usage
.runTime
.aggregate
== null) {
711 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
713 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
715 if (workerNode
.usage
.waitTime
.aggregate
== null) {
716 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
718 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
721 // We need to clean up the resources after our test
725 it('Verify LEAST_ELU strategy default policy', async () => {
726 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
727 let pool
= new FixedThreadPool(
729 './tests/worker-files/thread/testWorker.js',
730 { workerChoiceStrategy
}
732 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
733 useDynamicWorker
: false
736 pool
= new DynamicThreadPool(
739 './tests/worker-files/thread/testWorker.js',
740 { workerChoiceStrategy
}
742 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
743 useDynamicWorker
: false
745 // We need to clean up the resources after our test
749 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
750 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
751 let pool
= new FixedThreadPool(
753 './tests/worker-files/thread/testWorker.js',
754 { workerChoiceStrategy
}
757 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
776 pool
= new DynamicThreadPool(
779 './tests/worker-files/thread/testWorker.js',
780 { workerChoiceStrategy
}
783 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
801 // We need to clean up the resources after our test
805 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
806 const pool
= new FixedThreadPool(
808 './tests/worker-files/thread/testWorker.js',
809 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
811 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
812 const promises
= new Set()
813 const maxMultiplier
= 2
814 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
815 promises
.add(pool
.execute())
817 await Promise
.all(promises
)
818 for (const workerNode
of pool
.workerNodes
) {
819 expect(workerNode
.usage
).toMatchObject({
821 executed
: expect
.any(Number
),
828 history
: expect
.any(CircularArray
)
831 history
: expect
.any(CircularArray
)
834 idle
: expect
.objectContaining({
835 history
: expect
.any(CircularArray
)
837 active
: expect
.objectContaining({
838 history
: expect
.any(CircularArray
)
842 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
843 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
846 if (workerNode
.usage
.elu
.utilization
== null) {
847 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
849 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
850 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
853 // We need to clean up the resources after our test
857 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
858 const pool
= new DynamicThreadPool(
861 './tests/worker-files/thread/testWorker.js',
862 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
864 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
865 const promises
= new Set()
866 const maxMultiplier
= 2
867 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
868 promises
.add(pool
.execute())
870 await Promise
.all(promises
)
871 for (const workerNode
of pool
.workerNodes
) {
872 expect(workerNode
.usage
).toMatchObject({
874 executed
: expect
.any(Number
),
881 history
: expect
.any(CircularArray
)
884 history
: expect
.any(CircularArray
)
887 idle
: expect
.objectContaining({
888 history
: expect
.any(CircularArray
)
890 active
: expect
.objectContaining({
891 history
: expect
.any(CircularArray
)
895 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
896 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
899 if (workerNode
.usage
.elu
.utilization
== null) {
900 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
902 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
903 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
906 // We need to clean up the resources after our test
910 it('Verify FAIR_SHARE strategy default policy', async () => {
911 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
912 let pool
= new FixedThreadPool(
914 './tests/worker-files/thread/testWorker.js',
915 { workerChoiceStrategy
}
917 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
918 useDynamicWorker
: false
921 pool
= new DynamicThreadPool(
924 './tests/worker-files/thread/testWorker.js',
925 { workerChoiceStrategy
}
927 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
928 useDynamicWorker
: false
930 // We need to clean up the resources after our test
934 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
935 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
936 let pool
= new FixedThreadPool(
938 './tests/worker-files/thread/testWorker.js',
939 { workerChoiceStrategy
}
942 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
961 pool
= new DynamicThreadPool(
964 './tests/worker-files/thread/testWorker.js',
965 { workerChoiceStrategy
}
968 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
986 // We need to clean up the resources after our test
990 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
991 const pool
= new FixedThreadPool(
993 './tests/worker-files/thread/testWorker.js',
994 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
996 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
997 const promises
= new Set()
998 const maxMultiplier
= 2
999 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1000 promises
.add(pool
.execute())
1002 await Promise
.all(promises
)
1003 for (const workerNode
of pool
.workerNodes
) {
1004 expect(workerNode
.usage
).toMatchObject({
1006 executed
: expect
.any(Number
),
1012 runTime
: expect
.objectContaining({
1013 history
: expect
.any(CircularArray
)
1016 history
: expect
.any(CircularArray
)
1019 idle
: expect
.objectContaining({
1020 history
: expect
.any(CircularArray
)
1022 active
: expect
.objectContaining({
1023 history
: expect
.any(CircularArray
)
1027 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1028 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1031 if (workerNode
.usage
.runTime
.aggregate
== null) {
1032 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1034 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1036 if (workerNode
.usage
.runTime
.average
== null) {
1037 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1039 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1041 if (workerNode
.usage
.elu
.utilization
== null) {
1042 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1044 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1045 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1049 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1050 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1051 ).workersVirtualTaskEndTimestamp
.length
1052 ).toBe(pool
.workerNodes
.length
)
1053 // We need to clean up the resources after our test
1054 await pool
.destroy()
1057 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1058 const pool
= new DynamicThreadPool(
1061 './tests/worker-files/thread/testWorker.js',
1062 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1064 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1065 const promises
= new Set()
1066 const maxMultiplier
= 2
1067 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1068 promises
.add(pool
.execute())
1070 await Promise
.all(promises
)
1071 for (const workerNode
of pool
.workerNodes
) {
1072 expect(workerNode
.usage
).toMatchObject({
1074 executed
: expect
.any(Number
),
1080 runTime
: expect
.objectContaining({
1081 history
: expect
.any(CircularArray
)
1084 history
: expect
.any(CircularArray
)
1087 idle
: expect
.objectContaining({
1088 history
: expect
.any(CircularArray
)
1090 active
: expect
.objectContaining({
1091 history
: expect
.any(CircularArray
)
1095 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1096 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1099 if (workerNode
.usage
.runTime
.aggregate
== null) {
1100 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1102 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1104 if (workerNode
.usage
.runTime
.average
== null) {
1105 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1107 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1109 if (workerNode
.usage
.elu
.utilization
== null) {
1110 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1112 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1113 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1117 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1118 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1119 ).workersVirtualTaskEndTimestamp
.length
1120 ).toBe(pool
.workerNodes
.length
)
1121 // We need to clean up the resources after our test
1122 await pool
.destroy()
1125 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1126 const pool
= new DynamicThreadPool(
1129 './tests/worker-files/thread/testWorker.js',
1131 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1132 workerChoiceStrategyOptions
: {
1133 runTime
: { median
: true }
1137 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1138 const promises
= new Set()
1139 const maxMultiplier
= 2
1140 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1141 promises
.add(pool
.execute())
1143 await Promise
.all(promises
)
1144 for (const workerNode
of pool
.workerNodes
) {
1145 expect(workerNode
.usage
).toMatchObject({
1147 executed
: expect
.any(Number
),
1153 runTime
: expect
.objectContaining({
1154 history
: expect
.any(CircularArray
)
1157 history
: expect
.any(CircularArray
)
1160 idle
: expect
.objectContaining({
1161 history
: expect
.any(CircularArray
)
1163 active
: expect
.objectContaining({
1164 history
: expect
.any(CircularArray
)
1168 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1169 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1172 if (workerNode
.usage
.runTime
.aggregate
== null) {
1173 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1175 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1177 if (workerNode
.usage
.runTime
.median
== null) {
1178 expect(workerNode
.usage
.runTime
.median
).toBeUndefined()
1180 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1182 if (workerNode
.usage
.elu
.utilization
== null) {
1183 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1185 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1186 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1190 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1191 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1192 ).workersVirtualTaskEndTimestamp
.length
1193 ).toBe(pool
.workerNodes
.length
)
1194 // We need to clean up the resources after our test
1195 await pool
.destroy()
1198 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1199 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1200 let pool
= new FixedThreadPool(
1202 './tests/worker-files/thread/testWorker.js'
1205 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1206 workerChoiceStrategy
1207 ).workersVirtualTaskEndTimestamp
1208 ).toBeInstanceOf(Array
)
1210 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1211 workerChoiceStrategy
1212 ).workersVirtualTaskEndTimestamp
.length
1214 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1215 workerChoiceStrategy
1216 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1218 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1219 workerChoiceStrategy
1220 ).workersVirtualTaskEndTimestamp
.length
1222 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1224 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1225 workerChoiceStrategy
1226 ).workersVirtualTaskEndTimestamp
1227 ).toBeInstanceOf(Array
)
1229 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1230 workerChoiceStrategy
1231 ).workersVirtualTaskEndTimestamp
.length
1233 await pool
.destroy()
1234 pool
= new DynamicThreadPool(
1237 './tests/worker-files/thread/testWorker.js'
1240 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1241 workerChoiceStrategy
1242 ).workersVirtualTaskEndTimestamp
1243 ).toBeInstanceOf(Array
)
1245 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1246 workerChoiceStrategy
1247 ).workersVirtualTaskEndTimestamp
.length
1249 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1250 workerChoiceStrategy
1251 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1253 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1254 workerChoiceStrategy
1255 ).workersVirtualTaskEndTimestamp
.length
1257 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1259 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1260 workerChoiceStrategy
1261 ).workersVirtualTaskEndTimestamp
1262 ).toBeInstanceOf(Array
)
1264 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1265 workerChoiceStrategy
1266 ).workersVirtualTaskEndTimestamp
.length
1268 // We need to clean up the resources after our test
1269 await pool
.destroy()
1272 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1273 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1274 let pool
= new FixedThreadPool(
1276 './tests/worker-files/thread/testWorker.js',
1277 { workerChoiceStrategy
}
1279 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1280 useDynamicWorker
: true
1282 await pool
.destroy()
1283 pool
= new DynamicThreadPool(
1286 './tests/worker-files/thread/testWorker.js',
1287 { workerChoiceStrategy
}
1289 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1290 useDynamicWorker
: true
1292 // We need to clean up the resources after our test
1293 await pool
.destroy()
1296 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1297 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1298 let pool
= new FixedThreadPool(
1300 './tests/worker-files/thread/testWorker.js',
1301 { workerChoiceStrategy
}
1304 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1322 await pool
.destroy()
1323 pool
= new DynamicThreadPool(
1326 './tests/worker-files/thread/testWorker.js',
1327 { workerChoiceStrategy
}
1330 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1348 // We need to clean up the resources after our test
1349 await pool
.destroy()
1352 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1353 const pool
= new FixedThreadPool(
1355 './tests/worker-files/thread/testWorker.js',
1356 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1358 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1359 const promises
= new Set()
1360 const maxMultiplier
= 2
1361 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1362 promises
.add(pool
.execute())
1364 await Promise
.all(promises
)
1365 for (const workerNode
of pool
.workerNodes
) {
1366 expect(workerNode
.usage
).toStrictEqual({
1368 executed
: expect
.any(Number
),
1374 runTime
: expect
.objectContaining({
1375 history
: expect
.any(CircularArray
)
1378 history
: expect
.any(CircularArray
)
1382 history
: expect
.any(CircularArray
)
1385 history
: expect
.any(CircularArray
)
1389 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1390 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1393 if (workerNode
.usage
.runTime
.aggregate
== null) {
1394 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1396 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1398 if (workerNode
.usage
.runTime
.average
== null) {
1399 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1401 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1405 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1406 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1407 ).defaultWorkerWeight
1408 ).toBeGreaterThan(0)
1410 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1411 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1412 ).workerVirtualTaskRunTime
1413 ).toBeGreaterThanOrEqual(0)
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 dynamic pool', async () => {
1419 const pool
= new DynamicThreadPool(
1422 './tests/worker-files/thread/testWorker.js',
1423 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1425 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1426 const promises
= new Set()
1427 const maxMultiplier
= 2
1428 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1429 promises
.add(pool
.execute())
1431 await Promise
.all(promises
)
1432 for (const workerNode
of pool
.workerNodes
) {
1433 expect(workerNode
.usage
).toStrictEqual({
1435 executed
: expect
.any(Number
),
1442 aggregate
: expect
.any(Number
),
1443 maximum
: expect
.any(Number
),
1444 minimum
: expect
.any(Number
),
1445 average
: expect
.any(Number
),
1446 history
: expect
.any(CircularArray
)
1449 history
: expect
.any(CircularArray
)
1453 history
: expect
.any(CircularArray
)
1456 history
: expect
.any(CircularArray
)
1460 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1461 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1464 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1465 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1468 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1469 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1470 ).defaultWorkerWeight
1471 ).toBeGreaterThan(0)
1473 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1474 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1475 ).workerVirtualTaskRunTime
1476 ).toBeGreaterThanOrEqual(0)
1477 // We need to clean up the resources after our test
1478 await pool
.destroy()
1481 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1482 const pool
= new DynamicThreadPool(
1485 './tests/worker-files/thread/testWorker.js',
1487 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1488 workerChoiceStrategyOptions
: {
1489 runTime
: { median
: true }
1493 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1494 const promises
= new Set()
1495 const maxMultiplier
= 2
1496 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1497 promises
.add(pool
.execute())
1499 await Promise
.all(promises
)
1500 for (const workerNode
of pool
.workerNodes
) {
1501 expect(workerNode
.usage
).toStrictEqual({
1503 executed
: expect
.any(Number
),
1510 aggregate
: expect
.any(Number
),
1511 maximum
: expect
.any(Number
),
1512 minimum
: expect
.any(Number
),
1513 median
: expect
.any(Number
),
1514 history
: expect
.any(CircularArray
)
1517 history
: expect
.any(CircularArray
)
1521 history
: expect
.any(CircularArray
)
1524 history
: expect
.any(CircularArray
)
1528 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1529 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1532 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1533 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1536 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1537 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1538 ).defaultWorkerWeight
1539 ).toBeGreaterThan(0)
1541 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1542 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1543 ).workerVirtualTaskRunTime
1544 ).toBeGreaterThanOrEqual(0)
1545 // We need to clean up the resources after our test
1546 await pool
.destroy()
1549 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1550 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1551 let pool
= new FixedThreadPool(
1553 './tests/worker-files/thread/testWorker.js'
1556 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1557 workerChoiceStrategy
1561 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1562 workerChoiceStrategy
1563 ).defaultWorkerWeight
1566 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1567 workerChoiceStrategy
1568 ).workerVirtualTaskRunTime
1570 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1572 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1573 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1577 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1578 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1579 ).defaultWorkerWeight
1580 ).toBeGreaterThan(0)
1582 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1583 workerChoiceStrategy
1584 ).workerVirtualTaskRunTime
1586 await pool
.destroy()
1587 pool
= new DynamicThreadPool(
1590 './tests/worker-files/thread/testWorker.js'
1593 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1594 workerChoiceStrategy
1598 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1599 workerChoiceStrategy
1600 ).defaultWorkerWeight
1603 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1604 workerChoiceStrategy
1605 ).workerVirtualTaskRunTime
1607 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1609 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1610 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1614 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1615 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1616 ).defaultWorkerWeight
1617 ).toBeGreaterThan(0)
1619 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1620 workerChoiceStrategy
1621 ).workerVirtualTaskRunTime
1623 // We need to clean up the resources after our test
1624 await pool
.destroy()
1627 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1628 const workerChoiceStrategy
=
1629 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1630 let pool
= new FixedThreadPool(
1632 './tests/worker-files/thread/testWorker.js',
1633 { workerChoiceStrategy
}
1635 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1636 useDynamicWorker
: true
1638 await pool
.destroy()
1639 pool
= new DynamicThreadPool(
1642 './tests/worker-files/thread/testWorker.js',
1643 { workerChoiceStrategy
}
1645 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1646 useDynamicWorker
: true
1648 // We need to clean up the resources after our test
1649 await pool
.destroy()
1652 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1653 const workerChoiceStrategy
=
1654 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1655 let pool
= new FixedThreadPool(
1657 './tests/worker-files/thread/testWorker.js',
1658 { workerChoiceStrategy
}
1661 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1679 await pool
.destroy()
1680 pool
= new DynamicThreadPool(
1683 './tests/worker-files/thread/testWorker.js',
1684 { workerChoiceStrategy
}
1687 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1705 // We need to clean up the resources after our test
1706 await pool
.destroy()
1709 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1710 const pool
= new FixedThreadPool(
1712 './tests/worker-files/thread/testWorker.js',
1714 workerChoiceStrategy
:
1715 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1718 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1719 const promises
= new Set()
1720 const maxMultiplier
= 2
1721 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1722 promises
.add(pool
.execute())
1724 await Promise
.all(promises
)
1725 for (const workerNode
of pool
.workerNodes
) {
1726 expect(workerNode
.usage
).toStrictEqual({
1728 executed
: maxMultiplier
,
1735 history
: expect
.any(CircularArray
)
1738 history
: expect
.any(CircularArray
)
1742 history
: expect
.any(CircularArray
)
1745 history
: expect
.any(CircularArray
)
1751 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1752 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1753 ).defaultWorkerWeight
1754 ).toBeGreaterThan(0)
1756 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1757 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1761 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1762 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1766 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1767 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1770 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1771 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1772 ).defaultWorkerWeight
1774 // We need to clean up the resources after our test
1775 await pool
.destroy()
1778 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1779 const pool
= new DynamicThreadPool(
1782 './tests/worker-files/thread/testWorker.js',
1784 workerChoiceStrategy
:
1785 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1788 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1789 const promises
= new Set()
1790 const maxMultiplier
= 2
1791 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1792 promises
.add(pool
.execute())
1794 await Promise
.all(promises
)
1795 for (const workerNode
of pool
.workerNodes
) {
1796 expect(workerNode
.usage
).toStrictEqual({
1798 executed
: maxMultiplier
,
1805 history
: expect
.any(CircularArray
)
1808 history
: expect
.any(CircularArray
)
1812 history
: expect
.any(CircularArray
)
1815 history
: expect
.any(CircularArray
)
1821 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1822 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1823 ).defaultWorkerWeight
1824 ).toBeGreaterThan(0)
1826 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1827 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1831 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1832 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1836 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1837 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1840 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1841 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1842 ).defaultWorkerWeight
1844 // We need to clean up the resources after our test
1845 await pool
.destroy()
1848 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1849 const workerChoiceStrategy
=
1850 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1851 let pool
= new FixedThreadPool(
1853 './tests/worker-files/thread/testWorker.js'
1856 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1857 workerChoiceStrategy
1861 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1862 workerChoiceStrategy
1866 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1867 workerChoiceStrategy
1868 ).defaultWorkerWeight
1871 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1872 workerChoiceStrategy
1875 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1877 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1878 workerChoiceStrategy
1882 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1883 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1887 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1888 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1889 ).defaultWorkerWeight
1890 ).toBeGreaterThan(0)
1892 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1893 workerChoiceStrategy
1896 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1897 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1898 ).defaultWorkerWeight
1900 await pool
.destroy()
1901 pool
= new DynamicThreadPool(
1904 './tests/worker-files/thread/testWorker.js'
1907 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1908 workerChoiceStrategy
1912 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1913 workerChoiceStrategy
1917 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1918 workerChoiceStrategy
1919 ).defaultWorkerWeight
1922 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1923 workerChoiceStrategy
1926 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1928 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1929 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1933 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1934 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1935 ).defaultWorkerWeight
1936 ).toBeGreaterThan(0)
1938 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1939 workerChoiceStrategy
1942 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1943 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1944 ).defaultWorkerWeight
1946 // We need to clean up the resources after our test
1947 await pool
.destroy()
1950 it('Verify unknown strategy throw error', () => {
1953 new DynamicThreadPool(
1956 './tests/worker-files/thread/testWorker.js',
1957 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
1959 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")