tests/pools/thread/dynamic.test.js

   1 const expect = require('expect')
   2 const { DynamicThreadPool } = require('../../../lib/index')
   3 const min = 1
   4 const max = 3
   5 const pool = new DynamicThreadPool(
   6   min,
   7   max,
   8   './tests/worker/thread/testWorker.js',
   9   {
  10     errorHandler: e => console.error(e),
  11     onlineHandler: () => console.log('worker is online')
  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 closedThreads = 0
  25     let fullPool = 0
  26     pool.emitter.on('FullPool', () => fullPool++)
  27     for (let i = 0; i < max * 2; i++) {
  28       promises.push(pool.execute({ test: 'test' }))
  29     }
  30     expect(pool.workers.length).toBe(max)
  31     pool.workers.forEach(w => {
  32       w.on('exit', () => {
  33         closedThreads++
  34       })
  35     })
  36     expect(fullPool > 1).toBeTruthy()
  37     await new Promise(resolve => setTimeout(resolve, 2000))
  38     expect(closedThreads).toBe(max - min)
  39   })
  40
  41   it('Verify scale thread up and down is working', async () => {
  42     expect(pool.workers.length).toBe(min)
  43     for (let i = 0; i < max * 10; i++) {
  44       pool.execute({ test: 'test' })
  45     }
  46     expect(pool.workers.length).toBe(max)
  47     await new Promise(resolve => setTimeout(resolve, 1000))
  48     expect(pool.workers.length).toBe(min)
  49     for (let i = 0; i < max * 10; i++) {
  50       pool.execute({ test: 'test' })
  51     }
  52     expect(pool.workers.length).toBe(max)
  53     await new Promise(resolve => setTimeout(resolve, 1000))
  54     expect(pool.workers.length).toBe(min)
  55   })
  56
  57   it('Shutdown test', async () => {
  58     let closedThreads = 0
  59     pool.workers.forEach(w => {
  60       w.on('exit', () => {
  61         closedThreads++
  62       })
  63     })
  64     await pool.destroy()
  65     expect(closedThreads).toBe(min)
  66   })
  67
  68   it('Validations test', () => {
  69     let error
  70     try {
  71       const pool1 = new DynamicThreadPool()
  72       console.log(pool1)
  73     } catch (e) {
  74       error = e
  75     }
  76     expect(error).toBeTruthy()
  77     expect(error.message).toBeTruthy()
  78   })
  79
  80   it('Should work even without opts in input', async () => {
  81     const pool1 = new DynamicThreadPool(
  82       1,
  83       1,
  84       './tests/worker/thread/testWorker.js'
  85     )
  86     const res = await pool1.execute({ test: 'test' })
  87     expect(res).toBeFalsy()
  88   })
  89
  90   it('Verify scale thread up and down is working when long running task is used', async () => {
  91     const longRunningPool = new DynamicThreadPool(
  92       min,
  93       max,
  94       './tests/worker/thread/longRunningWorker.js',
  95       {
  96         errorHandler: e => console.error(e),
  97         onlineHandler: () => console.log('worker is online')
  98       }
  99     )
 100     expect(longRunningPool.workers.length).toBe(min)
 101     for (let i = 0; i < max * 10; i++) {
 102       longRunningPool.execute({ test: 'test' })
 103     }
 104     expect(longRunningPool.workers.length).toBe(max)
 105     await new Promise(resolve => setTimeout(resolve, 1000))
 106     // Here we expect the workers to be at the max size since that the task is still running
 107     expect(longRunningPool.workers.length).toBe(max)
 108   })
 109 })