X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=tests%2Ftest-utils.js;h=3234a6a22cb3af039b81494520178a996a95d9f3;hb=323daa7f98fd16385379e4b6e8def0a9a3f140c8;hp=ceaff7be4c605140c546d1773493b56dcfb1e309;hpb=024daf59a8f93e67b7a307d1b5690ba564c80bab;p=poolifier.git

diff --git a/tests/test-utils.js b/tests/test-utils.js
index ceaff7be..3234a6a2 100644
--- a/tests/test-utils.js
+++ b/tests/test-utils.js
@@ -1,114 +1,123 @@
-const { WorkerFunctions } = require('./test-types')
+const { TaskFunctions } = require('./test-types')
 
-class TestUtils {
-  static async waitWorkerEvents (pool, workerEvent, numberOfEventsToWait) {
-    return 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)
-          }
-        })
-      }
-    })
-  }
-
-  static async waitPoolEvents (pool, poolEvent, numberOfEventsToWait) {
-    return new Promise(resolve => {
-      let events = 0
-      if (numberOfEventsToWait === 0) {
-        resolve(events)
-      }
-      pool.emitter.on(poolEvent, () => {
+const waitWorkerEvents = async (pool, workerEvent, numberOfEventsToWait) => {
+  return 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 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 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 new Promise((resolve, reject) => {
+    setTimeout(
+      () =>
+        rejection === true
+          ? reject(new Error(rejectionMessage))
+          : resolve(data),
+      ms
+    )
+  })
+}
 
-  static 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))
+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 n
-    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
-    }
-    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
+}