homebridge-solaxcloud-api 2.5.0 → 2.5.1

package/test/helpers.ts

@@ -1,80 +1,80 @@
-import { API, Logging, MatterAccessory, MatterAPI } from 'homebridge';
-import { Characteristic, Service, uuid } from '@homebridge/hap-nodejs';
-import { createRequire } from 'module';
-import os from 'os';
-import path from 'path';
-
-const require = createRequire(import.meta.url);
-const { CharacteristicEventTypes, Formats, Perms } = require('@homebridge/hap-nodejs');
-
-export interface MatterApiHarness {
-  api: MatterAPI;
-  registrations: MatterAccessory[][];
-  updates: Array<{
-    uuid: string;
-    cluster: string;
-    attributes: Record<string, unknown>;
-  }>;
-}
-
-export function createLog(): Logging {
-  const noop = () => undefined;
-
-  return Object.assign(noop, {
-    debug: noop,
-    error: noop,
-    info: noop,
-    warn: noop,
-    log: noop,
-    prefix: '',
-  }) as unknown as Logging;
-}
-
-export function createApi(matter?: MatterAPI): API {
-  return {
-    hap: {
-      Characteristic,
-      CharacteristicEventTypes,
-      Formats,
-      Perms,
-      Service,
-      uuid,
-    },
-    on: () => undefined,
-    user: {
-      storagePath: () => path.join(os.tmpdir(), 'homebridge-solaxcloud-api-test'),
-    },
-    matter,
-  } as unknown as API;
-}
-
-export function createMatterApi(): MatterApiHarness {
-  const registrations: MatterAccessory[][] = [];
-  const updates: MatterApiHarness['updates'] = [];
-
-  const api = {
-    deviceTypes: {
-      ElectricalSensor: { name: 'ElectricalSensor' },
-    },
-    clusterNames: {
-      ElectricalPowerMeasurement: 'electricalPowerMeasurement',
-      ElectricalEnergyMeasurement: 'electricalEnergyMeasurement',
-    },
-    registerPlatformAccessories: async (
-      _pluginIdentifier: string,
-      _platformName: string,
-      accessories: MatterAccessory[],
-    ) => {
-      registrations.push(accessories);
-    },
-    updateAccessoryState: async (
-      uuid: string,
-      cluster: string,
-      attributes: Record<string, unknown>,
-    ) => {
-      updates.push({ uuid, cluster, attributes });
-    },
-  } as unknown as MatterAPI;
-
-  return { api, registrations, updates };
-}
+import { API, Logging, MatterAccessory, MatterAPI } from 'homebridge';
+import { Characteristic, Service, uuid } from '@homebridge/hap-nodejs';
+import { createRequire } from 'module';
+import os from 'os';
+import path from 'path';
+
+const require = createRequire(import.meta.url);
+const { CharacteristicEventTypes, Formats, Perms } = require('@homebridge/hap-nodejs');
+
+export interface MatterApiHarness {
+  api: MatterAPI;
+  registrations: MatterAccessory[][];
+  updates: Array<{
+    uuid: string;
+    cluster: string;
+    attributes: Record<string, unknown>;
+  }>;
+}
+
+export function createLog(): Logging {
+  const noop = () => undefined;
+
+  return Object.assign(noop, {
+    debug: noop,
+    error: noop,
+    info: noop,
+    warn: noop,
+    log: noop,
+    prefix: '',
+  }) as unknown as Logging;
+}
+
+export function createApi(matter?: MatterAPI): API {
+  return {
+    hap: {
+      Characteristic,
+      CharacteristicEventTypes,
+      Formats,
+      Perms,
+      Service,
+      uuid,
+    },
+    on: () => undefined,
+    user: {
+      storagePath: () => path.join(os.tmpdir(), 'homebridge-solaxcloud-api-test'),
+    },
+    matter,
+  } as unknown as API;
+}
+
+export function createMatterApi(): MatterApiHarness {
+  const registrations: MatterAccessory[][] = [];
+  const updates: MatterApiHarness['updates'] = [];
+
+  const api = {
+    deviceTypes: {
+      ElectricalSensor: { name: 'ElectricalSensor' },
+    },
+    clusterNames: {
+      ElectricalPowerMeasurement: 'electricalPowerMeasurement',
+      ElectricalEnergyMeasurement: 'electricalEnergyMeasurement',
+    },
+    registerPlatformAccessories: async (
+      _pluginIdentifier: string,
+      _platformName: string,
+      accessories: MatterAccessory[],
+    ) => {
+      registrations.push(accessories);
+    },
+    updateAccessoryState: async (
+      uuid: string,
+      cluster: string,
+      attributes: Record<string, unknown>,
+    ) => {
+      updates.push({ uuid, cluster, attributes });
+    },
+  } as unknown as MatterAPI;
+
+  return { api, registrations, updates };
+}

