const { expect } = require('expect')
+const sinon = require('sinon')
const {
DynamicClusterPool,
DynamicThreadPool,
FixedClusterPool,
FixedThreadPool,
PoolEvents,
- WorkerChoiceStrategies,
PoolTypes,
+ WorkerChoiceStrategies,
WorkerTypes
} = require('../../../lib')
const { CircularArray } = require('../../../lib/circular-array')
-const { Queue } = require('../../../lib/queue')
+const { Deque } = require('../../../lib/deque')
const { version } = require('../../../package.json')
const { waitPoolEvents } = require('../../test-utils')
}
}
+ afterEach(() => {
+ sinon.restore()
+ })
+
it('Simulate pool creation from a non main thread/process', () => {
expect(
() =>
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js',
{
- errorHandler: e => console.error(e)
+ errorHandler: (e) => console.error(e)
}
)
- ).toThrowError('Cannot start a pool from a worker!')
+ ).toThrowError(
+ new Error(
+ 'Cannot start a pool from a worker with the same type as the pool'
+ )
+ )
})
it('Verify that filePath is checked', () => {
expect(() => new FixedThreadPool(numberOfWorkers, '')).toThrowError(
expectedError
)
+ expect(() => new FixedThreadPool(numberOfWorkers, 0)).toThrowError(
+ expectedError
+ )
+ expect(() => new FixedThreadPool(numberOfWorkers, true)).toThrowError(
+ expectedError
+ )
+ expect(
+ () => new FixedThreadPool(numberOfWorkers, './dummyWorker.ts')
+ ).toThrowError(new Error("Cannot find the worker file './dummyWorker.ts'"))
})
it('Verify that numberOfWorkers is checked', () => {
expect(() => new FixedThreadPool()).toThrowError(
- 'Cannot instantiate a pool without specifying the number of workers'
+ new Error(
+ 'Cannot instantiate a pool without specifying the number of workers'
+ )
)
})
})
it('Verify that dynamic pool sizing is checked', () => {
+ expect(
+ () =>
+ new DynamicClusterPool(
+ 1,
+ undefined,
+ './tests/worker-files/cluster/testWorker.js'
+ )
+ ).toThrowError(
+ new TypeError(
+ 'Cannot instantiate a dynamic pool without specifying the maximum pool size'
+ )
+ )
+ expect(
+ () =>
+ new DynamicThreadPool(
+ 0.5,
+ 1,
+ './tests/worker-files/thread/testWorker.js'
+ )
+ ).toThrowError(
+ new TypeError(
+ 'Cannot instantiate a pool with a non safe integer number of workers'
+ )
+ )
+ expect(
+ () =>
+ new DynamicClusterPool(
+ 0,
+ 0.5,
+ './tests/worker-files/cluster/testWorker.js'
+ )
+ ).toThrowError(
+ new TypeError(
+ 'Cannot instantiate a dynamic pool with a non safe integer maximum pool size'
+ )
+ )
expect(
() =>
new DynamicThreadPool(2, 1, './tests/worker-files/thread/testWorker.js')
)
expect(
() =>
- new DynamicThreadPool(1, 1, './tests/worker-files/thread/testWorker.js')
+ new DynamicClusterPool(
+ 1,
+ 1,
+ './tests/worker-files/cluster/testWorker.js'
+ )
).toThrowError(
new RangeError(
'Cannot instantiate a dynamic pool with a minimum pool size equal to the maximum pool size. Use a fixed pool instead'
new DynamicThreadPool(0, 0, './tests/worker-files/thread/testWorker.js')
).toThrowError(
new RangeError(
- 'Cannot instantiate a dynamic pool with a minimum pool size and a maximum pool size equal to zero'
+ 'Cannot instantiate a dynamic pool with a maximum pool size equal to zero'
)
)
})
WorkerChoiceStrategies.ROUND_ROBIN
)
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
+ choiceRetries: 6,
+ runTime: { median: false },
+ waitTime: { median: false },
+ elu: { median: false }
+ })
+ expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
+ choiceRetries: 6,
runTime: { median: false },
waitTime: { median: false },
elu: { median: false }
expect(pool.opts.onlineHandler).toBeUndefined()
expect(pool.opts.exitHandler).toBeUndefined()
await pool.destroy()
- const testHandler = () => console.log('test handler executed')
+ const testHandler = () => console.info('test handler executed')
pool = new FixedThreadPool(
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js',
expect(pool.opts.enableEvents).toBe(false)
expect(pool.opts.restartWorkerOnError).toBe(false)
expect(pool.opts.enableTasksQueue).toBe(true)
- expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 2 })
+ expect(pool.opts.tasksQueueOptions).toStrictEqual({
+ concurrency: 2,
+ size: 4
+ })
expect(pool.opts.workerChoiceStrategy).toBe(
WorkerChoiceStrategies.LEAST_USED
)
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
+ choiceRetries: 6,
+ runTime: { median: true },
+ waitTime: { median: false },
+ elu: { median: false },
+ weights: { 0: 300, 1: 200 }
+ })
+ expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
+ choiceRetries: 6,
runTime: { median: true },
+ waitTime: { median: false },
+ elu: { median: false },
weights: { 0: 300, 1: 200 }
})
expect(pool.opts.messageHandler).toStrictEqual(testHandler)
workerChoiceStrategy: 'invalidStrategy'
}
)
- ).toThrowError("Invalid worker choice strategy 'invalidStrategy'")
- expect(
- () =>
- new FixedThreadPool(
- numberOfWorkers,
- './tests/worker-files/thread/testWorker.js',
- {
- workerChoiceStrategyOptions: 'invalidOptions'
- }
- )
).toThrowError(
- 'Invalid worker choice strategy options: must be a plain object'
+ new Error("Invalid worker choice strategy 'invalidStrategy'")
)
expect(
() =>
}
)
).toThrowError(
- 'Invalid worker choice strategy options: must have a weight for each worker node'
+ new Error(
+ 'Invalid worker choice strategy options: must have a weight for each worker node'
+ )
)
expect(
() =>
}
)
).toThrowError(
- "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
+ new Error(
+ "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
+ )
)
expect(
() =>
tasksQueueOptions: { concurrency: 0 }
}
)
- ).toThrowError("Invalid worker tasks concurrency '0'")
+ ).toThrowError(
+ new RangeError(
+ 'Invalid worker node tasks concurrency: 0 is a negative integer or zero'
+ )
+ )
expect(
() =>
new FixedThreadPool(
tasksQueueOptions: 'invalidTasksQueueOptions'
}
)
- ).toThrowError('Invalid tasks queue options: must be a plain object')
+ ).toThrowError(
+ new TypeError('Invalid tasks queue options: must be a plain object')
+ )
expect(
() =>
new FixedThreadPool(
tasksQueueOptions: { concurrency: 0.2 }
}
)
- ).toThrowError('Invalid worker tasks concurrency: must be an integer')
+ ).toThrowError(
+ new TypeError('Invalid worker node tasks concurrency: must be an integer')
+ )
})
it('Verify that pool worker choice strategy options can be set', async () => {
{ workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
)
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
+ choiceRetries: 6,
+ runTime: { median: false },
+ waitTime: { median: false },
+ elu: { median: false }
+ })
+ expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
+ choiceRetries: 6,
runTime: { median: false },
waitTime: { median: false },
elu: { median: false }
for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
.workerChoiceStrategies) {
expect(workerChoiceStrategy.opts).toStrictEqual({
+ choiceRetries: 6,
runTime: { median: false },
waitTime: { median: false },
elu: { median: false }
elu: { median: true }
})
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
+ choiceRetries: 6,
+ runTime: { median: true },
+ waitTime: { median: false },
+ elu: { median: true }
+ })
+ expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
+ choiceRetries: 6,
runTime: { median: true },
+ waitTime: { median: false },
elu: { median: true }
})
for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
.workerChoiceStrategies) {
expect(workerChoiceStrategy.opts).toStrictEqual({
+ choiceRetries: 6,
runTime: { median: true },
+ waitTime: { median: false },
elu: { median: true }
})
}
elu: { median: false }
})
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
+ choiceRetries: 6,
+ runTime: { median: false },
+ waitTime: { median: false },
+ elu: { median: false }
+ })
+ expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
+ choiceRetries: 6,
runTime: { median: false },
+ waitTime: { median: false },
elu: { median: false }
})
for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
.workerChoiceStrategies) {
expect(workerChoiceStrategy.opts).toStrictEqual({
+ choiceRetries: 6,
runTime: { median: false },
+ waitTime: { median: false },
elu: { median: false }
})
}
expect(() =>
pool.setWorkerChoiceStrategyOptions('invalidWorkerChoiceStrategyOptions')
).toThrowError(
- 'Invalid worker choice strategy options: must be a plain object'
+ new TypeError(
+ 'Invalid worker choice strategy options: must be a plain object'
+ )
)
expect(() =>
pool.setWorkerChoiceStrategyOptions({ weights: {} })
).toThrowError(
- 'Invalid worker choice strategy options: must have a weight for each worker node'
+ new Error(
+ 'Invalid worker choice strategy options: must have a weight for each worker node'
+ )
)
expect(() =>
pool.setWorkerChoiceStrategyOptions({ measurement: 'invalidMeasurement' })
).toThrowError(
- "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
+ new Error(
+ "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
+ )
)
await pool.destroy()
})
expect(pool.opts.tasksQueueOptions).toBeUndefined()
pool.enableTasksQueue(true)
expect(pool.opts.enableTasksQueue).toBe(true)
- expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 1 })
+ expect(pool.opts.tasksQueueOptions).toStrictEqual({
+ concurrency: 1,
+ size: 4
+ })
pool.enableTasksQueue(true, { concurrency: 2 })
expect(pool.opts.enableTasksQueue).toBe(true)
- expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 2 })
+ expect(pool.opts.tasksQueueOptions).toStrictEqual({
+ concurrency: 2,
+ size: 4
+ })
pool.enableTasksQueue(false)
expect(pool.opts.enableTasksQueue).toBe(false)
expect(pool.opts.tasksQueueOptions).toBeUndefined()
'./tests/worker-files/thread/testWorker.js',
{ enableTasksQueue: true }
)
- expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 1 })
+ expect(pool.opts.tasksQueueOptions).toStrictEqual({
+ concurrency: 1,
+ size: 4
+ })
pool.setTasksQueueOptions({ concurrency: 2 })
- expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 2 })
+ expect(pool.opts.tasksQueueOptions).toStrictEqual({
+ concurrency: 2,
+ size: 4
+ })
expect(() =>
pool.setTasksQueueOptions('invalidTasksQueueOptions')
- ).toThrowError('Invalid tasks queue options: must be a plain object')
+ ).toThrowError(
+ new TypeError('Invalid tasks queue options: must be a plain object')
+ )
expect(() => pool.setTasksQueueOptions({ concurrency: 0 })).toThrowError(
- "Invalid worker tasks concurrency '0'"
+ new RangeError(
+ 'Invalid worker node tasks concurrency: 0 is a negative integer or zero'
+ )
+ )
+ expect(() => pool.setTasksQueueOptions({ concurrency: -1 })).toThrowError(
+ new RangeError(
+ 'Invalid worker node tasks concurrency: -1 is a negative integer or zero'
+ )
)
expect(() => pool.setTasksQueueOptions({ concurrency: 0.2 })).toThrowError(
- 'Invalid worker tasks concurrency: must be an integer'
+ new TypeError('Invalid worker node tasks concurrency: must be an integer')
+ )
+ expect(() => pool.setTasksQueueOptions({ size: 0 })).toThrowError(
+ new RangeError(
+ 'Invalid worker node tasks queue max size: 0 is a negative integer or zero'
+ )
+ )
+ expect(() => pool.setTasksQueueOptions({ size: -1 })).toThrowError(
+ new RangeError(
+ 'Invalid worker node tasks queue max size: -1 is a negative integer or zero'
+ )
+ )
+ expect(() => pool.setTasksQueueOptions({ size: 0.2 })).toThrowError(
+ new TypeError(
+ 'Invalid worker node tasks queue max size: must be an integer'
+ )
)
await pool.destroy()
})
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js'
)
- expect(pool.info).toStrictEqual({
- version,
- type: PoolTypes.fixed,
- worker: WorkerTypes.thread,
- ready: false,
- strategy: WorkerChoiceStrategies.ROUND_ROBIN,
- minSize: numberOfWorkers,
- maxSize: numberOfWorkers,
- workerNodes: numberOfWorkers,
- idleWorkerNodes: numberOfWorkers,
- busyWorkerNodes: 0,
- executedTasks: 0,
- executingTasks: 0,
- queuedTasks: 0,
- maxQueuedTasks: 0,
- failedTasks: 0
- })
- await waitPoolEvents(pool, PoolEvents.ready, 1)
expect(pool.info).toStrictEqual({
version,
type: PoolTypes.fixed,
busyWorkerNodes: 0,
executedTasks: 0,
executingTasks: 0,
- queuedTasks: 0,
- maxQueuedTasks: 0,
failedTasks: 0
})
await pool.destroy()
numberOfWorkers,
'./tests/worker-files/cluster/testWorker.js'
)
- expect(pool.info).toStrictEqual({
- version,
- type: PoolTypes.dynamic,
- worker: WorkerTypes.cluster,
- ready: false,
- strategy: WorkerChoiceStrategies.ROUND_ROBIN,
- minSize: Math.floor(numberOfWorkers / 2),
- maxSize: numberOfWorkers,
- workerNodes: Math.floor(numberOfWorkers / 2),
- idleWorkerNodes: Math.floor(numberOfWorkers / 2),
- busyWorkerNodes: 0,
- executedTasks: 0,
- executingTasks: 0,
- queuedTasks: 0,
- maxQueuedTasks: 0,
- failedTasks: 0
- })
- await waitPoolEvents(pool, PoolEvents.ready, 1)
expect(pool.info).toStrictEqual({
version,
type: PoolTypes.dynamic,
busyWorkerNodes: 0,
executedTasks: 0,
executingTasks: 0,
- queuedTasks: 0,
- maxQueuedTasks: 0,
failedTasks: 0
})
await pool.destroy()
)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksQueue).toBeDefined()
- expect(workerNode.tasksQueue).toBeInstanceOf(Queue)
+ expect(workerNode.tasksQueue).toBeInstanceOf(Deque)
expect(workerNode.tasksQueue.size).toBe(0)
expect(workerNode.tasksQueue.maxSize).toBe(0)
}
)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksQueue).toBeDefined()
- expect(workerNode.tasksQueue).toBeInstanceOf(Queue)
+ expect(workerNode.tasksQueue).toBeInstanceOf(Deque)
expect(workerNode.tasksQueue.size).toBe(0)
expect(workerNode.tasksQueue.maxSize).toBe(0)
}
numberOfWorkers,
'./tests/worker-files/cluster/testWorker.js'
)
- for (const workerNode of pool.workerNodes) {
- expect(workerNode.info).toStrictEqual({
- id: expect.any(Number),
- type: WorkerTypes.cluster,
- dynamic: false,
- ready: false
- })
- }
- await waitPoolEvents(pool, PoolEvents.ready, 1)
for (const workerNode of pool.workerNodes) {
expect(workerNode.info).toStrictEqual({
id: expect.any(Number),
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js'
)
- for (const workerNode of pool.workerNodes) {
- expect(workerNode.info).toStrictEqual({
- id: expect.any(Number),
- type: WorkerTypes.thread,
- dynamic: false,
- ready: false
- })
- }
- await waitPoolEvents(pool, PoolEvents.ready, 1)
for (const workerNode of pool.workerNodes) {
expect(workerNode.info).toStrictEqual({
id: expect.any(Number),
}
})
expect(workerNode.usage.tasks.executed).toBeGreaterThan(0)
- expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(maxMultiplier)
+ expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
+ numberOfWorkers * maxMultiplier
+ )
+ expect(workerNode.usage.runTime.history.length).toBe(0)
+ expect(workerNode.usage.waitTime.history.length).toBe(0)
+ expect(workerNode.usage.elu.idle.history.length).toBe(0)
+ expect(workerNode.usage.elu.active.history.length).toBe(0)
}
pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
for (const workerNode of pool.workerNodes) {
})
expect(workerNode.usage.runTime.history.length).toBe(0)
expect(workerNode.usage.waitTime.history.length).toBe(0)
+ expect(workerNode.usage.elu.idle.history.length).toBe(0)
+ expect(workerNode.usage.elu.active.history.length).toBe(0)
}
await pool.destroy()
})
- it("Verify that pool event emitter 'full' event can register a callback", async () => {
- const pool = new DynamicThreadPool(
+ it("Verify that pool event emitter 'ready' event can register a callback", async () => {
+ const pool = new DynamicClusterPool(
Math.floor(numberOfWorkers / 2),
+ numberOfWorkers,
+ './tests/worker-files/cluster/testWorker.js'
+ )
+ let poolInfo
+ let poolReady = 0
+ pool.emitter.on(PoolEvents.ready, (info) => {
+ ++poolReady
+ poolInfo = info
+ })
+ await waitPoolEvents(pool, PoolEvents.ready, 1)
+ expect(poolReady).toBe(1)
+ expect(poolInfo).toStrictEqual({
+ version,
+ type: PoolTypes.dynamic,
+ worker: WorkerTypes.cluster,
+ ready: true,
+ strategy: WorkerChoiceStrategies.ROUND_ROBIN,
+ minSize: expect.any(Number),
+ maxSize: expect.any(Number),
+ workerNodes: expect.any(Number),
+ idleWorkerNodes: expect.any(Number),
+ busyWorkerNodes: expect.any(Number),
+ executedTasks: expect.any(Number),
+ executingTasks: expect.any(Number),
+ failedTasks: expect.any(Number)
+ })
+ await pool.destroy()
+ })
+
+ it("Verify that pool event emitter 'busy' event can register a callback", async () => {
+ const pool = new FixedThreadPool(
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js'
)
const promises = new Set()
- let poolFull = 0
+ let poolBusy = 0
let poolInfo
- pool.emitter.on(PoolEvents.full, info => {
- ++poolFull
+ pool.emitter.on(PoolEvents.busy, (info) => {
+ ++poolBusy
poolInfo = info
})
for (let i = 0; i < numberOfWorkers * 2; i++) {
promises.add(pool.execute())
}
await Promise.all(promises)
- // The `full` event is triggered when the number of submitted tasks at once reach the maximum number of workers in the dynamic pool.
- // So in total numberOfWorkers * 2 - 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the dynamic pool with min = (max = numberOfWorkers) / 2.
- expect(poolFull).toBe(numberOfWorkers * 2 - 1)
+ // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
+ // So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
+ expect(poolBusy).toBe(numberOfWorkers + 1)
expect(poolInfo).toStrictEqual({
version,
- type: PoolTypes.dynamic,
+ type: PoolTypes.fixed,
worker: WorkerTypes.thread,
ready: expect.any(Boolean),
strategy: WorkerChoiceStrategies.ROUND_ROBIN,
busyWorkerNodes: expect.any(Number),
executedTasks: expect.any(Number),
executingTasks: expect.any(Number),
- queuedTasks: expect.any(Number),
- maxQueuedTasks: expect.any(Number),
failedTasks: expect.any(Number)
})
await pool.destroy()
})
- it("Verify that pool event emitter 'ready' event can register a callback", async () => {
- const pool = new DynamicClusterPool(
+ it("Verify that pool event emitter 'full' event can register a callback", async () => {
+ const pool = new DynamicThreadPool(
Math.floor(numberOfWorkers / 2),
numberOfWorkers,
- './tests/worker-files/cluster/testWorker.js'
+ './tests/worker-files/thread/testWorker.js'
)
- let poolReady = 0
+ const promises = new Set()
+ let poolFull = 0
let poolInfo
- pool.emitter.on(PoolEvents.ready, info => {
- ++poolReady
+ pool.emitter.on(PoolEvents.full, (info) => {
+ ++poolFull
poolInfo = info
})
- await waitPoolEvents(pool, PoolEvents.ready, 1)
- expect(poolReady).toBe(1)
+ for (let i = 0; i < numberOfWorkers * 2; i++) {
+ promises.add(pool.execute())
+ }
+ await Promise.all(promises)
+ expect(poolFull).toBe(1)
expect(poolInfo).toStrictEqual({
version,
type: PoolTypes.dynamic,
- worker: WorkerTypes.cluster,
- ready: true,
+ worker: WorkerTypes.thread,
+ ready: expect.any(Boolean),
strategy: WorkerChoiceStrategies.ROUND_ROBIN,
minSize: expect.any(Number),
maxSize: expect.any(Number),
busyWorkerNodes: expect.any(Number),
executedTasks: expect.any(Number),
executingTasks: expect.any(Number),
- queuedTasks: expect.any(Number),
- maxQueuedTasks: expect.any(Number),
failedTasks: expect.any(Number)
})
await pool.destroy()
})
- it("Verify that pool event emitter 'busy' event can register a callback", async () => {
+ it("Verify that pool event emitter 'backPressure' event can register a callback", async () => {
const pool = new FixedThreadPool(
numberOfWorkers,
- './tests/worker-files/thread/testWorker.js'
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true
+ }
)
+ sinon.stub(pool, 'hasBackPressure').returns(true)
const promises = new Set()
- let poolBusy = 0
+ let poolBackPressure = 0
let poolInfo
- pool.emitter.on(PoolEvents.busy, info => {
- ++poolBusy
+ pool.emitter.on(PoolEvents.backPressure, (info) => {
+ ++poolBackPressure
poolInfo = info
})
for (let i = 0; i < numberOfWorkers * 2; i++) {
promises.add(pool.execute())
}
await Promise.all(promises)
- // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
- // So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
- expect(poolBusy).toBe(numberOfWorkers + 1)
+ expect(poolBackPressure).toBe(2)
expect(poolInfo).toStrictEqual({
version,
type: PoolTypes.fixed,
busyWorkerNodes: expect.any(Number),
executedTasks: expect.any(Number),
executingTasks: expect.any(Number),
- queuedTasks: expect.any(Number),
maxQueuedTasks: expect.any(Number),
+ queuedTasks: expect.any(Number),
+ backPressure: true,
failedTasks: expect.any(Number)
})
+ expect(pool.hasBackPressure.called).toBe(true)
await pool.destroy()
})
- it('Verify that multiple tasks worker is working', async () => {
+ it('Verify that listTaskFunctions() is working', async () => {
+ const dynamicThreadPool = new DynamicThreadPool(
+ Math.floor(numberOfWorkers / 2),
+ numberOfWorkers,
+ './tests/worker-files/thread/testMultipleTaskFunctionsWorker.js'
+ )
+ await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
+ expect(dynamicThreadPool.listTaskFunctions()).toStrictEqual([
+ 'default',
+ 'jsonIntegerSerialization',
+ 'factorial',
+ 'fibonacci'
+ ])
+ const fixedClusterPool = new FixedClusterPool(
+ numberOfWorkers,
+ './tests/worker-files/cluster/testMultipleTaskFunctionsWorker.js'
+ )
+ await waitPoolEvents(fixedClusterPool, PoolEvents.ready, 1)
+ expect(fixedClusterPool.listTaskFunctions()).toStrictEqual([
+ 'default',
+ 'jsonIntegerSerialization',
+ 'factorial',
+ 'fibonacci'
+ ])
+ })
+
+ it('Verify that multiple task functions worker is working', async () => {
const pool = new DynamicClusterPool(
Math.floor(numberOfWorkers / 2),
numberOfWorkers,
- './tests/worker-files/cluster/testMultiTasksWorker.js'
+ './tests/worker-files/cluster/testMultipleTaskFunctionsWorker.js'
)
const data = { n: 10 }
const result0 = await pool.execute(data)
expect(result2).toBe(3628800)
const result3 = await pool.execute(data, 'fibonacci')
expect(result3).toBe(55)
+ expect(pool.info.executingTasks).toBe(0)
+ expect(pool.info.executedTasks).toBe(4)
+ for (const workerNode of pool.workerNodes) {
+ expect(workerNode.info.taskFunctions).toStrictEqual([
+ 'default',
+ 'jsonIntegerSerialization',
+ 'factorial',
+ 'fibonacci'
+ ])
+ expect(workerNode.taskFunctionsUsage.size).toBe(3)
+ for (const name of pool.listTaskFunctions()) {
+ expect(workerNode.getTaskFunctionWorkerUsage(name)).toStrictEqual({
+ tasks: {
+ executed: expect.any(Number),
+ executing: expect.any(Number),
+ failed: 0,
+ queued: 0
+ },
+ runTime: {
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ history: expect.any(CircularArray)
+ },
+ elu: {
+ idle: {
+ history: expect.any(CircularArray)
+ },
+ active: {
+ history: expect.any(CircularArray)
+ }
+ }
+ })
+ expect(
+ workerNode.getTaskFunctionWorkerUsage(name).tasks.executing
+ ).toBeGreaterThanOrEqual(0)
+ }
+ }
})
})