X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=tests%2Fpools%2Fthread%2Ffixed.test.js;h=90dd110cd44ce0da7c2d43dd7b5cd0fd442be26b;hb=82f36766232abd4e4ffde72ecd68462adf59cca7;hp=e160f17c72b6d4db2e8111d7fed488f84a666610;hpb=e5177d860cd10dd89b107cc6692e9989286b3a7c;p=poolifier.git diff --git a/tests/pools/thread/fixed.test.js b/tests/pools/thread/fixed.test.js index e160f17c..90dd110c 100644 --- a/tests/pools/thread/fixed.test.js +++ b/tests/pools/thread/fixed.test.js @@ -1,117 +1,238 @@ -const expect = require('expect') -const { FixedThreadPool } = require('../../../lib/index') -const numberOfThreads = 10 -const maxTasks = 400 -const pool = new FixedThreadPool( - numberOfThreads, - './tests/worker/thread/testWorker.js', - { - errorHandler: e => console.error(e) - } -) -const emptyPool = new FixedThreadPool(1, './tests/worker/thread/emptyWorker.js') -const echoPool = new FixedThreadPool(1, './tests/worker/thread/echoWorker.js') -const errorPool = new FixedThreadPool( - 1, - './tests/worker/thread/errorWorker.js', - { - errorHandler: e => console.error(e), - onlineHandler: () => console.log('worker is online') - } -) -const asyncPool = new FixedThreadPool( - 1, - './tests/worker/thread/asyncWorker.js', - { maxTasks: maxTasks } -) +const { expect } = require('expect') +const { FixedThreadPool, PoolEvents } = require('../../../lib') +const { WorkerFunctions } = require('../../test-types') +const TestUtils = require('../../test-utils') -describe('Fixed thread pool test suite ', () => { - it('Choose worker round robin test', async () => { - const results = new Set() - for (let i = 0; i < numberOfThreads; i++) { - results.add(pool.chooseWorker().threadId) +describe('Fixed thread pool test suite', () => { + const numberOfThreads = 6 + const pool = new FixedThreadPool( + numberOfThreads, + './tests/worker-files/thread/testWorker.js', + { + errorHandler: e => console.error(e) } - expect(results.size).toBe(numberOfThreads) + ) + const queuePool = new FixedThreadPool( + numberOfThreads, + './tests/worker-files/thread/testWorker.js', + { + enableTasksQueue: true, + tasksQueueOptions: { + concurrency: 2 + }, + errorHandler: e => console.error(e) + } + ) + const emptyPool = new FixedThreadPool( + numberOfThreads, + './tests/worker-files/thread/emptyWorker.js', + { exitHandler: () => console.log('empty pool worker exited') } + ) + const echoPool = new FixedThreadPool( + numberOfThreads, + './tests/worker-files/thread/echoWorker.js' + ) + const errorPool = new FixedThreadPool( + numberOfThreads, + './tests/worker-files/thread/errorWorker.js', + { + errorHandler: e => console.error(e) + } + ) + const asyncErrorPool = new FixedThreadPool( + numberOfThreads, + './tests/worker-files/thread/asyncErrorWorker.js', + { + errorHandler: e => console.error(e) + } + ) + const asyncPool = new FixedThreadPool( + numberOfThreads, + './tests/worker-files/thread/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 thread', async () => { - const result = await pool.execute({ test: 'test' }) - expect(result).toBeDefined() - expect(result).toBeFalsy() + let result = await pool.execute({ + function: WorkerFunctions.fibonacci + }) + expect(result).toBe(121393) + result = await pool.execute({ + function: WorkerFunctions.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).toBe(false) + }) + + it("Verify that 'busy' event is emitted", async () => { + let poolBusy = 0 + pool.emitter.on(PoolEvents.busy, () => ++poolBusy) + for (let i = 0; i < numberOfThreads * 2; i++) { + pool.execute() + } + // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers. + // So in total numberOfThreads + 1 times for a loop submitting up to numberOfThreads * 2 tasks to the fixed pool. + expect(poolBusy).toBe(numberOfThreads + 1) + }) + + it('Verify that tasks queuing is working', async () => { + const promises = new Set() + const maxMultiplier = 2 + for (let i = 0; i < numberOfThreads * maxMultiplier; i++) { + promises.add(queuePool.execute()) + } + expect(promises.size).toBe(numberOfThreads * maxMultiplier) + for (const workerNode of queuePool.workerNodes) { + expect(workerNode.tasksUsage.running).toBeLessThanOrEqual( + queuePool.opts.tasksQueueOptions.concurrency + ) + expect(workerNode.tasksUsage.ran).toBe(0) + expect(workerNode.tasksQueue.size).toBeGreaterThan(0) + } + expect(queuePool.info.runningTasks).toBe(numberOfThreads) + expect(queuePool.info.queuedTasks).toBe( + numberOfThreads * maxMultiplier - numberOfThreads + ) + expect(queuePool.info.maxQueuedTasks).toBe( + numberOfThreads * maxMultiplier - numberOfThreads + ) + await Promise.all(promises) + for (const workerNode of queuePool.workerNodes) { + expect(workerNode.tasksUsage.running).toBe(0) + expect(workerNode.tasksUsage.ran).toBeGreaterThan(0) + expect(workerNode.tasksUsage.ran).toBeLessThanOrEqual(maxMultiplier) + expect(workerNode.tasksQueue.size).toBe(0) + } }) 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', async () => { + 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) } catch (e) { inError = e } - expect(inError).toBeTruthy() - expect(inError instanceof Error).toBeTruthy() - expect(inError.message).toBeTruthy() + expect(inError).toBeDefined() + expect(inError).toBeInstanceOf(Error) + expect(inError.message).toBeDefined() + expect(typeof inError.message === 'string').toBe(true) + expect(inError.message).toBe('Error Message from ThreadWorker') + expect(taskError).toStrictEqual({ + message: new Error('Error Message from ThreadWorker'), + data + }) + expect( + errorPool.workerNodes.some( + workerNode => workerNode.tasksUsage.error === 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) + } catch (e) { + inError = e + } + expect(inError).toBeDefined() + expect(inError).toBeInstanceOf(Error) + expect(inError.message).toBeDefined() + expect(typeof inError.message === 'string').toBe(true) + expect(inError.message).toBe('Error Message from ThreadWorker:async') + expect(taskError).toStrictEqual({ + message: new Error('Error Message from ThreadWorker:async'), + data + }) + expect( + asyncErrorPool.workerNodes.some( + workerNode => workerNode.tasksUsage.error === 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.port2.getMaxListeners()).toBe(maxTasks) - }) - it('Shutdown test', async () => { - let closedThreads = 0 - pool.workers.forEach(w => { - w.on('exit', () => { - closedThreads++ - }) - }) + const exitPromise = TestUtils.waitWorkerExits(pool, numberOfThreads) await pool.destroy() - expect(closedThreads).toBe(numberOfThreads) + const numberOfExitEvents = await exitPromise + expect(numberOfExitEvents).toBe(numberOfThreads) }) - it('Validations test', () => { - let error - try { - const pool1 = new FixedThreadPool() - console.log(pool1) - } catch (e) { - error = e - } - expect(error).toBeTruthy() - expect(error.message).toBeTruthy() + it('Verify that thread pool options are checked', async () => { + const workerFilePath = './tests/worker-files/cluster/testWorker.js' + let pool1 = new FixedThreadPool(numberOfThreads, workerFilePath) + expect(pool1.opts.workerOptions).toBeUndefined() + await pool1.destroy() + pool1 = new FixedThreadPool(numberOfThreads, workerFilePath, { + workerOptions: { + env: { TEST: 'test' }, + name: 'test' + } + }) + expect(pool1.opts.workerOptions).toStrictEqual({ + env: { TEST: 'test' }, + name: 'test' + }) + await pool1.destroy() }) it('Should work even without opts in input', async () => { - const pool1 = new FixedThreadPool(1, './tests/worker/thread/testWorker.js') - const res = await pool1.execute({ test: 'test' }) - expect(res).toBeFalsy() + const pool1 = new FixedThreadPool( + numberOfThreads, + './tests/worker-files/thread/testWorker.js' + ) + const res = await pool1.execute() + expect(res).toBe(false) + // We need to clean up the resources after our test + await pool1.destroy() + }) + + it('Verify that a pool with zero worker fails', async () => { + expect( + () => new FixedThreadPool(0, './tests/worker-files/thread/testWorker.js') + ).toThrowError('Cannot instantiate a fixed pool with no worker') }) })