@homebridge-plugins/homebridge-tuya 3.0.0-beta.2 → 3.0.0-beta.21

package/test/Logger.test.ts

@@ -0,0 +1,482 @@
+import { beforeEach, describe, expect, jest, test } from '@jest/globals';
+import { EOL } from 'os';
+import Logger, { initLogger, logger, PrefixLogger } from '../src/shared/util/Logger';
+
+describe('Logger', () => {
+  const output:string[] = [];
+  let spyStdout;
+  let spyStderr;
+  beforeEach(() => {
+    output.splice(0, output.length);
+    spyStdout = jest
+      .spyOn(process.stdout, 'write')
+      .mockImplementation((value) => {
+        const str = String(value);
+        if (str.startsWith('  ')) {
+          output.push(str.split(/\r\n|\r|\n/)[1].replace(/^    /, ''));
+        }
+        return true;
+      });
+    spyStderr = jest
+      .spyOn(process.stderr, 'write')
+      .mockImplementation((value) => {
+        const str = String(value);
+        if (str.startsWith('  ')) {
+          output.push(str.split(/\r\n|\r|\n/)[1].replace(/^    /, ''));
+        }
+        return true;
+      });
+    jest.clearAllMocks();
+  });
+
+  describe('info log', () => {
+    test('string message', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyInfo = jest.spyOn(mockLog, 'info');
+      instance.info('info');
+      expect(spyInfo).toHaveBeenCalledWith('[test] info');
+    });
+
+    test('number message', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyInfo = jest.spyOn(mockLog, 'info');
+      instance.info(1);
+      expect(spyInfo).toHaveBeenCalledWith('[test] 1');
+    });
+
+    test('object message', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        success: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyInfo = jest.spyOn(mockLog, 'info');
+      instance.info({ info: 'message'});
+      expect(spyInfo).toHaveBeenCalledWith('[test] { info: \'message\' }');
+    });
+
+    test('array message', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        success: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyInfo = jest.spyOn(mockLog, 'info');
+      instance.info(['a', 'b', 'c']);
+      expect(spyInfo).toHaveBeenCalledWith('[test] [ \'a\', \'b\', \'c\' ]');
+    });
+
+    test('message with arguments', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        success: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyInfo = jest.spyOn(mockLog, 'info');
+      instance.info('with arguments %s, %o', 'args', { arg: 'object' });
+      expect(spyInfo).toHaveBeenCalledWith("[test] with arguments %s, %o", "args", {"arg": "object"});
+    });
+  });
+
+  describe('success log', () => {
+    test('success method unavailable', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyInfo = jest.spyOn(mockLog, 'info');
+      instance.success('successed');
+      expect(spyInfo).toHaveBeenCalledWith('[test] successed');
+    });
+
+    test('success method available', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        success: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spySuccess = jest.spyOn(mockLog as any, 'success');
+      instance.success('successed');
+      expect(spySuccess).toHaveBeenCalledWith('[test] successed');
+    });
+
+    test('number message, success method unavailable', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyInfo = jest.spyOn(mockLog, 'info');
+      instance.success(1);
+      expect(spyInfo).toHaveBeenCalledWith('[test] 1');
+    });
+
+    test('number message. success method available', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        success: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spySuccess = jest.spyOn(mockLog as any, 'success');
+      instance.success(1);
+      expect(spySuccess).toHaveBeenCalledWith('[test] 1');
+    });
+
+    test('message with arguments(success method unavailable)', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyInfo = jest.spyOn(mockLog, 'info');
+      instance.success('with arguments %s, %o', 'args', { arg: 'object' });
+      expect(spyInfo).toHaveBeenCalledWith("[test] with arguments %s, %o", "args", {"arg": "object"});
+    });
+
+    test('message with arguments(success method available)', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        success: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spySuccess = jest.spyOn(mockLog as any, 'success');
+      instance.success('with arguments %s, %o', 'args', { arg: 'object' });
+      expect(spySuccess).toHaveBeenCalledWith("[test] with arguments %s, %o", "args", {"arg": "object"});
+    });
+  });
+
+  describe('debug log', () => {
+    test('debugMode disabled', () => {
+      const instance = new PrefixLogger(console, 'test', false);
+      const spyInfo = jest.spyOn(console, 'info');
+      const spyDebug = jest.spyOn(console, 'debug');
+      instance.debug('debug');
+      expect(spyInfo).toHaveBeenCalledTimes(0);
+      expect(spyDebug).toHaveBeenCalledWith('[test] debug');
+    });
+
+    test('debugMode enabled. (string)', () => {
+      const instance = new PrefixLogger(console, 'test', true);
+      const spyInfo = jest.spyOn(console, 'info');
+      const spyDebug = jest.spyOn(console, 'debug');
+      instance.debug('debug');
+      expect(spyInfo).toHaveBeenCalledTimes(1);
+      expect(spyDebug).toHaveBeenCalledTimes(0);
+      expect(spyInfo).toHaveBeenCalledWith('[test] debug');
+    });
+
+    test('debugMode enabled. (non-string)', () => {
+      const instance = new PrefixLogger(console, 'test', true);
+      const spyInfo = jest.spyOn(console, 'info');
+      const spyDebug = jest.spyOn(console, 'debug');
+      instance.debug({ debug: 'enabled' });
+      expect(spyInfo).toHaveBeenCalledTimes(1);
+      expect(spyDebug).toHaveBeenCalledTimes(0);
+      expect(spyInfo).toHaveBeenCalledWith('[test] { debug: \'enabled\' }');
+    });
+
+    test('number message', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyDebug = jest.spyOn(mockLog, 'debug');
+      instance.debug(1);
+      expect(spyDebug).toHaveBeenCalledWith('[test] 1');
+    });
+
+    test('message with arguments', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyDebug = jest.spyOn(mockLog as any, 'debug');
+      instance.debug('with arguments %s, %o', 'args', { arg: 'object' });
+      expect(spyDebug).toHaveBeenCalledWith("[test] with arguments %s, %o", "args", {"arg": "object"});
+    });
+  });
+
+  describe('warn log', () => {
+    test('string message', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyWarn = jest.spyOn(mockLog, 'warn');
+      instance.warn('warn');
+      expect(spyWarn).toHaveBeenCalledWith('[test] warn');
+    });
+
+    test('number message', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyWarn = jest.spyOn(mockLog, 'warn');
+      instance.warn(1);
+      expect(spyWarn).toHaveBeenCalledWith('[test] 1');
+    });
+
+    test('message with arguments', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyWarn = jest.spyOn(mockLog as any, 'warn');
+      instance.warn('with arguments %s, %o', 'args', { arg: 'object' });
+      expect(spyWarn).toHaveBeenCalledWith("[test] with arguments %s, %o", "args", {"arg": "object"});
+    });
+  });
+
+  describe('error log', () => {
+    test('string message', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyError = jest.spyOn(mockLog, 'error');
+      instance.error('error');
+      expect(spyError).toHaveBeenCalledWith('[test] error');
+    });
+
+    test('number message', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyError = jest.spyOn(mockLog, 'error');
+      instance.error(1);
+      expect(spyError).toHaveBeenCalledWith('[test] 1');
+    });
+
+    test('message with arguments', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test', false);
+      const spyError = jest.spyOn(mockLog as any, 'error');
+      instance.error('with arguments %s, %o', 'args', { arg: 'object' });
+      expect(spyError).toHaveBeenCalledWith("[test] with arguments %s, %o", "args", {"arg": "object"});
+    });
+  });
+
+  describe('init logger', () => {
+    test('before initLogger', () => {
+      expect(logger()).toBe(console);
+    });
+
+    test('after initLogger', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      initLogger(mockLog);
+      expect(logger()).toBe(mockLog);
+    });
+    
+    test('undefined prefix', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, undefined, false);
+      const spyInfo = jest.spyOn(mockLog, 'info');
+      instance.info('noprefix');
+      expect(spyInfo).toHaveBeenCalledWith('[] noprefix');
+    });
+    
+    test('undefined debugMode', () => {
+      const mockLog = {
+        info: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      } as Logger;
+      const instance = new PrefixLogger(mockLog, 'test');
+      expect(instance.debugMode).toBe(false);
+    });
+  });
+  
+  describe('masking()', () => {
+    test('Return as-is when masking is OFF (string)', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', true);
+      const input = `'password': 'abc'`;
+      expect((instance as any).masking(input)).toBe(input);
+    });
+
+    test('Return as-is when masking is OFF (object)', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', true);
+      const input = { password: 'abc' };
+      expect((instance as any).masking(input)).toBe(input);
+    });
+
+    test('Mask the password', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', false);
+      const input = `'password': 'abc'`;
+      const output = `'password': '********'`;
+      expect((instance as any).masking(input)).toBe(output);
+    });
+
+    test('Mask the token', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', false);
+      const input = `'token' : 'abcdef'`;
+      const output = `'token': '********'`;
+      expect((instance as any).masking(input)).toBe(output);
+    });
+
+    test('Mask the password in line', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', false);
+      const input = `abc 'password': 'abc' def`;
+      const output = `abc 'password': '********' def`;
+      expect((instance as any).masking(input)).toBe(output);
+    });
+
+    test('Two maskable targets within the string.', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', false);
+      const input = `'password': 'abc', 'password': 'def'`;
+      const output = `'password': '********', 'password': '********'`;
+      expect((instance as any).masking(input)).toBe(output);
+    });
+
+    test('Mask only the target lines in multi-line text', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', false);
+      const input = [
+        `normal line`,
+        `'password' : '123456'`,
+        `another line`,
+        `'apiKey': 'xyz'`
+      ].join('\n');
+
+      const expected = [
+        `normal line`,
+        `'password': '********'`,
+        `another line`,
+        `'apiKey': '********'`
+      ].join(EOL);
+      expect((instance as any).masking(input)).toBe(expected);
+    });
+
+    test('Leave unmatched strings unchanged', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', false);
+      const input = `no sensitive data here`;
+      expect((instance as any).masking(input)).toBe(input);
+    });
+
+    test('Leave unmatched objects unchanged', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', false);
+      const input = { test: 'unchanged' };
+      expect((instance as any).masking(input)).toBe(input);
+    });
+  });
+
+  describe('maskingValue()', () => {
+    test('Mask object value', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', false);
+      const input = {
+        id: 'testID',
+        password: 'testPassword',
+        token: 'testToken',
+        accessToken: 'testAccessToken',
+        Access_Token: 'testAccess_Token',
+        aCcEsSkEy: 'testAccessKey',
+        tuyakey: 'testTuyaKey',
+        api_key: 'testApiKey',
+        secret: 'testSecret',
+        name: 'testName',
+        obj: {
+          password: 'test-objpassword'
+        },
+        func: () => 'test'
+      };
+
+      const expected = {
+        id: 'testID',
+        password: '************',
+        token: '*********',
+        accessToken: '***************',
+        Access_Token: '****************',
+        aCcEsSkEy: '*************',
+        tuyakey: '***********',
+        api_key: '**********',
+        secret: '**********',
+        name: 'testName',
+        obj: {
+          password: '****************'
+        },
+        func: input.func
+      };
+      expect((instance as any).maskingValue(input)).toEqual(expected);
+    });
+
+    test('Leave matched objects unchanged', () => {
+      const instance = new PrefixLogger(console as unknown as Logger, 'test', true);
+      const input = { password: 'test' };
+      expect((instance as any).maskingValue(input)).toBe(input);
+    });
+  });
+});