package/test/lightSensorAccessory.test.ts

@@ -1,73 +1,73 @@
-import assert from 'assert';
-
-import { SolaxLightSensorAccessory } from '../src/lightSensorAccessory.js';
-import { createApi, createLog, createMatterApi } from './helpers.js';
-
-describe('SolaxLightSensorAccessory', () => {
-  it('stores ambient light values and applies the HomeKit minimum', () => {
-    const sensor = new SolaxLightSensorAccessory(createLog(), createApi(), 'Light sensor', 'light-1', 'Model');
-
-    sensor.setAmbientLightLevel(0);
-    sensor.getAmbientLightLevel((error, value) => {
-      assert.equal(error, null);
-      assert.equal(value, 0.1);
-    });
-
-    sensor.setAmbientLightLevel(123);
-    sensor.getAmbientLightLevel((error, value) => {
-      assert.equal(error, null);
-      assert.equal(value, 123);
-    });
-  });
-
-  it('exposes information and light services', () => {
-    const sensor = new SolaxLightSensorAccessory(createLog(), createApi(), 'Light sensor', 'light-1', 'Model');
-
-    assert.equal(sensor.getServices().length, 2);
-    assert.equal(sensor.isMatterAccessory(), false);
-  });
-
-  it('registers and updates a Matter electrical sensor', async () => {
-    const matter = createMatterApi();
-    const sensor = new SolaxLightSensorAccessory(
-      createLog(),
-      createApi(matter.api),
-      'Power sensor',
-      'power-1',
-      'Model',
-      true,
-    );
-
-    assert.equal(sensor.getServices().length, 1);
-    assert.equal(sensor.isMatterAccessory(), true);
-    assert.equal(matter.registrations.length, 1);
-
-    const accessory = matter.registrations[0][0];
-    assert.equal(accessory.deviceType, matter.api.deviceTypes.ElectricalSensor);
-    assert.deepEqual(accessory.clusters, {
-      electricalPowerMeasurement: { activePower: 0 },
-      electricalEnergyMeasurement: {
-        cumulativeEnergyExported: { energy: 0 },
-      },
-    });
-
-    sensor.setAmbientLightLevel(123.456);
-    sensor.setTotalEnergyConsumption(12.345);
-    await new Promise(resolve => setImmediate(resolve));
-
-    assert.deepEqual(matter.updates, [
-      {
-        uuid: accessory.UUID,
-        cluster: 'electricalPowerMeasurement',
-        attributes: { activePower: 123456 },
-      },
-      {
-        uuid: accessory.UUID,
-        cluster: 'electricalEnergyMeasurement',
-        attributes: {
-          cumulativeEnergyExported: { energy: 12345 },
-        },
-      },
-    ]);
-  });
-});
+import assert from 'assert';
+
+import { SolaxLightSensorAccessory } from '../src/lightSensorAccessory.js';
+import { createApi, createLog, createMatterApi } from './helpers.js';
+
+describe('SolaxLightSensorAccessory', () => {
+  it('stores ambient light values and applies the HomeKit minimum', () => {
+    const sensor = new SolaxLightSensorAccessory(createLog(), createApi(), 'Light sensor', 'light-1', 'Model');
+
+    sensor.setAmbientLightLevel(0);
+    sensor.getAmbientLightLevel((error, value) => {
+      assert.equal(error, null);
+      assert.equal(value, 0.1);
+    });
+
+    sensor.setAmbientLightLevel(123);
+    sensor.getAmbientLightLevel((error, value) => {
+      assert.equal(error, null);
+      assert.equal(value, 123);
+    });
+  });
+
+  it('exposes information and light services', () => {
+    const sensor = new SolaxLightSensorAccessory(createLog(), createApi(), 'Light sensor', 'light-1', 'Model');
+
+    assert.equal(sensor.getServices().length, 2);
+    assert.equal(sensor.isMatterAccessory(), false);
+  });
+
+  it('registers and updates a Matter electrical sensor', async () => {
+    const matter = createMatterApi();
+    const sensor = new SolaxLightSensorAccessory(
+      createLog(),
+      createApi(matter.api),
+      'Power sensor',
+      'power-1',
+      'Model',
+      true,
+    );
+
+    assert.equal(sensor.getServices().length, 1);
+    assert.equal(sensor.isMatterAccessory(), true);
+    assert.equal(matter.registrations.length, 1);
+
+    const accessory = matter.registrations[0][0];
+    assert.equal(accessory.deviceType, matter.api.deviceTypes.ElectricalSensor);
+    assert.deepEqual(accessory.clusters, {
+      electricalPowerMeasurement: { activePower: 0 },
+      electricalEnergyMeasurement: {
+        cumulativeEnergyExported: { energy: 0 },
+      },
+    });
+
+    sensor.setAmbientLightLevel(123.456);
+    sensor.setTotalEnergyConsumption(12.345);
+    await new Promise(resolve => setImmediate(resolve));
+
+    assert.deepEqual(matter.updates, [
+      {
+        uuid: accessory.UUID,
+        cluster: 'electricalPowerMeasurement',
+        attributes: { activePower: 123456 },
+      },
+      {
+        uuid: accessory.UUID,
+        cluster: 'electricalEnergyMeasurement',
+        attributes: {
+          cumulativeEnergyExported: { energy: 12345 },
+        },
+      },
+    ]);
+  });
+});

