tests/utils.test.mjs

   1 import { expect } from 'expect'
   2 import { randomInt } from 'node:crypto'
   3 import os from 'node:os'
   4
   5 import { KillBehaviors } from '../lib/index.cjs'
   6 import {
   7   availableParallelism,
   8   average,
   9   DEFAULT_TASK_NAME,
  10   EMPTY_FUNCTION,
  11   exponentialDelay,
  12   isAsyncFunction,
  13   isKillBehavior,
  14   isPlainObject,
  15   max,
  16   median,
  17   min,
  18   // once,
  19   round,
  20   secureRandom,
  21   sleep,
  22 } from '../lib/utils.cjs'
  23
  24 describe('Utils test suite', () => {
  25   it('Verify DEFAULT_TASK_NAME value', () => {
  26     expect(DEFAULT_TASK_NAME).toBe('default')
  27   })
  28
  29   it('Verify EMPTY_FUNCTION value', () => {
  30     expect(EMPTY_FUNCTION).toStrictEqual(expect.any(Function))
  31   })
  32
  33   it('Verify availableParallelism() behavior', () => {
  34     const parallelism = availableParallelism()
  35     expect(typeof parallelism === 'number').toBe(true)
  36     expect(Number.isSafeInteger(parallelism)).toBe(true)
  37     let expectedParallelism = 1
  38     try {
  39       // eslint-disable-next-line n/no-unsupported-features/node-builtins
  40       expectedParallelism = os.availableParallelism()
  41     } catch {
  42       expectedParallelism = os.cpus().length
  43     }
  44     expect(parallelism).toBe(expectedParallelism)
  45   })
  46
  47   it('Verify sleep() behavior', async () => {
  48     const start = performance.now()
  49     const sleepMs = 1000
  50     await sleep(sleepMs)
  51     const elapsed = performance.now() - start
  52     expect(elapsed).toBeGreaterThanOrEqual(sleepMs - 1)
  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(/[a-z]/i)).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(16))).toBe(false)
 173     expect(isAsyncFunction(new SharedArrayBuffer(16))).toBe(false)
 174     expect(isAsyncFunction(new DataView(new ArrayBuffer(16)))).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     class TestClass {
 184       testArrowAsync = async () => {}
 185       testArrowSync = () => {}
 186       static async testStaticAsync () {}
 187       static testStaticSync () {}
 188       async testAsync () {}
 189       testSync () {}
 190     }
 191     const testClass = new TestClass()
 192     expect(isAsyncFunction(testClass.testSync)).toBe(false)
 193     expect(isAsyncFunction(testClass.testAsync)).toBe(true)
 194     expect(isAsyncFunction(testClass.testArrowSync)).toBe(false)
 195     expect(isAsyncFunction(testClass.testArrowAsync)).toBe(true)
 196     expect(isAsyncFunction(TestClass.testStaticSync)).toBe(false)
 197     expect(isAsyncFunction(TestClass.testStaticAsync)).toBe(true)
 198   })
 199
 200   it('Verify secureRandom() behavior', () => {
 201     const randomNumber = secureRandom()
 202     expect(typeof randomNumber === 'number').toBe(true)
 203     expect(randomNumber).toBeGreaterThanOrEqual(0)
 204     expect(randomNumber).toBeLessThan(1)
 205   })
 206
 207   it('Verify min() behavior', () => {
 208     expect(min()).toBe(Number.POSITIVE_INFINITY)
 209     expect(min(1, 2)).toBe(1)
 210     expect(min(2, 1)).toBe(1)
 211     expect(min(1, 1)).toBe(1)
 212   })
 213
 214   it('Verify max() behavior', () => {
 215     expect(max()).toBe(Number.NEGATIVE_INFINITY)
 216     expect(max(1, 2)).toBe(2)
 217     expect(max(2, 1)).toBe(2)
 218     expect(max(1, 1)).toBe(1)
 219   })
 220
 221   // it('Verify once() behavior', () => {
 222   //   let called = 0
 223   //   const fn = () => ++called
 224   //   const onceFn = once(fn, this)
 225   //   const result1 = onceFn()
 226   //   expect(called).toBe(1)
 227   //   expect(result1).toBe(1)
 228   //   const result2 = onceFn()
 229   //   expect(called).toBe(1)
 230   //   expect(result2).toBe(1)
 231   //   const result3 = onceFn()
 232   //   expect(called).toBe(1)
 233   //   expect(result3).toBe(1)
 234   // })
 235 })