5bbc8e0e1bc918bf222907e4c76dad553424f9bc
1 const { expect
} = require('expect')
2 const { FixedThreadPool
} = require('../../../lib/index')
3 const WorkerFunctions
= require('../../test-types')
4 const TestUtils
= require('../../test-utils')
6 describe('Fixed thread pool test suite', () => {
7 const numberOfThreads
= 6
8 const pool
= new FixedThreadPool(
10 './tests/worker-files/thread/testWorker.js',
12 errorHandler
: e
=> console
.error(e
)
15 const emptyPool
= new FixedThreadPool(
17 './tests/worker-files/thread/emptyWorker.js',
18 { exitHandler
: () => console
.log('empty pool worker exited') }
20 const echoPool
= new FixedThreadPool(
22 './tests/worker-files/thread/echoWorker.js'
24 const errorPool
= new FixedThreadPool(
26 './tests/worker-files/thread/errorWorker.js',
28 errorHandler
: e
=> console
.error(e
)
31 const asyncErrorPool
= new FixedThreadPool(
33 './tests/worker-files/thread/asyncErrorWorker.js',
35 errorHandler
: e
=> console
.error(e
)
38 const asyncPool
= new FixedThreadPool(
40 './tests/worker-files/thread/asyncWorker.js'
43 after('Destroy all pools', async () => {
44 // We need to clean up the resources after our test
45 await echoPool
.destroy()
46 await asyncPool
.destroy()
47 await errorPool
.destroy()
48 await asyncErrorPool
.destroy()
49 await emptyPool
.destroy()
52 it('Choose worker round robin test', async () => {
53 const results
= new Set()
54 for (let i
= 0; i
< numberOfThreads
; i
++) {
55 results
.add(pool
.chooseWorker().threadId
)
57 expect(results
.size
).toBe(numberOfThreads
)
60 it('Verify that the function is executed in a worker thread', async () => {
61 let result
= await pool
.execute({
62 function: WorkerFunctions
.fibonacci
64 expect(result
).toBe(false)
65 result
= await pool
.execute({
66 function: WorkerFunctions
.factorial
68 expect(result
).toBe(false)
71 it('Verify that is possible to invoke the execute method without input', async () => {
72 const result
= await pool
.execute()
73 expect(result
).toBe(false)
76 it('Verify that busy event is emitted', async () => {
79 pool
.emitter
.on('busy', () => poolBusy
++)
80 for (let i
= 0; i
< numberOfThreads
* 2; i
++) {
81 promises
.push(pool
.execute())
83 // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
84 // So in total numberOfThreads + 1 times for a loop submitting up to numberOfThreads * 2 tasks to the fixed pool.
85 expect(poolBusy
).toBe(numberOfThreads
+ 1)
88 it('Verify that is possible to have a worker that return undefined', async () => {
89 const result
= await emptyPool
.execute()
90 expect(result
).toBeUndefined()
93 it('Verify that data are sent to the worker correctly', async () => {
94 const data
= { f
: 10 }
95 const result
= await echoPool
.execute(data
)
96 expect(result
).toStrictEqual(data
)
99 it('Verify that error handling is working properly:sync', async () => {
100 const data
= { f
: 10 }
103 await errorPool
.execute(data
)
107 expect(inError
).toBeDefined()
108 expect(inError
).toBeInstanceOf(Error
)
109 expect(inError
.message
).toBeDefined()
110 expect(typeof inError
.message
=== 'string').toBe(true)
111 expect(inError
.message
).toBe('Error Message from ThreadWorker')
114 it('Verify that error handling is working properly:async', async () => {
115 const data
= { f
: 10 }
118 await asyncErrorPool
.execute(data
)
122 expect(inError
).toBeDefined()
123 expect(inError
).toBeInstanceOf(Error
)
124 expect(inError
.message
).toBeDefined()
125 expect(typeof inError
.message
=== 'string').toBe(true)
126 expect(inError
.message
).toBe('Error Message from ThreadWorker:async')
129 it('Verify that async function is working properly', async () => {
130 const data
= { f
: 10 }
131 const startTime
= new Date().getTime()
132 const result
= await asyncPool
.execute(data
)
133 const usedTime
= new Date().getTime() - startTime
134 expect(result
).toStrictEqual(data
)
135 expect(usedTime
).toBeGreaterThanOrEqual(2000)
138 it('Shutdown test', async () => {
139 const exitPromise
= TestUtils
.waitExits(pool
, numberOfThreads
)
141 const numberOfExitEvents
= await exitPromise
142 expect(numberOfExitEvents
).toBe(numberOfThreads
)
145 it('Should work even without opts in input', async () => {
146 const pool1
= new FixedThreadPool(
148 './tests/worker-files/thread/testWorker.js'
150 const res
= await pool1
.execute()
151 expect(res
).toBe(false)
152 // We need to clean up the resources after our test
153 await pool1
.destroy()
156 it('Verify that a pool with zero worker fails', async () => {
158 () => new FixedThreadPool(0, './tests/worker-files/thread/testWorker.js')
159 ).toThrowError(new Error('Cannot instantiate a fixed pool with no worker'))