b6846cc4218c48b98ca7eb4d96ddb6e3d1ad957b
[poolifier.git] / tests / pools / abstract / abstract-pool.test.js
1 const expect = require('expect')
2 const {
3 FixedClusterPool,
4 FixedThreadPool,
5 WorkerChoiceStrategies
6 } = require('../../../lib/index')
7 const expectedError = new Error('Worker could not be found in tasks map')
8
9 const numberOfWorkers = 1
10
11 class StubPoolWithTasksMapClear extends FixedThreadPool {
12 removeAllWorker () {
13 this.tasks.clear()
14 }
15 }
16
17 class StubPoolWithIsMainMethod extends FixedThreadPool {
18 isMain () {
19 return false
20 }
21 }
22
23 describe('Abstract pool test suite', () => {
24 it('Simulate worker not found during increaseWorkersTask', () => {
25 const pool = new StubPoolWithTasksMapClear(
26 numberOfWorkers,
27 './tests/worker-files/thread/testWorker.js'
28 )
29 // Simulate worker not found.
30 pool.removeAllWorker()
31 expect(() => pool.increaseWorkersTask()).toThrowError(expectedError)
32 pool.destroy()
33 })
34
35 it('Simulate worker not found during decreaseWorkersTasks', () => {
36 const pool = new StubPoolWithTasksMapClear(
37 numberOfWorkers,
38 './tests/worker-files/thread/testWorker.js',
39 {
40 errorHandler: e => console.error(e)
41 }
42 )
43 // Simulate worker not found.
44 pool.removeAllWorker()
45 expect(() => pool.decreaseWorkersTasks()).toThrowError(expectedError)
46 pool.destroy()
47 })
48
49 it('Simulate pool creation from a non main thread/process', () => {
50 expect(
51 () =>
52 new StubPoolWithIsMainMethod(
53 numberOfWorkers,
54 './tests/worker-files/thread/testWorker.js',
55 {
56 errorHandler: e => console.error(e)
57 }
58 )
59 ).toThrowError(new Error('Cannot start a pool from a worker!'))
60 })
61
62 it('Verify that filePath is checked', () => {
63 const expectedError = new Error(
64 'Please specify a file with a worker implementation'
65 )
66 expect(() => new FixedThreadPool(numberOfWorkers)).toThrowError(
67 expectedError
68 )
69 expect(() => new FixedThreadPool(numberOfWorkers, '')).toThrowError(
70 expectedError
71 )
72 })
73
74 it('Verify that numberOfWorkers is checked', () => {
75 expect(() => new FixedThreadPool()).toThrowError(
76 new Error(
77 'Cannot instantiate a pool without specifying the number of workers'
78 )
79 )
80 })
81
82 it('Verify that a negative number of workers is checked', () => {
83 expect(
84 () =>
85 new FixedClusterPool(-1, './tests/worker-files/cluster/testWorker.js')
86 ).toThrowError(
87 new Error('Cannot instantiate a pool with a negative number of workers')
88 )
89 })
90
91 it('Verify that a non integer number of workers is checked', () => {
92 expect(
93 () =>
94 new FixedThreadPool(0.25, './tests/worker-files/thread/testWorker.js')
95 ).toThrowError(
96 new Error(
97 'Cannot instantiate a pool with a non integer number of workers'
98 )
99 )
100 })
101
102 it('Verify that pool options are checked', () => {
103 let pool = new FixedThreadPool(
104 numberOfWorkers,
105 './tests/worker-files/thread/testWorker.js'
106 )
107 expect(pool.opts.enableEvents).toBe(true)
108 expect(pool.emitter).toBeDefined()
109 expect(pool.opts.workerChoiceStrategy).toBe(
110 WorkerChoiceStrategies.ROUND_ROBIN
111 )
112 expect(pool.opts.messageHandler).toBeUndefined()
113 expect(pool.opts.errorHandler).toBeUndefined()
114 expect(pool.opts.onlineHandler).toBeUndefined()
115 expect(pool.opts.exitHandler).toBeUndefined()
116 pool.destroy()
117 const testHandler = () => console.log('test handler executed')
118 pool = new FixedThreadPool(
119 numberOfWorkers,
120 './tests/worker-files/thread/testWorker.js',
121 {
122 workerChoiceStrategy: WorkerChoiceStrategies.LESS_RECENTLY_USED,
123 enableEvents: false,
124 messageHandler: testHandler,
125 errorHandler: testHandler,
126 onlineHandler: testHandler,
127 exitHandler: testHandler
128 }
129 )
130 expect(pool.opts.enableEvents).toBe(false)
131 expect(pool.emitter).toBeUndefined()
132 expect(pool.opts.workerChoiceStrategy).toBe(
133 WorkerChoiceStrategies.LESS_RECENTLY_USED
134 )
135 expect(pool.opts.messageHandler).toStrictEqual(testHandler)
136 expect(pool.opts.errorHandler).toStrictEqual(testHandler)
137 expect(pool.opts.onlineHandler).toStrictEqual(testHandler)
138 expect(pool.opts.exitHandler).toStrictEqual(testHandler)
139 pool.destroy()
140 })
141
142 it("Verify that pool event emitter 'busy' event can register a callback", () => {
143 const pool = new FixedThreadPool(
144 numberOfWorkers,
145 './tests/worker-files/thread/testWorker.js'
146 )
147 const promises = []
148 let poolBusy = 0
149 pool.emitter.on('busy', () => poolBusy++)
150 for (let i = 0; i < numberOfWorkers * 2; i++) {
151 promises.push(pool.execute({ test: 'test' }))
152 }
153 // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
154 // So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
155 expect(poolBusy).toBe(numberOfWorkers + 1)
156 pool.destroy()
157 })
158 })