package/test/accessoryFactory.data.test.ts

@@ -0,0 +1,172 @@
+/* eslint-disable no-console */
+import { describe, expect, test, beforeEach, jest } from '@jest/globals';
+import { PlatformAccessory, Service } from 'homebridge';
+import AccessoryFactory from '../src/shared/accessory/AccessoryFactory';
+import TuyaDevice from '../src/cloud/device/TuyaDevice';
+import { TuyaPlatform, TuyaPluginAccessoryContext } from '../src/platform';
+import { ExLogger, initLogger } from '../src/shared/util/Logger';
+import cz from './data/cz/wja8imamn8sj2sjf.json';
+import qn from './data/qn/eabctkdf7akikibf.json';
+import SwitchAccessory from '../src/shared/accessory/SwitchAccessory';
+import HeaterAccessory from '../src/shared/accessory/HeaterAccessory';
+
+describe('AccessoryFactory data sample', () => {
+  let mockPlatform: Partial<TuyaPlatform>;
+  let mockAccessory: Partial<PlatformAccessory>;
+  let mockAccessoryService: Partial<Service>;
+
+  beforeEach(() => {
+    // Mock Logger
+    const mockLog: ExLogger = {
+      debug: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+      log: jest.fn(),
+      success: jest.fn(),
+    } as unknown as ExLogger;
+    initLogger(console);
+
+    // Create proper HAP mock structure
+    class MockService {
+      static AccessoryInformation = class {};
+      static Lightbulb = class {};
+      static Switch = class {};
+      static Outlet = class {};
+      static Fan = class {};
+      static Thermostat = class {};
+      static WindowCovering = class {};
+      static GarageDoorOpener = class {};
+      static LockMechanism = class {};
+      static Valve = class {};
+      static HeaterCooler = class {};
+      static Microphone = class {};
+      static Speaker = class {};
+    }
+
+    class MockCharacteristic {
+      static On = { UUID: 'uuid-on' };
+      static Brightness = { UUID: 'uuid-brightness' };
+      static Name = { UUID: 'uuid-name' };
+      static Manufacturer = { UUID: 'uuid-manufacturer' };
+      static Model = { UUID: 'uuid-model' };
+      static SerialNumber = { UUID: 'uuid-sn' };
+      static AccessoryFlags = { UUID: 'uuid-flags' };
+      static Identify = { UUID: 'uuid-identify' };
+      static CurrentTemperature = { UUID: 'uuid-temp' };
+      static TargetTemperature = { UUID: 'uuid-target-temp' };
+      static CurrentRelativeHumidity = { UUID: 'uuid-humidity' };
+      static Saturation = { UUID: 'uuid-saturation' };
+      static Hue = { UUID: 'uuid-hue' };
+      static ColorTemperature = { UUID: 'uuid-color-temp' };
+      static RotationSpeed = { UUID: 'uuid-rotation' };
+      static CurrentPosition = { UUID: 'uuid-position' };
+      static TargetPosition = { UUID: 'uuid-target-pos' };
+      static LockCurrentState = { UUID: 'uuid-lock-state' };
+      static LockTargetState = { UUID: 'uuid-lock-target' };
+      static LockPhysicalControls = { UUID: 'uuid-lock-physical-controls' };
+      static Active = { UUID: 'uuid-active', INACTIVE: 0, ACTIVE: 1 };
+      static CurrentHeatingCoolingState = { UUID: 'uuid-heating-cooling', OFF: 0, HEAT: 1, COOL: 2, AUTO: 3 };
+      static TargetHeatingCoolingState = { UUID: 'uuid-target-heating-cooling', OFF: 0, HEAT: 1, COOL: 2, AUTO: 3 };
+      static TemperatureDisplayUnits = { UUID: 'uuid-temp-units', CELSIUS: 0, FAHRENHEIT: 1 };
+      static CurrentHeaterCoolerState = { UUID: 'uuid-current-heater-cooler', IDLE: 0, HEATING: 1, COOLING: 2 };
+      static TargetHeaterCoolerState = { UUID: 'uuid-target-heater-cooler', OFF: 0, HEAT: 1, COOL: 2, AUTO: 3 };
+    }
+
+    mockPlatform = {
+      log: mockLog,
+      config: {} as any,
+      api: {
+        hap: {
+          Service: MockService as any,
+          Characteristic: MockCharacteristic as any,
+          CameraController: jest.fn(),
+        },
+      } as any,
+      accessories: [],
+      Service: MockService as any,
+      Characteristic: MockCharacteristic as any,
+      platformConfig: {
+        options: {
+          debug: false,
+          debugLevel: '',
+        }
+      },
+      deviceManager: {
+        getDevice: jest.fn(),
+        getDeviceSchemaConfig: jest.fn().mockReturnValue({})
+      },
+    } as any;
+
+    mockAccessoryService = {
+      testCharacteristic: jest.fn().mockReturnValue(true),
+      setCharacteristic: jest.fn().mockReturnThis(),
+      getCharacteristic: jest.fn().mockReturnValue({
+        onGet: jest.fn().mockReturnThis(),
+        onSet: jest.fn().mockReturnThis(),
+        setProps: jest.fn().mockReturnThis(),
+      }),
+    } as any;
+
+    mockAccessory = {
+      UUID: 'test-uuid',
+      displayName: 'Test Device',
+      context: {
+        deviceID: 'test_device',
+      },
+      services: [],
+      getService: jest.fn().mockReturnValue(mockAccessoryService),
+      addService: jest.fn().mockReturnValue(mockAccessoryService),
+      removeService: jest.fn().mockReturnThis(),
+      removeAllListeners: jest.fn(),
+      on: jest.fn(),
+      once: jest.fn(),
+      configureController: jest.fn(),
+    } as any;
+  });
+
+  test('SwitchAccessory', () => {
+    const device = new TuyaDevice(cz as any);
+
+    mockPlatform.deviceManager = {
+      ...mockPlatform.deviceManager,
+      getDevice: jest.fn().mockReturnValue(device),
+      getDeviceSchemaConfig: jest.fn().mockReturnValue(undefined)
+    } as any;
+
+    const spyGetCharacteristic = jest.spyOn(mockAccessoryService, 'getCharacteristic');
+
+    const accessory = AccessoryFactory.createAccessory(
+      mockPlatform as TuyaPlatform,
+      mockAccessory as PlatformAccessory<TuyaPluginAccessoryContext>,
+      device,
+    );
+
+    expect(accessory).toBeDefined();
+    expect(accessory).toBeInstanceOf(SwitchAccessory);
+    expect(spyGetCharacteristic).toHaveBeenCalledWith(mockPlatform.Characteristic!.On);
+    expect(spyGetCharacteristic).toHaveBeenCalledWith(mockPlatform.Characteristic!.InUse);
+  });
+
+  test('HeaterAccessory', () => {
+    const device = new TuyaDevice(qn as any);
+
+    mockPlatform.deviceManager = {
+      ...mockPlatform.deviceManager,
+      getDevice: jest.fn().mockReturnValue(device),
+      getDeviceSchemaConfig: jest.fn().mockReturnValue(undefined)
+    } as any;
+
+    const spyGetCharacteristic = jest.spyOn(mockAccessoryService, 'getCharacteristic');
+
+    const accessory = AccessoryFactory.createAccessory(
+      mockPlatform as TuyaPlatform,
+      mockAccessory as PlatformAccessory<TuyaPluginAccessoryContext>,
+      device,
+    );
+
+    expect(accessory).toBeDefined();
+    expect(accessory).toBeInstanceOf(HeaterAccessory);
+    expect(spyGetCharacteristic).toHaveBeenCalledWith(mockPlatform.Characteristic!.Active);
+  });
+});