X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=tests%2Fpools%2Fabstract%2Fabstract-pool.test.js;h=be745d94ce5e4b10c89012846f6f67d85899abc0;hb=bb9423b78d11f9420b9b2a8cb865ea8c1315e642;hp=8a8f779c41603f09859bf475d0c55406a04fa918;hpb=574b351dcb46b90a6a8d0ffb15b5016392e5a63f;p=poolifier.git

diff --git a/tests/pools/abstract/abstract-pool.test.js b/tests/pools/abstract/abstract-pool.test.js
index 8a8f779c..be745d94 100644
--- a/tests/pools/abstract/abstract-pool.test.js
+++ b/tests/pools/abstract/abstract-pool.test.js
@@ -12,6 +12,7 @@ const {
 } = require('../../../lib')
 const { CircularArray } = require('../../../lib/circular-array')
 const { Deque } = require('../../../lib/deque')
+const { DEFAULT_TASK_NAME } = require('../../../lib/utils')
 const { version } = require('../../../package.json')
 const { waitPoolEvents } = require('../../test-utils')
 
@@ -23,6 +24,10 @@ describe('Abstract pool test suite', () => {
     }
   }
 
+  afterEach(() => {
+    sinon.restore()
+  })
+
   it('Simulate pool creation from a non main thread/process', () => {
     expect(
       () =>
@@ -40,6 +45,16 @@ describe('Abstract pool test suite', () => {
     )
   })
 
+  it('Verify that pool statuses properties are set', async () => {
+    const pool = new FixedThreadPool(
+      numberOfWorkers,
+      './tests/worker-files/thread/testWorker.js'
+    )
+    expect(pool.starting).toBe(false)
+    expect(pool.started).toBe(true)
+    await pool.destroy()
+  })
+
   it('Verify that filePath is checked', () => {
     const expectedError = new Error(
       'Please specify a file with a worker implementation'
@@ -138,22 +153,22 @@ describe('Abstract pool test suite', () => {
     )
     expect(
       () =>
-        new DynamicClusterPool(
-          1,
-          1,
-          './tests/worker-files/cluster/testWorker.js'
-        )
+        new DynamicThreadPool(0, 0, './tests/worker-files/thread/testWorker.js')
     ).toThrowError(
       new RangeError(
-        'Cannot instantiate a dynamic pool with a minimum pool size equal to the maximum pool size. Use a fixed pool instead'
+        'Cannot instantiate a dynamic pool with a maximum pool size equal to zero'
       )
     )
     expect(
       () =>
-        new DynamicThreadPool(0, 0, './tests/worker-files/thread/testWorker.js')
+        new DynamicClusterPool(
+          1,
+          1,
+          './tests/worker-files/cluster/testWorker.js'
+        )
     ).toThrowError(
       new RangeError(
-        'Cannot instantiate a dynamic pool with a maximum pool size equal to zero'
+        'Cannot instantiate a dynamic pool with a minimum pool size equal to the maximum pool size. Use a fixed pool instead'
       )
     )
   })
@@ -172,13 +187,13 @@ describe('Abstract pool test suite', () => {
       WorkerChoiceStrategies.ROUND_ROBIN
     )
     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: false },
       waitTime: { median: false },
       elu: { median: false }
     })
     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: false },
       waitTime: { median: false },
       elu: { median: false }
@@ -214,20 +229,20 @@ describe('Abstract pool test suite', () => {
     expect(pool.opts.enableTasksQueue).toBe(true)
     expect(pool.opts.tasksQueueOptions).toStrictEqual({
       concurrency: 2,
-      queueMaxSize: 4
+      size: 4
     })
     expect(pool.opts.workerChoiceStrategy).toBe(
       WorkerChoiceStrategies.LEAST_USED
     )
     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: true },
       waitTime: { median: false },
       elu: { median: false },
       weights: { 0: 300, 1: 200 }
     })
     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: true },
       waitTime: { median: false },
       elu: { median: false },
