test: add missing pool destroy() calls

Signed-off-by: Jérôme Benoit <jerome.benoit@piment-noir.org>

diff --git a/tests/pools/abstract/abstract-pool.test.js b/tests/pools/abstract/abstract-pool.test.js
index 3b3c92c018ef186e0dc3b267b8ef68f889c066aa..945ee8e7acf6417b2e6816e87bce1dffce48265d 100644 (file)
--- a/tests/pools/abstract/abstract-pool.test.js
+++ b/tests/pools/abstract/abstract-pool.test.js
@@ -1172,6 +1172,8 @@ describe('Abstract pool test suite', () => {
       'factorial',
       'fibonacci'
     ])
+    await dynamicThreadPool.destroy()
+    await fixedClusterPool.destroy()
   })
 
   it('Verify that multiple task functions worker is working', async () => {
@@ -1228,5 +1230,6 @@ describe('Abstract pool test suite', () => {
         ).toBeGreaterThanOrEqual(0)
       }
     }
+    await pool.destroy()
   })
 })

diff --git a/tests/pools/cluster/dynamic.test.js b/tests/pools/cluster/dynamic.test.js
index 166b546db5bc147272672dff20cfc9d9600bbb8d..44d543ec5c83c032241a988555f7bccdabbc8812 100644 (file)
--- a/tests/pools/cluster/dynamic.test.js
+++ b/tests/pools/cluster/dynamic.test.js
@@ -72,15 +72,15 @@ describe('Dynamic cluster pool test suite', () => {
   })
 
   it('Should work even without opts in input', async () => {
-    const pool1 = new DynamicClusterPool(
+    const pool = new DynamicClusterPool(
       min,
       max,
       './tests/worker-files/cluster/testWorker.js'
     )
-    const result = await pool1.execute()
+    const result = await pool.execute()
     expect(result).toStrictEqual({ ok: 1 })
     // We need to clean up the resources after our test
-    await pool1.destroy()
+    await pool.destroy()
   })
 
   it('Verify scale processes up and down is working when long executing task is used:hard', async () => {

diff --git a/tests/pools/cluster/fixed.test.js b/tests/pools/cluster/fixed.test.js
index 42e13a9a83348f8b4d8c425f4f71ae32c77d6a7e..04af63846d2a30125f92eaae3311b237cab2b8a4 100644 (file)
--- a/tests/pools/cluster/fixed.test.js
+++ b/tests/pools/cluster/fixed.test.js
@@ -80,7 +80,7 @@ describe('Fixed cluster pool test suite', () => {
   })
 
   it("Verify that 'ready' event is emitted", async () => {
-    const pool1 = new FixedClusterPool(
+    const pool = new FixedClusterPool(
       numberOfWorkers,
       './tests/worker-files/cluster/testWorker.js',
       {
@@ -88,9 +88,10 @@ describe('Fixed cluster pool test suite', () => {
       }
     )
     let poolReady = 0
-    pool1.emitter.on(PoolEvents.ready, () => ++poolReady)
-    await waitPoolEvents(pool1, PoolEvents.ready, 1)
+    pool.emitter.on(PoolEvents.ready, () => ++poolReady)
+    await waitPoolEvents(pool, PoolEvents.ready, 1)
     expect(poolReady).toBe(1)
+    await pool.destroy()
   })
 
   it("Verify that 'busy' event is emitted", async () => {
@@ -251,36 +252,36 @@ describe('Fixed cluster pool test suite', () => {
 
   it('Verify that cluster pool options are checked', async () => {
     const workerFilePath = './tests/worker-files/cluster/testWorker.js'
-    let pool1 = new FixedClusterPool(numberOfWorkers, workerFilePath)
-    expect(pool1.opts.env).toBeUndefined()
-    expect(pool1.opts.settings).toBeUndefined()
-    await pool1.destroy()
-    pool1 = new FixedClusterPool(numberOfWorkers, workerFilePath, {
+    let pool = new FixedClusterPool(numberOfWorkers, workerFilePath)
+    expect(pool.opts.env).toBeUndefined()
+    expect(pool.opts.settings).toBeUndefined()
+    await pool.destroy()
+    pool = new FixedClusterPool(numberOfWorkers, workerFilePath, {
       env: { TEST: 'test' },
       settings: { args: ['--use', 'http'], silent: true }
     })
-    expect(pool1.opts.env).toStrictEqual({ TEST: 'test' })
-    expect(pool1.opts.settings).toStrictEqual({
+    expect(pool.opts.env).toStrictEqual({ TEST: 'test' })
+    expect(pool.opts.settings).toStrictEqual({
       args: ['--use', 'http'],
       silent: true
     })
-    expect({ ...pool1.opts.settings, exec: workerFilePath }).toStrictEqual({
+    expect({ ...pool.opts.settings, exec: workerFilePath }).toStrictEqual({
       args: ['--use', 'http'],
       silent: true,
       exec: workerFilePath
     })
-    await pool1.destroy()
+    await pool.destroy()
   })
 
   it('Should work even without opts in input', async () => {
-    const pool1 = new FixedClusterPool(
+    const pool = new FixedClusterPool(
       numberOfWorkers,
       './tests/worker-files/cluster/testWorker.js'
     )
-    const res = await pool1.execute()
+    const res = await pool.execute()
     expect(res).toStrictEqual({ ok: 1 })
     // We need to clean up the resources after our test
-    await pool1.destroy()
+    await pool.destroy()
   })
 
   it('Verify that a pool with zero worker fails', async () => {

diff --git a/tests/pools/thread/dynamic.test.js b/tests/pools/thread/dynamic.test.js
index ea9964caab100ac04a17deba24682f287d79cc7e..2f3f4510cdc9567bdceb7a3951a606afb0168909 100644 (file)
--- a/tests/pools/thread/dynamic.test.js
+++ b/tests/pools/thread/dynamic.test.js
@@ -72,15 +72,15 @@ describe('Dynamic thread pool test suite', () => {
   })
 
   it('Should work even without opts in input', async () => {
-    const pool1 = new DynamicThreadPool(
+    const pool = new DynamicThreadPool(
       min,
       max,
       './tests/worker-files/thread/testWorker.js'
     )
-    const res = await pool1.execute()
+    const res = await pool.execute()
     expect(res).toStrictEqual({ ok: 1 })
     // We need to clean up the resources after our test
-    await pool1.destroy()
+    await pool.destroy()
   })
 
   it('Verify scale thread up and down is working when long executing task is used:hard', async () => {

diff --git a/tests/pools/thread/fixed.test.js b/tests/pools/thread/fixed.test.js
index f63f2265a1bb6b7c42dde1a9b9cc7f58321c2204..09363b84e450f5aa201c2e3428b5003af9653ceb 100644 (file)
--- a/tests/pools/thread/fixed.test.js
+++ b/tests/pools/thread/fixed.test.js
@@ -80,7 +80,7 @@ describe('Fixed thread pool test suite', () => {
   })
 
   it("Verify that 'ready' event is emitted", async () => {
-    const pool1 = new FixedThreadPool(
+    const pool = new FixedThreadPool(
       numberOfThreads,
       './tests/worker-files/thread/testWorker.js',
       {
@@ -88,9 +88,10 @@ describe('Fixed thread pool test suite', () => {
       }
     )
     let poolReady = 0
-    pool1.emitter.on(PoolEvents.ready, () => ++poolReady)
-    await waitPoolEvents(pool1, PoolEvents.ready, 1)
+    pool.emitter.on(PoolEvents.ready, () => ++poolReady)
+    await waitPoolEvents(pool, PoolEvents.ready, 1)
     expect(poolReady).toBe(1)
+    await pool.destroy()
   })
 
   it("Verify that 'busy' event is emitted", async () => {
@@ -281,31 +282,31 @@ describe('Fixed thread pool test suite', () => {
 
   it('Verify that thread pool options are checked', async () => {
     const workerFilePath = './tests/worker-files/thread/testWorker.js'
-    let pool1 = new FixedThreadPool(numberOfThreads, workerFilePath)
-    expect(pool1.opts.workerOptions).toBeUndefined()
-    await pool1.destroy()
-    pool1 = new FixedThreadPool(numberOfThreads, workerFilePath, {
+    let pool = new FixedThreadPool(numberOfThreads, workerFilePath)
+    expect(pool.opts.workerOptions).toBeUndefined()
+    await pool.destroy()
+    pool = new FixedThreadPool(numberOfThreads, workerFilePath, {
       workerOptions: {
         env: { TEST: 'test' },
         name: 'test'
       }
     })
-    expect(pool1.opts.workerOptions).toStrictEqual({
+    expect(pool.opts.workerOptions).toStrictEqual({
       env: { TEST: 'test' },
       name: 'test'
     })
-    await pool1.destroy()
+    await pool.destroy()
   })
 
   it('Should work even without opts in input', async () => {
-    const pool1 = new FixedThreadPool(
+    const pool = new FixedThreadPool(
       numberOfThreads,
       './tests/worker-files/thread/testWorker.js'
     )
-    const res = await pool1.execute()
+    const res = await pool.execute()
     expect(res).toStrictEqual({ ok: 1 })
     // We need to clean up the resources after our test
-    await pool1.destroy()
+    await pool.destroy()
   })
 
   it('Verify that a pool with zero worker fails', async () => {