1 const { expect
} = require('expect')
2 const { FixedThreadPool
} = require('../../../lib/index')
3 const TestUtils
= require('../../test-utils')
4 const numberOfThreads
= 10
5 const pool
= new FixedThreadPool(
7 './tests/worker-files/thread/testWorker.js',
9 errorHandler
: e
=> console
.error(e
)
12 const emptyPool
= new FixedThreadPool(
14 './tests/worker-files/thread/emptyWorker.js',
15 { exitHandler
: () => console
.log('empty pool worker exited') }
17 const echoPool
= new FixedThreadPool(
19 './tests/worker-files/thread/echoWorker.js'
21 const errorPool
= new FixedThreadPool(
23 './tests/worker-files/thread/errorWorker.js',
25 errorHandler
: e
=> console
.error(e
)
28 const asyncErrorPool
= new FixedThreadPool(
30 './tests/worker-files/thread/asyncErrorWorker.js',
32 errorHandler
: e
=> console
.error(e
)
35 const asyncPool
= new FixedThreadPool(
37 './tests/worker-files/thread/asyncWorker.js'
40 describe('Fixed thread pool test suite', () => {
41 after('Destroy all pools', async () => {
42 // We need to clean up the resources after our test
43 await echoPool
.destroy()
44 await asyncPool
.destroy()
45 await errorPool
.destroy()
46 await asyncErrorPool
.destroy()
47 await emptyPool
.destroy()
50 it('Choose worker round robin test', async () => {
51 const results
= new Set()
52 for (let i
= 0; i
< numberOfThreads
; i
++) {
53 results
.add(pool
.chooseWorker().threadId
)
55 expect(results
.size
).toBe(numberOfThreads
)
58 it('Verify that the function is executed in a worker thread', async () => {
59 const result
= await pool
.execute({ test
: 'test' })
60 expect(result
).toBeDefined()
61 expect(result
).toBeFalsy()
64 it('Verify that is possible to invoke the execute method without input', async () => {
65 const result
= await pool
.execute()
66 expect(result
).toBeDefined()
67 expect(result
).toBeFalsy()
70 it('Verify that busy event is emitted', async () => {
73 pool
.emitter
.on('busy', () => poolBusy
++)
74 for (let i
= 0; i
< numberOfThreads
* 2; i
++) {
75 promises
.push(pool
.execute({ test
: 'test' }))
77 // await Promise.all(promises)
78 // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
79 // So in total numberOfThreads + 1 times for a loop submitting up to numberOfThreads * 2 tasks to the fixed pool.
80 expect(poolBusy
).toBe(numberOfThreads
+ 1)
83 it('Verify that is possible to have a worker that return undefined', async () => {
84 const result
= await emptyPool
.execute()
85 expect(result
).toBeFalsy()
88 it('Verify that data are sent to the worker correctly', async () => {
89 const data
= { f
: 10 }
90 const result
= await echoPool
.execute(data
)
91 expect(result
).toBeTruthy()
92 expect(result
.f
).toBe(data
.f
)
95 it('Verify that error handling is working properly:sync', async () => {
96 const data
= { f
: 10 }
99 await errorPool
.execute(data
)
103 expect(inError
).toBeDefined()
104 expect(inError
).toBeInstanceOf(Error
)
105 expect(inError
.message
).toBeDefined()
106 expect(typeof inError
.message
=== 'string').toBe(true)
107 expect(inError
.message
).toBe('Error Message from ThreadWorker')
110 it('Verify that error handling is working properly:async', async () => {
111 const data
= { f
: 10 }
114 await asyncErrorPool
.execute(data
)
118 expect(inError
).toBeDefined()
119 expect(inError
).toBeInstanceOf(Error
)
120 expect(inError
.message
).toBeDefined()
121 expect(typeof inError
.message
=== 'string').toBe(true)
122 expect(inError
.message
).toBe('Error Message from ThreadWorker:async')
125 it('Verify that async function is working properly', async () => {
126 const data
= { f
: 10 }
127 const startTime
= new Date().getTime()
128 const result
= await asyncPool
.execute(data
)
129 const usedTime
= new Date().getTime() - startTime
130 expect(result
).toBeTruthy()
131 expect(result
.f
).toBe(data
.f
)
132 expect(usedTime
).toBeGreaterThanOrEqual(2000)
135 it('Shutdown test', async () => {
136 const exitPromise
= TestUtils
.waitExits(pool
, numberOfThreads
)
138 const numberOfExitEvents
= await exitPromise
139 expect(numberOfExitEvents
).toBe(numberOfThreads
)
142 it('Should work even without opts in input', async () => {
143 const pool1
= new FixedThreadPool(
145 './tests/worker-files/thread/testWorker.js'
147 const res
= await pool1
.execute({ test
: 'test' })
148 expect(res
).toBeFalsy()
149 // We need to clean up the resources after our test
150 await pool1
.destroy()
153 it('Verify that a pool with zero worker fails', async () => {
155 () => new FixedThreadPool(0, './tests/worker-files/thread/testWorker.js')
156 ).toThrowError(new Error('Cannot instantiate a fixed pool with no worker'))