Merge branch 'master' into interleaved-weighted-round-robin-worker-choice-strategy
[poolifier.git] / tests / pools / thread / fixed.test.js
CommitLineData
a61a0724 1const { expect } = require('expect')
cdace0e5 2const { FixedThreadPool, PoolEvents } = require('../../../lib')
2d2e32c2 3const { WorkerFunctions } = require('../../test-types')
85a3f8a7 4const TestUtils = require('../../test-utils')
506c2a14 5
a35560ba 6describe('Fixed thread pool test suite', () => {
e1ffb94f
JB
7 const numberOfThreads = 6
8 const pool = new FixedThreadPool(
9 numberOfThreads,
10 './tests/worker-files/thread/testWorker.js',
11 {
12 errorHandler: e => console.error(e)
13 }
14 )
594bfb84
JB
15 const queuePool = new FixedThreadPool(
16 numberOfThreads,
17 './tests/worker-files/thread/testWorker.js',
18 {
19 enableTasksQueue: true,
20 tasksQueueOptions: {
21 concurrency: 2
22 },
23 errorHandler: e => console.error(e)
24 }
25 )
e1ffb94f
JB
26 const emptyPool = new FixedThreadPool(
27 numberOfThreads,
28 './tests/worker-files/thread/emptyWorker.js',
29 { exitHandler: () => console.log('empty pool worker exited') }
30 )
31 const echoPool = new FixedThreadPool(
32 numberOfThreads,
33 './tests/worker-files/thread/echoWorker.js'
34 )
35 const errorPool = new FixedThreadPool(
36 numberOfThreads,
37 './tests/worker-files/thread/errorWorker.js',
38 {
39 errorHandler: e => console.error(e)
40 }
41 )
42 const asyncErrorPool = new FixedThreadPool(
43 numberOfThreads,
44 './tests/worker-files/thread/asyncErrorWorker.js',
45 {
46 errorHandler: e => console.error(e)
47 }
48 )
49 const asyncPool = new FixedThreadPool(
50 numberOfThreads,
51 './tests/worker-files/thread/asyncWorker.js'
52 )
53
0e2503fc
JB
54 after('Destroy all pools', async () => {
55 // We need to clean up the resources after our test
56 await echoPool.destroy()
57 await asyncPool.destroy()
58 await errorPool.destroy()
7c0ba920 59 await asyncErrorPool.destroy()
0e2503fc 60 await emptyPool.destroy()
594bfb84 61 await queuePool.destroy()
0e2503fc
JB
62 })
63
506c2a14 64 it('Verify that the function is executed in a worker thread', async () => {
6db75ad9
JB
65 let result = await pool.execute({
66 function: WorkerFunctions.fibonacci
67 })
70a4f5ea 68 expect(result).toBe(121393)
6db75ad9
JB
69 result = await pool.execute({
70 function: WorkerFunctions.factorial
71 })
70a4f5ea 72 expect(result).toBe(9.33262154439441e157)
506c2a14 73 })
74
318d4156 75 it('Verify that is possible to invoke the execute() method without input', async () => {
106744f7 76 const result = await pool.execute()
6db75ad9 77 expect(result).toBe(false)
106744f7 78 })
79
aee46736 80 it("Verify that 'busy' event is emitted", async () => {
7c0ba920 81 let poolBusy = 0
aee46736 82 pool.emitter.on(PoolEvents.busy, () => ++poolBusy)
7c0ba920 83 for (let i = 0; i < numberOfThreads * 2; i++) {
8cbb82eb 84 pool.execute()
7c0ba920 85 }
14916bf9
JB
86 // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
87 // So in total numberOfThreads + 1 times for a loop submitting up to numberOfThreads * 2 tasks to the fixed pool.
88 expect(poolBusy).toBe(numberOfThreads + 1)
7c0ba920
JB
89 })
90
594bfb84 91 it('Verify that tasks queuing is working', async () => {
d3d4b67d 92 const promises = new Set()
ee9f5295 93 const maxMultiplier = 2
594bfb84 94 for (let i = 0; i < numberOfThreads * maxMultiplier; i++) {
d3d4b67d 95 promises.add(queuePool.execute())
594bfb84 96 }
d3d4b67d 97 expect(promises.size).toBe(numberOfThreads * maxMultiplier)
594bfb84
JB
98 for (const workerNode of queuePool.workerNodes) {
99 expect(workerNode.tasksUsage.running).toBeLessThanOrEqual(
100 queuePool.opts.tasksQueueOptions.concurrency
101 )
102 expect(workerNode.tasksUsage.run).toBe(0)
4d8bf9e4 103 expect(workerNode.tasksQueue.size).toBeGreaterThan(0)
594bfb84 104 }
d3d4b67d
JB
105 expect(queuePool.numberOfRunningTasks).toBe(numberOfThreads)
106 expect(queuePool.numberOfQueuedTasks).toBe(
107 numberOfThreads * maxMultiplier - numberOfThreads
108 )
594bfb84
JB
109 await Promise.all(promises)
110 for (const workerNode of queuePool.workerNodes) {
111 expect(workerNode.tasksUsage.running).toBe(0)
112 expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
fc027381 113 expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(maxMultiplier)
4d8bf9e4 114 expect(workerNode.tasksQueue.size).toBe(0)
594bfb84 115 }
d3d4b67d 116 promises.clear()
594bfb84
JB
117 })
118
106744f7 119 it('Verify that is possible to have a worker that return undefined', async () => {
120 const result = await emptyPool.execute()
6db75ad9 121 expect(result).toBeUndefined()
106744f7 122 })
123
124 it('Verify that data are sent to the worker correctly', async () => {
125 const data = { f: 10 }
126 const result = await echoPool.execute(data)
e1ffb94f 127 expect(result).toStrictEqual(data)
106744f7 128 })
129
7c0ba920 130 it('Verify that error handling is working properly:sync', async () => {
106744f7 131 const data = { f: 10 }
132 let inError
133 try {
134 await errorPool.execute(data)
135 } catch (e) {
136 inError = e
137 }
7c0ba920
JB
138 expect(inError).toBeDefined()
139 expect(inError).toBeInstanceOf(Error)
140 expect(inError.message).toBeDefined()
8620fb25 141 expect(typeof inError.message === 'string').toBe(true)
0302f8ec 142 expect(inError.message).toBe('Error Message from ThreadWorker')
18482cec
JB
143 expect(
144 errorPool.workerNodes.some(
145 workerNode => workerNode.tasksUsage.error === 1
146 )
147 ).toBe(true)
7c0ba920
JB
148 })
149
150 it('Verify that error handling is working properly:async', async () => {
151 const data = { f: 10 }
152 let inError
153 try {
154 await asyncErrorPool.execute(data)
155 } catch (e) {
156 inError = e
157 }
158 expect(inError).toBeDefined()
159 expect(inError).toBeInstanceOf(Error)
160 expect(inError.message).toBeDefined()
8620fb25 161 expect(typeof inError.message === 'string').toBe(true)
0302f8ec 162 expect(inError.message).toBe('Error Message from ThreadWorker:async')
18482cec
JB
163 expect(
164 asyncErrorPool.workerNodes.some(
165 workerNode => workerNode.tasksUsage.error === 1
166 )
167 ).toBe(true)
106744f7 168 })
169
7784f548 170 it('Verify that async function is working properly', async () => {
171 const data = { f: 10 }
15e5141f 172 const startTime = performance.now()
7784f548 173 const result = await asyncPool.execute(data)
15e5141f 174 const usedTime = performance.now() - startTime
e1ffb94f 175 expect(result).toStrictEqual(data)
32d490eb 176 expect(usedTime).toBeGreaterThanOrEqual(2000)
7784f548 177 })
178
506c2a14 179 it('Shutdown test', async () => {
85a3f8a7 180 const exitPromise = TestUtils.waitExits(pool, numberOfThreads)
1f9a5a44 181 await pool.destroy()
bdacc2d2
JB
182 const numberOfExitEvents = await exitPromise
183 expect(numberOfExitEvents).toBe(numberOfThreads)
506c2a14 184 })
185
186 it('Should work even without opts in input', async () => {
76b1e974 187 const pool1 = new FixedThreadPool(
e1ffb94f 188 numberOfThreads,
76b1e974
S
189 './tests/worker-files/thread/testWorker.js'
190 )
6db75ad9
JB
191 const res = await pool1.execute()
192 expect(res).toBe(false)
0e2503fc
JB
193 // We need to clean up the resources after our test
194 await pool1.destroy()
506c2a14 195 })
8d3782fa
JB
196
197 it('Verify that a pool with zero worker fails', async () => {
198 expect(
199 () => new FixedThreadPool(0, './tests/worker-files/thread/testWorker.js')
d4aeae5a 200 ).toThrowError('Cannot instantiate a fixed pool with no worker')
8d3782fa 201 })
506c2a14 202})