test: do not throw errors within async function

tests/power-switch/test00002.test.ts

@@ -10,19 +10,21 @@
 import { PowerSwitch } from '../../src/power-switch/power-switch';
 
 test('PowerSwitch: case 2', () => {
-  const powerSwitch = new PowerSwitch(false);
+  const powerSwitch = new PowerSwitch();
   expect(powerSwitch.isDown()).toBe(true);
   expect(powerSwitch.isRunning()).toBe(false);
 
   expect(powerSwitch.goingUp()).toBe(true);
   expect(powerSwitch.goingUp()).toBe(false);
 
-  powerSwitch.commit();
+  expect(powerSwitch.commit()).toBe(true);
+  expect(powerSwitch.commit()).toBe(false);
   expect(powerSwitch.goingUp()).toBe(false);
 
   expect(powerSwitch.goingDown()).toBe(true);
   expect(powerSwitch.goingDown()).toBe(false);
 
-  powerSwitch.commit();
+  expect(powerSwitch.commit()).toBe(true);
+  expect(powerSwitch.commit()).toBe(false);
   expect(powerSwitch.goingDown()).toBe(false);
 });

tests/worker/test00001.test.ts

@@ -8,7 +8,7 @@
  */
 
 import { Worker } from '../../src/worker/worker';
-import { delay } from 'bluebird';
+import { delay, promisifyAll } from 'bluebird';
 import { WorkerRunner } from '../../src/worker/worker-runner/worker-runner';
 import { getRedisInstance } from '../common';
 import { WorkerPool } from '../../src/worker/worker-runner/worker-pool';
@@ -43,29 +43,28 @@ class ManagedCounterWorker extends Worker {
 
 describe('Worker & WorkerRunner', () => {
   test('Case 1', async () => {
-    const worker = new UnmanagedCounterWorker();
-    worker.run();
+    const worker = promisifyAll(new UnmanagedCounterWorker());
+    await worker.runAsync();
     await delay(5000);
     expect(worker.count).toBe(3);
   });
 
   test('Case 2', async () => {
-    const worker1 = new ManagedCounterWorker();
-    const worker2 = new ManagedCounterWorker();
-    expect(() => worker1.run()).toThrow('You can not run a managed worker');
+    const worker1 = promisifyAll(new ManagedCounterWorker());
+    const worker2 = promisifyAll(new ManagedCounterWorker());
+    await expect(worker1.runAsync()).rejects.toThrow(
+      'You can not run a managed worker',
+    );
     const client = await getRedisInstance();
-    const workerRunner = new WorkerRunner(
-      client,
-      'my-runner',
-      new WorkerPool(),
-      console,
+    const workerRunner = promisifyAll(
+      new WorkerRunner(client, 'my-runner', new WorkerPool(), console),
     );
     workerRunner.addWorker(worker1);
     workerRunner.addWorker(worker2);
-    workerRunner.run();
+    await workerRunner.runAsync();
     await delay(10000);
     expect(worker1.count).toBe(3);
     expect(worker2.count).toBe(3);
-    await new Promise((resolve) => workerRunner.quit(resolve));
+    await workerRunner.quitAsync();
   });
 });