X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;ds=sidebyside;f=tests%2Fpools%2Fthread%2Ffixed.test.js;h=45197cbade4f5492ea2e2c5933f7a5294bea9bad;hb=bac873bd6581e5d5c0884bc520e9ec3c446509e6;hp=a42b5d37ede902bd5c6a490ce7ff832e6025d1fc;hpb=aee467366d8c393b79e7af82c6a7ab12338ee64e;p=poolifier.git diff --git a/tests/pools/thread/fixed.test.js b/tests/pools/thread/fixed.test.js index a42b5d37..45197cba 100644 --- a/tests/pools/thread/fixed.test.js +++ b/tests/pools/thread/fixed.test.js @@ -1,7 +1,7 @@ const { expect } = require('expect') -const { FixedThreadPool, PoolEvents } = require('../../../lib/index') +const { FixedThreadPool, PoolEvents } = require('../../../lib') const { WorkerFunctions } = require('../../test-types') -const TestUtils = require('../../test-utils') +const { waitWorkerEvents } = require('../../test-utils') describe('Fixed thread pool test suite', () => { const numberOfThreads = 6 @@ -12,6 +12,17 @@ describe('Fixed thread pool test suite', () => { errorHandler: e => console.error(e) } ) + 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', @@ -47,20 +58,21 @@ describe('Fixed thread pool test suite', () => { await errorPool.destroy() await asyncErrorPool.destroy() await emptyPool.destroy() + await queuePool.destroy() }) it('Verify that the function is executed in a worker thread', async () => { let result = await pool.execute({ function: WorkerFunctions.fibonacci }) - expect(result).toBe(false) + expect(result).toBe(75025) result = await pool.execute({ function: WorkerFunctions.factorial }) - expect(result).toBe(false) + 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).toBe(false) }) @@ -76,6 +88,38 @@ describe('Fixed thread pool test suite', () => { 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.usage.tasks.executing).toBeLessThanOrEqual( + queuePool.opts.tasksQueueOptions.concurrency + ) + expect(workerNode.usage.tasks.executed).toBe(0) + expect(workerNode.usage.tasks.queued).toBeGreaterThan(0) + expect(workerNode.usage.tasks.maxQueued).toBeGreaterThan(0) + } + expect(queuePool.info.executingTasks).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.usage.tasks.executing).toBe(0) + expect(workerNode.usage.tasks.executed).toBeGreaterThan(0) + expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(maxMultiplier) + expect(workerNode.usage.tasks.queued).toBe(0) + expect(workerNode.usage.tasks.maxQueued).toBe(1) + } + }) + it('Verify that is possible to have a worker that return undefined', async () => { const result = await emptyPool.execute() expect(result).toBeUndefined() @@ -89,6 +133,10 @@ describe('Fixed thread pool test suite', () => { 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) @@ -100,10 +148,24 @@ describe('Fixed thread pool test suite', () => { expect(inError.message).toBeDefined() expect(typeof inError.message === 'string').toBe(true) expect(inError.message).toBe('Error Message from ThreadWorker') + expect(taskError).toStrictEqual({ + workerId: expect.any(Number), + message: new Error('Error Message from ThreadWorker'), + 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) @@ -115,24 +177,52 @@ describe('Fixed thread pool test suite', () => { expect(inError.message).toBeDefined() expect(typeof inError.message === 'string').toBe(true) expect(inError.message).toBe('Error Message from ThreadWorker:async') + expect(taskError).toStrictEqual({ + workerId: expect.any(Number), + message: new Error('Error Message from ThreadWorker: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 = Date.now() + const startTime = performance.now() const result = await asyncPool.execute(data) - const usedTime = Date.now() - startTime + const usedTime = performance.now() - startTime expect(result).toStrictEqual(data) expect(usedTime).toBeGreaterThanOrEqual(2000) }) it('Shutdown test', async () => { - const exitPromise = TestUtils.waitExits(pool, numberOfThreads) + const exitPromise = waitWorkerEvents(pool, 'exit', numberOfThreads) await pool.destroy() const numberOfExitEvents = await exitPromise expect(numberOfExitEvents).toBe(numberOfThreads) }) + it('Verify that thread pool options are checked', async () => { + const workerFilePath = './tests/worker-files/thread/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( numberOfThreads, @@ -147,6 +237,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(new Error('Cannot instantiate a fixed pool with no worker')) + ).toThrowError('Cannot instantiate a fixed pool with no worker') }) })