import { expect } from 'expect'
-import { FixedThreadPool, PoolEvents } from '../../../lib/index.js'
-import { TaskFunctions } from '../../test-types.js'
-import { waitPoolEvents, waitWorkerEvents } from '../../test-utils.js'
-import { DEFAULT_TASK_NAME } from '../../../lib/utils.js'
+
+import { FixedThreadPool, PoolEvents } from '../../../lib/index.cjs'
+import { DEFAULT_TASK_NAME } from '../../../lib/utils.cjs'
+import { TaskFunctions } from '../../test-types.cjs'
+import { waitPoolEvents, waitWorkerEvents } from '../../test-utils.cjs'
describe('Fixed thread pool test suite', () => {
const numberOfThreads = 6
const tasksConcurrency = 2
const pool = new FixedThreadPool(
numberOfThreads,
- './tests/worker-files/thread/testWorker.js',
+ './tests/worker-files/thread/testWorker.mjs',
{
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
const queuePool = new FixedThreadPool(
numberOfThreads,
- './tests/worker-files/thread/testWorker.js',
+ './tests/worker-files/thread/testWorker.mjs',
{
enableTasksQueue: true,
tasksQueueOptions: {
- concurrency: tasksConcurrency
+ concurrency: tasksConcurrency,
},
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
const emptyPool = new FixedThreadPool(
numberOfThreads,
- './tests/worker-files/thread/emptyWorker.js',
+ './tests/worker-files/thread/emptyWorker.mjs',
{ exitHandler: () => console.info('empty pool worker exited') }
)
const echoPool = new FixedThreadPool(
numberOfThreads,
- './tests/worker-files/thread/echoWorker.js'
+ './tests/worker-files/thread/echoWorker.mjs'
)
const errorPool = new FixedThreadPool(
numberOfThreads,
- './tests/worker-files/thread/errorWorker.js',
+ './tests/worker-files/thread/errorWorker.mjs',
{
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
const asyncErrorPool = new FixedThreadPool(
numberOfThreads,
- './tests/worker-files/thread/asyncErrorWorker.js',
+ './tests/worker-files/thread/asyncErrorWorker.mjs',
{
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
const asyncPool = new FixedThreadPool(
numberOfThreads,
- './tests/worker-files/thread/asyncWorker.js'
+ './tests/worker-files/thread/asyncWorker.mjs'
)
after('Destroy all pools', async () => {
it('Verify that the function is executed in a worker thread', 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)
})
it("Verify that 'ready' event is emitted", async () => {
const pool = new FixedThreadPool(
numberOfThreads,
- './tests/worker-files/thread/testWorker.js',
+ './tests/worker-files/thread/testWorker.mjs',
{
- errorHandler: e => console.error(e)
+ errorHandler: e => console.error(e),
}
)
expect(pool.emitter.eventNames()).toStrictEqual([])
expect(workerNode.usage.tasks.maxQueued).toBe(
maxMultiplier - queuePool.opts.tasksQueueOptions.concurrency
)
+ expect(workerNode.usage.tasks.sequentiallyStolen).toBe(0)
expect(workerNode.usage.tasks.stolen).toBe(0)
}
expect(queuePool.info.executedTasks).toBe(0)
expect(workerNode.usage.tasks.maxQueued).toBe(
maxMultiplier - queuePool.opts.tasksQueueOptions.concurrency
)
+ expect(workerNode.usage.tasks.sequentiallyStolen).toBeGreaterThanOrEqual(
+ 0
+ )
+ expect(workerNode.usage.tasks.sequentiallyStolen).toBeLessThanOrEqual(
+ numberOfThreads * maxMultiplier
+ )
expect(workerNode.usage.tasks.stolen).toBeGreaterThanOrEqual(0)
expect(workerNode.usage.tasks.stolen).toBeLessThanOrEqual(
numberOfThreads * maxMultiplier
try {
result = await pool.execute(undefined, undefined, [
new ArrayBuffer(16),
- new MessageChannel().port1
+ new MessageChannel().port1,
])
} catch (e) {
error = e
expect(error).toBeUndefined()
try {
result = await pool.execute(undefined, undefined, [
- new SharedArrayBuffer(16)
+ new SharedArrayBuffer(16),
])
} catch (e) {
error = e
}
expect(result).toStrictEqual({ ok: 1 })
- expect(error).toStrictEqual(
- new TypeError('Found invalid object in transferList')
+ expect(error).toBeInstanceOf(Error)
+ expect(error.message).toMatch(
+ /Found invalid (object|value) in transferList/
)
})
expect(taskError).toStrictEqual({
name: DEFAULT_TASK_NAME,
message: new Error('Error Message from ThreadWorker'),
- data
+ data,
})
expect(
errorPool.workerNodes.some(
taskError = e
})
expect(asyncErrorPool.emitter.eventNames()).toStrictEqual([
- PoolEvents.taskError
+ PoolEvents.taskError,
])
let inError
try {
expect(taskError).toStrictEqual({
name: DEFAULT_TASK_NAME,
message: new Error('Error Message from ThreadWorker:async'),
- data
+ data,
})
expect(
asyncErrorPool.workerNodes.some(
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([
+ PoolEvents.busy,
+ PoolEvents.destroy,
+ ])
+ expect(pool.readyEventEmitted).toBe(false)
expect(pool.workerNodes.length).toBe(0)
expect(numberOfExitEvents).toBe(numberOfThreads)
expect(poolDestroy).toBe(1)
})
it('Verify that thread pool options are checked', async () => {
- const workerFilePath = './tests/worker-files/thread/testWorker.js'
+ const workerFilePath = './tests/worker-files/thread/testWorker.mjs'
let pool = new FixedThreadPool(numberOfThreads, workerFilePath)
expect(pool.opts.workerOptions).toBeUndefined()
await pool.destroy()
pool = new FixedThreadPool(numberOfThreads, workerFilePath, {
workerOptions: {
env: { TEST: 'test' },
- name: 'test'
- }
+ name: 'test',
+ },
})
expect(pool.opts.workerOptions).toStrictEqual({
env: { TEST: 'test' },
- name: 'test'
+ name: 'test',
})
await pool.destroy()
})
it('Should work even without opts in input', async () => {
- const workerFilePath = './tests/worker-files/thread/testWorker.js'
+ const workerFilePath = './tests/worker-files/thread/testWorker.mjs'
const pool = new FixedThreadPool(numberOfThreads, workerFilePath)
const res = await pool.execute()
expect(res).toStrictEqual({ ok: 1 })
})
it('Verify destroyWorkerNode()', async () => {
- const workerFilePath = './tests/worker-files/thread/testWorker.js'
+ const workerFilePath = './tests/worker-files/thread/testWorker.mjs'
const pool = new FixedThreadPool(numberOfThreads, workerFilePath)
const workerNodeKey = 0
let exitEvent = 0
})
await expect(pool.destroyWorkerNode(workerNodeKey)).resolves.toBeUndefined()
expect(exitEvent).toBe(1)
- expect(pool.workerNodes.length).toBe(numberOfThreads - 1)
+ // Simulates an illegitimate worker node destroy and the minimum number of worker nodes is guaranteed
+ expect(pool.workerNodes.length).toBe(numberOfThreads)
await pool.destroy()
})
- it('Verify that a pool with zero worker fails', async () => {
+ it('Verify that a pool with zero worker fails', () => {
expect(
- () => new FixedThreadPool(0, './tests/worker-files/thread/testWorker.js')
- ).toThrowError('Cannot instantiate a fixed pool with zero worker')
+ () => new FixedThreadPool(0, './tests/worker-files/thread/testWorker.mjs')
+ ).toThrow('Cannot instantiate a fixed pool with zero worker')
})
})