1 const { expect
} = require('expect')
2 const { FixedClusterPool
} = require('../../../lib/index')
3 const WorkerFunctions
= require('../../test-types')
4 const TestUtils
= require('../../test-utils')
6 describe('Fixed cluster pool test suite', () => {
7 const numberOfWorkers
= 6
8 const pool
= new FixedClusterPool(
10 './tests/worker-files/cluster/testWorker.js',
12 errorHandler
: e
=> console
.error(e
)
15 const emptyPool
= new FixedClusterPool(
17 './tests/worker-files/cluster/emptyWorker.js',
18 { exitHandler
: () => console
.log('empty pool worker exited') }
20 const echoPool
= new FixedClusterPool(
22 './tests/worker-files/cluster/echoWorker.js'
24 const errorPool
= new FixedClusterPool(
26 './tests/worker-files/cluster/errorWorker.js',
28 errorHandler
: e
=> console
.error(e
)
31 const asyncErrorPool
= new FixedClusterPool(
33 './tests/worker-files/cluster/asyncErrorWorker.js',
35 errorHandler
: e
=> console
.error(e
)
38 const asyncPool
= new FixedClusterPool(
40 './tests/worker-files/cluster/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
< numberOfWorkers
; i
++) {
55 results
.add(pool
.chooseWorker().id
)
57 expect(results
.size
).toBe(numberOfWorkers
)
60 it('Verify that the function is executed in a worker cluster', 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
< numberOfWorkers
* 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 numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
85 expect(poolBusy
).toBe(numberOfWorkers
+ 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(typeof inError
=== 'string').toBe(true)
109 expect(inError
).toBe('Error Message from ClusterWorker')
112 it('Verify that error handling is working properly:async', async () => {
113 const data
= { f
: 10 }
116 await asyncErrorPool
.execute(data
)
120 expect(inError
).toBeDefined()
121 expect(typeof inError
=== 'string').toBe(true)
122 expect(inError
).toBe('Error Message from ClusterWorker: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
).toStrictEqual(data
)
131 expect(usedTime
).toBeGreaterThanOrEqual(2000)
134 it('Shutdown test', async () => {
135 const exitPromise
= TestUtils
.waitExits(pool
, numberOfWorkers
)
137 const numberOfExitEvents
= await exitPromise
138 expect(numberOfExitEvents
).toBe(numberOfWorkers
)
141 it('Should work even without opts in input', async () => {
142 const pool1
= new FixedClusterPool(
144 './tests/worker-files/cluster/testWorker.js'
146 const res
= await pool1
.execute()
147 expect(res
).toBe(false)
148 // We need to clean up the resources after our test
149 await pool1
.destroy()
152 it('Verify that a pool with zero worker fails', async () => {
155 new FixedClusterPool(0, './tests/worker-files/cluster/testWorker.js')
156 ).toThrowError(new Error('Cannot instantiate a fixed pool with no worker'))