1 const { expect
} = require('expect')
6 } = require('../../../lib/index')
8 const numberOfWorkers
= 1
10 const workerNotFoundInTasksUsageMapError
= new Error(
11 'Worker could not be found in worker tasks usage map'
14 class StubPoolWithWorkerTasksUsageMapClear
extends FixedThreadPool
{
16 this.workersTasksUsage
.clear()
20 class StubPoolWithIsMainMethod
extends FixedThreadPool
{
26 describe('Abstract pool test suite', () => {
27 it('Simulate pool creation from a non main thread/process', () => {
30 new StubPoolWithIsMainMethod(
32 './tests/worker-files/thread/testWorker.js',
34 errorHandler
: e
=> console
.error(e
)
37 ).toThrowError(new Error('Cannot start a pool from a worker!'))
40 it('Verify that filePath is checked', () => {
41 const expectedError
= new Error(
42 'Please specify a file with a worker implementation'
44 expect(() => new FixedThreadPool(numberOfWorkers
)).toThrowError(
47 expect(() => new FixedThreadPool(numberOfWorkers
, '')).toThrowError(
52 it('Verify that numberOfWorkers is checked', () => {
53 expect(() => new FixedThreadPool()).toThrowError(
55 'Cannot instantiate a pool without specifying the number of workers'
60 it('Verify that a negative number of workers is checked', () => {
63 new FixedClusterPool(-1, './tests/worker-files/cluster/testWorker.js')
65 new Error('Cannot instantiate a pool with a negative number of workers')
69 it('Verify that a non integer number of workers is checked', () => {
72 new FixedThreadPool(0.25, './tests/worker-files/thread/testWorker.js')
75 'Cannot instantiate a pool with a non integer number of workers'
80 it('Verify that pool options are checked', () => {
81 let pool
= new FixedThreadPool(
83 './tests/worker-files/thread/testWorker.js'
85 expect(pool
.opts
.enableEvents
).toBe(true)
86 expect(pool
.emitter
).toBeDefined()
87 expect(pool
.opts
.workerChoiceStrategy
).toBe(
88 WorkerChoiceStrategies
.ROUND_ROBIN
90 expect(pool
.opts
.messageHandler
).toBeUndefined()
91 expect(pool
.opts
.errorHandler
).toBeUndefined()
92 expect(pool
.opts
.onlineHandler
).toBeUndefined()
93 expect(pool
.opts
.exitHandler
).toBeUndefined()
95 const testHandler
= () => console
.log('test handler executed')
96 pool
= new FixedThreadPool(
98 './tests/worker-files/thread/testWorker.js',
100 workerChoiceStrategy
: WorkerChoiceStrategies
.LESS_RECENTLY_USED
,
102 messageHandler
: testHandler
,
103 errorHandler
: testHandler
,
104 onlineHandler
: testHandler
,
105 exitHandler
: testHandler
108 expect(pool
.opts
.enableEvents
).toBe(false)
109 expect(pool
.emitter
).toBeUndefined()
110 expect(pool
.opts
.workerChoiceStrategy
).toBe(
111 WorkerChoiceStrategies
.LESS_RECENTLY_USED
113 expect(pool
.opts
.messageHandler
).toStrictEqual(testHandler
)
114 expect(pool
.opts
.errorHandler
).toStrictEqual(testHandler
)
115 expect(pool
.opts
.onlineHandler
).toStrictEqual(testHandler
)
116 expect(pool
.opts
.exitHandler
).toStrictEqual(testHandler
)
120 it('Simulate worker not found during increaseWorkerRunningTasks', () => {
121 const pool
= new StubPoolWithWorkerTasksUsageMapClear(
123 './tests/worker-files/cluster/testWorker.js'
125 // Simulate worker not found.
126 pool
.removeAllWorker()
127 expect(() => pool
.increaseWorkerRunningTasks()).toThrowError(
128 workerNotFoundInTasksUsageMapError
133 it('Simulate worker not found during decreaseWorkerRunningTasks', () => {
134 const pool
= new StubPoolWithWorkerTasksUsageMapClear(
136 './tests/worker-files/cluster/testWorker.js',
138 errorHandler
: e
=> console
.error(e
)
141 // Simulate worker not found.
142 pool
.removeAllWorker()
143 expect(() => pool
.decreaseWorkerRunningTasks()).toThrowError(
144 workerNotFoundInTasksUsageMapError
149 it('Simulate worker not found during stepWorkerRunTasks', () => {
150 const pool
= new StubPoolWithWorkerTasksUsageMapClear(
152 './tests/worker-files/cluster/testWorker.js',
154 errorHandler
: e
=> console
.error(e
)
157 // Simulate worker not found.
158 pool
.removeAllWorker()
159 expect(() => pool
.stepWorkerRunTasks()).toThrowError(
160 workerNotFoundInTasksUsageMapError
165 it('Simulate worker not found during updateWorkerTasksRunTime', () => {
166 const pool
= new StubPoolWithWorkerTasksUsageMapClear(
168 './tests/worker-files/cluster/testWorker.js',
170 errorHandler
: e
=> console
.error(e
)
173 // Simulate worker not found.
174 pool
.removeAllWorker()
175 expect(() => pool
.updateWorkerTasksRunTime()).toThrowError(
176 workerNotFoundInTasksUsageMapError
181 it('Verify that worker pool tasks usage are initialized', () => {
182 const pool
= new FixedClusterPool(
184 './tests/worker-files/cluster/testWorker.js'
186 for (const tasksUsage
of pool
.workersTasksUsage
.values()) {
187 expect(tasksUsage
).toBeDefined()
188 expect(tasksUsage
.run
).toBe(0)
189 expect(tasksUsage
.running
).toBe(0)
190 expect(tasksUsage
.runTime
).toBe(0)
191 expect(tasksUsage
.avgRunTime
).toBe(0)
196 it('Verify that worker pool tasks usage are computed', async () => {
197 const pool
= new FixedClusterPool(
199 './tests/worker-files/cluster/testWorker.js'
202 for (let i
= 0; i
< numberOfWorkers
* 2; i
++) {
203 promises
.push(pool
.execute({ test
: 'test' }))
205 for (const tasksUsage
of pool
.workersTasksUsage
.values()) {
206 expect(tasksUsage
).toBeDefined()
207 expect(tasksUsage
.run
).toBe(0)
208 expect(tasksUsage
.running
).toBe(numberOfWorkers
* 2)
209 expect(tasksUsage
.runTime
).toBe(0)
210 expect(tasksUsage
.avgRunTime
).toBe(0)
212 await Promise
.all(promises
)
213 for (const tasksUsage
of pool
.workersTasksUsage
.values()) {
214 expect(tasksUsage
).toBeDefined()
215 expect(tasksUsage
.run
).toBe(numberOfWorkers
* 2)
216 expect(tasksUsage
.running
).toBe(0)
217 expect(tasksUsage
.runTime
).toBeGreaterThanOrEqual(0)
218 expect(tasksUsage
.avgRunTime
).toBeGreaterThanOrEqual(0)
223 it("Verify that pool event emitter 'busy' event can register a callback", async () => {
224 const pool
= new FixedThreadPool(
226 './tests/worker-files/thread/testWorker.js'
230 pool
.emitter
.on('busy', () => poolBusy
++)
231 for (let i
= 0; i
< numberOfWorkers
* 2; i
++) {
232 promises
.push(pool
.execute({ test
: 'test' }))
234 await Promise
.all(promises
)
235 // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
236 // So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
237 expect(poolBusy
).toBe(numberOfWorkers
+ 1)