fix(emulator): clean up RTU transport event listener on initialization failure (#283)

Fixes #280 - RTU transport leaks event listener on initialization failure

When start() fails due to openCallback error, the 'error' event listener was not removed from the server instance, causing memory leaks in applications that retry connections.

Root cause: The openCallback error handler in start() rejected the Promise but didn't remove the 'error' listener attached after ServerSerial construction. This leaked 1 listener per failed start() attempt.

Fix: Add EventEmitter.prototype.removeAllListeners call in openCallback error path to clean up the listener before rejecting, matching the pattern used in TCP transport (issue #274) and stop() method (issue #253).

Also refactored to use local server variable instead of this.server in callbacks to avoid non-null assertion and match TCP transport pattern.

Test coverage: Added regression test verifying no listeners remain after failed start() due to openCallback error. Test uses EventEmitter-based mock with prototype spy to properly verify cleanup.

Pattern consistency: This completes the event listener cleanup pattern across transports. Matches TCP transport fix from #274 and stop() cleanup from #253.

Closes #280
Related to #274, #253

Author: groupsky

packages/emulator/src/transports/rtu.test.ts

@@ -191,6 +191,66 @@ describe('RtuTransport', () => {
       await expect(transport.start()).rejects.toThrow('Failed to open port')
     })
 
+    it('should clean up error listener when start() fails due to openCallback error', async () => {
+      // Test for issue #280: RTU transport leaks 'error' event listener on initialization failure
+      // When openCallback is called with an error, start() rejects but the 'error' listener
+      // added on line 116 of rtu.ts is never removed, causing a memory leak
+      const { EventEmitter } = await import('events')
+      const { ServerSerial } = await import('modbus-serial')
+      const startError = new Error('Failed to open port')
+      let mockInstance: any
+      ;(ServerSerial as any).mockImplementationOnce((vector: any, options: any) => {
+        capturedServiceVector = vector
+        eventListeners = new Map()
+
+        // Simulate openCallback error (port can't be opened)
+        if (options.openCallback) {
+          setImmediate(() => options.openCallback(startError))
+        }
+
+        // Create mock that inherits from EventEmitter to support EventEmitter.prototype.removeAllListeners.call()
+        const localMockInstance = Object.create(EventEmitter.prototype)
+        EventEmitter.call(localMockInstance)
+
+        // Add mock methods and properties
+        localMockInstance.close = jest.fn((cb: (err: Error | null) => void) => cb(null))
+        localMockInstance.socks = new Map()
+
+        // Wrap the on() method to track listeners in both EventEmitter and test Map
+        const originalOn = localMockInstance.on.bind(localMockInstance)
+        localMockInstance.on = jest.fn((event: string, listener: (...args: unknown[]) => void) => {
+          // Track in test Map for assertions
+          if (!eventListeners.has(event)) {
+            eventListeners.set(event, new Set())
+          }
+          eventListeners.get(event)!.add(listener)
+          // Register with real EventEmitter
+          return originalOn(event, listener)
+        })
+
+        mockInstance = localMockInstance
+        return localMockInstance
+      })
+
+      // Spy on EventEmitter.prototype.removeAllListeners to intercept calls via .call()
+      const prototypeSpy = jest.spyOn(EventEmitter.prototype, 'removeAllListeners')
+
+      transport = new RtuTransport({ port: '/dev/ttyUSB0' })
+
+      // Start should fail due to openCallback error
+      await expect(transport.start()).rejects.toThrow('Failed to open port')
+
+      // After the fix: removeAllListeners('error') should be called during failed start
+      // Before the fix: no cleanup happens, 'error' listener remains on the server instance
+      expect(prototypeSpy).toHaveBeenCalledWith('error')
+
+      // Verify that the 'error' listener was actually removed from EventEmitter
+      expect(mockInstance.listenerCount('error')).toBe(0)
+
+      // Clean up spy
+      prototypeSpy.mockRestore()
+    })
+
     it('should reject on stop error', async () => {
       const { ServerSerial } = await import('modbus-serial')
       const closeError = new Error('Failed to close port')

packages/emulator/src/transports/rtu.ts

@@ -91,12 +91,14 @@ export class RtuTransport extends BaseTransport {
 
     // Create and start server
     return new Promise<void>((resolve, reject) => {
-      this.server = new ServerSerial(
+      const server = new ServerSerial(
         serviceVector,
         {
           ...options,
           openCallback: (err: Error | null) => {
             if (err) {
+              // Clean up error listener to prevent memory leak (issue #280)
+              EventEmitter.prototype.removeAllListeners.call(server, 'error')
               reject(err)
             } else {
               this.started = true
@@ -110,8 +112,10 @@ export class RtuTransport extends BaseTransport {
         }
       )
 
+      this.server = server
+
       // Handle errors
-      this.server.on('error', (err) => {
+      server.on('error', (err) => {
         // Log error but don't stop server
         console.error('RTU transport error:', err)
       })