tests/worker/abstract-worker.test.js

   1 const { expect } = require('expect')
   2 const sinon = require('sinon')
   3 const { ClusterWorker, KillBehaviors, ThreadWorker } = require('../../lib')
   4 const { EMPTY_FUNCTION } = require('../../lib/utils')
   5
   6 describe('Abstract worker test suite', () => {
   7   class StubWorkerWithMainWorker extends ThreadWorker {
   8     constructor (fn, opts) {
   9       super(fn, opts)
  10       this.mainWorker = undefined
  11     }
  12   }
  13
  14   it('Verify worker options default values', () => {
  15     const worker = new ThreadWorker(() => {})
  16     expect(worker.opts.maxInactiveTime).toStrictEqual(60000)
  17     expect(worker.opts.killBehavior).toBe(KillBehaviors.SOFT)
  18     expect(worker.opts.killHandler).toStrictEqual(EMPTY_FUNCTION)
  19     expect(worker.opts.async).toBe(undefined)
  20   })
  21
  22   it('Verify that worker options are set at worker creation', () => {
  23     const killHandler = () => {
  24       console.info('Worker received kill message')
  25     }
  26     const worker = new ClusterWorker(() => {}, {
  27       maxInactiveTime: 6000,
  28       killBehavior: KillBehaviors.HARD,
  29       killHandler,
  30       async: true
  31     })
  32     expect(worker.opts.maxInactiveTime).toStrictEqual(6000)
  33     expect(worker.opts.killBehavior).toBe(KillBehaviors.HARD)
  34     expect(worker.opts.killHandler).toStrictEqual(killHandler)
  35     expect(worker.opts.async).toBe(undefined)
  36   })
  37
  38   it('Verify that taskFunctions parameter is mandatory', () => {
  39     expect(() => new ClusterWorker()).toThrowError(
  40       'taskFunctions parameter is mandatory'
  41     )
  42   })
  43
  44   it('Verify that taskFunctions parameter is a function or a plain object', () => {
  45     expect(() => new ClusterWorker(0)).toThrowError(
  46       new TypeError(
  47         'taskFunctions parameter is not a function or a plain object'
  48       )
  49     )
  50     expect(() => new ClusterWorker('')).toThrowError(
  51       new TypeError(
  52         'taskFunctions parameter is not a function or a plain object'
  53       )
  54     )
  55     expect(() => new ClusterWorker(true)).toThrowError(
  56       new TypeError(
  57         'taskFunctions parameter is not a function or a plain object'
  58       )
  59     )
  60     expect(() => new ClusterWorker([])).toThrowError(
  61       new TypeError(
  62         'taskFunctions parameter is not a function or a plain object'
  63       )
  64     )
  65     expect(() => new ClusterWorker(new Map())).toThrowError(
  66       new TypeError(
  67         'taskFunctions parameter is not a function or a plain object'
  68       )
  69     )
  70     expect(() => new ClusterWorker(new Set())).toThrowError(
  71       new TypeError(
  72         'taskFunctions parameter is not a function or a plain object'
  73       )
  74     )
  75     expect(() => new ClusterWorker(new WeakMap())).toThrowError(
  76       new TypeError(
  77         'taskFunctions parameter is not a function or a plain object'
  78       )
  79     )
  80     expect(() => new ClusterWorker(new WeakSet())).toThrowError(
  81       new TypeError(
  82         'taskFunctions parameter is not a function or a plain object'
  83       )
  84     )
  85   })
  86
  87   it('Verify that taskFunctions parameter is not an empty object', () => {
  88     expect(() => new ClusterWorker({})).toThrowError(
  89       new Error('taskFunctions parameter object is empty')
  90     )
  91   })
  92
  93   it('Verify that taskFunctions parameter with unique function is taken', () => {
  94     const worker = new ThreadWorker(() => {})
  95     expect(worker.taskFunctions.get('default')).toBeInstanceOf(Function)
  96     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
  97     expect(worker.taskFunctions.size).toBe(2)
  98     expect(worker.taskFunctions.get('default')).toStrictEqual(
  99       worker.taskFunctions.get('fn1')
 100     )
 101   })
 102
 103   it('Verify that taskFunctions parameter with multiple task functions contains function', () => {
 104     const fn1 = () => {
 105       return 1
 106     }
 107     const fn2 = ''
 108     expect(() => new ThreadWorker({ fn1, fn2 })).toThrowError(
 109       new TypeError('A taskFunctions parameter object value is not a function')
 110     )
 111   })
 112
 113   it('Verify that taskFunctions parameter with multiple task functions is taken', () => {
 114     const fn1 = () => {
 115       return 1
 116     }
 117     const fn2 = () => {
 118       return 2
 119     }
 120     const worker = new ClusterWorker({ fn1, fn2 })
 121     expect(worker.taskFunctions.get('default')).toBeInstanceOf(Function)
 122     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 123     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 124     expect(worker.taskFunctions.size).toBe(3)
 125     expect(worker.taskFunctions.get('default')).toStrictEqual(
 126       worker.taskFunctions.get('fn1')
 127     )
 128   })
 129
 130   it('Verify that sync kill handler is called when worker is killed', () => {
 131     const worker = new ClusterWorker(() => {}, {
 132       killHandler: sinon.stub().returns()
 133     })
 134     worker.isMain = false
 135     worker.getMainWorker = sinon.stub().returns({
 136       id: 1,
 137       send: sinon.stub().returns()
 138     })
 139     worker.handleKillMessage()
 140     expect(worker.getMainWorker().send.calledOnce).toBe(true)
 141     expect(worker.opts.killHandler.calledOnce).toBe(true)
 142   })
 143
 144   it('Verify that async kill handler is called when worker is killed', () => {
 145     const killHandlerStub = sinon.stub().returns()
 146     const worker = new ClusterWorker(() => {}, {
 147       killHandler: async () => Promise.resolve(killHandlerStub())
 148     })
 149     worker.isMain = false
 150     worker.handleKillMessage()
 151     expect(killHandlerStub.calledOnce).toBe(true)
 152   })
 153
 154   it('Verify that handleError() method works properly', () => {
 155     const error = new Error('Error as an error')
 156     const worker = new ClusterWorker(() => {})
 157     expect(worker.handleError(error)).not.toBeInstanceOf(Error)
 158     expect(worker.handleError(error)).toStrictEqual(error.message)
 159     const errorMessage = 'Error as a string'
 160     expect(worker.handleError(errorMessage)).toStrictEqual(errorMessage)
 161   })
 162
 163   it('Verify that getMainWorker() throw error if main worker is not set', () => {
 164     expect(() =>
 165       new StubWorkerWithMainWorker(() => {}).getMainWorker()
 166     ).toThrowError('Main worker not set')
 167   })
 168
 169   it('Verify that hasTaskFunction() works', () => {
 170     const fn1 = () => {
 171       return 1
 172     }
 173     const fn2 = () => {
 174       return 2
 175     }
 176     const worker = new ClusterWorker({ fn1, fn2 })
 177     expect(worker.hasTaskFunction('default')).toBe(true)
 178     expect(worker.hasTaskFunction('fn1')).toBe(true)
 179     expect(worker.hasTaskFunction('fn2')).toBe(true)
 180     expect(worker.hasTaskFunction('fn3')).toBe(false)
 181   })
 182
 183   it('Verify that addTaskFunction() works', () => {
 184     const fn1 = () => {
 185       return 1
 186     }
 187     const fn2 = () => {
 188       return 2
 189     }
 190     const fn1Replacement = () => {
 191       return 3
 192     }
 193     const worker = new ThreadWorker(fn1)
 194     expect(worker.taskFunctions.get('default')).toBeInstanceOf(Function)
 195     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 196     expect(worker.taskFunctions.size).toBe(2)
 197     expect(worker.taskFunctions.get('default')).toStrictEqual(
 198       worker.taskFunctions.get('fn1')
 199     )
 200     expect(() => worker.addTaskFunction('default', fn2)).toThrowError(
 201       new Error('Cannot add a task function with the default reserved name')
 202     )
 203     worker.addTaskFunction('fn2', fn2)
 204     expect(worker.taskFunctions.get('default')).toBeInstanceOf(Function)
 205     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 206     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 207     expect(worker.taskFunctions.size).toBe(3)
 208     expect(worker.taskFunctions.get('default')).toStrictEqual(
 209       worker.taskFunctions.get('fn1')
 210     )
 211     worker.addTaskFunction('fn1', fn1Replacement)
 212     expect(worker.taskFunctions.get('default')).toBeInstanceOf(Function)
 213     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 214     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 215     expect(worker.taskFunctions.size).toBe(3)
 216     expect(worker.taskFunctions.get('default')).toStrictEqual(
 217       worker.taskFunctions.get('fn1')
 218     )
 219   })
 220
 221   it('Verify that removeTaskFunction() works', () => {
 222     const fn1 = () => {
 223       return 1
 224     }
 225     const fn2 = () => {
 226       return 2
 227     }
 228     const worker = new ClusterWorker({ fn1, fn2 })
 229     expect(worker.taskFunctions.get('default')).toBeInstanceOf(Function)
 230     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 231     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 232     expect(worker.taskFunctions.size).toBe(3)
 233     expect(worker.taskFunctions.get('default')).toStrictEqual(
 234       worker.taskFunctions.get('fn1')
 235     )
 236     expect(() => worker.removeTaskFunction('default')).toThrowError(
 237       new Error(
 238         'Cannot remove the task function with the default reserved name'
 239       )
 240     )
 241     expect(() => worker.removeTaskFunction('fn1')).toThrowError(
 242       new Error(
 243         'Cannot remove the task function used as the default task function'
 244       )
 245     )
 246     worker.removeTaskFunction('fn2')
 247     expect(worker.taskFunctions.get('default')).toBeInstanceOf(Function)
 248     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 249     expect(worker.taskFunctions.get('fn2')).toBeUndefined()
 250     expect(worker.taskFunctions.size).toBe(2)
 251   })
 252
 253   it('Verify that listTaskFunctions() works', () => {
 254     const fn1 = () => {
 255       return 1
 256     }
 257     const fn2 = () => {
 258       return 2
 259     }
 260     const worker = new ClusterWorker({ fn1, fn2 })
 261     expect(worker.listTaskFunctions()).toStrictEqual(['default', 'fn1', 'fn2'])
 262   })
 263
 264   it('Verify that setDefaultTaskFunction() works', () => {
 265     const fn1 = () => {
 266       return 1
 267     }
 268     const fn2 = () => {
 269       return 2
 270     }
 271     const worker = new ThreadWorker({ fn1, fn2 })
 272     expect(worker.taskFunctions.get('default')).toBeInstanceOf(Function)
 273     expect(worker.taskFunctions.get('fn1')).toBeInstanceOf(Function)
 274     expect(worker.taskFunctions.get('fn2')).toBeInstanceOf(Function)
 275     expect(worker.taskFunctions.size).toBe(3)
 276     expect(worker.taskFunctions.get('default')).toStrictEqual(
 277       worker.taskFunctions.get('fn1')
 278     )
 279     expect(() => worker.setDefaultTaskFunction('default')).toThrowError(
 280       new Error(
 281         'Cannot set the default task function reserved name as the default task function'
 282       )
 283     )
 284     worker.setDefaultTaskFunction('fn1')
 285     expect(worker.taskFunctions.get('default')).toStrictEqual(
 286       worker.taskFunctions.get('fn1')
 287     )
 288     worker.setDefaultTaskFunction('fn2')
 289     expect(worker.taskFunctions.get('default')).toStrictEqual(
 290       worker.taskFunctions.get('fn2')
 291     )
 292   })
 293 })