package/test/motionAccessory.test.ts

@@ -1,36 +1,36 @@
-import assert from 'assert';
-
-import { SolaxMotionAccessory } from '../src/motionAccessory.js';
-import { createApi, createLog } from './helpers.js';
-
-function sleep(millis: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, millis));
-}
-
-describe('SolaxMotionAccessory', () => {
-  it('stores motion state and clears it after the configured timeout', async () => {
-    const motion = new SolaxMotionAccessory(createLog(), createApi(), 'Motion', 'motion-1', 'Model');
-
-    motion.setMotionTimeout(0);
-    assert.equal(motion.getMotionTimeout(), 0);
-
-    motion.setState(true);
-    motion.getState((error, value) => {
-      assert.equal(error, null);
-      assert.equal(value, true);
-    });
-
-    await sleep(5);
-
-    motion.getState((error, value) => {
-      assert.equal(error, null);
-      assert.equal(value, false);
-    });
-  });
-
-  it('exposes information and motion services', () => {
-    const motion = new SolaxMotionAccessory(createLog(), createApi(), 'Motion', 'motion-1', 'Model');
-
-    assert.equal(motion.getServices().length, 2);
-  });
-});
+import assert from 'assert';
+
+import { SolaxMotionAccessory } from '../src/motionAccessory.js';
+import { createApi, createLog } from './helpers.js';
+
+function sleep(millis: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, millis));
+}
+
+describe('SolaxMotionAccessory', () => {
+  it('stores motion state and clears it after the configured timeout', async () => {
+    const motion = new SolaxMotionAccessory(createLog(), createApi(), 'Motion', 'motion-1', 'Model');
+
+    motion.setMotionTimeout(0);
+    assert.equal(motion.getMotionTimeout(), 0);
+
+    motion.setState(true);
+    motion.getState((error, value) => {
+      assert.equal(error, null);
+      assert.equal(value, true);
+    });
+
+    await sleep(5);
+
+    motion.getState((error, value) => {
+      assert.equal(error, null);
+      assert.equal(value, false);
+    });
+  });
+
+  it('exposes information and motion services', () => {
+    const motion = new SolaxMotionAccessory(createLog(), createApi(), 'Motion', 'motion-1', 'Model');
+
+    assert.equal(motion.getServices().length, 2);
+  });
+});

