Merge branch 'master' into feature/task-functions

[poolifier.git] / tests / test-utils.js

diff --git a/tests/test-utils.js b/tests/test-utils.js
index 9a49c822991c2629ac45280776604cb3be188a04..4478d29015ede00b981e8e66262204e2dc686a04 100644 (file)
--- a/tests/test-utils.js
+++ b/tests/test-utils.js
@@ -1,96 +1,123 @@
-const { WorkerFunctions } = require('./test-types')
+const { TaskFunctions } = require('./test-types')
 
-class TestUtils {
-  static async waitExits (pool, numberOfExitEventsToWait) {
-    let exitEvents = 0
-    return new Promise(resolve => {
-      pool.workers.forEach(w => {
-        w.on('exit', () => {
-          exitEvents++
-          if (exitEvents === numberOfExitEventsToWait) {
-            resolve(exitEvents)
-          }
-        })
+const waitWorkerEvents = async (pool, workerEvent, numberOfEventsToWait) => {
+  return await new Promise(resolve => {
+    let events = 0
+    if (numberOfEventsToWait === 0) {
+      resolve(events)
+    }
+    for (const workerNode of pool.workerNodes) {
+      workerNode.worker.on(workerEvent, () => {
+        ++events
+        if (events === numberOfEventsToWait) {
+          resolve(events)
+        }
       })
+    }
+  })
+}
+
+const waitPoolEvents = async (pool, poolEvent, numberOfEventsToWait) => {
+  return await new Promise(resolve => {
+    let events = 0
+    if (numberOfEventsToWait === 0) {
+      resolve(events)
+    }
+    pool.emitter?.on(poolEvent, () => {
+      ++events
+      if (events === numberOfEventsToWait) {
+        resolve(events)
+      }
     })
-  }
+  })
+}
 
-  static async sleep (ms) {
-    return new Promise(resolve => setTimeout(resolve, ms))
-  }
+const sleep = async ms => {
+  return await new Promise(resolve => setTimeout(resolve, ms))
+}
 
-  static async sleepWorkerFunction (
-    data,
-    ms,
-    rejection = false,
-    rejectionMessage = ''
-  ) {
-    return new Promise((resolve, reject) => {
-      setTimeout(
-        () =>
-          rejection === true
-            ? reject(new Error(rejectionMessage))
-            : resolve(data),
-        ms
-      )
-    })
-  }
+const sleepTaskFunction = async (
+  data,
+  ms,
+  rejection = false,
+  rejectionMessage = ''
+) => {
+  return await new Promise((resolve, reject) => {
+    setTimeout(
+      () =>
+        rejection === true
+          ? reject(new Error(rejectionMessage))
+          : resolve(data),
+      ms
+    )
+  })
+}
 
-  static generateRandomInteger (max = Number.MAX_SAFE_INTEGER, min = 0) {
-    max = Math.floor(max)
-    if (min) {
-      min = Math.ceil(min)
-      return Math.floor(Math.random() * (max - min + 1)) + min
-    }
-    return Math.floor(Math.random() * (max + 1))
+const generateRandomInteger = (max = Number.MAX_SAFE_INTEGER, min = 0) => {
+  if (max < min || max < 0 || min < 0) {
+    throw new RangeError('Invalid interval')
+  }
+  max = Math.floor(max)
+  if (min != null && min !== 0) {
+    min = Math.ceil(min)
+    return Math.floor(Math.random() * (max - min + 1)) + min
   }
+  return Math.floor(Math.random() * (max + 1))
+}
 
-  static jsonIntegerSerialization (n) {
-    for (let i = 0; i < n; i++) {
-      const o = {
-        a: i
-      }
-      JSON.stringify(o)
+const jsonIntegerSerialization = n => {
+  for (let i = 0; i < n; i++) {
+    const o = {
+      a: i
     }
+    JSON.stringify(o)
   }
+  return { ok: 1 }
+}
 
-  /**
-   * Intentionally inefficient implementation.
-   *
-   * @param {number} n - The number of fibonacci numbers to generate.
-   * @returns {number} - The nth fibonacci number.
-   */
-  static fibonacci (n) {
-    if (n <= 1) return 1
-    return TestUtils.fibonacci(n - 1) + TestUtils.fibonacci(n - 2)
-  }
+/**
+ * Intentionally inefficient implementation.
+ * @param {number} n - The number of fibonacci numbers to generate.
+ * @returns {number} - The nth fibonacci number.
+ */
+const fibonacci = n => {
+  if (n <= 1) return n
+  return fibonacci(n - 1) + fibonacci(n - 2)
+}
 
-  /**
-   * Intentionally inefficient implementation.
-   *
-   * @param {number} n - The number to calculate the factorial of.
-   * @returns {number} - The factorial of n.
-   */
-  static factorial (n) {
-    if (n === 0) {
-      return 1
-    } else {
-      return TestUtils.factorial(n - 1) * n
-    }
+/**
+ * Intentionally inefficient implementation.
+ * @param {number} n - The number to calculate the factorial of.
+ * @returns {number} - The factorial of n.
+ */
+const factorial = n => {
+  if (n === 0) {
+    return 1
   }
+  return factorial(n - 1) * n
+}
 
-  static executeWorkerFunction (data) {
-    switch (data.function) {
-      case WorkerFunctions.jsonIntegerSerialization:
-        return TestUtils.jsonIntegerSerialization(data.n || 100)
-      case WorkerFunctions.fibonacci:
-        return TestUtils.fibonacci(data.n || 25)
-      case WorkerFunctions.factorial:
-        return TestUtils.factorial(data.n || 100)
-      default:
-        throw new Error('Unknown worker function')
-    }
+const executeTaskFunction = data => {
+  switch (data.function) {
+    case TaskFunctions.jsonIntegerSerialization:
+      return jsonIntegerSerialization(data.n || 100)
+    case TaskFunctions.fibonacci:
+      return fibonacci(data.n || 25)
+    case TaskFunctions.factorial:
+      return factorial(data.n || 100)
+    default:
+      throw new Error('Unknown worker function')
   }
 }
 
-module.exports = TestUtils
+module.exports = {
+  executeTaskFunction,
+  factorial,
+  fibonacci,
+  generateRandomInteger,
+  jsonIntegerSerialization,
+  sleep,
+  sleepTaskFunction,
+  waitPoolEvents,
+  waitWorkerEvents
+}