utils.test.js

   1 const { randomInt } = require('crypto')
   2 const { Worker } = require('worker_threads')
   3 const cluster = require('cluster')
   4 const { expect } = require('expect')
   5 const {
   6   CircularArray,
   7   DEFAULT_CIRCULAR_ARRAY_SIZE
   8 } = require('../lib/circular-array')
   9 const {
  10   availableParallelism,
  11   average,
  12   exponentialDelay,
  13   getWorkerType,
  14   getWorkerId,
  15   isAsyncFunction,
  16   isKillBehavior,
  17   isPlainObject,
  18   median,
  19   round,
  20   secureRandom,
  21   sleep,
  22   updateMeasurementStatistics
  23 } = require('../lib/utils')
  24 const { KillBehaviors, WorkerTypes } = require('../lib')
  25
  26 describe('Utils test suite', () => {
  27   it('Verify availableParallelism() behavior', () => {
  28     const parallelism = availableParallelism()
  29     expect(typeof parallelism === 'number').toBe(true)
  30     expect(parallelism).toBeGreaterThan(0)
  31     expect(Number.isSafeInteger(parallelism)).toBe(true)
  32   })
  33
  34   it('Verify getWorkerType() behavior', () => {
  35     expect(
  36       getWorkerType(new Worker('./tests/worker-files/thread/testWorker.js'))
  37     ).toBe(WorkerTypes.thread)
  38     expect(getWorkerType(cluster.fork())).toBe(WorkerTypes.cluster)
  39   })
  40
  41   it('Verify getWorkerId() behavior', () => {
  42     const threadWorker = new Worker('./tests/worker-files/thread/testWorker.js')
  43     const clusterWorker = cluster.fork()
  44     expect(getWorkerId(threadWorker)).toBe(threadWorker.threadId)
  45     expect(getWorkerId(clusterWorker)).toBe(clusterWorker.id)
  46   })
  47
  48   it.skip('Verify sleep() behavior', async () => {
  49     const start = performance.now()
  50     await sleep(1000)
  51     const elapsed = performance.now() - start
  52     expect(elapsed).toBeGreaterThanOrEqual(1000)
  53   })
  54
  55   it('Verify exponentialDelay() behavior', () => {
  56     const delay = exponentialDelay(randomInt(1000))
  57     expect(typeof delay === 'number').toBe(true)
  58     expect(delay).toBeGreaterThanOrEqual(Number.MIN_VALUE)
  59     expect(delay).toBeLessThanOrEqual(Number.MAX_VALUE)
  60   })
  61
  62   it('Verify average() computation', () => {
  63     expect(average([])).toBe(0)
  64     expect(average([0.08])).toBe(0.08)
  65     expect(average([0.25, 4.75, 3.05, 6.04, 1.01, 2.02, 5.03])).toBe(
  66       3.1642857142857146
  67     )
  68     expect(average([0.25, 4.75, 3.05, 6.04, 1.01, 2.02])).toBe(
  69       2.8533333333333335
  70     )
  71   })
  72
  73   it('Verify median() computation', () => {
  74     expect(median([])).toBe(0)
  75     expect(median([0.08])).toBe(0.08)
  76     expect(median([0.25, 4.75, 3.05, 6.04, 1.01, 2.02, 5.03])).toBe(3.05)
  77     expect(median([0.25, 4.75, 3.05, 6.04, 1.01, 2.02])).toBe(2.535)
  78   })
  79
  80   it('Verify round() behavior', () => {
  81     expect(round(0)).toBe(0)
  82     expect(round(0.5, 0)).toBe(1)
  83     expect(round(0.5)).toBe(0.5)
  84     expect(round(-0.5, 0)).toBe(-1)
  85     expect(round(-0.5)).toBe(-0.5)
  86     expect(round(1.005)).toBe(1.01)
  87     expect(round(2.175)).toBe(2.18)
  88     expect(round(5.015)).toBe(5.02)
  89     expect(round(-1.005)).toBe(-1.01)
  90     expect(round(-2.175)).toBe(-2.18)
  91     expect(round(-5.015)).toBe(-5.02)
  92   })
  93
  94   it('Verify isPlainObject() behavior', () => {
  95     expect(isPlainObject(null)).toBe(false)
  96     expect(isPlainObject(undefined)).toBe(false)
  97     expect(isPlainObject(true)).toBe(false)
  98     expect(isPlainObject(false)).toBe(false)
  99     expect(isPlainObject(0)).toBe(false)
 100     expect(isPlainObject('')).toBe(false)
 101     expect(isPlainObject([])).toBe(false)
 102     expect(isPlainObject(() => {})).toBe(false)
 103     expect(isPlainObject(new Date())).toBe(false)
 104     expect(isPlainObject(new RegExp())).toBe(false)
 105     expect(isPlainObject(new Error())).toBe(false)
 106     expect(isPlainObject(new Map())).toBe(false)
 107     expect(isPlainObject(new Set())).toBe(false)
 108     expect(isPlainObject(new WeakMap())).toBe(false)
 109     expect(isPlainObject(new WeakSet())).toBe(false)
 110     expect(isPlainObject(new Int8Array())).toBe(false)
 111     expect(isPlainObject(new Uint8Array())).toBe(false)
 112     expect(isPlainObject(new Uint8ClampedArray())).toBe(false)
 113     expect(isPlainObject(new Int16Array())).toBe(false)
 114     expect(isPlainObject(new Uint16Array())).toBe(false)
 115     expect(isPlainObject(new Int32Array())).toBe(false)
 116     expect(isPlainObject(new Uint32Array())).toBe(false)
 117     expect(isPlainObject(new Float32Array())).toBe(false)
 118     expect(isPlainObject(new Float64Array())).toBe(false)
 119     expect(isPlainObject(new BigInt64Array())).toBe(false)
 120     expect(isPlainObject(new BigUint64Array())).toBe(false)
 121     expect(isPlainObject(new Promise(() => {}))).toBe(false)
 122     expect(isPlainObject(new WeakRef({}))).toBe(false)
 123     expect(isPlainObject(new FinalizationRegistry(() => {}))).toBe(false)
 124     expect(isPlainObject(new ArrayBuffer())).toBe(false)
 125     expect(isPlainObject(new SharedArrayBuffer())).toBe(false)
 126     expect(isPlainObject(new DataView(new ArrayBuffer()))).toBe(false)
 127     expect(isPlainObject({})).toBe(true)
 128     expect(isPlainObject({ a: 1 })).toBe(true)
 129   })
 130
 131   it('Verify isKillBehavior() behavior', () => {
 132     expect(isKillBehavior(KillBehaviors.SOFT, KillBehaviors.SOFT)).toBe(true)
 133     expect(isKillBehavior(KillBehaviors.SOFT, KillBehaviors.HARD)).toBe(false)
 134     expect(isKillBehavior(KillBehaviors.HARD, KillBehaviors.HARD)).toBe(true)
 135     expect(isKillBehavior(KillBehaviors.HARD, KillBehaviors.SOFT)).toBe(false)
 136     expect(isKillBehavior(KillBehaviors.SOFT)).toBe(false)
 137     expect(isKillBehavior(KillBehaviors.HARD)).toBe(false)
 138     expect(isKillBehavior(KillBehaviors.HARD, null)).toBe(false)
 139     expect(isKillBehavior(KillBehaviors.HARD, undefined)).toBe(false)
 140     expect(isKillBehavior(KillBehaviors.SOFT, 'unknown')).toBe(false)
 141   })
 142
 143   it('Verify isAsyncFunction() behavior', () => {
 144     expect(isAsyncFunction(null)).toBe(false)
 145     expect(isAsyncFunction(undefined)).toBe(false)
 146     expect(isAsyncFunction(true)).toBe(false)
 147     expect(isAsyncFunction(false)).toBe(false)
 148     expect(isAsyncFunction(0)).toBe(false)
 149     expect(isAsyncFunction('')).toBe(false)
 150     expect(isAsyncFunction([])).toBe(false)
 151     expect(isAsyncFunction(new Date())).toBe(false)
 152     expect(isAsyncFunction(new RegExp())).toBe(false)
 153     expect(isAsyncFunction(new Error())).toBe(false)
 154     expect(isAsyncFunction(new Map())).toBe(false)
 155     expect(isAsyncFunction(new Set())).toBe(false)
 156     expect(isAsyncFunction(new WeakMap())).toBe(false)
 157     expect(isAsyncFunction(new WeakSet())).toBe(false)
 158     expect(isAsyncFunction(new Int8Array())).toBe(false)
 159     expect(isAsyncFunction(new Uint8Array())).toBe(false)
 160     expect(isAsyncFunction(new Uint8ClampedArray())).toBe(false)
 161     expect(isAsyncFunction(new Int16Array())).toBe(false)
 162     expect(isAsyncFunction(new Uint16Array())).toBe(false)
 163     expect(isAsyncFunction(new Int32Array())).toBe(false)
 164     expect(isAsyncFunction(new Uint32Array())).toBe(false)
 165     expect(isAsyncFunction(new Float32Array())).toBe(false)
 166     expect(isAsyncFunction(new Float64Array())).toBe(false)
 167     expect(isAsyncFunction(new BigInt64Array())).toBe(false)
 168     expect(isAsyncFunction(new BigUint64Array())).toBe(false)
 169     expect(isAsyncFunction(new Promise(() => {}))).toBe(false)
 170     expect(isAsyncFunction(new WeakRef({}))).toBe(false)
 171     expect(isAsyncFunction(new FinalizationRegistry(() => {}))).toBe(false)
 172     expect(isAsyncFunction(new ArrayBuffer())).toBe(false)
 173     expect(isAsyncFunction(new SharedArrayBuffer())).toBe(false)
 174     expect(isAsyncFunction(new DataView(new ArrayBuffer()))).toBe(false)
 175     expect(isAsyncFunction({})).toBe(false)
 176     expect(isAsyncFunction({ a: 1 })).toBe(false)
 177     expect(isAsyncFunction(() => {})).toBe(false)
 178     expect(isAsyncFunction(function () {})).toBe(false)
 179     expect(isAsyncFunction(function named () {})).toBe(false)
 180     expect(isAsyncFunction(async () => {})).toBe(true)
 181     expect(isAsyncFunction(async function () {})).toBe(true)
 182     expect(isAsyncFunction(async function named () {})).toBe(true)
 183   })
 184
 185   it('Verify updateMeasurementStatistics() behavior', () => {
 186     const measurementStatistics = {
 187       history: new CircularArray()
 188     }
 189     updateMeasurementStatistics(
 190       measurementStatistics,
 191       { aggregate: true, average: false, median: false },
 192       0.01
 193     )
 194     expect(measurementStatistics).toStrictEqual({
 195       aggregate: 0.01,
 196       maximum: 0.01,
 197       minimum: 0.01,
 198       history: new CircularArray()
 199     })
 200     updateMeasurementStatistics(
 201       measurementStatistics,
 202       { aggregate: true, average: false, median: false },
 203       0.02
 204     )
 205     expect(measurementStatistics).toStrictEqual({
 206       aggregate: 0.03,
 207       maximum: 0.02,
 208       minimum: 0.01,
 209       history: new CircularArray()
 210     })
 211     updateMeasurementStatistics(
 212       measurementStatistics,
 213       { aggregate: true, average: true, median: false },
 214       0.001
 215     )
 216     expect(measurementStatistics).toStrictEqual({
 217       aggregate: 0.031,
 218       maximum: 0.02,
 219       minimum: 0.001,
 220       average: 0.001,
 221       history: new CircularArray(DEFAULT_CIRCULAR_ARRAY_SIZE, 0.001)
 222     })
 223     updateMeasurementStatistics(
 224       measurementStatistics,
 225       { aggregate: true, average: true, median: false },
 226       0.003
 227     )
 228     expect(measurementStatistics).toStrictEqual({
 229       aggregate: 0.034,
 230       maximum: 0.02,
 231       minimum: 0.001,
 232       average: 0.002,
 233       history: new CircularArray(DEFAULT_CIRCULAR_ARRAY_SIZE, 0.001, 0.003)
 234     })
 235     updateMeasurementStatistics(
 236       measurementStatistics,
 237       { aggregate: true, average: false, median: true },
 238       0.006
 239     )
 240     expect(measurementStatistics).toStrictEqual({
 241       aggregate: 0.04,
 242       maximum: 0.02,
 243       minimum: 0.001,
 244       median: 0.003,
 245       history: new CircularArray(
 246         DEFAULT_CIRCULAR_ARRAY_SIZE,
 247         0.001,
 248         0.003,
 249         0.006
 250       )
 251     })
 252     updateMeasurementStatistics(
 253       measurementStatistics,
 254       { aggregate: true, average: true, median: false },
 255       0.01
 256     )
 257     expect(measurementStatistics).toStrictEqual({
 258       aggregate: 0.05,
 259       maximum: 0.02,
 260       minimum: 0.001,
 261       average: 0.005,
 262       history: new CircularArray(
 263         DEFAULT_CIRCULAR_ARRAY_SIZE,
 264         0.001,
 265         0.003,
 266         0.006,
 267         0.01
 268       )
 269     })
 270   })
 271
 272   it('Verify secureRandom() behavior', () => {
 273     const randomNumber = secureRandom()
 274     expect(typeof randomNumber === 'number').toBe(true)
 275     expect(randomNumber).toBeGreaterThanOrEqual(0)
 276     expect(randomNumber).toBeLessThan(1)
 277   })
 278 })