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 async kill handler is called when worker is killed', () => {
 180     const killHandlerStub = stub().returns()
 181     const worker = new ClusterWorker(() => {}, {
 182       killHandler: async () => Promise.resolve(killHandlerStub())
 183     })
 184     worker.isMain = false
 185     worker.handleKillMessage()
 186     expect(killHandlerStub.calledOnce).toBe(true)
 187   })
 188
 189   it('Verify that getMainWorker() throw error if main worker is not set', () => {
 190     expect(() =>
 191       new StubWorkerWithMainWorker(() => {}).getMainWorker()
 192     ).toThrowError('Main worker not set')
 193   })
 194
 195   it('Verify that hasTaskFunction() is working', () => {
 196     const fn1 = () => {
 197       return 1
 198     }
 199     const fn2 = () => {
 200       return 2
 201     }
 202     const worker = new ClusterWorker({ fn1, fn2 })
 203     expect(worker.hasTaskFunction(0)).toStrictEqual({
 204       status: false,
 205       error: new TypeError('name parameter is not a string')
 206     })
 207     expect(worker.hasTaskFunction('')).toStrictEqual({
 208       status: false,
 209       error: new TypeError('name parameter is an empty string')
 210     })
 211     expect(worker.hasTaskFunction(DEFAULT_TASK_NAME)).toStrictEqual({
 212       status: true
 213     })
 214     expect(worker.hasTaskFunction('fn1')).toStrictEqual({ status: true })
 215     expect(worker.hasTaskFunction('fn2')).toStrictEqual({ status: true })
 216     expect(worker.hasTaskFunction('fn3')).toStrictEqual({ status: false })
 217   })
 218
 219   it('Verify that addTaskFunction() is working', () => {
 220     const fn1 = () => {
 221       return 1
 222     }
 223     const fn2 = () => {
 224       return 2
 225     }
 226     const fn1Replacement = () => {
 227       return 3
 228     }
 229     const worker = new ThreadWorker(fn1)
 230     expect(worker.addTaskFunction(0, fn1)).toStrictEqual({
 231       status: false,
 232       error: new TypeError('name parameter is not a string')
 233     })
 234     expect(worker.addTaskFunction('', fn1)).toStrictEqual({
 235       status: false,
 236       error: new TypeError('name parameter is an empty string')
 237     })
 238     expect(worker.addTaskFunction('fn3', '')).toStrictEqual({
 239       status: false,
 240       error: new TypeError('fn parameter is not a function')
 241     })
 242     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 243     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 244     expect(worker.taskFunctions.size).toBe(2)
 245     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 246       worker.taskFunctions.get('fn1')
 247     )
 248     expect(worker.addTaskFunction(DEFAULT_TASK_NAME, fn2)).toStrictEqual({
 249       status: false,
 250       error: new Error(
 251         'Cannot add a task function with the default reserved name'
 252       )
 253     })
 254     worker.addTaskFunction('fn2', fn2)
 255     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 256     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 257     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 258     expect(worker.taskFunctions.size).toBe(3)
 259     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 260       worker.taskFunctions.get('fn1')
 261     )
 262     worker.addTaskFunction('fn1', fn1Replacement)
 263     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 264     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 265     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 266     expect(worker.taskFunctions.size).toBe(3)
 267     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 268       worker.taskFunctions.get('fn1')
 269     )
 270   })
 271
 272   it('Verify that listTaskFunctionNames() is working', () => {
 273     const fn1 = () => {
 274       return 1
 275     }
 276     const fn2 = () => {
 277       return 2
 278     }
 279     const worker = new ClusterWorker({ fn1, fn2 })
 280     expect(worker.listTaskFunctionNames()).toStrictEqual([
 281       DEFAULT_TASK_NAME,
 282       'fn1',
 283       'fn2'
 284     ])
 285   })
 286
 287   it('Verify that setDefaultTaskFunction() is working', () => {
 288     const fn1 = () => {
 289       return 1
 290     }
 291     const fn2 = () => {
 292       return 2
 293     }
 294     const worker = new ThreadWorker({ fn1, fn2 })
 295     expect(worker.setDefaultTaskFunction(0, fn1)).toStrictEqual({
 296       status: false,
 297       error: new TypeError('name parameter is not a string')
 298     })
 299     expect(worker.setDefaultTaskFunction('', fn1)).toStrictEqual({
 300       status: false,
 301       error: new TypeError('name parameter is an empty string')
 302     })
 303     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toBeInstanceOf(Function)
 304     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 305     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 306     expect(worker.taskFunctions.size).toBe(3)
 307     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 308       worker.taskFunctions.get('fn1')
 309     )
 310     expect(worker.setDefaultTaskFunction(DEFAULT_TASK_NAME)).toStrictEqual({
 311       status: false,
 312       error: new Error(
 313         'Cannot set the default task function reserved name as the default task function'
 314       )
 315     })
 316     expect(worker.setDefaultTaskFunction('fn3')).toStrictEqual({
 317       status: false,
 318       error: new Error(
 319         'Cannot set the default task function to a non-existing task function'
 320       )
 321     })
 322     worker.setDefaultTaskFunction('fn1')
 323     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 324       worker.taskFunctions.get('fn1')
 325     )
 326     worker.setDefaultTaskFunction('fn2')
 327     expect(worker.taskFunctions.get(DEFAULT_TASK_NAME)).toStrictEqual(
 328       worker.taskFunctions.get('fn2')
 329     )
 330   })
 331 })