tests/pools/thread/dynamic.test.js

   1 const expect = require('expect')
   2 const { DynamicThreadPool } = require('../../../lib/index')
   3 const TestUtils = require('../../test-utils')
   4 const min = 1
   5 const max = 3
   6 const pool = new DynamicThreadPool(
   7   min,
   8   max,
   9   './tests/worker-files/thread/testWorker.js',
  10   {
  11     errorHandler: e => console.error(e)
  12   }
  13 )
  14
  15 describe('Dynamic thread pool test suite', () => {
  16   it('Verify that the function is executed in a worker thread', async () => {
  17     const result = await pool.execute({ test: 'test' })
  18     expect(result).toBeDefined()
  19     expect(result).toBeFalsy()
  20   })
  21
  22   it('Verify that new workers are created when required, max size is not exceeded and that after a while new workers will die', async () => {
  23     const promises = []
  24     let poolBusy = 0
  25     pool.emitter.on('busy', () => poolBusy++)
  26     for (let i = 0; i < max * 2; i++) {
  27       promises.push(pool.execute({ test: 'test' }))
  28     }
  29     expect(pool.workers.length).toBe(max)
  30     // The `busy` event is triggered when the number of submitted tasks at once reach the max number of workers in the dynamic pool.
  31     // So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the dynamic pool.
  32     expect(poolBusy).toBe(max + 1)
  33     const res = await TestUtils.waitExits(pool, max - min)
  34     expect(res).toBe(max - min)
  35   })
  36
  37   it('Verify scale thread up and down is working', async () => {
  38     expect(pool.workers.length).toBe(min)
  39     for (let i = 0; i < max * 10; i++) {
  40       pool.execute({ test: 'test' })
  41     }
  42     expect(pool.workers.length).toBe(max)
  43     await TestUtils.waitExits(pool, max - min)
  44     expect(pool.workers.length).toBe(min)
  45     for (let i = 0; i < max * 10; i++) {
  46       pool.execute({ test: 'test' })
  47     }
  48     expect(pool.workers.length).toBe(max)
  49     await TestUtils.waitExits(pool, max - min)
  50     expect(pool.workers.length).toBe(min)
  51   })
  52
  53   it('Shutdown test', async () => {
  54     let closedThreads = 0
  55     pool.workers.forEach(w => {
  56       w.on('exit', () => {
  57         closedThreads++
  58       })
  59     })
  60     await pool.destroy()
  61     expect(closedThreads).toBe(min)
  62   })
  63
  64   it('Validation of inputs test', () => {
  65     expect(() => new DynamicThreadPool(min)).toThrowError(
  66       new Error('Please specify a file with a worker implementation')
  67     )
  68   })
  69
  70   it('Should work even without opts in input', async () => {
  71     const pool1 = new DynamicThreadPool(
  72       1,
  73       1,
  74       './tests/worker-files/thread/testWorker.js'
  75     )
  76     const res = await pool1.execute({ test: 'test' })
  77     expect(res).toBeDefined()
  78     expect(res).toBeFalsy()
  79     // We need to clean up the resources after our test
  80     await pool1.destroy()
  81   })
  82
  83   it('Verify scale thread up and down is working when long running task is used:hard', async () => {
  84     const longRunningPool = new DynamicThreadPool(
  85       min,
  86       max,
  87       './tests/worker-files/thread/longRunningWorkerHardBehavior.js',
  88       {
  89         errorHandler: e => console.error(e),
  90         onlineHandler: () => console.log('long running worker is online'),
  91         exitHandler: () => console.log('long running worker exited')
  92       }
  93     )
  94     expect(longRunningPool.workers.length).toBe(min)
  95     for (let i = 0; i < max * 10; i++) {
  96       longRunningPool.execute({ test: 'test' })
  97     }
  98     expect(longRunningPool.workers.length).toBe(max)
  99     await TestUtils.waitExits(longRunningPool, max - min)
 100     expect(longRunningPool.workers.length).toBe(min)
 101     // We need to clean up the resources after our test
 102     await longRunningPool.destroy()
 103   })
 104
 105   it('Verify scale thread up and down is working when long running task is used:soft', async () => {
 106     const longRunningPool = new DynamicThreadPool(
 107       min,
 108       max,
 109       './tests/worker-files/thread/longRunningWorkerSoftBehavior.js',
 110       {
 111         errorHandler: e => console.error(e),
 112         onlineHandler: () => console.log('long running worker is online'),
 113         exitHandler: () => console.log('long running worker exited')
 114       }
 115     )
 116     expect(longRunningPool.workers.length).toBe(min)
 117     for (let i = 0; i < max * 10; i++) {
 118       longRunningPool.execute({ test: 'test' })
 119     }
 120     expect(longRunningPool.workers.length).toBe(max)
 121     await TestUtils.sleep(1500)
 122     // Here we expect the workers to be at the max size since that the task is still running
 123     expect(longRunningPool.workers.length).toBe(max)
 124     // We need to clean up the resources after our test
 125     await longRunningPool.destroy()
 126   })
 127
 128   it('Verify that a pool with zero worker can be instantiated', async () => {
 129     const pool = new DynamicThreadPool(
 130       0,
 131       max,
 132       './tests/worker-files/thread/testWorker.js'
 133     )
 134     expect(pool).toBeInstanceOf(DynamicThreadPool)
 135     // We need to clean up the resources after our test
 136     await pool.destroy()
 137   })
 138 })