@@ -253,6 +268,38 @@ describe('Abstract pool test suite', () => {
     ).toThrowError(
       new Error("Invalid worker choice strategy 'invalidStrategy'")
     )
+    expect(
+      () =>
+        new FixedThreadPool(
+          numberOfWorkers,
+          './tests/worker-files/thread/testWorker.js',
+          {
+            workerChoiceStrategyOptions: {
+              retries: 'invalidChoiceRetries'
+            }
+          }
+        )
+    ).toThrowError(
+      new TypeError(
+        'Invalid worker choice strategy options: retries must be an integer'
+      )
+    )
+    expect(
+      () =>
+        new FixedThreadPool(
+          numberOfWorkers,
+          './tests/worker-files/thread/testWorker.js',
+          {
+            workerChoiceStrategyOptions: {
+              retries: -1
+            }
+          }
+        )
+    ).toThrowError(
+      new RangeError(
+        "Invalid worker choice strategy options: retries '-1' must be greater or equal than zero"
+      )
+    )
     expect(
       () =>
         new FixedThreadPool(
@@ -281,6 +328,19 @@ describe('Abstract pool test suite', () => {
         "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
       )
     )
+    expect(
+      () =>
+        new FixedThreadPool(
+          numberOfWorkers,
+          './tests/worker-files/thread/testWorker.js',
+          {
+            enableTasksQueue: true,
+            tasksQueueOptions: 'invalidTasksQueueOptions'
+          }
+        )
+    ).toThrowError(
+      new TypeError('Invalid tasks queue options: must be a plain object')
+    )
     expect(
       () =>
         new FixedThreadPool(
@@ -303,11 +363,13 @@ describe('Abstract pool test suite', () => {
           './tests/worker-files/thread/testWorker.js',
           {
             enableTasksQueue: true,
-            tasksQueueOptions: 'invalidTasksQueueOptions'
+            tasksQueueOptions: { concurrency: -1 }
           }
         )
     ).toThrowError(
-      new TypeError('Invalid tasks queue options: must be a plain object')
+      new RangeError(
+        'Invalid worker node tasks concurrency: -1 is a negative integer or zero'
+      )
     )
     expect(
       () =>
@@ -322,6 +384,64 @@ describe('Abstract pool test suite', () => {
     ).toThrowError(
       new TypeError('Invalid worker node tasks concurrency: must be an integer')
     )
+    expect(
+      () =>
+        new FixedThreadPool(
+          numberOfWorkers,
+          './tests/worker-files/thread/testWorker.js',
+          {
+            enableTasksQueue: true,
+            tasksQueueOptions: { queueMaxSize: 2 }
+          }
+        )
+    ).toThrowError(
+      new Error(
+        'Invalid tasks queue options: queueMaxSize is deprecated, please use size instead'
+      )
+    )
+    expect(
+      () =>
+        new FixedThreadPool(
+          numberOfWorkers,
+          './tests/worker-files/thread/testWorker.js',
+          {
+            enableTasksQueue: true,
+            tasksQueueOptions: { size: 0 }
+          }
+        )
+    ).toThrowError(
+      new RangeError(
+        'Invalid worker node tasks queue size: 0 is a negative integer or zero'
+      )
+    )
+    expect(
+      () =>
+        new FixedThreadPool(
+          numberOfWorkers,
+          './tests/worker-files/thread/testWorker.js',
+          {
+            enableTasksQueue: true,
+            tasksQueueOptions: { size: -1 }
+          }
+        )
+    ).toThrowError(
+      new RangeError(
+        'Invalid worker node tasks queue size: -1 is a negative integer or zero'
+      )
+    )
+    expect(
+      () =>
+        new FixedThreadPool(
+          numberOfWorkers,
+          './tests/worker-files/thread/testWorker.js',
+          {
+            enableTasksQueue: true,
+            tasksQueueOptions: { size: 0.2 }
+          }
+        )
+    ).toThrowError(
+      new TypeError('Invalid worker node tasks queue size: must be an integer')
+    )
   })
 
   it('Verify that pool worker choice strategy options can be set', async () => {
@@ -331,13 +451,13 @@ describe('Abstract pool test suite', () => {
       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
     )
     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: false },
       waitTime: { median: false },
       elu: { median: false }
     })
     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: false },
       waitTime: { median: false },
       elu: { median: false }
@@ -345,7 +465,7 @@ describe('Abstract pool test suite', () => {
     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
       .workerChoiceStrategies) {
       expect(workerChoiceStrategy.opts).toStrictEqual({
-        choiceRetries: 6,
+        retries: 6,
         runTime: { median: false },
         waitTime: { median: false },
         elu: { median: false }
@@ -375,13 +495,13 @@ describe('Abstract pool test suite', () => {
       elu: { median: true }
     })
     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: true },
       waitTime: { median: false },
       elu: { median: true }
     })
     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: true },
       waitTime: { median: false },
       elu: { median: true }
@@ -389,7 +509,7 @@ describe('Abstract pool test suite', () => {
     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
       .workerChoiceStrategies) {
       expect(workerChoiceStrategy.opts).toStrictEqual({
-        choiceRetries: 6,
+        retries: 6,
         runTime: { median: true },
         waitTime: { median: false },
         elu: { median: true }
@@ -419,13 +539,13 @@ describe('Abstract pool test suite', () => {
       elu: { median: false }
     })
     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: false },
       waitTime: { median: false },
       elu: { median: false }
     })
     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
-      choiceRetries: 6,
+      retries: 6,
       runTime: { median: false },
       waitTime: { median: false },
       elu: { median: false }
@@ -433,7 +553,7 @@ describe('Abstract pool test suite', () => {
     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
       .workerChoiceStrategies) {
       expect(workerChoiceStrategy.opts).toStrictEqual({
-        choiceRetries: 6,
+        retries: 6,
         runTime: { median: false },
         waitTime: { median: false },
         elu: { median: false }
@@ -465,6 +585,22 @@ describe('Abstract pool test suite', () => {
         'Invalid worker choice strategy options: must be a plain object'
       )
     )
+    expect(() =>
+      pool.setWorkerChoiceStrategyOptions({
+        retries: 'invalidChoiceRetries'
+      })
+    ).toThrowError(
+      new TypeError(
+        'Invalid worker choice strategy options: retries must be an integer'
+      )
+    )
+    expect(() =>
+      pool.setWorkerChoiceStrategyOptions({ retries: -1 })
+    ).toThrowError(
+      new RangeError(
+        "Invalid worker choice strategy options: retries '-1' must be greater or equal than zero"
+      )
+    )
     expect(() =>
       pool.setWorkerChoiceStrategyOptions({ weights: {} })
     ).toThrowError(
@@ -493,13 +629,13 @@ describe('Abstract pool test suite', () => {
     expect(pool.opts.enableTasksQueue).toBe(true)
     expect(pool.opts.tasksQueueOptions).toStrictEqual({
       concurrency: 1,
-      queueMaxSize: 4
+      size: 4
     })
     pool.enableTasksQueue(true, { concurrency: 2 })
     expect(pool.opts.enableTasksQueue).toBe(true)
     expect(pool.opts.tasksQueueOptions).toStrictEqual({
       concurrency: 2,
-      queueMaxSize: 4
+      size: 4
     })
     pool.enableTasksQueue(false)
     expect(pool.opts.enableTasksQueue).toBe(false)
@@ -515,12 +651,12 @@ describe('Abstract pool test suite', () => {
     )
     expect(pool.opts.tasksQueueOptions).toStrictEqual({
       concurrency: 1,
-      queueMaxSize: 4
+      size: 4
     })
     pool.setTasksQueueOptions({ concurrency: 2 })
     expect(pool.opts.tasksQueueOptions).toStrictEqual({
       concurrency: 2,
-      queueMaxSize: 4
+      size: 4
     })
     expect(() =>
       pool.setTasksQueueOptions('invalidTasksQueueOptions')
@@ -540,21 +676,24 @@ describe('Abstract pool test suite', () => {
     expect(() => pool.setTasksQueueOptions({ concurrency: 0.2 })).toThrowError(
       new TypeError('Invalid worker node tasks concurrency: must be an integer')
     )
-    expect(() => pool.setTasksQueueOptions({ queueMaxSize: 0 })).toThrowError(
-      new RangeError(
-        'Invalid worker node tasks queue max size: 0 is a negative integer or zero'
+    expect(() => pool.setTasksQueueOptions({ queueMaxSize: 2 })).toThrowError(
+      new Error(
+        'Invalid tasks queue options: queueMaxSize is deprecated, please use size instead'
       )
     )
-    expect(() => pool.setTasksQueueOptions({ queueMaxSize: -1 })).toThrowError(
+    expect(() => pool.setTasksQueueOptions({ size: 0 })).toThrowError(
       new RangeError(
-        'Invalid worker node tasks queue max size: -1 is a negative integer or zero'
+        'Invalid worker node tasks queue size: 0 is a negative integer or zero'
       )
     )
-    expect(() => pool.setTasksQueueOptions({ queueMaxSize: 0.2 })).toThrowError(
-      new TypeError(
-        'Invalid worker node tasks queue max size: must be an integer'
+    expect(() => pool.setTasksQueueOptions({ size: -1 })).toThrowError(
+      new RangeError(
+        'Invalid worker node tasks queue size: -1 is a negative integer or zero'
       )
     )
+    expect(() => pool.setTasksQueueOptions({ size: 0.2 })).toThrowError(
+      new TypeError('Invalid worker node tasks queue size: must be an integer')
+    )
     await pool.destroy()
   })
 
@@ -614,6 +753,7 @@ describe('Abstract pool test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          stolen: 0,
           failed: 0
         },
         runTime: {
@@ -658,6 +798,7 @@ describe('Abstract pool test suite', () => {
       expect(workerNode.tasksQueue.size).toBe(0)
       expect(workerNode.tasksQueue.maxSize).toBe(0)
     }
+    await pool.destroy()
   })
 
   it('Verify that pool worker info are initialized', async () => {
@@ -687,6 +828,30 @@ describe('Abstract pool test suite', () => {
         ready: true
       })
     }
+    await pool.destroy()
+  })
+
+  it('Verify that pool execute() arguments are checked', async () => {
+    const pool = new FixedClusterPool(
+      numberOfWorkers,
+      './tests/worker-files/cluster/testWorker.js'
+    )
+    await expect(pool.execute(undefined, 0)).rejects.toThrowError(
+      new TypeError('name argument must be a string')
+    )
+    await expect(pool.execute(undefined, '')).rejects.toThrowError(
+      new TypeError('name argument must not be an empty string')
+    )
+    await expect(pool.execute(undefined, undefined, {})).rejects.toThrowError(
+      new TypeError('transferList argument must be an array')
+    )
+    await expect(pool.execute(undefined, 'unknown')).rejects.toBe(
+      "Task function 'unknown' not found"
+    )
+    await pool.destroy()
+    await expect(pool.execute(undefined, undefined, {})).rejects.toThrowError(
+      new Error('Cannot execute a task on destroyed pool')
+    )
   })
 
   it('Verify that pool worker tasks usage are computed', async () => {
@@ -706,6 +871,7 @@ describe('Abstract pool test suite', () => {
           executing: maxMultiplier,
           queued: 0,
           maxQueued: 0,
+          stolen: 0,
           failed: 0
         },
         runTime: {
@@ -732,6 +898,7 @@ describe('Abstract pool test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          stolen: 0,
           failed: 0
         },
         runTime: {
@@ -772,6 +939,7 @@ describe('Abstract pool test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          stolen: 0,
           failed: 0
         },
         runTime: {
@@ -806,6 +974,7 @@ describe('Abstract pool test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          stolen: 0,
           failed: 0
         },
         runTime: {
@@ -952,11 +1121,11 @@ describe('Abstract pool test suite', () => {
       ++poolBackPressure
       poolInfo = info
     })
-    for (let i = 0; i < numberOfWorkers * 2; i++) {
+    for (let i = 0; i < numberOfWorkers + 1; i++) {
       promises.add(pool.execute())
     }
     await Promise.all(promises)
-    expect(poolBackPressure).toBe(2)
+    expect(poolBackPressure).toBe(1)
     expect(poolInfo).toStrictEqual({
       version,
       type: PoolTypes.fixed,
@@ -973,6 +1142,7 @@ describe('Abstract pool test suite', () => {
       maxQueuedTasks: expect.any(Number),
       queuedTasks: expect.any(Number),
       backPressure: true,
+      stolenTasks: expect.any(Number),
       failedTasks: expect.any(Number)
     })
     expect(pool.hasBackPressure.called).toBe(true)
@@ -987,7 +1157,7 @@ describe('Abstract pool test suite', () => {
     )
     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
     expect(dynamicThreadPool.listTaskFunctions()).toStrictEqual([
-      'default',
+      DEFAULT_TASK_NAME,
       'jsonIntegerSerialization',
       'factorial',
       'fibonacci'
@@ -998,11 +1168,13 @@ describe('Abstract pool test suite', () => {
     )
     await waitPoolEvents(fixedClusterPool, PoolEvents.ready, 1)
     expect(fixedClusterPool.listTaskFunctions()).toStrictEqual([
-      'default',
+      DEFAULT_TASK_NAME,
       'jsonIntegerSerialization',
       'factorial',
       'fibonacci'
     ])
+    await dynamicThreadPool.destroy()
+    await fixedClusterPool.destroy()
   })
 
   it('Verify that multiple task functions worker is working', async () => {
@@ -1024,7 +1196,7 @@ describe('Abstract pool test suite', () => {
     expect(pool.info.executedTasks).toBe(4)
     for (const workerNode of pool.workerNodes) {
       expect(workerNode.info.taskFunctions).toStrictEqual([
-        'default',
+        DEFAULT_TASK_NAME,
         'jsonIntegerSerialization',
         'factorial',
         'fibonacci'
@@ -1036,7 +1208,8 @@ describe('Abstract pool test suite', () => {
             executed: expect.any(Number),
             executing: expect.any(Number),
             failed: 0,
-            queued: 0
+            queued: 0,
+            stolen: 0
           },
           runTime: {
             history: expect.any(CircularArray)
@@ -1058,5 +1231,6 @@ describe('Abstract pool test suite', () => {
         ).toBeGreaterThanOrEqual(0)
       }
     }
+    await pool.destroy()
   })
 })