FixedClusterPool,
FixedThreadPool,
PoolEvents,
- WorkerChoiceStrategies,
PoolTypes,
+ WorkerChoiceStrategies,
WorkerTypes
} = require('../../../lib')
const { CircularArray } = require('../../../lib/circular-array')
const { Queue } = require('../../../lib/queue')
const { version } = require('../../../package.json')
+const { waitPoolEvents } = require('../../test-utils')
describe('Abstract pool test suite', () => {
const numberOfWorkers = 2
- class StubPoolWithRemoveAllWorker extends FixedThreadPool {
- removeAllWorker () {
- this.workerNodes = []
- this.promiseResponseMap.clear()
- }
- }
class StubPoolWithIsMain extends FixedThreadPool {
isMain () {
return false
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', () => {
)
})
+ it('Verify that dynamic pool sizing is checked', () => {
+ expect(
+ () =>
+ new DynamicThreadPool(2, 1, './tests/worker-files/thread/testWorker.js')
+ ).toThrowError(
+ new RangeError(
+ 'Cannot instantiate a dynamic pool with a maximum pool size inferior to the minimum pool size'
+ )
+ )
+ expect(
+ () =>
+ new DynamicThreadPool(1, 1, './tests/worker-files/thread/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'
+ )
+ )
+ expect(
+ () =>
+ 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'
+ )
+ )
+ })
+
it('Verify that pool options are checked', async () => {
let pool = new FixedThreadPool(
numberOfWorkers,
).toThrowError('Invalid worker tasks concurrency: must be an integer')
})
- it('Verify that worker choice strategy options can be set', async () => {
+ it('Verify that pool worker choice strategy options can be set', async () => {
const pool = new FixedThreadPool(
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js',
await pool.destroy()
})
- it('Verify that tasks queue can be enabled/disabled', async () => {
+ it('Verify that pool tasks queue can be enabled/disabled', async () => {
const pool = new FixedThreadPool(
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js'
await pool.destroy()
})
- it('Verify that tasks queue options can be set', async () => {
+ it('Verify that pool tasks queue options can be set', async () => {
const pool = new FixedThreadPool(
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js',
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,
+ worker: WorkerTypes.thread,
+ ready: true,
+ strategy: WorkerChoiceStrategies.ROUND_ROBIN,
minSize: numberOfWorkers,
maxSize: numberOfWorkers,
workerNodes: numberOfWorkers,
})
await pool.destroy()
pool = new DynamicClusterPool(
+ Math.floor(numberOfWorkers / 2),
numberOfWorkers,
- numberOfWorkers * 2,
'./tests/worker-files/cluster/testWorker.js'
)
expect(pool.info).toStrictEqual({
version,
type: PoolTypes.dynamic,
worker: WorkerTypes.cluster,
- minSize: numberOfWorkers,
- maxSize: numberOfWorkers * 2,
- workerNodes: numberOfWorkers,
- idleWorkerNodes: numberOfWorkers,
+ 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,
+ worker: WorkerTypes.cluster,
+ ready: true,
+ 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,
await pool.destroy()
})
- it('Simulate worker not found', async () => {
- const pool = new StubPoolWithRemoveAllWorker(
- numberOfWorkers,
- './tests/worker-files/thread/testWorker.js',
- {
- errorHandler: e => console.error(e)
- }
- )
- expect(pool.workerNodes.length).toBe(numberOfWorkers)
- // Simulate worker not found.
- pool.removeAllWorker()
- expect(pool.workerNodes.length).toBe(0)
- await pool.destroy()
- })
-
- it('Verify that worker pool tasks usage are initialized', async () => {
+ it('Verify that pool worker tasks usage are initialized', async () => {
const pool = new FixedClusterPool(
numberOfWorkers,
'./tests/worker-files/cluster/testWorker.js'
failed: 0
},
runTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
waitTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
elu: {
idle: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
active: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
}
}
await pool.destroy()
})
- it('Verify that worker pool tasks queue are initialized', async () => {
- const pool = new FixedClusterPool(
+ it('Verify that pool worker tasks queue are initialized', async () => {
+ let pool = new FixedClusterPool(
numberOfWorkers,
'./tests/worker-files/cluster/testWorker.js'
)
expect(workerNode.tasksQueue.maxSize).toBe(0)
}
await pool.destroy()
+ pool = new DynamicThreadPool(
+ Math.floor(numberOfWorkers / 2),
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js'
+ )
+ for (const workerNode of pool.workerNodes) {
+ expect(workerNode.tasksQueue).toBeDefined()
+ expect(workerNode.tasksQueue).toBeInstanceOf(Queue)
+ expect(workerNode.tasksQueue.size).toBe(0)
+ expect(workerNode.tasksQueue.maxSize).toBe(0)
+ }
})
- it('Verify that worker pool tasks usage are computed', async () => {
+ it('Verify that pool worker info are initialized', async () => {
+ let pool = new FixedClusterPool(
+ 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),
+ type: WorkerTypes.cluster,
+ dynamic: false,
+ ready: true
+ })
+ }
+ await pool.destroy()
+ pool = new DynamicThreadPool(
+ Math.floor(numberOfWorkers / 2),
+ 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),
+ type: WorkerTypes.thread,
+ dynamic: false,
+ ready: true
+ })
+ }
+ })
+
+ it('Verify that pool worker tasks usage are computed', async () => {
const pool = new FixedClusterPool(
numberOfWorkers,
'./tests/worker-files/cluster/testWorker.js'
failed: 0
},
runTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
waitTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
elu: {
idle: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
active: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
}
}
failed: 0
},
runTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
waitTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
elu: {
idle: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
active: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
}
}
await pool.destroy()
})
- it('Verify that worker pool tasks usage are reset at worker choice strategy change', async () => {
+ it('Verify that pool worker tasks usage are reset at worker choice strategy change', async () => {
const pool = new DynamicThreadPool(
- numberOfWorkers,
+ Math.floor(numberOfWorkers / 2),
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js'
)
failed: 0
},
runTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
waitTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
elu: {
idle: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
active: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
}
}
failed: 0
},
runTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
waitTime: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
elu: {
idle: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
},
active: {
- aggregate: 0,
- maximum: 0,
- minimum: 0,
- average: 0,
- median: 0,
history: expect.any(CircularArray)
}
}
it("Verify that pool event emitter 'full' event can register a callback", async () => {
const pool = new DynamicThreadPool(
- numberOfWorkers,
+ Math.floor(numberOfWorkers / 2),
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js'
)
promises.add(pool.execute())
}
await Promise.all(promises)
- // The `full` event is triggered when the number of submitted tasks at once reach the max number of workers in the dynamic pool.
- // So in total numberOfWorkers * 2 times for a loop submitting up to numberOfWorkers * 2 tasks to the dynamic pool with min = max = numberOfWorkers.
- expect(poolFull).toBe(numberOfWorkers * 2)
+ // 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)
expect(poolInfo).toStrictEqual({
version,
type: PoolTypes.dynamic,
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),
+ 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(
+ Math.floor(numberOfWorkers / 2),
+ numberOfWorkers,
+ './tests/worker-files/cluster/testWorker.js'
+ )
+ let poolReady = 0
+ let poolInfo
+ 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),
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),
it('Verify that multiple tasks worker is working', async () => {
const pool = new DynamicClusterPool(
+ Math.floor(numberOfWorkers / 2),
numberOfWorkers,
- numberOfWorkers * 2,
'./tests/worker-files/cluster/testMultiTasksWorker.js'
)
const data = { n: 10 }
const result0 = await pool.execute(data)
- expect(result0).toBe(false)
+ expect(result0).toStrictEqual({ ok: 1 })
const result1 = await pool.execute(data, 'jsonIntegerSerialization')
- expect(result1).toBe(false)
+ expect(result1).toStrictEqual({ ok: 1 })
const result2 = await pool.execute(data, 'factorial')
expect(result2).toBe(3628800)
const result3 = await pool.execute(data, 'fibonacci')
repositories / poolifier.git / blobdiff