gameglue 4.0.1 → 4.0.2

package/src/listener.spec.js

@@ -1,598 +1,598 @@
-const { Listener } = require('./listener');
-const { createMockSocket, mockListenerConfig } = require('./test/fixtures');
-
-// Mock the schemas module with an identity mapping (passes through field names unchanged)
-jest.mock('@gameglue/schemas', () => ({
-  getGameSchema: jest.fn(() => ({
-    gameId: 'msfs',
-    fieldMappings: {},  // Empty means no transformation, fields pass through
-    commandMappings: {
-      gear_up: { gameCommand: 'GEAR_UP', type: 'command' }
-    },
-    extraFields: {}
-  })),
-  normalizeTelemetry: jest.fn((raw) => raw)  // Identity function - return raw data as-is
-}));
-
-describe('Listener', () => {
-  let mockSocket;
-  let listener;
-
-  beforeEach(() => {
-    mockSocket = createMockSocket();
-    listener = new Listener(mockSocket, mockListenerConfig);
-  });
-
-  describe('constructor', () => {
-    it('should initialize with config and socket', () => {
-      expect(listener._config).toEqual(mockListenerConfig);
-      expect(listener._socket).toBe(mockSocket);
-      expect(listener._callbacks).toEqual([]);
-    });
-
-    it('should copy fields array from config', () => {
-      expect(listener._fields).toEqual(['altitude', 'airspeed', 'heading']);
-      expect(listener._fields).not.toBe(mockListenerConfig.fields); // Should be a copy
-    });
-
-    it('should handle config without fields', () => {
-      const configWithoutFields = { gameId: 'msfs', userId: 'user-123' };
-      const listenerNoFields = new Listener(mockSocket, configWithoutFields);
-
-      expect(listenerNoFields._fields).toBeNull();
-    });
-  });
-
-  describe('establishConnection', () => {
-    it('should emit listen event with object payload when fields are specified', async () => {
-      const result = await listener.establishConnection();
-
-      expect(mockSocket.timeout).toHaveBeenCalledWith(5000);
-      expect(mockSocket.emit).toHaveBeenCalledWith(
-        'listen',
-        {
-          userId: 'user-123',
-          gameId: 'msfs',
-          fields: ['altitude', 'airspeed', 'heading']
-        },
-        expect.any(Function)
-      );
-      expect(result).toEqual({ status: 'success' });
-    });
-
-    it('should emit listen event with legacy string format when no fields', async () => {
-      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
-      const listenerNoFields = new Listener(mockSocket, configNoFields);
-
-      await listenerNoFields.establishConnection();
-
-      expect(mockSocket.emit).toHaveBeenCalledWith(
-        'listen',
-        'user-123:msfs',
-        expect.any(Function)
-      );
-    });
-
-    it('should throw error when socket is missing', async () => {
-      const invalidListener = new Listener(null, mockListenerConfig);
-
-      await expect(invalidListener.establishConnection()).rejects.toThrow(
-        'Missing arguments in establishConnection'
-      );
-    });
-
-    it('should throw error when userId is missing', async () => {
-      const invalidConfig = { gameId: 'msfs' };
-      const invalidListener = new Listener(mockSocket, invalidConfig);
-
-      await expect(invalidListener.establishConnection()).rejects.toThrow(
-        'Missing arguments in establishConnection'
-      );
-    });
-
-    it('should throw error when gameId is missing', async () => {
-      const invalidConfig = { userId: 'user-123' };
-      const invalidListener = new Listener(mockSocket, invalidConfig);
-
-      await expect(invalidListener.establishConnection()).rejects.toThrow(
-        'Missing arguments in establishConnection'
-      );
-    });
-
-    it('should handle timeout error', async () => {
-      mockSocket.emit = jest.fn((event, data, callback) => {
-        callback(new Error('timeout'), null);
-      });
-
-      const result = await listener.establishConnection();
-
-      expect(result).toEqual({
-        status: 'failed',
-        reason: 'Listen request timed out.'
-      });
-    });
-
-    it('should handle failure response from server', async () => {
-      mockSocket.emit = jest.fn((event, data, callback) => {
-        callback(null, { status: 'failed', reason: 'Unauthorized' });
-      });
-
-      const result = await listener.establishConnection();
-
-      expect(result).toEqual({
-        status: 'failed',
-        reason: 'Unauthorized'
-      });
-    });
-  });
-
-  describe('setupEventListener', () => {
-    it('should register update event handler and return self', () => {
-      const result = listener.setupEventListener();
-
-      expect(mockSocket.on).toHaveBeenCalledWith('update', expect.any(Function));
-      expect(result).toBe(listener);
-    });
-
-    it('should filter update payload to subscribed fields only', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      // Simulate server sending full telemetry payload
-      const fullPayload = {
-        data: {
-          altitude: 35000,
-          airspeed: 250,
-          heading: 180,
-          fuel: 5000,
-          temperature: 25
-        }
-      };
-
-      // Trigger the update event
-      mockSocket._trigger('update', fullPayload);
-
-      // Should only receive subscribed fields: altitude, airspeed, heading (plus raw data)
-      expect(emitSpy).toHaveBeenCalledWith('update', {
-        raw: fullPayload.data,
-        data: {
-          altitude: 35000,
-          airspeed: 250,
-          heading: 180
-        }
-      });
-    });
-
-    it('should pass through full payload when no fields specified', () => {
-      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
-      const listenerNoFields = new Listener(mockSocket, configNoFields);
-      const emitSpy = jest.fn();
-      listenerNoFields.emit = emitSpy;
-      listenerNoFields.setupEventListener();
-
-      const fullPayload = {
-        data: {
-          altitude: 35000,
-          airspeed: 250,
-          fuel: 5000
-        }
-      };
-
-      mockSocket._trigger('update', fullPayload);
-
-      // Should receive all fields (with raw data)
-      expect(emitSpy).toHaveBeenCalledWith('update', {
-        raw: fullPayload.data,
-        data: fullPayload.data
-      });
-    });
-
-    it('should handle payload with missing subscribed fields', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      // Server sends partial data (missing some subscribed fields)
-      const partialPayload = {
-        data: {
-          altitude: 35000
-          // airspeed and heading missing
-        }
-      };
-
-      mockSocket._trigger('update', partialPayload);
-
-      // Should only include fields that exist in payload (plus raw data)
-      expect(emitSpy).toHaveBeenCalledWith('update', {
-        raw: partialPayload.data,
-        data: {
-          altitude: 35000
-        }
-      });
-    });
-
-    it('should handle empty data payload', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      const emptyPayload = { data: {} };
-      mockSocket._trigger('update', emptyPayload);
-
-      expect(emitSpy).toHaveBeenCalledWith('update', { raw: {}, data: {} });
-    });
-
-    it('should handle null/undefined data gracefully', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      const nullPayload = { data: null };
-      mockSocket._trigger('update', nullPayload);
-
-      // Should pass through when data is null (with raw)
-      expect(emitSpy).toHaveBeenCalledWith('update', { raw: null, data: null });
-    });
-
-    it('should preserve other payload properties when filtering', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      const payloadWithMeta = {
-        data: { altitude: 35000, fuel: 5000 },
-        timestamp: 1234567890,
-        sequence: 42
-      };
-
-      mockSocket._trigger('update', payloadWithMeta);
-
-      expect(emitSpy).toHaveBeenCalledWith('update', {
-        raw: payloadWithMeta.data,
-        data: { altitude: 35000 },
-        timestamp: 1234567890,
-        sequence: 42
-      });
-    });
-
-    it('should reflect field changes after subscribe/unsubscribe', async () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      // Add a new field
-      await listener.subscribe(['fuel']);
-
-      const payload = {
-        data: { altitude: 35000, fuel: 5000, temperature: 25 }
-      };
-
-      mockSocket._trigger('update', payload);
-
-      // Should now include fuel (plus raw data)
-      expect(emitSpy).toHaveBeenCalledWith('update', {
-        raw: payload.data,
-        data: {
-          altitude: 35000,
-          fuel: 5000
-        }
-      });
-    });
-  });
-
-  describe('subscribe', () => {
-    it('should add new fields to subscription', async () => {
-      await listener.subscribe(['fuel', 'temperature']);
-
-      expect(listener._fields).toContain('altitude');
-      expect(listener._fields).toContain('fuel');
-      expect(listener._fields).toContain('temperature');
-    });
-
-    it('should not add duplicate fields', async () => {
-      await listener.subscribe(['altitude', 'fuel']);
-
-      const altitudeCount = listener._fields.filter(f => f === 'altitude').length;
-      expect(altitudeCount).toBe(1);
-      expect(listener._fields).toContain('fuel');
-    });
-
-    it('should emit listen-update event', async () => {
-      await listener.subscribe(['fuel']);
-
-      expect(mockSocket.emit).toHaveBeenCalledWith(
-        'listen-update',
-        expect.objectContaining({
-          userId: 'user-123',
-          gameId: 'msfs',
-          fields: expect.arrayContaining(['altitude', 'airspeed', 'heading', 'fuel'])
-        }),
-        expect.any(Function)
-      );
-    });
-
-    it('should initialize fields array if none existed', async () => {
-      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
-      const listenerNoFields = new Listener(mockSocket, configNoFields);
-
-      await listenerNoFields.subscribe(['fuel', 'temperature']);
-
-      expect(listenerNoFields._fields).toEqual(['fuel', 'temperature']);
-    });
-
-    it('should throw error for non-array input', async () => {
-      await expect(listener.subscribe('fuel')).rejects.toThrow(
-        'fields must be a non-empty array'
-      );
-    });
-
-    it('should throw error for empty array', async () => {
-      await expect(listener.subscribe([])).rejects.toThrow(
-        'fields must be a non-empty array'
-      );
-    });
-  });
-
-  describe('unsubscribe', () => {
-    it('should remove fields from subscription', async () => {
-      await listener.unsubscribe(['altitude']);
-
-      expect(listener._fields).not.toContain('altitude');
-      expect(listener._fields).toContain('airspeed');
-      expect(listener._fields).toContain('heading');
-    });
-
-    it('should emit listen-update event with updated fields', async () => {
-      await listener.unsubscribe(['altitude', 'airspeed']);
-
-      expect(mockSocket.emit).toHaveBeenCalledWith(
-        'listen-update',
-        {
-          userId: 'user-123',
-          gameId: 'msfs',
-          fields: ['heading']
-        },
-        expect.any(Function)
-      );
-    });
-
-    it('should throw error when no explicit fields exist', async () => {
-      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
-      const listenerNoFields = new Listener(mockSocket, configNoFields);
-
-      await expect(listenerNoFields.unsubscribe(['fuel'])).rejects.toThrow(
-        'Cannot unsubscribe when receiving all fields'
-      );
-    });
-
-    it('should throw error for non-array input', async () => {
-      await expect(listener.unsubscribe('altitude')).rejects.toThrow(
-        'fields must be a non-empty array'
-      );
-    });
-
-    it('should throw error for empty array', async () => {
-      await expect(listener.unsubscribe([])).rejects.toThrow(
-        'fields must be a non-empty array'
-      );
-    });
-
-    it('should handle unsubscribing non-existent field gracefully', async () => {
-      await listener.unsubscribe(['nonexistent']);
-
-      expect(listener._fields).toEqual(['altitude', 'airspeed', 'heading']);
-    });
-  });
-
-  describe('getFields', () => {
-    it('should return copy of fields array', () => {
-      const fields = listener.getFields();
-
-      expect(fields).toEqual(['altitude', 'airspeed', 'heading']);
-      expect(fields).not.toBe(listener._fields); // Should be a copy
-    });
-
-    it('should return null when no explicit fields', () => {
-      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
-      const listenerNoFields = new Listener(mockSocket, configNoFields);
-
-      expect(listenerNoFields.getFields()).toBeNull();
-    });
-  });
-
-  describe('sendCommand', () => {
-    it('should emit set event with correct payload', async () => {
-      const result = await listener.sendCommand('autopilot', true);
-
-      expect(mockSocket.timeout).toHaveBeenCalledWith(5000);
-      expect(mockSocket.emit).toHaveBeenCalledWith(
-        'set',
-        {
-          userId: 'user-123',
-          gameId: 'msfs',
-          data: {
-            fieldName: 'autopilot',
-            value: true
-          }
-        },
-        expect.any(Function)
-      );
-      expect(result).toEqual({ status: 'success' });
-    });
-
-    it('should send canonical command without denormalizing', async () => {
-      await listener.sendCommand('gear_up', true);
-
-      expect(mockSocket.emit).toHaveBeenCalledWith(
-        'set',
-        expect.objectContaining({
-          data: {
-            fieldName: 'gear_up',
-            value: true
-          }
-        }),
-        expect.any(Function)
-      );
-    });
-
-    it('should handle various value types', async () => {
-      await listener.sendCommand('altitude', 35000);
-      await listener.sendCommand('flaps', 0.5);
-      await listener.sendCommand('status', 'active');
-      await listener.sendCommand('config', { mode: 'auto' });
-
-      expect(mockSocket.emit).toHaveBeenCalledTimes(4);
-    });
-
-    it('should throw error for invalid command', async () => {
-      await expect(listener.sendCommand('', true)).rejects.toThrow(
-        'command must be a non-empty string'
-      );
-      await expect(listener.sendCommand(null, true)).rejects.toThrow(
-        'command must be a non-empty string'
-      );
-      await expect(listener.sendCommand(123, true)).rejects.toThrow(
-        'command must be a non-empty string'
-      );
-    });
-
-    it('should handle timeout error', async () => {
-      mockSocket.emit = jest.fn((event, data, callback) => {
-        callback(new Error('timeout'), null);
-      });
-
-      const result = await listener.sendCommand('autopilot', true);
-
-      expect(result).toEqual({
-        status: 'failed',
-        reason: 'Command request timed out.'
-      });
-    });
-  });
-
-  describe('key events', () => {
-    it('should register handler for key-events', () => {
-      listener.setupEventListener();
-
-      expect(mockSocket.on).toHaveBeenCalledWith('key-events', expect.any(Function));
-    });
-
-    it('should emit landing event when received', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      const landingPayload = {
-        gameId: 'msfs',
-        eventType: 'landing',
-        data: {
-          landing_rate: -150,
-          quality: 'normal',
-          pitch_at_touchdown: 3.5,
-          roll_at_touchdown: 0.5,
-          speed_at_touchdown: 135,
-          heading_at_touchdown: 270,
-          position: { lat: 47.5, lon: -122.3 },
-          bounce_count: 0,
-          bounces: [],
-          timestamp: 1234567890
-        }
-      };
-
-      mockSocket._trigger('key-events', landingPayload);
-
-      expect(emitSpy).toHaveBeenCalledWith('landing', landingPayload.data);
-    });
-
-    it('should emit takeoff event when received', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      const takeoffPayload = {
-        gameId: 'msfs',
-        eventType: 'takeoff',
-        data: {
-          rotation_speed: 145,
-          pitch_at_liftoff: 10,
-          heading_at_liftoff: 270,
-          position: { lat: 47.5, lon: -122.3 },
-          flaps_setting: 0.2,
-          timestamp: 1234567890
-        }
-      };
-
-      mockSocket._trigger('key-events', takeoffPayload);
-
-      expect(emitSpy).toHaveBeenCalledWith('takeoff', takeoffPayload.data);
-    });
-
-    it('should emit flight_phase event when received', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      const phasePayload = {
-        gameId: 'msfs',
-        eventType: 'flight_phase',
-        data: {
-          phase: 'cruise',
-          previous_phase: 'climb',
-          altitude_agl: 34500,
-          altitude_msl: 35000,
-          speed: 280,
-          timestamp: 1234567890
-        }
-      };
-
-      mockSocket._trigger('key-events', phasePayload);
-
-      expect(emitSpy).toHaveBeenCalledWith('flight_phase', phasePayload.data);
-    });
-
-    it('should not emit event for different gameId', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      const otherGamePayload = {
-        gameId: 'xplane', // Different from listener's 'msfs'
-        eventType: 'landing',
-        data: { landing_rate: -100 }
-      };
-
-      mockSocket._trigger('key-events', otherGamePayload);
-
-      expect(emitSpy).not.toHaveBeenCalledWith('landing', expect.anything());
-    });
-
-    it('should handle null payload gracefully', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      mockSocket._trigger('key-events', null);
-
-      expect(emitSpy).not.toHaveBeenCalledWith('landing', expect.anything());
-      expect(emitSpy).not.toHaveBeenCalledWith('takeoff', expect.anything());
-      expect(emitSpy).not.toHaveBeenCalledWith('flight_phase', expect.anything());
-    });
-
-    it('should handle payload with missing eventType', () => {
-      const emitSpy = jest.fn();
-      listener.emit = emitSpy;
-      listener.setupEventListener();
-
-      const invalidPayload = {
-        gameId: 'msfs',
-        data: { landing_rate: -100 }
-        // eventType missing
-      };
-
-      mockSocket._trigger('key-events', invalidPayload);
-
-      expect(emitSpy).not.toHaveBeenCalledWith(undefined, expect.anything());
-    });
-  });
-});
+const { Listener } = require('./listener');
+const { createMockSocket, mockListenerConfig } = require('./test/fixtures');
+
+// Mock the schemas module with an identity mapping (passes through field names unchanged)
+jest.mock('@gameglue/schemas', () => ({
+  getGameSchema: jest.fn(() => ({
+    gameId: 'msfs',
+    fieldMappings: {},  // Empty means no transformation, fields pass through
+    commandMappings: {
+      gear_up: { gameCommand: 'GEAR_UP', type: 'command' }
+    },
+    extraFields: {}
+  })),
+  normalizeTelemetry: jest.fn((raw) => raw)  // Identity function - return raw data as-is
+}));
+
+describe('Listener', () => {
+  let mockSocket;
+  let listener;
+
+  beforeEach(() => {
+    mockSocket = createMockSocket();
+    listener = new Listener(mockSocket, mockListenerConfig);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with config and socket', () => {
+      expect(listener._config).toEqual(mockListenerConfig);
+      expect(listener._socket).toBe(mockSocket);
+      expect(listener._callbacks).toEqual([]);
+    });
+
+    it('should copy fields array from config', () => {
+      expect(listener._fields).toEqual(['altitude', 'airspeed', 'heading']);
+      expect(listener._fields).not.toBe(mockListenerConfig.fields); // Should be a copy
+    });
+
+    it('should handle config without fields', () => {
+      const configWithoutFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configWithoutFields);
+
+      expect(listenerNoFields._fields).toBeNull();
+    });
+  });
+
+  describe('establishConnection', () => {
+    it('should emit listen event with object payload when fields are specified', async () => {
+      const result = await listener.establishConnection();
+
+      expect(mockSocket.timeout).toHaveBeenCalledWith(5000);
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'listen',
+        {
+          userId: 'user-123',
+          gameId: 'msfs',
+          fields: ['altitude', 'airspeed', 'heading']
+        },
+        expect.any(Function)
+      );
+      expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should emit listen event with legacy string format when no fields', async () => {
+      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configNoFields);
+
+      await listenerNoFields.establishConnection();
+
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'listen',
+        'user-123:msfs',
+        expect.any(Function)
+      );
+    });
+
+    it('should throw error when socket is missing', async () => {
+      const invalidListener = new Listener(null, mockListenerConfig);
+
+      await expect(invalidListener.establishConnection()).rejects.toThrow(
+        'Missing arguments in establishConnection'
+      );
+    });
+
+    it('should throw error when userId is missing', async () => {
+      const invalidConfig = { gameId: 'msfs' };
+      const invalidListener = new Listener(mockSocket, invalidConfig);
+
+      await expect(invalidListener.establishConnection()).rejects.toThrow(
+        'Missing arguments in establishConnection'
+      );
+    });
+
+    it('should throw error when gameId is missing', async () => {
+      const invalidConfig = { userId: 'user-123' };
+      const invalidListener = new Listener(mockSocket, invalidConfig);
+
+      await expect(invalidListener.establishConnection()).rejects.toThrow(
+        'Missing arguments in establishConnection'
+      );
+    });
+
+    it('should handle timeout error', async () => {
+      mockSocket.emit = jest.fn((event, data, callback) => {
+        callback(new Error('timeout'), null);
+      });
+
+      const result = await listener.establishConnection();
+
+      expect(result).toEqual({
+        status: 'failed',
+        reason: 'Listen request timed out.'
+      });
+    });
+
+    it('should handle failure response from server', async () => {
+      mockSocket.emit = jest.fn((event, data, callback) => {
+        callback(null, { status: 'failed', reason: 'Unauthorized' });
+      });
+
+      const result = await listener.establishConnection();
+
+      expect(result).toEqual({
+        status: 'failed',
+        reason: 'Unauthorized'
+      });
+    });
+  });
+
+  describe('setupEventListener', () => {
+    it('should register update event handler and return self', () => {
+      const result = listener.setupEventListener();
+
+      expect(mockSocket.on).toHaveBeenCalledWith('update', expect.any(Function));
+      expect(result).toBe(listener);
+    });
+
+    it('should filter update payload to subscribed fields only', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      // Simulate server sending full telemetry payload
+      const fullPayload = {
+        data: {
+          altitude: 35000,
+          airspeed: 250,
+          heading: 180,
+          fuel: 5000,
+          temperature: 25
+        }
+      };
+
+      // Trigger the update event
+      mockSocket._trigger('update', fullPayload);
+
+      // Should only receive subscribed fields: altitude, airspeed, heading (plus raw data)
+      expect(emitSpy).toHaveBeenCalledWith('update', {
+        raw: fullPayload.data,
+        data: {
+          altitude: 35000,
+          airspeed: 250,
+          heading: 180
+        }
+      });
+    });
+
+    it('should pass through full payload when no fields specified', () => {
+      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configNoFields);
+      const emitSpy = jest.fn();
+      listenerNoFields.emit = emitSpy;
+      listenerNoFields.setupEventListener();
+
+      const fullPayload = {
+        data: {
+          altitude: 35000,
+          airspeed: 250,
+          fuel: 5000
+        }
+      };
+
+      mockSocket._trigger('update', fullPayload);
+
+      // Should receive all fields (with raw data)
+      expect(emitSpy).toHaveBeenCalledWith('update', {
+        raw: fullPayload.data,
+        data: fullPayload.data
+      });
+    });
+
+    it('should handle payload with missing subscribed fields', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      // Server sends partial data (missing some subscribed fields)
+      const partialPayload = {
+        data: {
+          altitude: 35000
+          // airspeed and heading missing
+        }
+      };
+
+      mockSocket._trigger('update', partialPayload);
+
+      // Should only include fields that exist in payload (plus raw data)
+      expect(emitSpy).toHaveBeenCalledWith('update', {
+        raw: partialPayload.data,
+        data: {
+          altitude: 35000
+        }
+      });
+    });
+
+    it('should handle empty data payload', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      const emptyPayload = { data: {} };
+      mockSocket._trigger('update', emptyPayload);
+
+      expect(emitSpy).toHaveBeenCalledWith('update', { raw: {}, data: {} });
+    });
+
+    it('should handle null/undefined data gracefully', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      const nullPayload = { data: null };
+      mockSocket._trigger('update', nullPayload);
+
+      // Should pass through when data is null (with raw)
+      expect(emitSpy).toHaveBeenCalledWith('update', { raw: null, data: null });
+    });
+
+    it('should preserve other payload properties when filtering', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      const payloadWithMeta = {
+        data: { altitude: 35000, fuel: 5000 },
+        timestamp: 1234567890,
+        sequence: 42
+      };
+
+      mockSocket._trigger('update', payloadWithMeta);
+
+      expect(emitSpy).toHaveBeenCalledWith('update', {
+        raw: payloadWithMeta.data,
+        data: { altitude: 35000 },
+        timestamp: 1234567890,
+        sequence: 42
+      });
+    });
+
+    it('should reflect field changes after subscribe/unsubscribe', async () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      // Add a new field
+      await listener.subscribe(['fuel']);
+
+      const payload = {
+        data: { altitude: 35000, fuel: 5000, temperature: 25 }
+      };
+
+      mockSocket._trigger('update', payload);
+
+      // Should now include fuel (plus raw data)
+      expect(emitSpy).toHaveBeenCalledWith('update', {
+        raw: payload.data,
+        data: {
+          altitude: 35000,
+          fuel: 5000
+        }
+      });
+    });
+  });
+
+  describe('subscribe', () => {
+    it('should add new fields to subscription', async () => {
+      await listener.subscribe(['fuel', 'temperature']);
+
+      expect(listener._fields).toContain('altitude');
+      expect(listener._fields).toContain('fuel');
+      expect(listener._fields).toContain('temperature');
+    });
+
+    it('should not add duplicate fields', async () => {
+      await listener.subscribe(['altitude', 'fuel']);
+
+      const altitudeCount = listener._fields.filter(f => f === 'altitude').length;
+      expect(altitudeCount).toBe(1);
+      expect(listener._fields).toContain('fuel');
+    });
+
+    it('should emit listen-update event', async () => {
+      await listener.subscribe(['fuel']);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'listen-update',
+        expect.objectContaining({
+          userId: 'user-123',
+          gameId: 'msfs',
+          fields: expect.arrayContaining(['altitude', 'airspeed', 'heading', 'fuel'])
+        }),
+        expect.any(Function)
+      );
+    });
+
+    it('should initialize fields array if none existed', async () => {
+      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configNoFields);
+
+      await listenerNoFields.subscribe(['fuel', 'temperature']);
+
+      expect(listenerNoFields._fields).toEqual(['fuel', 'temperature']);
+    });
+
+    it('should throw error for non-array input', async () => {
+      await expect(listener.subscribe('fuel')).rejects.toThrow(
+        'fields must be a non-empty array'
+      );
+    });
+
+    it('should throw error for empty array', async () => {
+      await expect(listener.subscribe([])).rejects.toThrow(
+        'fields must be a non-empty array'
+      );
+    });
+  });
+
+  describe('unsubscribe', () => {
+    it('should remove fields from subscription', async () => {
+      await listener.unsubscribe(['altitude']);
+
+      expect(listener._fields).not.toContain('altitude');
+      expect(listener._fields).toContain('airspeed');
+      expect(listener._fields).toContain('heading');
+    });
+
+    it('should emit listen-update event with updated fields', async () => {
+      await listener.unsubscribe(['altitude', 'airspeed']);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'listen-update',
+        {
+          userId: 'user-123',
+          gameId: 'msfs',
+          fields: ['heading']
+        },
+        expect.any(Function)
+      );
+    });
+
+    it('should throw error when no explicit fields exist', async () => {
+      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configNoFields);
+
+      await expect(listenerNoFields.unsubscribe(['fuel'])).rejects.toThrow(
+        'Cannot unsubscribe when receiving all fields'
+      );
+    });
+
+    it('should throw error for non-array input', async () => {
+      await expect(listener.unsubscribe('altitude')).rejects.toThrow(
+        'fields must be a non-empty array'
+      );
+    });
+
+    it('should throw error for empty array', async () => {
+      await expect(listener.unsubscribe([])).rejects.toThrow(
+        'fields must be a non-empty array'
+      );
+    });
+
+    it('should handle unsubscribing non-existent field gracefully', async () => {
+      await listener.unsubscribe(['nonexistent']);
+
+      expect(listener._fields).toEqual(['altitude', 'airspeed', 'heading']);
+    });
+  });
+
+  describe('getFields', () => {
+    it('should return copy of fields array', () => {
+      const fields = listener.getFields();
+
+      expect(fields).toEqual(['altitude', 'airspeed', 'heading']);
+      expect(fields).not.toBe(listener._fields); // Should be a copy
+    });
+
+    it('should return null when no explicit fields', () => {
+      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configNoFields);
+
+      expect(listenerNoFields.getFields()).toBeNull();
+    });
+  });
+
+  describe('sendCommand', () => {
+    it('should emit set event with correct payload', async () => {
+      const result = await listener.sendCommand('autopilot', true);
+
+      expect(mockSocket.timeout).toHaveBeenCalledWith(5000);
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'set',
+        {
+          userId: 'user-123',
+          gameId: 'msfs',
+          data: {
+            fieldName: 'autopilot',
+            value: true
+          }
+        },
+        expect.any(Function)
+      );
+      expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should send canonical command without denormalizing', async () => {
+      await listener.sendCommand('gear_up', true);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'set',
+        expect.objectContaining({
+          data: {
+            fieldName: 'gear_up',
+            value: true
+          }
+        }),
+        expect.any(Function)
+      );
+    });
+
+    it('should handle various value types', async () => {
+      await listener.sendCommand('altitude', 35000);
+      await listener.sendCommand('flaps', 0.5);
+      await listener.sendCommand('status', 'active');
+      await listener.sendCommand('config', { mode: 'auto' });
+
+      expect(mockSocket.emit).toHaveBeenCalledTimes(4);
+    });
+
+    it('should throw error for invalid command', async () => {
+      await expect(listener.sendCommand('', true)).rejects.toThrow(
+        'command must be a non-empty string'
+      );
+      await expect(listener.sendCommand(null, true)).rejects.toThrow(
+        'command must be a non-empty string'
+      );
+      await expect(listener.sendCommand(123, true)).rejects.toThrow(
+        'command must be a non-empty string'
+      );
+    });
+
+    it('should handle timeout error', async () => {
+      mockSocket.emit = jest.fn((event, data, callback) => {
+        callback(new Error('timeout'), null);
+      });
+
+      const result = await listener.sendCommand('autopilot', true);
+
+      expect(result).toEqual({
+        status: 'failed',
+        reason: 'Command request timed out.'
+      });
+    });
+  });
+
+  describe('key events', () => {
+    it('should register handler for key-events', () => {
+      listener.setupEventListener();
+
+      expect(mockSocket.on).toHaveBeenCalledWith('key-events', expect.any(Function));
+    });
+
+    it('should emit landing event when received', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      const landingPayload = {
+        gameId: 'msfs',
+        eventType: 'landing',
+        data: {
+          landing_rate: -150,
+          quality: 'normal',
+          pitch_at_touchdown: 3.5,
+          roll_at_touchdown: 0.5,
+          speed_at_touchdown: 135,
+          heading_at_touchdown: 270,
+          position: { lat: 47.5, lon: -122.3 },
+          bounce_count: 0,
+          bounces: [],
+          timestamp: 1234567890
+        }
+      };
+
+      mockSocket._trigger('key-events', landingPayload);
+
+      expect(emitSpy).toHaveBeenCalledWith('landing', landingPayload.data);
+    });
+
+    it('should emit takeoff event when received', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      const takeoffPayload = {
+        gameId: 'msfs',
+        eventType: 'takeoff',
+        data: {
+          rotation_speed: 145,
+          pitch_at_liftoff: 10,
+          heading_at_liftoff: 270,
+          position: { lat: 47.5, lon: -122.3 },
+          flaps_setting: 0.2,
+          timestamp: 1234567890
+        }
+      };
+
+      mockSocket._trigger('key-events', takeoffPayload);
+
+      expect(emitSpy).toHaveBeenCalledWith('takeoff', takeoffPayload.data);
+    });
+
+    it('should emit flight_phase event when received', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      const phasePayload = {
+        gameId: 'msfs',
+        eventType: 'flight_phase',
+        data: {
+          phase: 'cruise',
+          previous_phase: 'climb',
+          altitude_agl: 34500,
+          altitude_msl: 35000,
+          speed: 280,
+          timestamp: 1234567890
+        }
+      };
+
+      mockSocket._trigger('key-events', phasePayload);
+
+      expect(emitSpy).toHaveBeenCalledWith('flight_phase', phasePayload.data);
+    });
+
+    it('should not emit event for different gameId', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      const otherGamePayload = {
+        gameId: 'xplane', // Different from listener's 'msfs'
+        eventType: 'landing',
+        data: { landing_rate: -100 }
+      };
+
+      mockSocket._trigger('key-events', otherGamePayload);
+
+      expect(emitSpy).not.toHaveBeenCalledWith('landing', expect.anything());
+    });
+
+    it('should handle null payload gracefully', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      mockSocket._trigger('key-events', null);
+
+      expect(emitSpy).not.toHaveBeenCalledWith('landing', expect.anything());
+      expect(emitSpy).not.toHaveBeenCalledWith('takeoff', expect.anything());
+      expect(emitSpy).not.toHaveBeenCalledWith('flight_phase', expect.anything());
+    });
+
+    it('should handle payload with missing eventType', () => {
+      const emitSpy = jest.fn();
+      listener.emit = emitSpy;
+      listener.setupEventListener();
+
+      const invalidPayload = {
+        gameId: 'msfs',
+        data: { landing_rate: -100 }
+        // eventType missing
+      };
+
+      mockSocket._trigger('key-events', invalidPayload);
+
+      expect(emitSpy).not.toHaveBeenCalledWith(undefined, expect.anything());
+    });
+  });
+});