X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=tests%2Fpools%2Fcluster%2Ffixed.test.js;h=21dcd78bfeb6f3016eb5826025198329a4f244c7;hb=7d27ec0dd77a2b67c9e7ab20831bc70a6051a853;hp=aae9127f9f354e79a41f2d3ac3eb3322d2ef3342;hpb=5c5a1fb79906f18560012263239e7bd611ee8d2b;p=poolifier.git diff --git a/tests/pools/cluster/fixed.test.js b/tests/pools/cluster/fixed.test.js index aae9127f..675bf707 100644 --- a/tests/pools/cluster/fixed.test.js +++ b/tests/pools/cluster/fixed.test.js @@ -1,79 +1,188 @@ -const expect = require('expect') -const { FixedClusterPool } = require('../../../lib/index') -const numberOfWorkers = 10 -const maxTasks = 500 -const pool = new FixedClusterPool( - numberOfWorkers, - './tests/worker/cluster/testWorker.js', - { - errorHandler: e => console.error(e), - onlineHandler: () => console.log('worker is online') - } -) -const emptyPool = new FixedClusterPool( - 1, - './tests/worker/cluster/emptyWorker.js' -) -const echoPool = new FixedClusterPool(1, './tests/worker/cluster/echoWorker.js') -const errorPool = new FixedClusterPool( - 1, - './tests/worker/cluster/errorWorker.js', - { - errorHandler: e => console.error(e), - onlineHandler: () => console.log('worker is online') - } -) - -const asyncErrorPool = new FixedClusterPool( - 1, - './tests/worker/cluster/asyncErrorWorker.js', - { - onlineHandler: () => console.log('worker is online') - } -) -const asyncPool = new FixedClusterPool( - 1, - './tests/worker/cluster/asyncWorker.js', - { - maxTasks: maxTasks - } -) - -describe('Fixed cluster pool test suite ', () => { - it('Choose worker round robin test', async () => { - const results = new Set() - for (let i = 0; i < numberOfWorkers; i++) { - results.add(pool.chooseWorker().id) +const { expect } = require('expect') +const { FixedClusterPool, PoolEvents } = require('../../../lib') +const { TaskFunctions } = require('../../test-types') +const { waitPoolEvents, waitWorkerEvents } = require('../../test-utils') +const { DEFAULT_TASK_NAME } = require('../../../lib/utils') + +describe('Fixed cluster pool test suite', () => { + const numberOfWorkers = 8 + const tasksConcurrency = 2 + const pool = new FixedClusterPool( + numberOfWorkers, + './tests/worker-files/cluster/testWorker.js', + { + errorHandler: (e) => console.error(e) + } + ) + const queuePool = new FixedClusterPool( + numberOfWorkers, + './tests/worker-files/cluster/testWorker.js', + { + enableTasksQueue: true, + tasksQueueOptions: { + concurrency: tasksConcurrency + }, + errorHandler: (e) => console.error(e) + } + ) + const emptyPool = new FixedClusterPool( + numberOfWorkers, + './tests/worker-files/cluster/emptyWorker.js', + { exitHandler: () => console.info('empty pool worker exited') } + ) + const echoPool = new FixedClusterPool( + numberOfWorkers, + './tests/worker-files/cluster/echoWorker.js' + ) + const errorPool = new FixedClusterPool( + numberOfWorkers, + './tests/worker-files/cluster/errorWorker.js', + { + errorHandler: (e) => console.error(e) } - expect(results.size).toBe(numberOfWorkers) + ) + const asyncErrorPool = new FixedClusterPool( + numberOfWorkers, + './tests/worker-files/cluster/asyncErrorWorker.js', + { + errorHandler: (e) => console.error(e) + } + ) + const asyncPool = new FixedClusterPool( + numberOfWorkers, + './tests/worker-files/cluster/asyncWorker.js' + ) + + after('Destroy all pools', async () => { + // We need to clean up the resources after our test + await echoPool.destroy() + await asyncPool.destroy() + await errorPool.destroy() + await asyncErrorPool.destroy() + await emptyPool.destroy() + await queuePool.destroy() }) it('Verify that the function is executed in a worker cluster', async () => { - const result = await pool.execute({ test: 'test' }) - expect(result).toBeDefined() - expect(result).toBeFalsy() + let result = await pool.execute({ + function: TaskFunctions.fibonacci + }) + expect(result).toBe(75025) + result = await pool.execute({ + function: TaskFunctions.factorial + }) + expect(result).toBe(9.33262154439441e157) }) - it('Verify that is possible to invoke the execute method without input', async () => { + it('Verify that is possible to invoke the execute() method without input', async () => { const result = await pool.execute() - expect(result).toBeDefined() - expect(result).toBeFalsy() + expect(result).toStrictEqual({ ok: 1 }) + }) + + it("Verify that 'ready' event is emitted", async () => { + const pool = new FixedClusterPool( + numberOfWorkers, + './tests/worker-files/cluster/testWorker.js', + { + errorHandler: (e) => console.error(e) + } + ) + let poolReady = 0 + pool.emitter.on(PoolEvents.ready, () => ++poolReady) + await waitPoolEvents(pool, PoolEvents.ready, 1) + expect(poolReady).toBe(1) + await pool.destroy() + }) + + it("Verify that 'busy' event is emitted", async () => { + const promises = new Set() + let poolBusy = 0 + pool.emitter.on(PoolEvents.busy, () => ++poolBusy) + 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) + }) + + it('Verify that tasks queuing is working', async () => { + const promises = new Set() + const maxMultiplier = 3 // Must be greater than tasksConcurrency + for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) { + promises.add(queuePool.execute()) + } + expect(promises.size).toBe(numberOfWorkers * maxMultiplier) + for (const workerNode of queuePool.workerNodes) { + expect(workerNode.usage.tasks.executing).toBeGreaterThanOrEqual(0) + expect(workerNode.usage.tasks.executing).toBeLessThanOrEqual( + queuePool.opts.tasksQueueOptions.concurrency + ) + expect(workerNode.usage.tasks.executed).toBe(0) + expect(workerNode.usage.tasks.queued).toBe( + maxMultiplier - queuePool.opts.tasksQueueOptions.concurrency + ) + expect(workerNode.usage.tasks.maxQueued).toBe( + maxMultiplier - queuePool.opts.tasksQueueOptions.concurrency + ) + expect(workerNode.usage.tasks.stolen).toBe(0) + } + expect(queuePool.info.executedTasks).toBe(0) + expect(queuePool.info.executingTasks).toBe( + numberOfWorkers * queuePool.opts.tasksQueueOptions.concurrency + ) + expect(queuePool.info.queuedTasks).toBe( + numberOfWorkers * + (maxMultiplier - queuePool.opts.tasksQueueOptions.concurrency) + ) + expect(queuePool.info.maxQueuedTasks).toBe( + numberOfWorkers * + (maxMultiplier - queuePool.opts.tasksQueueOptions.concurrency) + ) + expect(queuePool.info.backPressure).toBe(false) + expect(queuePool.info.stolenTasks).toBe(0) + await Promise.all(promises) + for (const workerNode of queuePool.workerNodes) { + expect(workerNode.usage.tasks.executing).toBeGreaterThanOrEqual(0) + expect(workerNode.usage.tasks.executing).toBeLessThanOrEqual( + numberOfWorkers * maxMultiplier + ) + expect(workerNode.usage.tasks.executed).toBe(maxMultiplier) + expect(workerNode.usage.tasks.queued).toBe(0) + expect(workerNode.usage.tasks.maxQueued).toBe( + maxMultiplier - queuePool.opts.tasksQueueOptions.concurrency + ) + expect(workerNode.usage.tasks.stolen).toBeGreaterThanOrEqual(0) + expect(workerNode.usage.tasks.stolen).toBeLessThanOrEqual( + numberOfWorkers * maxMultiplier + ) + } + expect(queuePool.info.executedTasks).toBe(numberOfWorkers * maxMultiplier) + expect(queuePool.info.backPressure).toBe(false) + expect(queuePool.info.stolenTasks).toBeGreaterThanOrEqual(0) + expect(queuePool.info.stolenTasks).toBeLessThanOrEqual( + numberOfWorkers * maxMultiplier + ) }) it('Verify that is possible to have a worker that return undefined', async () => { const result = await emptyPool.execute() - expect(result).toBeFalsy() + expect(result).toBeUndefined() }) it('Verify that data are sent to the worker correctly', async () => { const data = { f: 10 } const result = await echoPool.execute(data) - expect(result).toBeTruthy() - expect(result.f).toBe(data.f) + expect(result).toStrictEqual(data) }) it('Verify that error handling is working properly:sync', async () => { const data = { f: 10 } + let taskError + errorPool.emitter.on(PoolEvents.taskError, (e) => { + taskError = e + }) let inError try { await errorPool.execute(data) @@ -81,12 +190,26 @@ describe('Fixed cluster pool test suite ', () => { inError = e } expect(inError).toBeDefined() - expect(typeof inError === 'string').toBeTruthy() + expect(typeof inError === 'string').toBe(true) expect(inError).toBe('Error Message from ClusterWorker') + expect(taskError).toStrictEqual({ + name: DEFAULT_TASK_NAME, + message: 'Error Message from ClusterWorker', + data + }) + expect( + errorPool.workerNodes.some( + (workerNode) => workerNode.usage.tasks.failed === 1 + ) + ).toBe(true) }) it('Verify that error handling is working properly:async', async () => { const data = { f: 10 } + let taskError + asyncErrorPool.emitter.on(PoolEvents.taskError, (e) => { + taskError = e + }) let inError try { await asyncErrorPool.execute(data) @@ -94,55 +217,101 @@ describe('Fixed cluster pool test suite ', () => { inError = e } expect(inError).toBeDefined() - expect(typeof inError === 'string').toBeTruthy() + expect(typeof inError === 'string').toBe(true) expect(inError).toBe('Error Message from ClusterWorker:async') + expect(taskError).toStrictEqual({ + name: DEFAULT_TASK_NAME, + message: 'Error Message from ClusterWorker:async', + data + }) + expect( + asyncErrorPool.workerNodes.some( + (workerNode) => workerNode.usage.tasks.failed === 1 + ) + ).toBe(true) }) it('Verify that async function is working properly', async () => { const data = { f: 10 } - const startTime = new Date().getTime() + const startTime = performance.now() const result = await asyncPool.execute(data) - const usedTime = new Date().getTime() - startTime - expect(result).toBeTruthy() - expect(result.f).toBe(data.f) + const usedTime = performance.now() - startTime + expect(result).toStrictEqual(data) expect(usedTime).toBeGreaterThanOrEqual(2000) }) - it('Verify that maxTasks is set properly', async () => { - const worker = asyncPool.chooseWorker() - expect(worker.getMaxListeners()).toBe(maxTasks) + it('Shutdown test', async () => { + const exitPromise = waitWorkerEvents(pool, 'exit', numberOfWorkers) + let poolDestroy = 0 + pool.emitter.on(PoolEvents.destroy, () => ++poolDestroy) + await pool.destroy() + const numberOfExitEvents = await exitPromise + expect(pool.started).toBe(false) + expect(pool.workerNodes.length).toBe(0) + expect(numberOfExitEvents).toBe(numberOfWorkers) + expect(poolDestroy).toBe(1) }) - it('Shutdown test', async () => { - let closedWorkers = 0 - pool.workers.forEach(w => { - w.on('exit', () => { - closedWorkers++ - }) + it('Verify that cluster pool options are checked', async () => { + const workerFilePath = './tests/worker-files/cluster/testWorker.js' + let pool = new FixedClusterPool(numberOfWorkers, workerFilePath) + expect(pool.opts.env).toBeUndefined() + expect(pool.opts.settings).toBeUndefined() + await pool.destroy() + pool = new FixedClusterPool(numberOfWorkers, workerFilePath, { + env: { TEST: 'test' }, + settings: { args: ['--use', 'http'], silent: true } }) - pool.destroy() - await new Promise(resolve => setTimeout(resolve, 200)) - expect(closedWorkers).toBe(numberOfWorkers) + expect(pool.opts.env).toStrictEqual({ TEST: 'test' }) + expect(pool.opts.settings).toStrictEqual({ + args: ['--use', 'http'], + silent: true + }) + expect({ ...pool.opts.settings, exec: workerFilePath }).toStrictEqual({ + args: ['--use', 'http'], + silent: true, + exec: workerFilePath + }) + await pool.destroy() + }) + + it('Should work even without opts in input', async () => { + const workerFilePath = './tests/worker-files/cluster/testWorker.js' + const pool = new FixedClusterPool(numberOfWorkers, workerFilePath) + const res = await pool.execute() + expect(res).toStrictEqual({ ok: 1 }) + // We need to clean up the resources after our test + await pool.destroy() }) - it('Validations test', () => { + it('Verify destroyWorkerNode()', async () => { + const workerFilePath = './tests/worker-files/cluster/testWorker.js' + const pool = new FixedClusterPool(numberOfWorkers, workerFilePath) + let disconnectEvent = 0 + pool.workerNodes[0].worker.on('disconnect', () => { + ++disconnectEvent + }) + let exitEvent = 0 + pool.workerNodes[0].worker.on('exit', () => { + ++exitEvent + }) let error try { - const pool1 = new FixedClusterPool() - console.log(pool1) + await pool.destroyWorkerNode(0) } catch (e) { error = e } - expect(error).toBeTruthy() - expect(error.message).toBeTruthy() + expect(error).toBeUndefined() + expect(disconnectEvent).toBe(1) + expect(exitEvent).toBe(1) + expect(pool.workerNodes.length).toBe(numberOfWorkers - 1) + await pool.destroy() }) - it('Should work even without opts in input', async () => { - const pool1 = new FixedClusterPool( - 1, - './tests/worker/cluster/testWorker.js' - ) - const res = await pool1.execute({ test: 'test' }) - expect(res).toBeFalsy() + it('Verify that a pool with zero worker fails', async () => { + expect( + () => + new FixedClusterPool(0, './tests/worker-files/cluster/testWorker.js') + ).toThrowError('Cannot instantiate a fixed pool with zero worker') }) })