Commit | Line | Data |
---|---|---|
a61a0724 | 1 | const { expect } = require('expect') |
a35560ba S |
2 | const { |
3 | WorkerChoiceStrategies, | |
4 | DynamicThreadPool, | |
5 | FixedThreadPool | |
15d56315 | 6 | } = require('../../../lib/index') |
a35560ba S |
7 | |
8 | describe('Selection strategies test suite', () => { | |
e1ffb94f JB |
9 | const min = 0 |
10 | const max = 3 | |
11 | ||
a35560ba S |
12 | it('Verify that WorkerChoiceStrategies enumeration provides string values', () => { |
13 | expect(WorkerChoiceStrategies.ROUND_ROBIN).toBe('ROUND_ROBIN') | |
14 | expect(WorkerChoiceStrategies.LESS_RECENTLY_USED).toBe('LESS_RECENTLY_USED') | |
23ff945a | 15 | expect(WorkerChoiceStrategies.FAIR_SHARE).toBe('FAIR_SHARE') |
b3432a63 JB |
16 | expect(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN).toBe( |
17 | 'WEIGHTED_ROUND_ROBIN' | |
18 | ) | |
a35560ba S |
19 | }) |
20 | ||
e843b904 | 21 | it('Verify ROUND_ROBIN strategy is the default at pool creation', async () => { |
e843b904 JB |
22 | const pool = new DynamicThreadPool( |
23 | min, | |
24 | max, | |
25 | './tests/worker-files/thread/testWorker.js' | |
26 | ) | |
27 | expect(pool.opts.workerChoiceStrategy).toBe( | |
28 | WorkerChoiceStrategies.ROUND_ROBIN | |
29 | ) | |
30 | // We need to clean up the resources after our test | |
31 | await pool.destroy() | |
32 | }) | |
33 | ||
34 | it('Verify ROUND_ROBIN strategy can be set after pool creation', async () => { | |
e843b904 JB |
35 | const pool = new DynamicThreadPool( |
36 | min, | |
37 | max, | |
38 | './tests/worker-files/thread/testWorker.js' | |
39 | ) | |
40 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.ROUND_ROBIN) | |
41 | expect(pool.opts.workerChoiceStrategy).toBe( | |
42 | WorkerChoiceStrategies.ROUND_ROBIN | |
43 | ) | |
44 | // We need to clean up the resources after our test | |
45 | await pool.destroy() | |
46 | }) | |
47 | ||
10fcfaf4 | 48 | it('Verify ROUND_ROBIN strategy default tasks usage statistics requirements', async () => { |
10fcfaf4 JB |
49 | let pool = new FixedThreadPool( |
50 | max, | |
51 | './tests/worker-files/thread/testWorker.js' | |
52 | ) | |
53 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.ROUND_ROBIN) | |
54 | expect( | |
55 | pool.workerChoiceStrategyContext.getWorkerChoiceStrategy() | |
56 | .requiredStatistics.runTime | |
57 | ).toBe(false) | |
58 | pool = new DynamicThreadPool( | |
59 | min, | |
60 | max, | |
61 | './tests/worker-files/thread/testWorker.js' | |
62 | ) | |
63 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.ROUND_ROBIN) | |
64 | expect( | |
65 | pool.workerChoiceStrategyContext.getWorkerChoiceStrategy() | |
66 | .requiredStatistics.runTime | |
67 | ).toBe(false) | |
68 | // We need to clean up the resources after our test | |
69 | await pool.destroy() | |
70 | }) | |
71 | ||
bdaf31cd | 72 | it('Verify ROUND_ROBIN strategy can be run in a fixed pool', async () => { |
bdaf31cd JB |
73 | const pool = new FixedThreadPool( |
74 | max, | |
75 | './tests/worker-files/thread/testWorker.js', | |
76 | { workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN } | |
77 | ) | |
78 | expect(pool.opts.workerChoiceStrategy).toBe( | |
79 | WorkerChoiceStrategies.ROUND_ROBIN | |
80 | ) | |
81 | // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose` | |
82 | const promises = [] | |
83 | for (let i = 0; i < max * 2; i++) { | |
6db75ad9 | 84 | promises.push(pool.execute()) |
bdaf31cd JB |
85 | } |
86 | await Promise.all(promises) | |
87 | // We need to clean up the resources after our test | |
88 | await pool.destroy() | |
89 | }) | |
90 | ||
91 | it('Verify ROUND_ROBIN strategy can be run in a dynamic pool', async () => { | |
bdaf31cd JB |
92 | const pool = new DynamicThreadPool( |
93 | min, | |
94 | max, | |
95 | './tests/worker-files/thread/testWorker.js', | |
96 | { workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN } | |
97 | ) | |
98 | expect(pool.opts.workerChoiceStrategy).toBe( | |
99 | WorkerChoiceStrategies.ROUND_ROBIN | |
100 | ) | |
101 | // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose` | |
102 | const promises = [] | |
103 | for (let i = 0; i < max * 2; i++) { | |
6db75ad9 | 104 | promises.push(pool.execute()) |
bdaf31cd JB |
105 | } |
106 | await Promise.all(promises) | |
107 | // We need to clean up the resources after our test | |
108 | await pool.destroy() | |
109 | }) | |
110 | ||
b98ec2e6 | 111 | it('Verify LESS_RECENTLY_USED strategy is taken at pool creation', async () => { |
a35560ba S |
112 | const pool = new FixedThreadPool( |
113 | max, | |
114 | './tests/worker-files/thread/testWorker.js', | |
115 | { workerChoiceStrategy: WorkerChoiceStrategies.LESS_RECENTLY_USED } | |
116 | ) | |
b98ec2e6 JB |
117 | expect(pool.opts.workerChoiceStrategy).toBe( |
118 | WorkerChoiceStrategies.LESS_RECENTLY_USED | |
119 | ) | |
120 | // We need to clean up the resources after our test | |
121 | await pool.destroy() | |
122 | }) | |
a35560ba | 123 | |
b98ec2e6 | 124 | it('Verify LESS_RECENTLY_USED strategy can be set after pool creation', async () => { |
b98ec2e6 JB |
125 | const pool = new FixedThreadPool( |
126 | max, | |
127 | './tests/worker-files/thread/testWorker.js' | |
128 | ) | |
129 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.LESS_RECENTLY_USED) | |
a35560ba S |
130 | expect(pool.opts.workerChoiceStrategy).toBe( |
131 | WorkerChoiceStrategies.LESS_RECENTLY_USED | |
132 | ) | |
b98ec2e6 JB |
133 | // We need to clean up the resources after our test |
134 | await pool.destroy() | |
135 | }) | |
a35560ba | 136 | |
10fcfaf4 | 137 | it('Verify LESS_RECENTLY_USED strategy default tasks usage statistics requirements', async () => { |
10fcfaf4 JB |
138 | let pool = new FixedThreadPool( |
139 | max, | |
140 | './tests/worker-files/thread/testWorker.js' | |
141 | ) | |
142 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.LESS_RECENTLY_USED) | |
143 | expect( | |
144 | pool.workerChoiceStrategyContext.getWorkerChoiceStrategy() | |
145 | .requiredStatistics.runTime | |
146 | ).toBe(false) | |
147 | pool = new DynamicThreadPool( | |
148 | min, | |
149 | max, | |
150 | './tests/worker-files/thread/testWorker.js' | |
151 | ) | |
152 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.LESS_RECENTLY_USED) | |
153 | expect( | |
154 | pool.workerChoiceStrategyContext.getWorkerChoiceStrategy() | |
155 | .requiredStatistics.runTime | |
156 | ).toBe(false) | |
157 | // We need to clean up the resources after our test | |
158 | await pool.destroy() | |
159 | }) | |
160 | ||
ff5e76e1 | 161 | it('Verify LESS_RECENTLY_USED strategy can be run in a fixed pool', async () => { |
b98ec2e6 JB |
162 | const pool = new FixedThreadPool( |
163 | max, | |
164 | './tests/worker-files/thread/testWorker.js', | |
165 | { workerChoiceStrategy: WorkerChoiceStrategies.LESS_RECENTLY_USED } | |
166 | ) | |
a35560ba S |
167 | // TODO: Create a better test to cover `LessRecentlyUsedWorkerChoiceStrategy#choose` |
168 | const promises = [] | |
169 | for (let i = 0; i < max * 2; i++) { | |
6db75ad9 | 170 | promises.push(pool.execute()) |
a35560ba S |
171 | } |
172 | await Promise.all(promises) | |
a35560ba S |
173 | // We need to clean up the resources after our test |
174 | await pool.destroy() | |
175 | }) | |
176 | ||
ff5e76e1 | 177 | it('Verify LESS_RECENTLY_USED strategy can be run in a dynamic pool', async () => { |
ff5e76e1 JB |
178 | const pool = new DynamicThreadPool( |
179 | min, | |
180 | max, | |
181 | './tests/worker-files/thread/testWorker.js', | |
182 | { workerChoiceStrategy: WorkerChoiceStrategies.LESS_RECENTLY_USED } | |
183 | ) | |
184 | // TODO: Create a better test to cover `LessRecentlyUsedWorkerChoiceStrategy#choose` | |
185 | const promises = [] | |
186 | for (let i = 0; i < max * 2; i++) { | |
6db75ad9 | 187 | promises.push(pool.execute()) |
ff5e76e1 JB |
188 | } |
189 | await Promise.all(promises) | |
ff5e76e1 JB |
190 | // We need to clean up the resources after our test |
191 | await pool.destroy() | |
192 | }) | |
193 | ||
23ff945a | 194 | it('Verify FAIR_SHARE strategy is taken at pool creation', async () => { |
23ff945a JB |
195 | const pool = new FixedThreadPool( |
196 | max, | |
197 | './tests/worker-files/thread/testWorker.js', | |
198 | { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE } | |
199 | ) | |
200 | expect(pool.opts.workerChoiceStrategy).toBe( | |
201 | WorkerChoiceStrategies.FAIR_SHARE | |
202 | ) | |
203 | // We need to clean up the resources after our test | |
204 | await pool.destroy() | |
205 | }) | |
206 | ||
207 | it('Verify FAIR_SHARE strategy can be set after pool creation', async () => { | |
23ff945a JB |
208 | const pool = new FixedThreadPool( |
209 | max, | |
210 | './tests/worker-files/thread/testWorker.js' | |
211 | ) | |
212 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE) | |
213 | expect(pool.opts.workerChoiceStrategy).toBe( | |
214 | WorkerChoiceStrategies.FAIR_SHARE | |
215 | ) | |
216 | // We need to clean up the resources after our test | |
217 | await pool.destroy() | |
218 | }) | |
219 | ||
10fcfaf4 | 220 | it('Verify FAIR_SHARE strategy default tasks usage statistics requirements', async () => { |
10fcfaf4 JB |
221 | let pool = new FixedThreadPool( |
222 | max, | |
223 | './tests/worker-files/thread/testWorker.js' | |
224 | ) | |
225 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE) | |
226 | expect( | |
227 | pool.workerChoiceStrategyContext.getWorkerChoiceStrategy() | |
228 | .requiredStatistics.runTime | |
229 | ).toBe(true) | |
230 | pool = new DynamicThreadPool( | |
231 | min, | |
232 | max, | |
233 | './tests/worker-files/thread/testWorker.js' | |
234 | ) | |
235 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE) | |
236 | expect( | |
237 | pool.workerChoiceStrategyContext.getWorkerChoiceStrategy() | |
238 | .requiredStatistics.runTime | |
239 | ).toBe(true) | |
240 | // We need to clean up the resources after our test | |
241 | await pool.destroy() | |
242 | }) | |
243 | ||
23ff945a | 244 | it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => { |
23ff945a JB |
245 | const pool = new FixedThreadPool( |
246 | max, | |
247 | './tests/worker-files/thread/testWorker.js', | |
248 | { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE } | |
249 | ) | |
250 | // TODO: Create a better test to cover `FairShareChoiceStrategy#choose` | |
251 | const promises = [] | |
252 | for (let i = 0; i < max * 2; i++) { | |
6db75ad9 | 253 | promises.push(pool.execute()) |
23ff945a JB |
254 | } |
255 | await Promise.all(promises) | |
256 | // We need to clean up the resources after our test | |
257 | await pool.destroy() | |
258 | }) | |
259 | ||
260 | it('Verify FAIR_SHARE strategy can be run in a dynamic pool', async () => { | |
23ff945a JB |
261 | const pool = new DynamicThreadPool( |
262 | min, | |
263 | max, | |
264 | './tests/worker-files/thread/testWorker.js', | |
265 | { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE } | |
266 | ) | |
267 | // TODO: Create a better test to cover `FairShareChoiceStrategy#choose` | |
268 | const promises = [] | |
269 | for (let i = 0; i < max * 2; i++) { | |
6db75ad9 | 270 | promises.push(pool.execute()) |
23ff945a JB |
271 | } |
272 | await Promise.all(promises) | |
273 | // We need to clean up the resources after our test | |
274 | await pool.destroy() | |
275 | }) | |
276 | ||
b3432a63 | 277 | it('Verify WEIGHTED_ROUND_ROBIN strategy is taken at pool creation', async () => { |
b3432a63 JB |
278 | const pool = new FixedThreadPool( |
279 | max, | |
280 | './tests/worker-files/thread/testWorker.js', | |
281 | { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN } | |
282 | ) | |
283 | expect(pool.opts.workerChoiceStrategy).toBe( | |
284 | WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN | |
285 | ) | |
286 | // We need to clean up the resources after our test | |
287 | await pool.destroy() | |
288 | }) | |
289 | ||
290 | it('Verify WEIGHTED_ROUND_ROBIN strategy can be set after pool creation', async () => { | |
b3432a63 JB |
291 | const pool = new FixedThreadPool( |
292 | max, | |
293 | './tests/worker-files/thread/testWorker.js' | |
294 | ) | |
295 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN) | |
296 | expect(pool.opts.workerChoiceStrategy).toBe( | |
297 | WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN | |
298 | ) | |
299 | // We need to clean up the resources after our test | |
300 | await pool.destroy() | |
301 | }) | |
302 | ||
10fcfaf4 | 303 | it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks usage statistics requirements', async () => { |
10fcfaf4 JB |
304 | let pool = new FixedThreadPool( |
305 | max, | |
306 | './tests/worker-files/thread/testWorker.js' | |
307 | ) | |
308 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN) | |
309 | expect( | |
310 | pool.workerChoiceStrategyContext.getWorkerChoiceStrategy() | |
311 | .requiredStatistics.runTime | |
312 | ).toBe(true) | |
313 | pool = new DynamicThreadPool( | |
314 | min, | |
315 | max, | |
316 | './tests/worker-files/thread/testWorker.js' | |
317 | ) | |
318 | pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN) | |
319 | expect( | |
320 | pool.workerChoiceStrategyContext.getWorkerChoiceStrategy() | |
321 | .requiredStatistics.runTime | |
322 | ).toBe(true) | |
323 | // We need to clean up the resources after our test | |
324 | await pool.destroy() | |
325 | }) | |
326 | ||
b3432a63 | 327 | it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => { |
b3432a63 JB |
328 | const pool = new FixedThreadPool( |
329 | max, | |
330 | './tests/worker-files/thread/testWorker.js', | |
331 | { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN } | |
332 | ) | |
333 | // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose` | |
334 | const promises = [] | |
335 | for (let i = 0; i < max * 2; i++) { | |
6db75ad9 | 336 | promises.push(pool.execute()) |
b3432a63 JB |
337 | } |
338 | await Promise.all(promises) | |
339 | // We need to clean up the resources after our test | |
340 | await pool.destroy() | |
341 | }) | |
342 | ||
343 | it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a dynamic pool', async () => { | |
b3432a63 JB |
344 | const pool = new DynamicThreadPool( |
345 | min, | |
346 | max, | |
347 | './tests/worker-files/thread/testWorker.js', | |
348 | { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN } | |
349 | ) | |
350 | // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose` | |
351 | const promises = [] | |
352 | for (let i = 0; i < max * 2; i++) { | |
6db75ad9 | 353 | promises.push(pool.execute()) |
b3432a63 JB |
354 | } |
355 | await Promise.all(promises) | |
356 | // We need to clean up the resources after our test | |
357 | await pool.destroy() | |
358 | }) | |
359 | ||
a35560ba | 360 | it('Verify unknown strategies throw error', () => { |
a35560ba S |
361 | expect( |
362 | () => | |
363 | new DynamicThreadPool( | |
364 | min, | |
365 | max, | |
366 | './tests/worker-files/thread/testWorker.js', | |
1927ee67 | 367 | { workerChoiceStrategy: 'UNKNOWN_STRATEGY' } |
a35560ba S |
368 | ) |
369 | ).toThrowError( | |
370 | new Error("Worker choice strategy 'UNKNOWN_STRATEGY' not found") | |
371 | ) | |
372 | }) | |
373 | }) |