tests/test-utils.js

   1 const { WorkerFunctions } = require('./test-types')
   2
   3 class TestUtils {
   4   static async waitExits (pool, numberOfExitEventsToWait) {
   5     return new Promise(resolve => {
   6       let exitEvents = 0
   7       if (numberOfExitEventsToWait === 0) {
   8         resolve(exitEvents)
   9       }
  10       for (const workerNode of pool.workerNodes) {
  11         workerNode.worker.on('exit', () => {
  12           ++exitEvents
  13           if (exitEvents === numberOfExitEventsToWait) {
  14             resolve(exitEvents)
  15           }
  16         })
  17       }
  18     })
  19   }
  20
  21   static async sleep (ms) {
  22     return new Promise(resolve => setTimeout(resolve, ms))
  23   }
  24
  25   static async sleepWorkerFunction (
  26     data,
  27     ms,
  28     rejection = false,
  29     rejectionMessage = ''
  30   ) {
  31     return new Promise((resolve, reject) => {
  32       setTimeout(
  33         () =>
  34           rejection === true
  35             ? reject(new Error(rejectionMessage))
  36             : resolve(data),
  37         ms
  38       )
  39     })
  40   }
  41
  42   static generateRandomInteger (max = Number.MAX_SAFE_INTEGER, min = 0) {
  43     if (max < min || max < 0 || min < 0) {
  44       throw new RangeError('Invalid interval')
  45     }
  46     max = Math.floor(max)
  47     if (min != null && min !== 0) {
  48       min = Math.ceil(min)
  49       return Math.floor(Math.random() * (max - min + 1)) + min
  50     }
  51     return Math.floor(Math.random() * (max + 1))
  52   }
  53
  54   static jsonIntegerSerialization (n) {
  55     for (let i = 0; i < n; i++) {
  56       const o = {
  57         a: i
  58       }
  59       JSON.stringify(o)
  60     }
  61   }
  62
  63   /**
  64    * Intentionally inefficient implementation.
  65    * @param {number} n - The number of fibonacci numbers to generate.
  66    * @returns {number} - The nth fibonacci number.
  67    */
  68   static fibonacci (n) {
  69     if (n <= 1) return 1
  70     return TestUtils.fibonacci(n - 1) + TestUtils.fibonacci(n - 2)
  71   }
  72
  73   /**
  74    * Intentionally inefficient implementation.
  75    * @param {number} n - The number to calculate the factorial of.
  76    * @returns {number} - The factorial of n.
  77    */
  78   static factorial (n) {
  79     if (n === 0) {
  80       return 1
  81     }
  82     return TestUtils.factorial(n - 1) * n
  83   }
  84
  85   static executeWorkerFunction (data) {
  86     switch (data.function) {
  87       case WorkerFunctions.jsonIntegerSerialization:
  88         return TestUtils.jsonIntegerSerialization(data.n || 100)
  89       case WorkerFunctions.fibonacci:
  90         return TestUtils.fibonacci(data.n || 25)
  91       case WorkerFunctions.factorial:
  92         return TestUtils.factorial(data.n || 100)
  93       default:
  94         throw new Error('Unknown worker function')
  95     }
  96   }
  97 }
  98
  99 module.exports = TestUtils