tests/worker/abstract-worker.test.mjs

   1 import { expect } from 'expect'
   2 import { restore, stub } from 'sinon'
   3 import { ClusterWorker, KillBehaviors, ThreadWorker } from '../../lib/index.js'
   4 import { DEFAULT_TASK_NAME, EMPTY_FUNCTION } from '../../lib/utils.js'
   5
   6 describe('Abstract worker test suite', () => {
   7   class StubWorkerWithMainWorker extends ThreadWorker {
   8     constructor (fn, opts) {
   9       super(fn, opts)
  10       delete this.mainWorker
  11     }
  12   }
  13
  14   afterEach(() => {
  15     restore()
  16   })
  17
  18   it('Verify worker options default values', () => {
  19     const worker = new ThreadWorker(() => {})
  20     expect(worker.opts).toStrictEqual({
  21       killBehavior: KillBehaviors.SOFT,
  22       maxInactiveTime: 60000,
  23       killHandler: EMPTY_FUNCTION
  24     })
  25   })
  26
  27   it('Verify that worker options are checked at worker creation', () => {
  28     expect(() => new ClusterWorker(() => {}, '')).toThrowError(
  29       new TypeError('opts worker options parameter is not a plain object')
  30     )
  31     expect(
  32       () => new ClusterWorker(() => {}, { killBehavior: '' })
  33     ).toThrowError(new TypeError("killBehavior option '' is not valid"))
  34     expect(() => new ClusterWorker(() => {}, { killBehavior: 0 })).toThrowError(
  35       new TypeError("killBehavior option '0' is not valid")
  36     )
  37     expect(
  38       () => new ThreadWorker(() => {}, { maxInactiveTime: '' })
  39     ).toThrowError(new TypeError('maxInactiveTime option is not an integer'))
  40     expect(
  41       () => new ThreadWorker(() => {}, { maxInactiveTime: 0.5 })
  42     ).toThrowError(new TypeError('maxInactiveTime option is not an integer'))
  43     expect(
  44       () => new ThreadWorker(() => {}, { maxInactiveTime: 0 })
  45     ).toThrowError(
  46       new TypeError(
  47         'maxInactiveTime option is not a positive integer greater or equal than 5'
  48       )
  49     )
  50     expect(
  51       () => new ThreadWorker(() => {}, { maxInactiveTime: 4 })
  52     ).toThrowError(
  53       new TypeError(
  54         'maxInactiveTime option is not a positive integer greater or equal than 5'
  55       )
  56     )
  57     expect(() => new ThreadWorker(() => {}, { killHandler: '' })).toThrowError(
  58       new TypeError('killHandler option is not a function')
  59     )
  60     expect(() => new ThreadWorker(() => {}, { killHandler: 0 })).toThrowError(
  61       new TypeError('killHandler option is not a function')
  62     )
  63     expect(() => new ThreadWorker(() => {}, { async: true })).toThrowError(
  64       new TypeError('async option is deprecated')
  65     )
  66   })
  67
  68   it('Verify that worker options are set at worker creation', () => {
  69     const killHandler = () => {
  70       console.info('Worker received kill message')
  71     }
  72     const worker = new ClusterWorker(() => {}, {
  73       killBehavior: KillBehaviors.HARD,
  74       maxInactiveTime: 6000,
  75       killHandler
  76     })
  77     expect(worker.opts).toStrictEqual({
  78       killBehavior: KillBehaviors.HARD,
  79       maxInactiveTime: 6000,
  80       killHandler
  81     })
  82   })
  83
  84   it('Verify that taskFunctions parameter is mandatory', () => {
  85     expect(() => new ClusterWorker()).toThrowError(
  86       new Error('taskFunctions parameter is mandatory')
  87     )
  88   })
  89
  90   it('Verify that taskFunctions parameter is a function or a plain object', () => {
  91     expect(() => new ClusterWorker(0)).toThrowError(
  92       new TypeError(
  93         'taskFunctions parameter is not a function or a plain object'
  94       )
  95     )
  96     expect(() => new ClusterWorker('')).toThrowError(
  97       new TypeError(
  98         'taskFunctions parameter is not a function or a plain object'
  99       )
 100     )
 101     expect(() => new ClusterWorker(true)).toThrowError(
 102       new TypeError(
 103         'taskFunctions parameter is not a function or a plain object'
 104       )
 105     )
 106     expect(() => new ClusterWorker([])).toThrowError(
 107       new TypeError(
 108         'taskFunctions parameter is not a function or a plain object'
 109       )
 110     )
 111     expect(() => new ClusterWorker(new Map())).toThrowError(
 112       new TypeError(
 113         'taskFunctions parameter is not a function or a plain object'
 114       )
 115     )
 116     expect(() => new ClusterWorker(new Set())).toThrowError(
 117       new TypeError(
 118         'taskFunctions parameter is not a function or a plain object'
 119       )
 120     )
 121     expect(() => new ClusterWorker(new WeakMap())).toThrowError(
 122       new TypeError(
 123         'taskFunctions parameter is not a function or a plain object'
 124       )
 125     )
 126     expect(() => new ClusterWorker(new WeakSet())).toThrowError(
 127       new TypeError(
 128         'taskFunctions parameter is not a function or a plain object'
 129       )
 130     )
 131   })
 132
 133   it('Verify that taskFunctions parameter is not an empty object', () => {
 134     expect(() => new ClusterWorker({})).toThrowError(
 135       new Error('taskFunctions parameter object is empty')
 136     )
 137   })
 138
 139   it('Verify that taskFunctions parameter with unique function is taken', () => {
 140     const worker = new ThreadWorker(() => {})
 141     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 142     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 143     expect(worker.taskFunctions.size).toBe(2)
 144     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 145       worker.taskFunctions.get('fn1')
 146     )
 147   })
 148
 149   it('Verify that taskFunctions parameter with multiple task functions is checked', () => {
 150     const fn1 = () => {
 151       return 1
 152     }
 153     const fn2 = ''
 154     expect(() => new ThreadWorker({ '': fn1 })).toThrowError(
 155       new TypeError('A taskFunctions parameter object key is an empty string')
 156     )
 157     expect(() => new ThreadWorker({ fn1, fn2 })).toThrowError(
 158       new TypeError('A taskFunctions parameter object value is not a function')
 159     )
 160   })
 161
 162   it('Verify that taskFunctions parameter with multiple task functions is taken', () => {
 163     const fn1 = () => {
 164       return 1
 165     }
 166     const fn2 = () => {
 167       return 2
 168     }
 169     const worker = new ClusterWorker({ fn1, fn2 })
 170     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 171     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 172     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 173     expect(worker.taskFunctions.size).toBe(3)
 174     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 175       worker.taskFunctions.get('fn1')
 176     )
 177   })
 178
 179   it('Verify that sync kill handler is called when worker is killed', () => {
 180     const worker = new ClusterWorker(() => {}, {
 181       killHandler: stub().returns()
 182     })
 183     worker.isMain = false
 184     worker.getMainWorker = stub().returns({
 185       id: 1,
 186       send: stub().returns()
 187     })
 188     worker.handleKillMessage()
 189     expect(worker.getMainWorker().send.calledOnce).toBe(true)
 190     expect(worker.opts.killHandler.calledOnce).toBe(true)
 191   })
 192
 193   it('Verify that async kill handler is called when worker is killed', () => {
 194     const killHandlerStub = stub().returns()
 195     const worker = new ClusterWorker(() => {}, {
 196       killHandler: async () => Promise.resolve(killHandlerStub())
 197     })
 198     worker.isMain = false
 199     worker.handleKillMessage()
 200     expect(killHandlerStub.calledOnce).toBe(true)
 201   })
 202
 203   it('Verify that getMainWorker() throw error if main worker is not set', () => {
 204     expect(() =>
 205       new StubWorkerWithMainWorker(() => {}).getMainWorker()
 206     ).toThrowError('Main worker not set')
 207   })
 208
 209   it('Verify that hasTaskFunction() is working', () => {
 210     const fn1 = () => {
 211       return 1
 212     }
 213     const fn2 = () => {
 214       return 2
 215     }
 216     const worker = new ClusterWorker({ fn1, fn2 })
 217     expect(worker.hasTaskFunction(0)).toStrictEqual({
 218       status: false,
 219       error: new TypeError('name parameter is not a string')
 220     })
 221     expect(worker.hasTaskFunction('')).toStrictEqual({
 222       status: false,
 223       error: new TypeError('name parameter is an empty string')
 224     })
 225     expect(worker.hasTaskFunction(DEFAULT_TASK_NAME)).toStrictEqual({
 226       status: true
 227     })
 228     expect(worker.hasTaskFunction('fn1')).toStrictEqual({ status: true })
 229     expect(worker.hasTaskFunction('fn2')).toStrictEqual({ status: true })
 230     expect(worker.hasTaskFunction('fn3')).toStrictEqual({ status: false })
 231   })
 232
 233   it('Verify that addTaskFunction() is working', () => {
 234     const fn1 = () => {
 235       return 1
 236     }
 237     const fn2 = () => {
 238       return 2
 239     }
 240     const fn1Replacement = () => {
 241       return 3
 242     }
 243     const worker = new ThreadWorker(fn1)
 244     expect(worker.addTaskFunction(0, fn1)).toStrictEqual({
 245       status: false,
 246       error: new TypeError('name parameter is not a string')
 247     })
 248     expect(worker.addTaskFunction('', fn1)).toStrictEqual({
 249       status: false,
 250       error: new TypeError('name parameter is an empty string')
 251     })
 252     expect(worker.addTaskFunction('fn3', '')).toStrictEqual({
 253       status: false,
 254       error: new TypeError('fn parameter is not a function')
 255     })
 256     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 257     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 258     expect(worker.taskFunctions.size).toBe(2)
 259     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 260       worker.taskFunctions.get('fn1')
 261     )
 262     expect(worker.addTaskFunction(DEFAULT_TASK_NAME, fn2)).toStrictEqual({
 263       status: false,
 264       error: new Error(
 265         'Cannot add a task function with the default reserved name'
 266       )
 267     })
 268     worker.addTaskFunction('fn2', fn2)
 269     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 270     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 271     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 272     expect(worker.taskFunctions.size).toBe(3)
 273     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 274       worker.taskFunctions.get('fn1')
 275     )
 276     worker.addTaskFunction('fn1', fn1Replacement)
 277     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 278     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 279     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 280     expect(worker.taskFunctions.size).toBe(3)
 281     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 282       worker.taskFunctions.get('fn1')
 283     )
 284   })
 285
 286   it('Verify that removeTaskFunction() is working', () => {
 287     const fn1 = () => {
 288       return 1
 289     }
 290     const fn2 = () => {
 291       return 2
 292     }
 293     const worker = new ClusterWorker({ fn1, fn2 })
 294     expect(worker.removeTaskFunction(0, fn1)).toStrictEqual({
 295       status: false,
 296       error: new TypeError('name parameter is not a string')
 297     })
 298     expect(worker.removeTaskFunction('', fn1)).toStrictEqual({
 299       status: false,
 300       error: new TypeError('name parameter is an empty string')
 301     })
 302     worker.getMainWorker = stub().returns({
 303       id: 1,
 304       send: stub().returns()
 305     })
 306     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 307     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 308     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 309     expect(worker.taskFunctions.size).toBe(3)
 310     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 311       worker.taskFunctions.get('fn1')
 312     )
 313     expect(worker.removeTaskFunction(DEFAULT_TASK_NAME)).toStrictEqual({
 314       status: false,
 315       error: new Error(
 316         'Cannot remove the task function with the default reserved name'
 317       )
 318     })
 319     expect(worker.removeTaskFunction('fn1')).toStrictEqual({
 320       status: false,
 321       error: new Error(
 322         'Cannot remove the task function used as the default task function'
 323       )
 324     })
 325     worker.removeTaskFunction('fn2')
 326     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 327     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 328     expect(worker.taskFunctions.get('fn2')).toBeUndefined()
 329     expect(worker.taskFunctions.size).toBe(2)
 330     expect(worker.getMainWorker().send.calledOnce).toBe(true)
 331   })
 332
 333   it('Verify that listTaskFunctionNames() is working', () => {
 334     const fn1 = () => {
 335       return 1
 336     }
 337     const fn2 = () => {
 338       return 2
 339     }
 340     const worker = new ClusterWorker({ fn1, fn2 })
 341     expect(worker.listTaskFunctionNames()).toStrictEqual([
 342       DEFAULT_TASK_NAME,
 343       'fn1',
 344       'fn2'
 345     ])
 346   })
 347
 348   it('Verify that setDefaultTaskFunction() is working', () => {
 349     const fn1 = () => {
 350       return 1
 351     }
 352     const fn2 = () => {
 353       return 2
 354     }
 355     const worker = new ThreadWorker({ fn1, fn2 })
 356     expect(worker.setDefaultTaskFunction(0, fn1)).toStrictEqual({
 357       status: false,
 358       error: new TypeError('name parameter is not a string')
 359     })
 360     expect(worker.setDefaultTaskFunction('', fn1)).toStrictEqual({
 361       status: false,
 362       error: new TypeError('name parameter is an empty string')
 363     })
 364     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 365     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 366     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 367     expect(worker.taskFunctions.size).toBe(3)
 368     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 369       worker.taskFunctions.get('fn1')
 370     )
 371     expect(worker.setDefaultTaskFunction(DEFAULT_TASK_NAME)).toStrictEqual({
 372       status: false,
 373       error: new Error(
 374         'Cannot set the default task function reserved name as the default task function'
 375       )
 376     })
 377     expect(worker.setDefaultTaskFunction('fn3')).toStrictEqual({
 378       status: false,
 379       error: new Error(
 380         'Cannot set the default task function to a non-existing task function'
 381       )
 382     })
 383     worker.setDefaultTaskFunction('fn1')
 384     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 385       worker.taskFunctions.get('fn1')
 386     )
 387     worker.setDefaultTaskFunction('fn2')
 388     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 389       worker.taskFunctions.get('fn2')
 390     )
 391   })
 392 })