X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=tests%2Fpools%2Fthread%2Ffixed.test.js;h=aeebc4a7a623a1151f37f41aaf7f56ddcfcadbc1;hb=a1763c54c962c69b5e02a30c0909724986495fcd;hp=90dd110cd44ce0da7c2d43dd7b5cd0fd442be26b;hpb=4f487526a63c873d168386250b40ad8103c5a4d8;p=poolifier.git diff --git a/tests/pools/thread/fixed.test.js b/tests/pools/thread/fixed.test.js index 90dd110c..aeebc4a7 100644 --- a/tests/pools/thread/fixed.test.js +++ b/tests/pools/thread/fixed.test.js @@ -1,15 +1,16 @@ const { expect } = require('expect') const { FixedThreadPool, PoolEvents } = require('../../../lib') -const { WorkerFunctions } = require('../../test-types') -const TestUtils = require('../../test-utils') +const { TaskFunctions } = require('../../test-types') +const { waitPoolEvents, waitWorkerEvents } = require('../../test-utils') describe('Fixed thread pool test suite', () => { const numberOfThreads = 6 + const tasksConcurrency = 2 const pool = new FixedThreadPool( numberOfThreads, './tests/worker-files/thread/testWorker.js', { - errorHandler: e => console.error(e) + errorHandler: (e) => console.error(e) } ) const queuePool = new FixedThreadPool( @@ -18,15 +19,15 @@ describe('Fixed thread pool test suite', () => { { enableTasksQueue: true, tasksQueueOptions: { - concurrency: 2 + concurrency: tasksConcurrency }, - errorHandler: e => console.error(e) + errorHandler: (e) => console.error(e) } ) const emptyPool = new FixedThreadPool( numberOfThreads, './tests/worker-files/thread/emptyWorker.js', - { exitHandler: () => console.log('empty pool worker exited') } + { exitHandler: () => console.info('empty pool worker exited') } ) const echoPool = new FixedThreadPool( numberOfThreads, @@ -36,14 +37,14 @@ describe('Fixed thread pool test suite', () => { numberOfThreads, './tests/worker-files/thread/errorWorker.js', { - errorHandler: e => console.error(e) + errorHandler: (e) => console.error(e) } ) const asyncErrorPool = new FixedThreadPool( numberOfThreads, './tests/worker-files/thread/asyncErrorWorker.js', { - errorHandler: e => console.error(e) + errorHandler: (e) => console.error(e) } ) const asyncPool = new FixedThreadPool( @@ -63,21 +64,35 @@ describe('Fixed thread pool test suite', () => { it('Verify that the function is executed in a worker thread', async () => { let result = await pool.execute({ - function: WorkerFunctions.fibonacci + function: TaskFunctions.fibonacci }) - expect(result).toBe(121393) + expect(result).toBe(75025) result = await pool.execute({ - function: WorkerFunctions.factorial + function: TaskFunctions.factorial }) expect(result).toBe(9.33262154439441e157) }) it('Verify that is possible to invoke the execute() method without input', async () => { const result = await pool.execute() - expect(result).toBe(false) + expect(result).toStrictEqual({ ok: 1 }) }) - it("Verify that 'busy' event is emitted", async () => { + it("Verify that 'ready' event is emitted", async () => { + const pool1 = new FixedThreadPool( + numberOfThreads, + './tests/worker-files/thread/testWorker.js', + { + errorHandler: (e) => console.error(e) + } + ) + let poolReady = 0 + pool1.emitter.on(PoolEvents.ready, () => ++poolReady) + await waitPoolEvents(pool1, 'ready', 1) + expect(poolReady).toBe(1) + }) + + it("Verify that 'busy' event is emitted", () => { let poolBusy = 0 pool.emitter.on(PoolEvents.busy, () => ++poolBusy) for (let i = 0; i < numberOfThreads * 2; i++) { @@ -90,31 +105,44 @@ describe('Fixed thread pool test suite', () => { it('Verify that tasks queuing is working', async () => { const promises = new Set() - const maxMultiplier = 2 + const maxMultiplier = 3 // Must be greater than tasksConcurrency 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( + expect(workerNode.usage.tasks.executing).toBeGreaterThanOrEqual(0) + expect(workerNode.usage.tasks.executing).toBeLessThanOrEqual( queuePool.opts.tasksQueueOptions.concurrency ) - expect(workerNode.tasksUsage.ran).toBe(0) - expect(workerNode.tasksQueue.size).toBeGreaterThan(0) + 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(queuePool.info.runningTasks).toBe(numberOfThreads) + expect(queuePool.info.executingTasks).toBe( + numberOfThreads * queuePool.opts.tasksQueueOptions.concurrency + ) expect(queuePool.info.queuedTasks).toBe( - numberOfThreads * maxMultiplier - numberOfThreads + numberOfThreads * + (maxMultiplier - queuePool.opts.tasksQueueOptions.concurrency) ) expect(queuePool.info.maxQueuedTasks).toBe( - numberOfThreads * maxMultiplier - numberOfThreads + numberOfThreads * + (maxMultiplier - queuePool.opts.tasksQueueOptions.concurrency) ) + expect(queuePool.info.backPressure).toBe(false) 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) + expect(workerNode.usage.tasks.executing).toBe(0) + 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 + ) } }) @@ -129,10 +157,36 @@ describe('Fixed thread pool test suite', () => { expect(result).toStrictEqual(data) }) + it('Verify that transferable objects are sent to the worker correctly', async () => { + let error + let result + try { + result = await pool.execute(undefined, undefined, [ + new ArrayBuffer(16), + new MessageChannel().port1 + ]) + } catch (e) { + error = e + } + expect(result).toStrictEqual({ ok: 1 }) + expect(error).toBeUndefined() + try { + result = await pool.execute(undefined, undefined, [ + new SharedArrayBuffer(16) + ]) + } catch (e) { + error = e + } + expect(result).toStrictEqual({ ok: 1 }) + expect(error).toStrictEqual( + new TypeError('Found invalid object in transferList') + ) + }) + it('Verify that error handling is working properly:sync', async () => { const data = { f: 10 } let taskError - errorPool.emitter.on(PoolEvents.taskError, e => { + errorPool.emitter.on(PoolEvents.taskError, (e) => { taskError = e }) let inError @@ -147,12 +201,13 @@ describe('Fixed thread pool test suite', () => { expect(typeof inError.message === 'string').toBe(true) expect(inError.message).toBe('Error Message from ThreadWorker') expect(taskError).toStrictEqual({ + name: 'default', message: new Error('Error Message from ThreadWorker'), data }) expect( errorPool.workerNodes.some( - workerNode => workerNode.tasksUsage.error === 1 + (workerNode) => workerNode.usage.tasks.failed === 1 ) ).toBe(true) }) @@ -160,7 +215,7 @@ describe('Fixed thread pool test suite', () => { it('Verify that error handling is working properly:async', async () => { const data = { f: 10 } let taskError - asyncErrorPool.emitter.on(PoolEvents.taskError, e => { + asyncErrorPool.emitter.on(PoolEvents.taskError, (e) => { taskError = e }) let inError @@ -175,12 +230,13 @@ describe('Fixed thread pool test suite', () => { expect(typeof inError.message === 'string').toBe(true) expect(inError.message).toBe('Error Message from ThreadWorker:async') expect(taskError).toStrictEqual({ + name: 'default', message: new Error('Error Message from ThreadWorker:async'), data }) expect( asyncErrorPool.workerNodes.some( - workerNode => workerNode.tasksUsage.error === 1 + (workerNode) => workerNode.usage.tasks.failed === 1 ) ).toBe(true) }) @@ -195,14 +251,17 @@ describe('Fixed thread pool test suite', () => { }) it('Shutdown test', async () => { - const exitPromise = TestUtils.waitWorkerExits(pool, numberOfThreads) + const exitPromise = waitWorkerEvents(pool, 'exit', numberOfThreads) + let poolDestroy = 0 + pool.emitter.on(PoolEvents.destroy, () => ++poolDestroy) await pool.destroy() const numberOfExitEvents = await exitPromise expect(numberOfExitEvents).toBe(numberOfThreads) + expect(poolDestroy).toBe(1) }) it('Verify that thread pool options are checked', async () => { - const workerFilePath = './tests/worker-files/cluster/testWorker.js' + const workerFilePath = './tests/worker-files/thread/testWorker.js' let pool1 = new FixedThreadPool(numberOfThreads, workerFilePath) expect(pool1.opts.workerOptions).toBeUndefined() await pool1.destroy() @@ -225,7 +284,7 @@ describe('Fixed thread pool test suite', () => { './tests/worker-files/thread/testWorker.js' ) const res = await pool1.execute() - expect(res).toBe(false) + expect(res).toStrictEqual({ ok: 1 }) // We need to clean up the resources after our test await pool1.destroy() }) @@ -233,6 +292,6 @@ describe('Fixed thread pool test suite', () => { 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') + ).toThrowError('Cannot instantiate a fixed pool with zero worker') }) })