const { expect } = require('expect')
+const sinon = require('sinon')
const {
DynamicClusterPool,
DynamicThreadPool,
WorkerTypes
} = require('../../../lib')
const { CircularArray } = require('../../../lib/circular-array')
-const { Queue } = require('../../../lib/queue')
+const { Deque } = require('../../../lib/deque')
+const { DEFAULT_TASK_NAME } = require('../../../lib/utils')
const { version } = require('../../../package.json')
const { waitPoolEvents } = require('../../test-utils')
}
}
+ afterEach(() => {
+ sinon.restore()
+ })
+
it('Simulate pool creation from a non main thread/process', () => {
expect(
() =>
}
)
).toThrowError(
- 'Cannot start a pool from a worker with the same type as the pool'
+ new Error(
+ 'Cannot start a pool from a worker with the same type as the pool'
+ )
)
})
+ it('Verify that pool statuses properties are set', async () => {
+ const pool = new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js'
+ )
+ expect(pool.starting).toBe(false)
+ expect(pool.started).toBe(true)
+ await pool.destroy()
+ expect(pool.started).toBe(false)
+ })
+
it('Verify that filePath is checked', () => {
const expectedError = new Error(
'Please specify a file with a worker implementation'
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'
+ )
)
})
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
)
workerChoiceStrategy: 'invalidStrategy'
}
)
- ).toThrowError("Invalid worker choice strategy 'invalidStrategy'")
+ ).toThrowError(
+ new Error("Invalid worker choice strategy 'invalidStrategy'")
+ )
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ workerChoiceStrategyOptions: {
+ choiceRetries: 'invalidChoiceRetries'
+ }
+ }
+ )
+ ).toThrowError(
+ new TypeError(
+ 'Invalid worker choice strategy options: choice retries must be an integer'
+ )
+ )
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ workerChoiceStrategyOptions: {
+ choiceRetries: -1
+ }
+ }
+ )
+ ).toThrowError(
+ new RangeError(
+ "Invalid worker choice strategy options: choice retries '-1' must be greater or equal than zero"
+ )
+ )
expect(
() =>
new FixedThreadPool(
}
)
).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(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true,
+ tasksQueueOptions: 'invalidTasksQueueOptions'
+ }
+ )
+ ).toThrowError(
+ new TypeError('Invalid tasks queue options: must be a plain object')
)
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(
'./tests/worker-files/thread/testWorker.js',
{
enableTasksQueue: true,
- tasksQueueOptions: 'invalidTasksQueueOptions'
+ tasksQueueOptions: { concurrency: -1 }
}
)
- ).toThrowError('Invalid tasks queue options: must be a plain object')
+ ).toThrowError(
+ new RangeError(
+ 'Invalid worker node tasks concurrency: -1 is a negative integer or zero'
+ )
+ )
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')
+ )
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true,
+ tasksQueueOptions: { queueMaxSize: 2 }
+ }
+ )
+ ).toThrowError(
+ new Error(
+ 'Invalid tasks queue options: queueMaxSize is deprecated, please use size instead'
+ )
+ )
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true,
+ tasksQueueOptions: { size: 0 }
+ }
+ )
+ ).toThrowError(
+ new RangeError(
+ 'Invalid worker node tasks queue size: 0 is a negative integer or zero'
+ )
+ )
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true,
+ tasksQueueOptions: { size: -1 }
+ }
+ )
+ ).toThrowError(
+ new RangeError(
+ 'Invalid worker node tasks queue size: -1 is a negative integer or zero'
+ )
+ )
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true,
+ tasksQueueOptions: { size: 0.2 }
+ }
+ )
+ ).toThrowError(
+ new TypeError('Invalid worker node tasks queue size: must be an integer')
+ )
})
it('Verify that pool worker choice strategy options can be set', async () => {
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({
+ choiceRetries: 'invalidChoiceRetries'
+ })
+ ).toThrowError(
+ new TypeError(
+ 'Invalid worker choice strategy options: choice retries must be an integer'
+ )
+ )
+ expect(() =>
+ pool.setWorkerChoiceStrategyOptions({ choiceRetries: -1 })
+ ).toThrowError(
+ new RangeError(
+ "Invalid worker choice strategy options: choice retries '-1' must be greater or equal than zero"
+ )
)
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({ queueMaxSize: 2 })).toThrowError(
+ new Error(
+ 'Invalid tasks queue options: queueMaxSize is deprecated, please use size instead'
+ )
+ )
+ expect(() => pool.setTasksQueueOptions({ size: 0 })).toThrowError(
+ new RangeError(
+ 'Invalid worker node tasks queue size: 0 is a negative integer or zero'
+ )
+ )
+ expect(() => pool.setTasksQueueOptions({ size: -1 })).toThrowError(
+ new RangeError(
+ 'Invalid worker node tasks queue size: -1 is a negative integer or zero'
+ )
+ )
+ expect(() => pool.setTasksQueueOptions({ size: 0.2 })).toThrowError(
+ new TypeError('Invalid worker node tasks queue size: must be an integer')
)
await pool.destroy()
})
executing: 0,
queued: 0,
maxQueued: 0,
+ stolen: 0,
failed: 0
},
runTime: {
)
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)
}
}
})
+ it('Verify that pool execute() arguments are checked', async () => {
+ const pool = new FixedClusterPool(
+ numberOfWorkers,
+ './tests/worker-files/cluster/testWorker.js'
+ )
+ await expect(pool.execute(undefined, 0)).rejects.toThrowError(
+ new TypeError('name argument must be a string')
+ )
+ await expect(pool.execute(undefined, '')).rejects.toThrowError(
+ new TypeError('name argument must not be an empty string')
+ )
+ await expect(pool.execute(undefined, undefined, {})).rejects.toThrowError(
+ new TypeError('transferList argument must be an array')
+ )
+ await expect(pool.execute(undefined, 'unknown')).rejects.toBe(
+ "Task function 'unknown' not found"
+ )
+ await pool.destroy()
+ await expect(pool.execute(undefined, undefined, {})).rejects.toThrowError(
+ new Error('Cannot execute a task on destroyed pool')
+ )
+ })
+
it('Verify that pool worker tasks usage are computed', async () => {
const pool = new FixedClusterPool(
numberOfWorkers,
executing: maxMultiplier,
queued: 0,
maxQueued: 0,
+ stolen: 0,
failed: 0
},
runTime: {
executing: 0,
queued: 0,
maxQueued: 0,
+ stolen: 0,
failed: 0
},
runTime: {
executing: 0,
queued: 0,
maxQueued: 0,
+ stolen: 0,
failed: 0
},
runTime: {
}
})
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)
executing: 0,
queued: 0,
maxQueued: 0,
+ stolen: 0,
failed: 0
},
runTime: {
await pool.destroy()
})
+ it("Verify that pool event emitter 'backPressure' event can register a callback", async () => {
+ const pool = new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true
+ }
+ )
+ sinon.stub(pool, 'hasBackPressure').returns(true)
+ const promises = new Set()
+ let poolBackPressure = 0
+ let poolInfo
+ pool.emitter.on(PoolEvents.backPressure, (info) => {
+ ++poolBackPressure
+ poolInfo = info
+ })
+ for (let i = 0; i < numberOfWorkers + 1; i++) {
+ promises.add(pool.execute())
+ }
+ await Promise.all(promises)
+ expect(poolBackPressure).toBe(1)
+ expect(poolInfo).toStrictEqual({
+ version,
+ type: PoolTypes.fixed,
+ worker: WorkerTypes.thread,
+ ready: expect.any(Boolean),
+ 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),
+ maxQueuedTasks: expect.any(Number),
+ queuedTasks: expect.any(Number),
+ backPressure: true,
+ stolenTasks: expect.any(Number),
+ failedTasks: expect.any(Number)
+ })
+ expect(pool.hasBackPressure.called).toBe(true)
+ await pool.destroy()
+ })
+
it('Verify that listTaskFunctions() is working', async () => {
const dynamicThreadPool = new DynamicThreadPool(
Math.floor(numberOfWorkers / 2),
)
await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
expect(dynamicThreadPool.listTaskFunctions()).toStrictEqual([
- 'default',
+ DEFAULT_TASK_NAME,
'jsonIntegerSerialization',
'factorial',
'fibonacci'
)
await waitPoolEvents(fixedClusterPool, PoolEvents.ready, 1)
expect(fixedClusterPool.listTaskFunctions()).toStrictEqual([
- 'default',
+ DEFAULT_TASK_NAME,
'jsonIntegerSerialization',
'factorial',
'fibonacci'
])
+ await dynamicThreadPool.destroy()
+ await fixedClusterPool.destroy()
})
it('Verify that multiple task functions worker is working', async () => {
expect(pool.info.executedTasks).toBe(4)
for (const workerNode of pool.workerNodes) {
expect(workerNode.info.taskFunctions).toStrictEqual([
- 'default',
+ DEFAULT_TASK_NAME,
'jsonIntegerSerialization',
'factorial',
'fibonacci'
executed: expect.any(Number),
executing: expect.any(Number),
failed: 0,
- queued: 0
+ queued: 0,
+ stolen: 0
},
runTime: {
history: expect.any(CircularArray)
).toBeGreaterThanOrEqual(0)
}
}
+ await pool.destroy()
})
})
repositories / poolifier.git / blobdiff