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('Verify that the function is executed in a worker thread', async () => {
53 let result
= await pool
.execute({
54 function: WorkerFunctions
.fibonacci
56 expect(result
).toBe(false)
57 result
= await pool
.execute({
58 function: WorkerFunctions
.factorial
60 expect(result
).toBe(false)
63 it('Verify that is possible to invoke the execute method without input', async () => {
64 const result
= await pool
.execute()
65 expect(result
).toBe(false)
68 it('Verify that busy event is emitted', async () => {
70 pool
.emitter
.on('busy', () => poolBusy
++)
71 for (let i
= 0; i
< numberOfThreads
* 2; i
++) {
74 // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
75 // So in total numberOfThreads + 1 times for a loop submitting up to numberOfThreads * 2 tasks to the fixed pool.
76 expect(poolBusy
).toBe(numberOfThreads
+ 1)
79 it('Verify that is possible to have a worker that return undefined', async () => {
80 const result
= await emptyPool
.execute()
81 expect(result
).toBeUndefined()
84 it('Verify that data are sent to the worker correctly', async () => {
85 const data
= { f
: 10 }
86 const result
= await echoPool
.execute(data
)
87 expect(result
).toStrictEqual(data
)
90 it('Verify that error handling is working properly:sync', async () => {
91 const data
= { f
: 10 }
94 await errorPool
.execute(data
)
98 expect(inError
).toBeDefined()
99 expect(inError
).toBeInstanceOf(Error
)
100 expect(inError
.message
).toBeDefined()
101 expect(typeof inError
.message
=== 'string').toBe(true)
102 expect(inError
.message
).toBe('Error Message from ThreadWorker')
105 it('Verify that error handling is working properly:async', async () => {
106 const data
= { f
: 10 }
109 await asyncErrorPool
.execute(data
)
113 expect(inError
).toBeDefined()
114 expect(inError
).toBeInstanceOf(Error
)
115 expect(inError
.message
).toBeDefined()
116 expect(typeof inError
.message
=== 'string').toBe(true)
117 expect(inError
.message
).toBe('Error Message from ThreadWorker:async')
120 it('Verify that async function is working properly', async () => {
121 const data
= { f
: 10 }
122 const startTime
= Date
.now()
123 const result
= await asyncPool
.execute(data
)
124 const usedTime
= Date
.now() - startTime
125 expect(result
).toStrictEqual(data
)
126 expect(usedTime
).toBeGreaterThanOrEqual(2000)
129 it('Shutdown test', async () => {
130 const exitPromise
= TestUtils
.waitExits(pool
, numberOfThreads
)
132 const numberOfExitEvents
= await exitPromise
133 expect(numberOfExitEvents
).toBe(numberOfThreads
)
136 it('Should work even without opts in input', async () => {
137 const pool1
= new FixedThreadPool(
139 './tests/worker-files/thread/testWorker.js'
141 const res
= await pool1
.execute()
142 expect(res
).toBe(false)
143 // We need to clean up the resources after our test
144 await pool1
.destroy()
147 it('Verify that a pool with zero worker fails', async () => {
149 () => new FixedThreadPool(0, './tests/worker-files/thread/testWorker.js')
150 ).toThrowError(new Error('Cannot instantiate a fixed pool with no worker'))