package/test/outletAccessory.test.ts

@@ -1,75 +1,75 @@
-import assert from 'assert';
-import { SolaxOutletAccessory } from '../src/outletAccessory.js';
-import { createApi, createLog } from './helpers.js';
-
-describe('SolaxOutletAccessory', () => {
-  function withOutlet(test: (outlet: SolaxOutletAccessory) => void): void {
-    const api = createApi();
-    const outlet = new SolaxOutletAccessory(createLog(), api, 'Outlet', 'outlet-1', 'Model');
-
-    try {
-      test(outlet);
-    } finally {
-      api['globalFakeGatoTimer']?.stop();
-    }
-  }
-
-  it('stores power values, clamps negative power, and tracks power series', () => {
-    withOutlet(outlet => {
-      outlet.setPowerConsumption(-10);
-      assert.equal(outlet.getPowerConsumptionValue(), 0);
-
-      outlet.getState((error, value) => {
-        assert.equal(error, null);
-        assert.equal(value, false);
-      });
-
-      outlet.setPowerConsumption(42);
-      assert.equal(outlet.getPowerConsumptionValue(), 42);
-      assert.deepEqual(outlet.getPowerSeries(), [0, 42]);
-
-      outlet.getState((error, value) => {
-        assert.equal(error, null);
-        assert.equal(value, true);
-      });
-    });
-  });
-
-  it('stores total energy consumption', () => {
-    withOutlet(outlet => {
-      outlet.setTotalEnergyConsumption(12.5);
-      assert.equal(outlet.getTotalEnergyConsumptionValue(), 12.5);
-
-      outlet.getTotalEnergyConsumption((error, value) => {
-        assert.equal(error, null);
-        assert.equal(value, 12.5);
-      });
-    });
-  });
-
-  it('calculates smoothed power from the stored power series', () => {
-    withOutlet(outlet => {
-      outlet.setPowerConsumption(10);
-      outlet.setPowerConsumption(20);
-      outlet.setPowerConsumption(30);
-
-      assert.equal(outlet.getSmoothPowerConsumption('sma', 3), 20);
-      assert.equal(outlet.getSmoothPowerConsumption('ema', 3), 15);
-    });
-  });
-
-  it('exposes information, outlet, and history services', () => {
-    withOutlet(outlet => {
-      assert.equal(outlet.getServices().length, 3);
-    });
-  });
-
-  it('does not create history service when history is disabled', () => {
-    const outlet = new SolaxOutletAccessory(createLog(), createApi(), 'Outlet', 'outlet-1', 'Model', false);
-
-    outlet.setPowerConsumption(42);
-
-    assert.equal(outlet.getPowerConsumptionValue(), 42);
-    assert.equal(outlet.getServices().length, 2);
-  });
-});
+import assert from 'assert';
+import { SolaxOutletAccessory } from '../src/outletAccessory.js';
+import { createApi, createLog } from './helpers.js';
+
+describe('SolaxOutletAccessory', () => {
+  function withOutlet(test: (outlet: SolaxOutletAccessory) => void): void {
+    const api = createApi();
+    const outlet = new SolaxOutletAccessory(createLog(), api, 'Outlet', 'outlet-1', 'Model');
+
+    try {
+      test(outlet);
+    } finally {
+      api['globalFakeGatoTimer']?.stop();
+    }
+  }
+
+  it('stores power values, clamps negative power, and tracks power series', () => {
+    withOutlet(outlet => {
+      outlet.setPowerConsumption(-10);
+      assert.equal(outlet.getPowerConsumptionValue(), 0);
+
+      outlet.getState((error, value) => {
+        assert.equal(error, null);
+        assert.equal(value, false);
+      });
+
+      outlet.setPowerConsumption(42);
+      assert.equal(outlet.getPowerConsumptionValue(), 42);
+      assert.deepEqual(outlet.getPowerSeries(), [0, 42]);
+
+      outlet.getState((error, value) => {
+        assert.equal(error, null);
+        assert.equal(value, true);
+      });
+    });
+  });
+
+  it('stores total energy consumption', () => {
+    withOutlet(outlet => {
+      outlet.setTotalEnergyConsumption(12.5);
+      assert.equal(outlet.getTotalEnergyConsumptionValue(), 12.5);
+
+      outlet.getTotalEnergyConsumption((error, value) => {
+        assert.equal(error, null);
+        assert.equal(value, 12.5);
+      });
+    });
+  });
+
+  it('calculates smoothed power from the stored power series', () => {
+    withOutlet(outlet => {
+      outlet.setPowerConsumption(10);
+      outlet.setPowerConsumption(20);
+      outlet.setPowerConsumption(30);
+
+      assert.equal(outlet.getSmoothPowerConsumption('sma', 3), 20);
+      assert.equal(outlet.getSmoothPowerConsumption('ema', 3), 15);
+    });
+  });
+
+  it('exposes information, outlet, and history services', () => {
+    withOutlet(outlet => {
+      assert.equal(outlet.getServices().length, 3);
+    });
+  });
+
+  it('does not create history service when history is disabled', () => {
+    const outlet = new SolaxOutletAccessory(createLog(), createApi(), 'Outlet', 'outlet-1', 'Model', false);
+
+    outlet.setPowerConsumption(42);
+
+    assert.equal(outlet.getPowerConsumptionValue(), 42);
+    assert.equal(outlet.getServices().length, 2);
+  });
+});

