From d71efad4fb767fd167a55c0f49de6f0cf904552d Mon Sep 17 00:00:00 2001
From: Denis Davidyuk <denis_davidyuk@hotmail.com>
Date: Wed, 31 Aug 2022 13:26:06 +0300
Subject: [PATCH] fix(channel): emit incoming message handler error instead of
 printing

---
 docs/guides/error-handling.md |  1 +
 src/channel/internal.ts       |  5 ++---
 src/utils/errors.ts           | 16 ++++++++++++++++
 test/integration/channel.ts   | 36 ++++++++++++++++++++++-------------
 4 files changed, 42 insertions(+), 16 deletions(-)

diff --git a/docs/guides/error-handling.md b/docs/guides/error-handling.md
index 8cadc82007..3977333c07 100644
--- a/docs/guides/error-handling.md
+++ b/docs/guides/error-handling.md
@@ -42,6 +42,7 @@ BaseError
 │   │   ChannelConnectionError
 │   │   ChannelPingTimedOutError
 │   │   UnexpectedChannelMessageError
+│   │   ChannelIncomingMessageError
 │   │   UnknownChannelStateError
 │
 └───CompilerError
diff --git a/src/channel/internal.ts b/src/channel/internal.ts
index c6757b7c5b..8a10500161 100644
--- a/src/channel/internal.ts
+++ b/src/channel/internal.ts
@@ -28,6 +28,7 @@ import {
   ChannelPingTimedOutError,
   UnexpectedTsError,
   UnknownChannelStateError,
+  ChannelIncomingMessageError,
 } from '../utils/errors';
 
 interface ChannelAction {
@@ -233,9 +234,7 @@ async function dequeueMessage(channel: Channel): Promise<void> {
     try {
       await handleMessage(channel, message);
     } catch (error) {
-      console.error('Error handling incoming message:');
-      console.error(message);
-      console.error(error);
+      emit(channel, 'error', new ChannelIncomingMessageError(error, message));
     }
   }
   messageQueueLocked.set(channel, false);
diff --git a/src/utils/errors.ts b/src/utils/errors.ts
index 266b499a31..054d0917f6 100644
--- a/src/utils/errors.ts
+++ b/src/utils/errors.ts
@@ -395,6 +395,22 @@ export class UnexpectedChannelMessageError extends ChannelError {
   }
 }
 
+/**
+ * @category exception
+ */
+export class ChannelIncomingMessageError extends ChannelError {
+  handlerError: BaseError;
+
+  incomingMessage: { [key: string]: any };
+
+  constructor(handlerError: BaseError, incomingMessage: { [key: string]: any }) {
+    super(handlerError.message);
+    this.handlerError = handlerError;
+    this.incomingMessage = incomingMessage;
+    this.name = 'ChannelIncomingMessageError';
+  }
+}
+
 /**
  * @category exception
  */
diff --git a/test/integration/channel.ts b/test/integration/channel.ts
index 817b430da2..26755299ee 100644
--- a/test/integration/channel.ts
+++ b/test/integration/channel.ts
@@ -22,8 +22,18 @@ import * as sinon from 'sinon';
 import BigNumber from 'bignumber.js';
 import { getSdk } from '.';
 import {
-  unpackTx, buildTx, buildTxHash, encode, decode, Tag,
-  IllegalArgumentError, InsufficientBalanceError, ChannelConnectionError, encodeContractAddress,
+  unpackTx,
+  buildTx,
+  buildTxHash,
+  encode,
+  decode,
+  Tag,
+  IllegalArgumentError,
+  InsufficientBalanceError,
+  ChannelConnectionError,
+  encodeContractAddress,
+  ChannelIncomingMessageError,
+  UnknownChannelStateError,
 } from '../../src';
 import { pause } from '../../src/utils/other';
 import Channel from '../../src/channel';
@@ -147,23 +157,23 @@ describe('Channel', () => {
     responderTx.should.eql({ ...responderTx, ...expectedTxParams });
   });
 
-  it('prints error on handling incoming messages', async () => {
-    const stub = sinon.stub(console, 'error');
-    const received = new Promise((resolve) => {
-      stub.callsFake(resolve);
+  it('emits error on handling incoming messages', async () => {
+    const getError = new Promise<ChannelIncomingMessageError>((resolve) => {
+      function handler(error: ChannelIncomingMessageError): void {
+        resolve(error);
+        initiatorCh.off('error', handler);
+      }
+      initiatorCh.on('error', handler);
     });
     send(initiatorCh, {
       jsonrpc: '2.0',
       method: 'not-existing-method',
       params: {},
     });
-    await received;
-    expect(stub.callCount).to.be.equal(3);
-    expect(stub.getCall(0).firstArg).to.be.equal('Error handling incoming message:');
-    expect(stub.getCall(1).firstArg.error.message).to.be.equal('Method not found');
-    expect(stub.getCall(2).firstArg.toString())
-      .to.be.equal('UnknownChannelStateError: State Channels FSM entered unknown state');
-    stub.restore();
+    const error = await getError;
+    expect(error.incomingMessage.error.message).to.be.equal('Method not found');
+    expect(() => { throw error.handlerError; })
+      .to.throw(UnknownChannelStateError, 'State Channels FSM entered unknown state');
   });
 
   it('can post update and accept', async () => {