1 const { expect
} = require('expect')
2 const { FixedClusterPool
} = require('../../../lib/index')
3 const TestUtils
= require('../../test-utils')
4 const numberOfWorkers
= 10
5 const pool
= new FixedClusterPool(
7 './tests/worker-files/cluster/testWorker.js',
9 errorHandler
: e
=> console
.error(e
)
12 const emptyPool
= new FixedClusterPool(
14 './tests/worker-files/cluster/emptyWorker.js',
15 { exitHandler
: () => console
.log('empty pool worker exited') }
17 const echoPool
= new FixedClusterPool(
19 './tests/worker-files/cluster/echoWorker.js'
21 const errorPool
= new FixedClusterPool(
23 './tests/worker-files/cluster/errorWorker.js',
25 errorHandler
: e
=> console
.error(e
)
28 const asyncErrorPool
= new FixedClusterPool(
30 './tests/worker-files/cluster/asyncErrorWorker.js',
32 errorHandler
: e
=> console
.error(e
)
35 const asyncPool
= new FixedClusterPool(
37 './tests/worker-files/cluster/asyncWorker.js'
40 describe('Fixed cluster 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
< numberOfWorkers
; i
++) {
53 results
.add(pool
.chooseWorker().id
)
55 expect(results
.size
).toBe(numberOfWorkers
)
58 it('Verify that the function is executed in a worker cluster', 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
< numberOfWorkers
* 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 numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
80 expect(poolBusy
).toBe(numberOfWorkers
+ 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(typeof inError
=== 'string').toBe(true)
105 expect(inError
).toBe('Error Message from ClusterWorker')
108 it('Verify that error handling is working properly:async', async () => {
109 const data
= { f
: 10 }
112 await asyncErrorPool
.execute(data
)
116 expect(inError
).toBeDefined()
117 expect(typeof inError
=== 'string').toBe(true)
118 expect(inError
).toBe('Error Message from ClusterWorker:async')
121 it('Verify that async function is working properly', async () => {
122 const data
= { f
: 10 }
123 const startTime
= new Date().getTime()
124 const result
= await asyncPool
.execute(data
)
125 const usedTime
= new Date().getTime() - startTime
126 expect(result
).toBeTruthy()
127 expect(result
.f
).toBe(data
.f
)
128 expect(usedTime
).toBeGreaterThanOrEqual(2000)
131 it('Shutdown test', async () => {
132 const exitPromise
= TestUtils
.waitExits(pool
, numberOfWorkers
)
134 const numberOfExitEvents
= await exitPromise
135 expect(numberOfExitEvents
).toBe(numberOfWorkers
)
138 it('Should work even without opts in input', async () => {
139 const pool1
= new FixedClusterPool(
141 './tests/worker-files/cluster/testWorker.js'
143 const res
= await pool1
.execute({ test
: 'test' })
144 expect(res
).toBeFalsy()
145 // We need to clean up the resources after our test
146 await pool1
.destroy()
149 it('Verify that a pool with zero worker fails', async () => {
152 new FixedClusterPool(0, './tests/worker-files/cluster/testWorker.js')
153 ).toThrowError(new Error('Cannot instantiate a fixed pool with no worker'))