package/test/platformAccessory.test.ts

@@ -1,24 +1,24 @@
-import assert from 'assert';
-
-import { SolaxPlatformAccessory } from '../src/platformAccessory.js';
-import { createApi, createLog } from './helpers.js';
-
-describe('SolaxPlatformAccessory', () => {
-  it('exposes normalized model and stable hashed serial information', () => {
-    const accessory = new SolaxPlatformAccessory(createLog(), createApi(), 'Base accessory', 'serial-1', 'Model / 1!');
-
-    assert.equal(accessory.getModel(), 'Model  1');
-    assert.notEqual(accessory.getSerial(), 'serial-1');
-    assert.equal(accessory.getServices().length, 1);
-  });
-
-  it('updates model and serial characteristics', () => {
-    const accessory = new SolaxPlatformAccessory(createLog(), createApi(), 'Base accessory', 'serial-1', 'Model');
-
-    accessory.setModel('Updated Model');
-    accessory.setSerial('updated-serial');
-
-    assert.equal(accessory.getModel(), 'Updated Model');
-    assert.equal(accessory.getSerial(), 'updated-serial');
-  });
-});
+import assert from 'assert';
+
+import { SolaxPlatformAccessory } from '../src/platformAccessory.js';
+import { createApi, createLog } from './helpers.js';
+
+describe('SolaxPlatformAccessory', () => {
+  it('exposes normalized model and stable hashed serial information', () => {
+    const accessory = new SolaxPlatformAccessory(createLog(), createApi(), 'Base accessory', 'serial-1', 'Model / 1!');
+
+    assert.equal(accessory.getModel(), 'Model  1');
+    assert.notEqual(accessory.getSerial(), 'serial-1');
+    assert.equal(accessory.getServices().length, 1);
+  });
+
+  it('updates model and serial characteristics', () => {
+    const accessory = new SolaxPlatformAccessory(createLog(), createApi(), 'Base accessory', 'serial-1', 'Model');
+
+    accessory.setModel('Updated Model');
+    accessory.setSerial('updated-serial');
+
+    assert.equal(accessory.getModel(), 'Updated Model');
+    assert.equal(accessory.getSerial(), 'updated-serial');
+  });
+});