feat: add event to allow listening to side-effect errors

nytamin · Jul 22, 2022 · 4ce09c9 · 4ce09c9
1 parent 75685ae
commit 4ce09c9
Show file tree

Hide file tree

Showing 4 changed files with 40 additions and 2 deletions.
diff --git a/src/__tests__/errors.spec.ts b/src/__tests__/errors.spec.ts
@@ -13,7 +13,9 @@ const getTests = (disableMultithreading: boolean) => {
 
 		let threaded: ThreadedClass<TestClassErrors>
 		let onClosed = jest.fn()
+		let onError = jest.fn()
 		let onClosedListener: any
+		let onErrorListener: any
 
 		beforeAll(async () => {
 
@@ -22,6 +24,7 @@ const getTests = (disableMultithreading: boolean) => {
 
 			threaded = await threadedClass<TestClassErrors, typeof TestClassErrors>(TESTCLASS_PATH, 'TestClassErrors', [], { disableMultithreading })
 			onClosedListener = ThreadedClassManager.onEvent(threaded, 'thread_closed', onClosed)
+			onErrorListener = ThreadedClassManager.onEvent(threaded, 'error', onError)
 
 		})
 		beforeEach(() => {
@@ -34,6 +37,7 @@ const getTests = (disableMultithreading: boolean) => {
 			await ThreadedClassManager.destroy(threaded)
 			expect(ThreadedClassManager.getThreadCount()).toEqual(0)
 			onClosedListener.stop()
+			onErrorListener.stop();
 			expect(onClosed).toHaveBeenCalledTimes(1)
 		})
 
@@ -44,6 +48,13 @@ const getTests = (disableMultithreading: boolean) => {
 			await expect(threaded.doError()).rejects.toMatch(/testClassErrors.js/)
 			await expect(threaded.doError()).rejects.toMatch(/errors.spec/)
 		})
+		test('SyntaxError in called method', async () => {
+
+			await expect(threaded.doSyntaxError()).rejects.toMatch(/SyntaxError/)
+			// ensure that the original path is included in the stack-trace:
+			await expect(threaded.doSyntaxError()).rejects.toMatch(/testClassErrors.js/)
+			await expect(threaded.doSyntaxError()).rejects.toMatch(/errors.spec/)
+		})
 		test('Error in callback', async () => {
 			// Pre-test: check that cbError throws an error:
 			expect(returnError(cbError)).toMatch(/TestError in callback 123/)
@@ -154,6 +165,13 @@ const getTests = (disableMultithreading: boolean) => {
 					expect(err).toMatch(/errors.spec/)
 				})
 			}
+
+			test('Error thrown in a setTimeout', async () => {
+				await expect(threaded.doAsyncError()).resolves.toBeTruthy();
+				await sleep(10);
+				expect(onError).toHaveBeenCalledTimes(1);
+				expect(onError.mock.calls[0][0].message).toMatch(/setTimeout/)
+			})
 		}
 	}
 }

diff --git a/src/parent-process/manager.ts b/src/parent-process/manager.ts
@@ -63,13 +63,13 @@ export class ThreadedClassManagerClass {
 		return this._internal.getMemoryUsage()
 	}
 	public onEvent (proxy: ThreadedClass<any>, event: string, cb: Function) {
-		const onEvent = (child: Child) => {
+		const onEvent = (child: Child, ...args: any[]) => {
 			let foundChild = Object.keys(child.instances).find((instanceId) => {
 				const instance = child.instances[instanceId]
 				return instance.proxy === proxy
 			})
 			if (foundChild) {
-				cb()
+				cb(...args)
 			}
 		}
 		this._internal.on(event, onEvent)

diff --git a/test-lib/testClassErrors.js b/test-lib/testClassErrors.js
@@ -16,6 +16,15 @@ class TestClassErrors extends events_1.EventEmitter {
     doError() {
         throw new Error('TestError in doError');
     }
+    doSyntaxError() {
+		DaleATuCuerpoAlegría(Macarena)
+	}
+    doAsyncError() {
+		setTimeout(() => {
+			throw new Error('Error in setTimeout');
+		}, 1);
+        return true;
+	}
     emitEvent(eventName) {
         this.emit(eventName, 'testData');
         // await Promise.resolve(this.emit(eventName, 'testData'))

diff --git a/test-lib/testClassErrors.ts b/test-lib/testClassErrors.ts
@@ -16,6 +16,17 @@ export class TestClassErrors extends EventEmitter {
 	public doError (): void {
 		throw new Error('TestError in doError')
 	}
+	public doSyntaxError (): void {
+		// @ts-ignore
+		DaleATuCuerpoAlegría(Macarena)
+	}
+	public doAsyncError (): boolean {
+		setTimeout(() => {
+			throw new Error('Error in setTimeout');
+		}, 1);
+
+		return true;
+	}
 	public emitEvent (eventName: string): void {
 		this.emit(eventName, 'testData')
 		// await Promise.resolve(this.emit(eventName, 'testData'))