tests/test-utils.cjs

   1 const { TaskFunctions } = require('./test-types.cjs')
   2
   3 const waitWorkerEvents = async (pool, workerEvent, numberOfEventsToWait) => {
   4   return await new Promise(resolve => {
   5     let events = 0
   6     if (numberOfEventsToWait === 0) {
   7       resolve(events)
   8       return
   9     }
  10     for (const workerNode of pool.workerNodes) {
  11       workerNode.worker.on(workerEvent, () => {
  12         ++events
  13         if (events === numberOfEventsToWait) {
  14           resolve(events)
  15         }
  16       })
  17     }
  18   })
  19 }
  20
  21 const waitPoolEvents = async (pool, poolEvent, numberOfEventsToWait) => {
  22   return await new Promise(resolve => {
  23     let events = 0
  24     if (numberOfEventsToWait === 0) {
  25       resolve(events)
  26       return
  27     }
  28     pool.emitter?.on(poolEvent, () => {
  29       ++events
  30       if (events === numberOfEventsToWait) {
  31         resolve(events)
  32       }
  33     })
  34   })
  35 }
  36
  37 const sleep = async ms => {
  38   return await new Promise(resolve => setTimeout(resolve, ms))
  39 }
  40
  41 const sleepTaskFunction = async (
  42   data,
  43   ms,
  44   rejection = false,
  45   rejectionMessage = ''
  46 ) => {
  47   return await new Promise((resolve, reject) => {
  48     setTimeout(
  49       () =>
  50         rejection === true
  51           ? reject(new Error(rejectionMessage))
  52           : resolve(data),
  53       ms
  54     )
  55   })
  56 }
  57
  58 const jsonIntegerSerialization = n => {
  59   for (let i = 0; i < n; i++) {
  60     const o = {
  61       a: i
  62     }
  63     JSON.stringify(o)
  64   }
  65   return { ok: 1 }
  66 }
  67
  68 /**
  69  * @param {number} n - The number of fibonacci numbers to generate.
  70  * @returns {number} - The nth fibonacci number.
  71  */
  72 const fibonacci = n => {
  73   let current = 1
  74   let previous = 0
  75   while (--n) {
  76     const tmp = current
  77     current += previous
  78     previous = tmp
  79   }
  80   return current
  81 }
  82
  83 /**
  84  * @param {number} n - The number to calculate the factorial of.
  85  * @returns {number} - The factorial of n.
  86  */
  87 const factorial = n => {
  88   if (n === 0 || n === 1) {
  89     return 1
  90   } else {
  91     let factorial = 1
  92     for (let i = 1; i <= n; i++) {
  93       factorial *= i
  94     }
  95     return factorial
  96   }
  97 }
  98
  99 const executeTaskFunction = data => {
 100   switch (data.function) {
 101     case TaskFunctions.jsonIntegerSerialization:
 102       return jsonIntegerSerialization(data.n || 100)
 103     case TaskFunctions.fibonacci:
 104       return fibonacci(data.n || 100)
 105     case TaskFunctions.factorial:
 106       return factorial(data.n || 100)
 107     default:
 108       throw new Error('Unknown worker function')
 109   }
 110 }
 111
 112 module.exports = {
 113   executeTaskFunction,
 114   factorial,
 115   fibonacci,
 116   jsonIntegerSerialization,
 117   sleep,
 118   sleepTaskFunction,
 119   waitPoolEvents,
 120   waitWorkerEvents
 121 }