fix: handle attempt to send response when port is disconnected

https://gitlab.dashlane.com/dashlane/teams/domains/platforms/web/web-platform/-/issues/948

src/Transport.ts

@@ -177,23 +177,33 @@ export class Transport {
         // Call local handlers with the request data
         callHandlers(data, handlers)
             // If the resulting promise is fulfilled, send a response to the far end
-            .then(response => this._channel.send({
-                type: 'response',
-                slotName,
-                id,
-                data: response,
-                param
-            }))
+            .then(async (response) => {
+                await this.autoReconnect()
+                if (!this.isDisconnected()) {
+                    this._channel.send({
+                        type: 'response',
+                        slotName,
+                        id,
+                        data: response,
+                        param
+                    })
+                }
+            })
 
             // If the resulting promise is rejected, send an error to the far end
-            .catch((error: Error) => this._channel.send({
-                id,
-                message: `${error}`,
-                param,
-                slotName,
-                stack: error.stack || '',
-                type: 'error'
-            }))
+            .catch(async (error: Error) => {
+                await this.autoReconnect()
+                if (!this.isDisconnected()) {
+                    this._channel.send({
+                        id,
+                        message: `${error}`,
+                        param,
+                        slotName,
+                        stack: error.stack || '',
+                        type: 'error'
+                    })
+                }
+            })
     }
 
     /**

test/TestChannel.ts

@@ -9,8 +9,18 @@ export class TestChannel extends GenericChannel {
 
     public autoReconnectSpy = jest.fn()
 
-    constructor() {
+    constructor(
+        options: { withAutoReconnect: boolean } = { withAutoReconnect: true }
+    ) {
         super()
+
+        if (options.withAutoReconnect) {
+            this.autoReconnect = () => {
+                this.callConnected()
+
+                this.autoReconnectSpy()
+            }
+        }
     }
 
     /**
@@ -39,11 +49,7 @@ export class TestChannel extends GenericChannel {
         this._error(new Error('LOLOL'))
     }
 
-    public autoReconnect() {
-        this.callConnected()
-
-        this.autoReconnectSpy()
-    }
+    public autoReconnect?: () => void | undefined
 
     public send(message: TransportMessage) {
         this.sendSpy(message)

test/Transport.spec.ts

@@ -68,7 +68,6 @@ describe('Transport', () => {
             expect(channel.sendSpy).not.toHaveBeenCalledWith({ type: 'handler_unregistered', slotName, param })
         })
 
-
         it('should call the appropriate handler when a request is received', async () => {
 
             const slotName = 'buildCelery'
@@ -103,6 +102,86 @@ describe('Transport', () => {
             })
         })
 
+        describe('when the channel has autoReconnect capability', () => {
+            it('should call the handler when a request is received if the channel went disconnected', async () => {
+
+                const slotName = 'buildCelery'
+                const handler = slots[slotName][0]
+
+                // Register handler on slot
+                transport.registerHandler(slotName, param, handler)
+
+                const request: TransportMessage = {
+                    type: 'request',
+                    slotName,
+                    id: '5',
+                    param,
+                    data: {
+                        height: 5,
+                        constitution: 'strong'
+                    }
+                }
+
+                channel.callDisconnected()
+                channel.fakeReceive(request)
+
+                await flushPromises()
+                expect(handler).toHaveBeenCalledWith(request.data)
+                expect(channel.sendSpy).toHaveBeenCalledWith({
+                    slotName,
+                    type: 'response',
+                    id: '5',
+                    param,
+                    data: {
+                        color: 'blue'
+                    }
+                })
+            })
+        })
+
+        describe('when the channel does not have autoReconnect capability', () => {
+            beforeEach(() => {
+                channel = new TestChannel({ withAutoReconnect: false })
+                transport = new Transport(channel)
+                channel.callConnected()
+            })
+
+            it('should not call the handler when a request is received if the channel went disconnected', async () => {
+
+                const slotName = 'buildCelery'
+                const handler = slots[slotName][0]
+
+                // Register handler on slot
+                transport.registerHandler(slotName, param, handler)
+
+                const request: TransportMessage = {
+                    type: 'request',
+                    slotName,
+                    id: '5',
+                    param,
+                    data: {
+                        height: 5,
+                        constitution: 'strong'
+                    }
+                }
+
+                channel.fakeReceive(request)
+                channel.callDisconnected()
+
+                await flushPromises()
+                expect(handler).toHaveBeenCalledWith(request.data)
+                expect(channel.sendSpy).not.toHaveBeenCalledWith({
+                    slotName,
+                    type: 'response',
+                    id: '5',
+                    param,
+                    data: {
+                        color: 'blue'
+                    }
+                })
+            })
+        })
+
         it('should send a handler_unregistered message when the last local handler is unregistered', () => {
 
             const slotName = 'buildCelery'