import { expect } from 'expect'
-import { DynamicClusterPool, PoolEvents } from '../../../lib/index.cjs'
+
+import {
+ DynamicClusterPool,
+ PoolEvents,
+ WorkerChoiceStrategies,
+} from '../../../lib/index.cjs'
import { TaskFunctions } from '../../test-types.cjs'
-import { sleep, waitWorkerEvents } from '../../test-utils.cjs'
+import { sleep, waitPoolEvents, waitWorkerEvents } from '../../test-utils.cjs'
describe('Dynamic cluster pool test suite', () => {
const min = 1
max,
'./tests/worker-files/cluster/testWorker.cjs',
{
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
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(75025)
+ expect(result).toBe(354224848179262000000)
result = await pool.execute({
- function: TaskFunctions.factorial
+ function: TaskFunctions.factorial,
})
expect(result).toBe(9.33262154439441e157)
})
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([])
+ expect(pool.emitter.eventNames()).toStrictEqual([
+ PoolEvents.busy,
+ PoolEvents.destroy,
+ ])
expect(pool.readyEventEmitted).toBe(false)
expect(pool.workerNodes.length).toBe(0)
expect(numberOfExitEvents).toBe(min)
{
errorHandler: e => console.error(e),
onlineHandler: () => console.info('long executing worker is online'),
- exitHandler: () => console.info('long executing worker exited')
+ exitHandler: () => console.info('long executing worker exited'),
}
)
expect(longRunningPool.workerNodes.length).toBe(min)
await waitWorkerEvents(longRunningPool, 'exit', max - min)
expect(longRunningPool.workerNodes.length).toBe(min)
expect(
- longRunningPool.workerChoiceStrategyContext.workerChoiceStrategies.get(
- longRunningPool.workerChoiceStrategyContext.workerChoiceStrategy
+ longRunningPool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+ longRunningPool.workerChoiceStrategiesContext
+ .defaultWorkerChoiceStrategy
).nextWorkerNodeKey
).toBeLessThan(longRunningPool.workerNodes.length)
// We need to clean up the resources after our test
{
errorHandler: e => console.error(e),
onlineHandler: () => console.info('long executing worker is online'),
- exitHandler: () => console.info('long executing worker exited')
+ exitHandler: () => console.info('long executing worker exited'),
}
)
expect(longRunningPool.workerNodes.length).toBe(min)
await pool.destroy()
})
- it.skip('Verify that a pool with zero worker works', async () => {
- const pool = new DynamicClusterPool(
- 0,
- max,
- './tests/worker-files/thread/testWorker.mjs'
- )
- expect(pool.starting).toBe(false)
- expect(pool.workerNodes.length).toBe(pool.info.minSize)
- for (let run = 0; run < 4; run++) {
- // pool.enableTasksQueue(true, { concurrency: 2 })
- const maxMultiplier = 10000
- const promises = new Set()
- for (let i = 0; i < max * maxMultiplier; i++) {
- promises.add(pool.execute())
+ it('Verify that a pool with zero worker works', async () => {
+ for (const workerChoiceStrategy of Object.values(WorkerChoiceStrategies)) {
+ const pool = new DynamicClusterPool(
+ 0,
+ max,
+ './tests/worker-files/cluster/testWorker.cjs',
+ {
+ workerChoiceStrategy,
+ }
+ )
+ expect(pool.starting).toBe(false)
+ expect(pool.readyEventEmitted).toBe(false)
+ for (let run = 0; run < 2; run++) {
+ // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+ run % 2 !== 0 && pool.enableTasksQueue(true)
+ const maxMultiplier = 4
+ const promises = new Set()
+ expect(pool.workerNodes.length).toBe(pool.info.minSize)
+ for (let i = 0; i < max * maxMultiplier; i++) {
+ promises.add(pool.execute())
+ }
+ await Promise.all(promises)
+ expect(pool.readyEventEmitted).toBe(true)
+ expect(pool.workerNodes.length).toBeGreaterThan(pool.info.minSize)
+ expect(pool.workerNodes.length).toBeLessThanOrEqual(pool.info.maxSize)
+ await waitPoolEvents(pool, PoolEvents.empty, 1)
+ expect(pool.readyEventEmitted).toBe(false)
+ expect(pool.workerNodes.length).toBe(pool.info.minSize)
}
- await Promise.all(promises)
- expect(pool.workerNodes.length).toBe(max)
- await waitWorkerEvents(pool, 'exit', max)
- expect(pool.workerNodes.length).toBe(pool.info.minSize)
+ // We need to clean up the resources after our test
+ await pool.destroy()
}
- // We need to clean up the resources after our test
- await pool.destroy()
})
})