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 dynamicWorkerUsage
: false,
127 dynamicWorkerReady
: true
130 pool
= new DynamicThreadPool(
133 './tests/worker-files/thread/testWorker.js',
134 { workerChoiceStrategy
}
136 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
137 dynamicWorkerUsage
: false,
138 dynamicWorkerReady
: true
140 // We need to clean up the resources after our test
144 it('Verify ROUND_ROBIN strategy default tasks statistics requirements', async () => {
145 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
146 let pool
= new FixedThreadPool(
148 './tests/worker-files/thread/testWorker.js',
149 { workerChoiceStrategy
}
152 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
171 pool
= new DynamicThreadPool(
174 './tests/worker-files/thread/testWorker.js',
175 { workerChoiceStrategy
}
178 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
196 // We need to clean up the resources after our test
200 it('Verify ROUND_ROBIN strategy can be run in a fixed pool', async () => {
201 const pool
= new FixedThreadPool(
203 './tests/worker-files/thread/testWorker.js',
204 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
206 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
207 const promises
= new Set()
208 const maxMultiplier
= 2
209 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
210 promises
.add(pool
.execute())
212 await Promise
.all(promises
)
213 for (const workerNode
of pool
.workerNodes
) {
214 expect(workerNode
.usage
).toStrictEqual({
216 executed
: maxMultiplier
,
223 history
: expect
.any(CircularArray
)
226 history
: expect
.any(CircularArray
)
230 history
: expect
.any(CircularArray
)
233 history
: expect
.any(CircularArray
)
239 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
240 WorkerChoiceStrategies
.ROUND_ROBIN
243 // We need to clean up the resources after our test
247 it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
248 const pool
= new DynamicThreadPool(
251 './tests/worker-files/thread/testWorker.js',
252 { workerChoiceStrategy
: WorkerChoiceStrategies
.ROUND_ROBIN
}
254 // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
255 const promises
= new Set()
256 const maxMultiplier
= 2
257 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
258 promises
.add(pool
.execute())
260 await Promise
.all(promises
)
261 for (const workerNode
of pool
.workerNodes
) {
262 expect(workerNode
.usage
).toStrictEqual({
264 executed
: expect
.any(Number
),
271 history
: expect
.any(CircularArray
)
274 history
: expect
.any(CircularArray
)
278 history
: expect
.any(CircularArray
)
281 history
: expect
.any(CircularArray
)
285 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
286 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
291 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
292 WorkerChoiceStrategies
.ROUND_ROBIN
295 // We need to clean up the resources after our test
299 it('Verify ROUND_ROBIN strategy runtime behavior', async () => {
300 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
301 let pool
= new FixedClusterPool(
303 './tests/worker-files/cluster/testWorker.js',
304 { workerChoiceStrategy
}
306 let results
= new Set()
307 for (let i
= 0; i
< max
; i
++) {
308 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.id
)
310 expect(results
.size
).toBe(max
)
312 pool
= new FixedThreadPool(
314 './tests/worker-files/thread/testWorker.js',
315 { workerChoiceStrategy
}
318 for (let i
= 0; i
< max
; i
++) {
319 results
.add(pool
.workerNodes
[pool
.chooseWorkerNode()].worker
.threadId
)
321 expect(results
.size
).toBe(max
)
325 it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
326 const workerChoiceStrategy
= WorkerChoiceStrategies
.ROUND_ROBIN
327 let pool
= new FixedThreadPool(
329 './tests/worker-files/thread/testWorker.js',
330 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
333 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
337 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
339 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
340 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
344 pool
= new DynamicThreadPool(
347 './tests/worker-files/thread/testWorker.js',
348 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
351 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
355 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
357 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
358 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
361 // We need to clean up the resources after our test
365 it('Verify LEAST_USED strategy default policy', async () => {
366 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
367 let pool
= new FixedThreadPool(
369 './tests/worker-files/thread/testWorker.js',
370 { workerChoiceStrategy
}
372 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
373 dynamicWorkerUsage
: false,
374 dynamicWorkerReady
: true
377 pool
= new DynamicThreadPool(
380 './tests/worker-files/thread/testWorker.js',
381 { workerChoiceStrategy
}
383 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
384 dynamicWorkerUsage
: false,
385 dynamicWorkerReady
: true
387 // We need to clean up the resources after our test
391 it('Verify LEAST_USED strategy default tasks statistics requirements', async () => {
392 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_USED
393 let pool
= new FixedThreadPool(
395 './tests/worker-files/thread/testWorker.js',
396 { workerChoiceStrategy
}
399 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
418 pool
= new DynamicThreadPool(
421 './tests/worker-files/thread/testWorker.js',
422 { workerChoiceStrategy
}
425 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
443 // We need to clean up the resources after our test
447 it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
448 const pool
= new FixedThreadPool(
450 './tests/worker-files/thread/testWorker.js',
451 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
453 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
454 const promises
= new Set()
455 const maxMultiplier
= 2
456 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
457 promises
.add(pool
.execute())
459 await Promise
.all(promises
)
460 for (const workerNode
of pool
.workerNodes
) {
461 expect(workerNode
.usage
).toStrictEqual({
463 executed
: expect
.any(Number
),
470 history
: expect
.any(CircularArray
)
473 history
: expect
.any(CircularArray
)
477 history
: expect
.any(CircularArray
)
480 history
: expect
.any(CircularArray
)
484 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
485 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
489 // We need to clean up the resources after our test
493 it('Verify LEAST_USED strategy can be run in a dynamic pool', async () => {
494 const pool
= new DynamicThreadPool(
497 './tests/worker-files/thread/testWorker.js',
498 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_USED
}
500 // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
501 const promises
= new Set()
502 const maxMultiplier
= 2
503 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
504 promises
.add(pool
.execute())
506 await Promise
.all(promises
)
507 for (const workerNode
of pool
.workerNodes
) {
508 expect(workerNode
.usage
).toStrictEqual({
510 executed
: expect
.any(Number
),
517 history
: expect
.any(CircularArray
)
520 history
: expect
.any(CircularArray
)
524 history
: expect
.any(CircularArray
)
527 history
: expect
.any(CircularArray
)
531 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
532 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
536 // We need to clean up the resources after our test
540 it('Verify LEAST_BUSY strategy default policy', async () => {
541 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
542 let pool
= new FixedThreadPool(
544 './tests/worker-files/thread/testWorker.js',
545 { workerChoiceStrategy
}
547 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
548 dynamicWorkerUsage
: false,
549 dynamicWorkerReady
: true
552 pool
= new DynamicThreadPool(
555 './tests/worker-files/thread/testWorker.js',
556 { workerChoiceStrategy
}
558 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
559 dynamicWorkerUsage
: false,
560 dynamicWorkerReady
: true
562 // We need to clean up the resources after our test
566 it('Verify LEAST_BUSY strategy default tasks statistics requirements', async () => {
567 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_BUSY
568 let pool
= new FixedThreadPool(
570 './tests/worker-files/thread/testWorker.js',
571 { workerChoiceStrategy
}
574 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
593 pool
= new DynamicThreadPool(
596 './tests/worker-files/thread/testWorker.js',
597 { workerChoiceStrategy
}
600 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
618 // We need to clean up the resources after our test
622 it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
623 const pool
= new FixedThreadPool(
625 './tests/worker-files/thread/testWorker.js',
626 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
628 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
629 const promises
= new Set()
630 const maxMultiplier
= 2
631 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
632 promises
.add(pool
.execute())
634 await Promise
.all(promises
)
635 for (const workerNode
of pool
.workerNodes
) {
636 expect(workerNode
.usage
).toMatchObject({
638 executed
: expect
.any(Number
),
645 history
: expect
.any(CircularArray
)
648 history
: expect
.any(CircularArray
)
652 history
: expect
.any(CircularArray
)
655 history
: expect
.any(CircularArray
)
659 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
660 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
663 if (workerNode
.usage
.runTime
.aggregate
== null) {
664 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
666 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
668 if (workerNode
.usage
.waitTime
.aggregate
== null) {
669 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
671 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
674 // We need to clean up the resources after our test
678 it('Verify LEAST_BUSY strategy can be run in a dynamic pool', async () => {
679 const pool
= new DynamicThreadPool(
682 './tests/worker-files/thread/testWorker.js',
683 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_BUSY
}
685 // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
686 const promises
= new Set()
687 const maxMultiplier
= 2
688 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
689 promises
.add(pool
.execute())
691 await Promise
.all(promises
)
692 for (const workerNode
of pool
.workerNodes
) {
693 expect(workerNode
.usage
).toMatchObject({
695 executed
: expect
.any(Number
),
702 history
: expect
.any(CircularArray
)
705 history
: expect
.any(CircularArray
)
709 history
: expect
.any(CircularArray
)
712 history
: expect
.any(CircularArray
)
716 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
717 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
720 if (workerNode
.usage
.runTime
.aggregate
== null) {
721 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
723 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
725 if (workerNode
.usage
.waitTime
.aggregate
== null) {
726 expect(workerNode
.usage
.waitTime
.aggregate
).toBeUndefined()
728 expect(workerNode
.usage
.waitTime
.aggregate
).toBeGreaterThan(0)
731 // We need to clean up the resources after our test
735 it('Verify LEAST_ELU strategy default policy', async () => {
736 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
737 let pool
= new FixedThreadPool(
739 './tests/worker-files/thread/testWorker.js',
740 { workerChoiceStrategy
}
742 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
743 dynamicWorkerUsage
: false,
744 dynamicWorkerReady
: true
747 pool
= new DynamicThreadPool(
750 './tests/worker-files/thread/testWorker.js',
751 { workerChoiceStrategy
}
753 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
754 dynamicWorkerUsage
: false,
755 dynamicWorkerReady
: true
757 // We need to clean up the resources after our test
761 it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
762 const workerChoiceStrategy
= WorkerChoiceStrategies
.LEAST_ELU
763 let pool
= new FixedThreadPool(
765 './tests/worker-files/thread/testWorker.js',
766 { workerChoiceStrategy
}
769 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
788 pool
= new DynamicThreadPool(
791 './tests/worker-files/thread/testWorker.js',
792 { workerChoiceStrategy
}
795 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
813 // We need to clean up the resources after our test
817 it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
818 const pool
= new FixedThreadPool(
820 './tests/worker-files/thread/testWorker.js',
821 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
823 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
824 const promises
= new Set()
825 const maxMultiplier
= 2
826 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
827 promises
.add(pool
.execute())
829 await Promise
.all(promises
)
830 for (const workerNode
of pool
.workerNodes
) {
831 expect(workerNode
.usage
).toMatchObject({
833 executed
: expect
.any(Number
),
840 history
: expect
.any(CircularArray
)
843 history
: expect
.any(CircularArray
)
846 idle
: expect
.objectContaining({
847 history
: expect
.any(CircularArray
)
849 active
: expect
.objectContaining({
850 history
: expect
.any(CircularArray
)
854 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
855 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
858 if (workerNode
.usage
.elu
.utilization
== null) {
859 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
861 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
862 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
865 // We need to clean up the resources after our test
869 it('Verify LEAST_ELU strategy can be run in a dynamic pool', async () => {
870 const pool
= new DynamicThreadPool(
873 './tests/worker-files/thread/testWorker.js',
874 { workerChoiceStrategy
: WorkerChoiceStrategies
.LEAST_ELU
}
876 // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
877 const promises
= new Set()
878 const maxMultiplier
= 2
879 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
880 promises
.add(pool
.execute())
882 await Promise
.all(promises
)
883 for (const workerNode
of pool
.workerNodes
) {
884 expect(workerNode
.usage
).toMatchObject({
886 executed
: expect
.any(Number
),
893 history
: expect
.any(CircularArray
)
896 history
: expect
.any(CircularArray
)
899 idle
: expect
.objectContaining({
900 history
: expect
.any(CircularArray
)
902 active
: expect
.objectContaining({
903 history
: expect
.any(CircularArray
)
907 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
908 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
911 if (workerNode
.usage
.elu
.utilization
== null) {
912 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
914 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
915 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
918 // We need to clean up the resources after our test
922 it('Verify FAIR_SHARE strategy default policy', async () => {
923 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
924 let pool
= new FixedThreadPool(
926 './tests/worker-files/thread/testWorker.js',
927 { workerChoiceStrategy
}
929 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
930 dynamicWorkerUsage
: false,
931 dynamicWorkerReady
: true
934 pool
= new DynamicThreadPool(
937 './tests/worker-files/thread/testWorker.js',
938 { workerChoiceStrategy
}
940 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
941 dynamicWorkerUsage
: false,
942 dynamicWorkerReady
: true
944 // We need to clean up the resources after our test
948 it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
949 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
950 let pool
= new FixedThreadPool(
952 './tests/worker-files/thread/testWorker.js',
953 { workerChoiceStrategy
}
956 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
975 pool
= new DynamicThreadPool(
978 './tests/worker-files/thread/testWorker.js',
979 { workerChoiceStrategy
}
982 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1000 // We need to clean up the resources after our test
1001 await pool
.destroy()
1004 it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
1005 const pool
= new FixedThreadPool(
1007 './tests/worker-files/thread/testWorker.js',
1008 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1010 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1011 const promises
= new Set()
1012 const maxMultiplier
= 2
1013 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1014 promises
.add(pool
.execute())
1016 await Promise
.all(promises
)
1017 for (const workerNode
of pool
.workerNodes
) {
1018 expect(workerNode
.usage
).toMatchObject({
1020 executed
: expect
.any(Number
),
1026 runTime
: expect
.objectContaining({
1027 history
: expect
.any(CircularArray
)
1030 history
: expect
.any(CircularArray
)
1033 idle
: expect
.objectContaining({
1034 history
: expect
.any(CircularArray
)
1036 active
: expect
.objectContaining({
1037 history
: expect
.any(CircularArray
)
1041 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1042 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1045 if (workerNode
.usage
.runTime
.aggregate
== null) {
1046 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1048 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1050 if (workerNode
.usage
.runTime
.average
== null) {
1051 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1053 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1055 if (workerNode
.usage
.elu
.utilization
== null) {
1056 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1058 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1059 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1063 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1064 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1065 ).workersVirtualTaskEndTimestamp
.length
1066 ).toBe(pool
.workerNodes
.length
)
1067 // We need to clean up the resources after our test
1068 await pool
.destroy()
1071 it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => {
1072 const pool
= new DynamicThreadPool(
1075 './tests/worker-files/thread/testWorker.js',
1076 { workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
}
1078 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1079 const promises
= new Set()
1080 const maxMultiplier
= 2
1081 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1082 promises
.add(pool
.execute())
1084 await Promise
.all(promises
)
1085 for (const workerNode
of pool
.workerNodes
) {
1086 expect(workerNode
.usage
).toMatchObject({
1088 executed
: expect
.any(Number
),
1094 runTime
: expect
.objectContaining({
1095 history
: expect
.any(CircularArray
)
1098 history
: expect
.any(CircularArray
)
1101 idle
: expect
.objectContaining({
1102 history
: expect
.any(CircularArray
)
1104 active
: expect
.objectContaining({
1105 history
: expect
.any(CircularArray
)
1109 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1110 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1113 if (workerNode
.usage
.runTime
.aggregate
== null) {
1114 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1116 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1118 if (workerNode
.usage
.runTime
.average
== null) {
1119 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1121 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1123 if (workerNode
.usage
.elu
.utilization
== null) {
1124 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1126 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1127 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1131 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1132 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1133 ).workersVirtualTaskEndTimestamp
.length
1134 ).toBe(pool
.workerNodes
.length
)
1135 // We need to clean up the resources after our test
1136 await pool
.destroy()
1139 it('Verify FAIR_SHARE strategy can be run in a dynamic pool with median runtime statistic', async () => {
1140 const pool
= new DynamicThreadPool(
1143 './tests/worker-files/thread/testWorker.js',
1145 workerChoiceStrategy
: WorkerChoiceStrategies
.FAIR_SHARE
,
1146 workerChoiceStrategyOptions
: {
1147 runTime
: { median
: true }
1151 // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
1152 const promises
= new Set()
1153 const maxMultiplier
= 2
1154 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1155 promises
.add(pool
.execute())
1157 await Promise
.all(promises
)
1158 for (const workerNode
of pool
.workerNodes
) {
1159 expect(workerNode
.usage
).toMatchObject({
1161 executed
: expect
.any(Number
),
1167 runTime
: expect
.objectContaining({
1168 history
: expect
.any(CircularArray
)
1171 history
: expect
.any(CircularArray
)
1174 idle
: expect
.objectContaining({
1175 history
: expect
.any(CircularArray
)
1177 active
: expect
.objectContaining({
1178 history
: expect
.any(CircularArray
)
1182 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1183 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1186 if (workerNode
.usage
.runTime
.aggregate
== null) {
1187 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1189 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1191 if (workerNode
.usage
.runTime
.median
== null) {
1192 expect(workerNode
.usage
.runTime
.median
).toBeUndefined()
1194 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1196 if (workerNode
.usage
.elu
.utilization
== null) {
1197 expect(workerNode
.usage
.elu
.utilization
).toBeUndefined()
1199 expect(workerNode
.usage
.elu
.utilization
).toBeGreaterThanOrEqual(0)
1200 expect(workerNode
.usage
.elu
.utilization
).toBeLessThanOrEqual(1)
1204 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1205 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1206 ).workersVirtualTaskEndTimestamp
.length
1207 ).toBe(pool
.workerNodes
.length
)
1208 // We need to clean up the resources after our test
1209 await pool
.destroy()
1212 it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
1213 const workerChoiceStrategy
= WorkerChoiceStrategies
.FAIR_SHARE
1214 let pool
= new FixedThreadPool(
1216 './tests/worker-files/thread/testWorker.js'
1219 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1220 workerChoiceStrategy
1221 ).workersVirtualTaskEndTimestamp
1222 ).toBeInstanceOf(Array
)
1224 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1225 workerChoiceStrategy
1226 ).workersVirtualTaskEndTimestamp
.length
1228 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1229 workerChoiceStrategy
1230 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1232 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1233 workerChoiceStrategy
1234 ).workersVirtualTaskEndTimestamp
.length
1236 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1238 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1239 workerChoiceStrategy
1240 ).workersVirtualTaskEndTimestamp
1241 ).toBeInstanceOf(Array
)
1243 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1244 workerChoiceStrategy
1245 ).workersVirtualTaskEndTimestamp
.length
1247 await pool
.destroy()
1248 pool
= new DynamicThreadPool(
1251 './tests/worker-files/thread/testWorker.js'
1254 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1255 workerChoiceStrategy
1256 ).workersVirtualTaskEndTimestamp
1257 ).toBeInstanceOf(Array
)
1259 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1260 workerChoiceStrategy
1261 ).workersVirtualTaskEndTimestamp
.length
1263 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1264 workerChoiceStrategy
1265 ).workersVirtualTaskEndTimestamp
[0] = performance
.now()
1267 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1268 workerChoiceStrategy
1269 ).workersVirtualTaskEndTimestamp
.length
1271 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1273 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1274 workerChoiceStrategy
1275 ).workersVirtualTaskEndTimestamp
1276 ).toBeInstanceOf(Array
)
1278 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1279 workerChoiceStrategy
1280 ).workersVirtualTaskEndTimestamp
.length
1282 // We need to clean up the resources after our test
1283 await pool
.destroy()
1286 it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1287 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1288 let pool
= new FixedThreadPool(
1290 './tests/worker-files/thread/testWorker.js',
1291 { workerChoiceStrategy
}
1293 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1294 dynamicWorkerUsage
: false,
1295 dynamicWorkerReady
: true
1297 await pool
.destroy()
1298 pool
= new DynamicThreadPool(
1301 './tests/worker-files/thread/testWorker.js',
1302 { workerChoiceStrategy
}
1304 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1305 dynamicWorkerUsage
: false,
1306 dynamicWorkerReady
: true
1308 // We need to clean up the resources after our test
1309 await pool
.destroy()
1312 it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1313 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1314 let pool
= new FixedThreadPool(
1316 './tests/worker-files/thread/testWorker.js',
1317 { workerChoiceStrategy
}
1320 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1338 await pool
.destroy()
1339 pool
= new DynamicThreadPool(
1342 './tests/worker-files/thread/testWorker.js',
1343 { workerChoiceStrategy
}
1346 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1364 // We need to clean up the resources after our test
1365 await pool
.destroy()
1368 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1369 const pool
= new FixedThreadPool(
1371 './tests/worker-files/thread/testWorker.js',
1372 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1374 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1375 const promises
= new Set()
1376 const maxMultiplier
= 2
1377 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1378 promises
.add(pool
.execute())
1380 await Promise
.all(promises
)
1381 for (const workerNode
of pool
.workerNodes
) {
1382 expect(workerNode
.usage
).toStrictEqual({
1384 executed
: expect
.any(Number
),
1390 runTime
: expect
.objectContaining({
1391 history
: expect
.any(CircularArray
)
1394 history
: expect
.any(CircularArray
)
1398 history
: expect
.any(CircularArray
)
1401 history
: expect
.any(CircularArray
)
1405 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1406 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1409 if (workerNode
.usage
.runTime
.aggregate
== null) {
1410 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1412 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1414 if (workerNode
.usage
.runTime
.average
== null) {
1415 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1417 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1421 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1422 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1423 ).defaultWorkerWeight
1424 ).toBeGreaterThan(0)
1426 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1427 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1428 ).workerVirtualTaskRunTime
1429 ).toBeGreaterThanOrEqual(0)
1430 // We need to clean up the resources after our test
1431 await pool
.destroy()
1434 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1435 const pool
= new DynamicThreadPool(
1438 './tests/worker-files/thread/testWorker.js',
1439 { workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
}
1441 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1442 const promises
= new Set()
1443 const maxMultiplier
= 2
1444 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1445 promises
.add(pool
.execute())
1447 await Promise
.all(promises
)
1448 for (const workerNode
of pool
.workerNodes
) {
1449 expect(workerNode
.usage
).toStrictEqual({
1451 executed
: expect
.any(Number
),
1457 runTime
: expect
.objectContaining({
1458 history
: expect
.any(CircularArray
)
1461 history
: expect
.any(CircularArray
)
1465 history
: expect
.any(CircularArray
)
1468 history
: expect
.any(CircularArray
)
1472 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1473 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1476 if (workerNode
.usage
.runTime
.aggregate
== null) {
1477 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1479 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1481 if (workerNode
.usage
.runTime
.average
== null) {
1482 expect(workerNode
.usage
.runTime
.average
).toBeUndefined()
1484 expect(workerNode
.usage
.runTime
.average
).toBeGreaterThan(0)
1488 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1489 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1490 ).defaultWorkerWeight
1491 ).toBeGreaterThan(0)
1493 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1494 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1495 ).workerVirtualTaskRunTime
1496 ).toBeGreaterThanOrEqual(0)
1497 // We need to clean up the resources after our test
1498 await pool
.destroy()
1501 it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool with median runtime statistic', async () => {
1502 const pool
= new DynamicThreadPool(
1505 './tests/worker-files/thread/testWorker.js',
1507 workerChoiceStrategy
: WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
,
1508 workerChoiceStrategyOptions
: {
1509 runTime
: { median
: true }
1513 // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
1514 const promises
= new Set()
1515 const maxMultiplier
= 2
1516 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1517 promises
.add(pool
.execute())
1519 await Promise
.all(promises
)
1520 for (const workerNode
of pool
.workerNodes
) {
1521 expect(workerNode
.usage
).toStrictEqual({
1523 executed
: expect
.any(Number
),
1529 runTime
: expect
.objectContaining({
1530 history
: expect
.any(CircularArray
)
1533 history
: expect
.any(CircularArray
)
1537 history
: expect
.any(CircularArray
)
1540 history
: expect
.any(CircularArray
)
1544 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1545 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1548 if (workerNode
.usage
.runTime
.aggregate
== null) {
1549 expect(workerNode
.usage
.runTime
.aggregate
).toBeUndefined()
1551 expect(workerNode
.usage
.runTime
.aggregate
).toBeGreaterThan(0)
1553 if (workerNode
.usage
.runTime
.median
== null) {
1554 expect(workerNode
.usage
.runTime
.median
).toBeUndefined()
1556 expect(workerNode
.usage
.runTime
.median
).toBeGreaterThan(0)
1560 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1561 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1562 ).defaultWorkerWeight
1563 ).toBeGreaterThan(0)
1565 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1566 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1567 ).workerVirtualTaskRunTime
1568 ).toBeGreaterThanOrEqual(0)
1569 // We need to clean up the resources after our test
1570 await pool
.destroy()
1573 it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1574 const workerChoiceStrategy
= WorkerChoiceStrategies
.WEIGHTED_ROUND_ROBIN
1575 let pool
= new FixedThreadPool(
1577 './tests/worker-files/thread/testWorker.js'
1580 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1581 workerChoiceStrategy
1585 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1586 workerChoiceStrategy
1587 ).defaultWorkerWeight
1590 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1591 workerChoiceStrategy
1592 ).workerVirtualTaskRunTime
1594 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1596 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1597 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1601 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1602 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1603 ).defaultWorkerWeight
1604 ).toBeGreaterThan(0)
1606 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1607 workerChoiceStrategy
1608 ).workerVirtualTaskRunTime
1610 await pool
.destroy()
1611 pool
= new DynamicThreadPool(
1614 './tests/worker-files/thread/testWorker.js'
1617 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1618 workerChoiceStrategy
1622 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1623 workerChoiceStrategy
1624 ).defaultWorkerWeight
1627 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1628 workerChoiceStrategy
1629 ).workerVirtualTaskRunTime
1631 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1633 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1634 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1638 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1639 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1640 ).defaultWorkerWeight
1641 ).toBeGreaterThan(0)
1643 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1644 workerChoiceStrategy
1645 ).workerVirtualTaskRunTime
1647 // We need to clean up the resources after our test
1648 await pool
.destroy()
1651 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
1652 const workerChoiceStrategy
=
1653 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1654 let pool
= new FixedThreadPool(
1656 './tests/worker-files/thread/testWorker.js',
1657 { workerChoiceStrategy
}
1659 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1660 dynamicWorkerUsage
: false,
1661 dynamicWorkerReady
: true
1663 await pool
.destroy()
1664 pool
= new DynamicThreadPool(
1667 './tests/worker-files/thread/testWorker.js',
1668 { workerChoiceStrategy
}
1670 expect(pool
.workerChoiceStrategyContext
.getStrategyPolicy()).toStrictEqual({
1671 dynamicWorkerUsage
: false,
1672 dynamicWorkerReady
: true
1674 // We need to clean up the resources after our test
1675 await pool
.destroy()
1678 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
1679 const workerChoiceStrategy
=
1680 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1681 let pool
= new FixedThreadPool(
1683 './tests/worker-files/thread/testWorker.js',
1684 { workerChoiceStrategy
}
1687 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1705 await pool
.destroy()
1706 pool
= new DynamicThreadPool(
1709 './tests/worker-files/thread/testWorker.js',
1710 { workerChoiceStrategy
}
1713 pool
.workerChoiceStrategyContext
.getTaskStatisticsRequirements()
1731 // We need to clean up the resources after our test
1732 await pool
.destroy()
1735 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
1736 const pool
= new FixedThreadPool(
1738 './tests/worker-files/thread/testWorker.js',
1740 workerChoiceStrategy
:
1741 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1744 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1745 const promises
= new Set()
1746 const maxMultiplier
= 2
1747 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1748 promises
.add(pool
.execute())
1750 await Promise
.all(promises
)
1751 for (const workerNode
of pool
.workerNodes
) {
1752 expect(workerNode
.usage
).toStrictEqual({
1754 executed
: maxMultiplier
,
1761 history
: expect
.any(CircularArray
)
1764 history
: expect
.any(CircularArray
)
1768 history
: expect
.any(CircularArray
)
1771 history
: expect
.any(CircularArray
)
1777 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1778 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1779 ).defaultWorkerWeight
1780 ).toBeGreaterThan(0)
1782 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1783 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1787 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1788 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1792 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1793 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1796 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1797 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1798 ).defaultWorkerWeight
1800 // We need to clean up the resources after our test
1801 await pool
.destroy()
1804 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => {
1805 const pool
= new DynamicThreadPool(
1808 './tests/worker-files/thread/testWorker.js',
1810 workerChoiceStrategy
:
1811 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1814 // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
1815 const promises
= new Set()
1816 const maxMultiplier
= 2
1817 for (let i
= 0; i
< max
* maxMultiplier
; i
++) {
1818 promises
.add(pool
.execute())
1820 await Promise
.all(promises
)
1821 for (const workerNode
of pool
.workerNodes
) {
1822 expect(workerNode
.usage
).toStrictEqual({
1824 executed
: expect
.any(Number
),
1831 history
: expect
.any(CircularArray
)
1834 history
: expect
.any(CircularArray
)
1838 history
: expect
.any(CircularArray
)
1841 history
: expect
.any(CircularArray
)
1845 expect(workerNode
.usage
.tasks
.executed
).toBeGreaterThanOrEqual(0)
1846 expect(workerNode
.usage
.tasks
.executed
).toBeLessThanOrEqual(
1851 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1852 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1853 ).defaultWorkerWeight
1854 ).toBeGreaterThan(0)
1856 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1857 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1861 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1862 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1866 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1867 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1870 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1871 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1872 ).defaultWorkerWeight
1874 // We need to clean up the resources after our test
1875 await pool
.destroy()
1878 it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
1879 const workerChoiceStrategy
=
1880 WorkerChoiceStrategies
.INTERLEAVED_WEIGHTED_ROUND_ROBIN
1881 let pool
= new FixedThreadPool(
1883 './tests/worker-files/thread/testWorker.js'
1886 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1887 workerChoiceStrategy
1891 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1892 workerChoiceStrategy
1896 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1897 workerChoiceStrategy
1898 ).defaultWorkerWeight
1901 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1902 workerChoiceStrategy
1905 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1907 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1908 workerChoiceStrategy
1912 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1913 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1917 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1918 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1919 ).defaultWorkerWeight
1920 ).toBeGreaterThan(0)
1922 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1923 workerChoiceStrategy
1926 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1927 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1928 ).defaultWorkerWeight
1930 await pool
.destroy()
1931 pool
= new DynamicThreadPool(
1934 './tests/worker-files/thread/testWorker.js'
1937 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1938 workerChoiceStrategy
1942 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1943 workerChoiceStrategy
1947 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1948 workerChoiceStrategy
1949 ).defaultWorkerWeight
1952 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1953 workerChoiceStrategy
1956 pool
.setWorkerChoiceStrategy(workerChoiceStrategy
)
1958 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1959 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1963 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1964 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1965 ).defaultWorkerWeight
1966 ).toBeGreaterThan(0)
1968 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1969 workerChoiceStrategy
1972 pool
.workerChoiceStrategyContext
.workerChoiceStrategies
.get(
1973 pool
.workerChoiceStrategyContext
.workerChoiceStrategy
1974 ).defaultWorkerWeight
1976 // We need to clean up the resources after our test
1977 await pool
.destroy()
1980 it('Verify unknown strategy throw error', () => {
1983 new DynamicThreadPool(
1986 './tests/worker-files/thread/testWorker.js',
1987 { workerChoiceStrategy
: 'UNKNOWN_STRATEGY' }
1989 ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")