} = require('../../../lib')
const { CircularArray } = require('../../../lib/circular-array')
const { Queue } = require('../../../lib/queue')
+const { version } = require('../../../package.json')
describe('Abstract pool test suite', () => {
const numberOfWorkers = 2
)
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
runTime: { median: false },
- waitTime: { median: false }
+ waitTime: { median: false },
+ elu: { median: false }
})
expect(pool.opts.messageHandler).toBeUndefined()
expect(pool.opts.errorHandler).toBeUndefined()
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js',
{
- enableTasksQueue: true,
- tasksQueueOptions: { concurrency: 0 }
+ workerChoiceStrategy: 'invalidStrategy'
}
)
- ).toThrowError("Invalid worker tasks concurrency '0'")
+ ).toThrowError("Invalid worker choice strategy 'invalidStrategy'")
expect(
() =>
new FixedThreadPool(
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js',
{
- workerChoiceStrategy: 'invalidStrategy'
+ workerChoiceStrategyOptions: 'invalidOptions'
}
)
- ).toThrowError("Invalid worker choice strategy 'invalidStrategy'")
+ ).toThrowError(
+ 'Invalid worker choice strategy options: must be a plain object'
+ )
expect(
() =>
new FixedThreadPool(
).toThrowError(
'Invalid worker choice strategy options: must have a weight for each worker node'
)
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ workerChoiceStrategyOptions: { measurement: 'invalidMeasurement' }
+ }
+ )
+ ).toThrowError(
+ "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
+ )
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true,
+ tasksQueueOptions: { concurrency: 0 }
+ }
+ )
+ ).toThrowError("Invalid worker tasks concurrency '0'")
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true,
+ tasksQueueOptions: 'invalidTasksQueueOptions'
+ }
+ )
+ ).toThrowError('Invalid tasks queue options: must be a plain object')
+ expect(
+ () =>
+ new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js',
+ {
+ enableTasksQueue: true,
+ tasksQueueOptions: { concurrency: 0.2 }
+ }
+ )
+ ).toThrowError('Invalid worker tasks concurrency: must be an integer')
})
it('Verify that worker choice strategy options can be set', async () => {
)
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
runTime: { median: false },
- waitTime: { median: false }
+ waitTime: { median: false },
+ elu: { median: false }
})
for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
.workerChoiceStrategies) {
expect(workerChoiceStrategy.opts).toStrictEqual({
runTime: { median: false },
- waitTime: { median: false }
+ waitTime: { median: false },
+ elu: { median: false }
})
}
expect(
average: false,
median: false
},
- elu: false
+ elu: {
+ aggregate: true,
+ average: true,
+ median: false
+ }
+ })
+ pool.setWorkerChoiceStrategyOptions({
+ runTime: { median: true },
+ elu: { median: true }
})
- pool.setWorkerChoiceStrategyOptions({ runTime: { median: true } })
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
- runTime: { median: true }
+ runTime: { median: true },
+ elu: { median: true }
})
for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
.workerChoiceStrategies) {
expect(workerChoiceStrategy.opts).toStrictEqual({
- runTime: { median: true }
+ runTime: { median: true },
+ elu: { median: true }
})
}
expect(
average: false,
median: false
},
- elu: false
+ elu: {
+ aggregate: true,
+ average: false,
+ median: true
+ }
+ })
+ pool.setWorkerChoiceStrategyOptions({
+ runTime: { median: false },
+ elu: { median: false }
})
- pool.setWorkerChoiceStrategyOptions({ runTime: { median: false } })
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
- runTime: { median: false }
+ runTime: { median: false },
+ elu: { median: false }
})
for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
.workerChoiceStrategies) {
expect(workerChoiceStrategy.opts).toStrictEqual({
- runTime: { median: false }
+ runTime: { median: false },
+ elu: { median: false }
})
}
expect(
average: false,
median: false
},
- elu: false
+ elu: {
+ aggregate: true,
+ average: true,
+ median: false
+ }
})
+ expect(() =>
+ pool.setWorkerChoiceStrategyOptions('invalidWorkerChoiceStrategyOptions')
+ ).toThrowError(
+ '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'
+ )
+ expect(() =>
+ pool.setWorkerChoiceStrategyOptions({ measurement: 'invalidMeasurement' })
+ ).toThrowError(
+ "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
+ )
await pool.destroy()
})
expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 1 })
pool.setTasksQueueOptions({ concurrency: 2 })
expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 2 })
+ expect(() =>
+ pool.setTasksQueueOptions('invalidTasksQueueOptions')
+ ).toThrowError('Invalid tasks queue options: must be a plain object')
expect(() => pool.setTasksQueueOptions({ concurrency: 0 })).toThrowError(
"Invalid worker tasks concurrency '0'"
)
+ expect(() => pool.setTasksQueueOptions({ concurrency: 0.2 })).toThrowError(
+ 'Invalid worker tasks concurrency: must be an integer'
+ )
await pool.destroy()
})
'./tests/worker-files/thread/testWorker.js'
)
expect(pool.info).toStrictEqual({
+ version,
type: PoolTypes.fixed,
worker: WorkerTypes.thread,
minSize: numberOfWorkers,
pool = new DynamicClusterPool(
numberOfWorkers,
numberOfWorkers * 2,
- './tests/worker-files/thread/testWorker.js'
+ './tests/worker-files/cluster/testWorker.js'
)
expect(pool.info).toStrictEqual({
+ version,
type: PoolTypes.dynamic,
worker: WorkerTypes.cluster,
minSize: numberOfWorkers,
it('Simulate worker not found', async () => {
const pool = new StubPoolWithRemoveAllWorker(
numberOfWorkers,
- './tests/worker-files/cluster/testWorker.js',
+ './tests/worker-files/thread/testWorker.js',
{
errorHandler: e => console.error(e)
}
'./tests/worker-files/cluster/testWorker.js'
)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.workerUsage).toStrictEqual({
+ expect(workerNode.usage).toStrictEqual({
tasks: {
executed: 0,
executing: 0,
queued: 0,
+ maxQueued: 0,
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: undefined
+ 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()
expect(workerNode.tasksQueue).toBeDefined()
expect(workerNode.tasksQueue).toBeInstanceOf(Queue)
expect(workerNode.tasksQueue.size).toBe(0)
+ expect(workerNode.tasksQueue.maxSize).toBe(0)
}
await pool.destroy()
})
promises.add(pool.execute())
}
for (const workerNode of pool.workerNodes) {
- expect(workerNode.workerUsage).toStrictEqual({
+ expect(workerNode.usage).toStrictEqual({
tasks: {
executed: 0,
executing: maxMultiplier,
queued: 0,
+ maxQueued: 0,
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: undefined
+ 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 Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.workerUsage).toStrictEqual({
+ expect(workerNode.usage).toStrictEqual({
tasks: {
executed: maxMultiplier,
executing: 0,
queued: 0,
+ maxQueued: 0,
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: undefined
+ 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()
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.workerUsage).toStrictEqual({
+ expect(workerNode.usage).toStrictEqual({
tasks: {
executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
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: undefined
+ 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)
+ }
+ }
})
- expect(workerNode.workerUsage.tasks.executed).toBeGreaterThan(0)
- expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
- maxMultiplier
- )
+ expect(workerNode.usage.tasks.executed).toBeGreaterThan(0)
+ expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(maxMultiplier)
}
pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.workerUsage).toStrictEqual({
+ expect(workerNode.usage).toStrictEqual({
tasks: {
executed: 0,
executing: 0,
queued: 0,
+ maxQueued: 0,
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: undefined
+ 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)
+ }
+ }
})
- expect(workerNode.workerUsage.runTime.history.length).toBe(0)
- expect(workerNode.workerUsage.waitTime.history.length).toBe(0)
+ expect(workerNode.usage.runTime.history.length).toBe(0)
+ expect(workerNode.usage.waitTime.history.length).toBe(0)
}
await pool.destroy()
})
// 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)
expect(poolInfo).toStrictEqual({
+ version,
type: PoolTypes.dynamic,
worker: WorkerTypes.thread,
minSize: expect.any(Number),
// 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.fixed,
worker: WorkerTypes.thread,
minSize: expect.any(Number),
const result2 = await pool.execute(data, 'factorial')
expect(result2).toBe(3628800)
const result3 = await pool.execute(data, 'fibonacci')
- expect(result3).toBe(89)
+ expect(result3).toBe(55)
})
})