numberOfWorkers,
'./tests/worker-files/cluster/testWorker.cjs',
{
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
const queuePool = new FixedClusterPool(
{
enableTasksQueue: true,
tasksQueueOptions: {
- concurrency: tasksConcurrency
+ concurrency: tasksConcurrency,
},
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
const emptyPool = new FixedClusterPool(
numberOfWorkers,
'./tests/worker-files/cluster/errorWorker.cjs',
{
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
const asyncErrorPool = new FixedClusterPool(
numberOfWorkers,
'./tests/worker-files/cluster/asyncErrorWorker.cjs',
{
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
const asyncPool = new FixedClusterPool(
it('Verify that the function is executed in a worker cluster', async () => {
let result = await pool.execute({
- function: TaskFunctions.fibonacci
+ function: TaskFunctions.fibonacci,
})
expect(result).toBe(354224848179262000000)
result = await pool.execute({
- function: TaskFunctions.factorial
+ function: TaskFunctions.factorial,
})
expect(result).toBe(9.33262154439441e157)
})
numberOfWorkers,
'./tests/worker-files/cluster/testWorker.cjs',
{
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
expect(pool.emitter.eventNames()).toStrictEqual([])
expect(taskError).toStrictEqual({
name: DEFAULT_TASK_NAME,
message: 'Error Message from ClusterWorker',
- data
+ data,
})
expect(
errorPool.workerNodes.some(
taskError = e
})
expect(asyncErrorPool.emitter.eventNames()).toStrictEqual([
- PoolEvents.taskError
+ PoolEvents.taskError,
])
let inError
try {
expect(taskError).toStrictEqual({
name: DEFAULT_TASK_NAME,
message: 'Error Message from ClusterWorker:async',
- data
+ data,
})
expect(
asyncErrorPool.workerNodes.some(
pool.emitter.on(PoolEvents.destroy, () => ++poolDestroy)
expect(pool.emitter.eventNames()).toStrictEqual([
PoolEvents.busy,
- PoolEvents.destroy
+ PoolEvents.destroy,
])
await pool.destroy()
const numberOfExitEvents = await exitPromise
expect(pool.started).toBe(false)
expect(pool.emitter.eventNames()).toStrictEqual([
PoolEvents.busy,
- PoolEvents.destroy
+ PoolEvents.destroy,
])
expect(pool.readyEventEmitted).toBe(false)
expect(pool.workerNodes.length).toBe(0)
let pool = new FixedClusterPool(numberOfWorkers, workerFilePath)
expect(pool.opts.env).toBeUndefined()
expect(pool.opts.settings).toBeUndefined()
+ expect(cluster.settings).toMatchObject({
+ exec: workerFilePath,
+ silent: false,
+ })
await pool.destroy()
pool = new FixedClusterPool(numberOfWorkers, workerFilePath, {
env: { TEST: 'test' },
- settings: { args: ['--use', 'http'], silent: true }
+ settings: { args: ['--use', 'http'], silent: true },
})
expect(pool.opts.env).toStrictEqual({ TEST: 'test' })
expect(pool.opts.settings).toStrictEqual({
- args: ['--use', 'http'],
- silent: true
- })
- expect({ ...pool.opts.settings, exec: workerFilePath }).toStrictEqual({
args: ['--use', 'http'],
silent: true,
- exec: workerFilePath
})
expect(cluster.settings).toMatchObject({
args: ['--use', 'http'],
silent: true,
- exec: workerFilePath
+ exec: workerFilePath,
})
await pool.destroy()
})