@digital-alchemy/hass 24.9.3 → 24.9.5

package/src/testing/device.spec.ts

@@ -0,0 +1,89 @@
+import { sleep } from "@digital-alchemy/core";
+
+import { DeviceDetails } from "../helpers";
+import { hassTestRunner } from "../mock_assistant";
+
+describe("Device", () => {
+  const EXAMPLE_DEVICE = {
+    area_id: null,
+    config_entries: ["42816b768aa8697c18c1b6d241112cef"],
+    configuration_url: null,
+    connections: [],
+    disabled_by: null,
+    entry_type: "service",
+    hw_version: null,
+    id: "e328cb3f7ec4e37b3b102374b05c37a9",
+    identifiers: [["hassio", "core"]],
+    labels: [],
+    manufacturer: "Home Assistant",
+    model: "Home Assistant Core",
+    name: "Home Assistant Core",
+    name_by_user: null,
+    serial_number: null,
+    sw_version: "2024.4.3",
+    via_device_id: null,
+  } as unknown as DeviceDetails;
+
+  afterEach(async () => {
+    await hassTestRunner.teardown();
+    jest.restoreAllMocks();
+  });
+
+  describe("Lifecycle", () => {
+    it("should force values to be available before ready", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        const spy = jest
+          .spyOn(hass.socket, "sendMessage")
+          .mockImplementation(async () => [EXAMPLE_DEVICE]);
+        lifecycle.onReady(async () => {
+          await hass.device.list();
+          expect(spy).toHaveBeenCalledWith(
+            expect.objectContaining({ type: "config/device_registry/list" }),
+          );
+        });
+      });
+    });
+  });
+
+  it("should debounce updates properly", async () => {
+    expect.assertions(1);
+    await hassTestRunner.run(({ lifecycle, hass }) => {
+      jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+      let counter = 0;
+      hass.events.onDeviceRegistryUpdate(() => counter++);
+      lifecycle.onReady(async () => {
+        setImmediate(async () => {
+          hass.socket.socketEvents.emit("device_registry_updated");
+          await sleep(5);
+          hass.socket.socketEvents.emit("device_registry_updated");
+          await sleep(5);
+          hass.socket.socketEvents.emit("device_registry_updated");
+          await sleep(75);
+          hass.socket.socketEvents.emit("device_registry_updated");
+        });
+        await sleep(200);
+        expect(counter).toBe(2);
+      });
+    });
+  });
+
+  describe("API", () => {
+    describe("Formatting", () => {
+      it("should call list properly", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass }) => {
+          const spy = jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => []);
+          lifecycle.onReady(async () => {
+            await hass.device.list();
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({
+                type: "config/device_registry/list",
+              }),
+            );
+          });
+        });
+      });
+    });
+  });
+});

package/src/testing/entity.spec.ts

@@ -0,0 +1,171 @@
+import { sleep } from "@digital-alchemy/core";
+
+import { ANY_ENTITY, ENTITY_STATE } from "../helpers";
+import { hassTestRunner } from "../mock_assistant";
+
+describe("Entity", () => {
+  afterEach(async () => {
+    await hassTestRunner.teardown();
+    jest.restoreAllMocks();
+  });
+
+  describe("API", () => {
+    describe("Updates", () => {
+      xit("should debounce updates properly", async () => {
+        expect.assertions(1);
+        await new Promise<void>(async done => {
+          await hassTestRunner.run(({ hass }) => {
+            const spy = jest.fn();
+            hass.events.onEntityRegistryUpdate(spy);
+            hass.socket.onConnect(async () => {
+              setImmediate(async () => {
+                hass.socket.socketEvents.emit("entity_registry_updated");
+                await sleep(5);
+                hass.socket.socketEvents.emit("entity_registry_updated");
+                await sleep(5);
+                hass.socket.socketEvents.emit("entity_registry_updated");
+                await sleep(20);
+                hass.socket.socketEvents.emit("entity_registry_updated");
+              });
+              await sleep(50);
+              expect(spy).toHaveReturnedTimes(2);
+              done();
+            });
+          });
+        });
+      });
+
+      it("should emit updates on change", async () => {
+        expect.assertions(3);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          lifecycle.onReady(() => {
+            const old_state = hass.entity.getCurrentState("sensor.magic");
+            const new_state = { ...old_state, state: "test" };
+            const spy = jest.spyOn(event, "emit");
+            hass.entity._entityUpdateReceiver("sensor.magic", new_state, old_state);
+            expect(spy).toHaveReturnedTimes(2);
+            expect(spy).toHaveBeenCalledWith("sensor.magic", new_state, old_state);
+            expect(spy).toHaveBeenCalledWith(
+              "e1806fdc93296bbd5ab42967003cd38729ff9ba6cfeefc3e15a03ad01ac894fe",
+              new_state,
+              old_state,
+            );
+          });
+        });
+      });
+
+      it("returns undefined from nextState when timeout is exceeded", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass }) => {
+          lifecycle.onReady(async () => {
+            const entity = hass.refBy.id("sensor.magic");
+            const old_state = hass.entity.getCurrentState("sensor.magic");
+
+            // Set a timeout of 100ms
+            const wait = new Promise<ENTITY_STATE<ANY_ENTITY> | undefined>(async done => {
+              done(await entity.nextState(25));
+            });
+
+            // Simulate delay longer than the timeout to ensure timeout is exceeded
+            setTimeout(() => {
+              const new_state = { ...old_state, state: "test" };
+              hass.entity._entityUpdateReceiver("sensor.magic", new_state, old_state);
+            }, 50); // 200ms delay
+
+            const result = await wait;
+            expect(result).toBeUndefined();
+          });
+        });
+      });
+    });
+
+    it("should find entities by unique_id", async () => {
+      expect.assertions(2);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const entity = hass.refBy.unique_id("5622d76001a335e3ea893c4d60d31b3d-next_dawn");
+          expect(entity).toBeDefined();
+          expect(entity.entity_id).toBe("sensor.sun_next_dawn");
+        });
+      });
+    });
+
+    it("should return unmodified entity state with .raw", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const allData = hass.entity._masterState();
+          const single = hass.entity.getCurrentState("sun.sun");
+          expect(single).toBe(allData.sun.sun);
+        });
+      });
+    });
+
+    it("should return previous entity state with .previous", async () => {
+      expect.assertions(3);
+      await hassTestRunner.run(({ lifecycle, hass, mock_assistant }) => {
+        const entity_id = "sensor.magic";
+        const value = "bar";
+        lifecycle.onReady(async () => {
+          const start = hass.entity.getCurrentState(entity_id);
+          await mock_assistant.events.emitEntityUpdate(entity_id, {
+            state: value,
+          });
+          const updated = hass.entity.getCurrentState(entity_id);
+          const previous = hass.entity.previousState(entity_id);
+          expect(updated.state).toBe(value);
+          expect(start.state).not.toBe(value);
+          expect(start).toEqual(previous);
+        });
+      });
+    });
+
+    it("should return undefined for no matches", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const entity = hass.refBy.unique_id(
+            // @ts-expect-error test
+            "5622d76001a335e3ea893c4d60d31b3d-previous_dawn",
+          );
+          expect(entity).not.toBeDefined();
+        });
+      });
+    });
+  });
+
+  describe("Refresh", () => {
+    it("should attempt to load entities onBootstrap", async () => {
+      expect.assertions(2);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        const spy = jest.spyOn(hass.entity, "refresh").mockImplementation(async () => undefined);
+
+        lifecycle.onPostConfig(function latePostConfig() {
+          expect(spy).toHaveBeenCalled();
+        }, -1);
+        lifecycle.onPostConfig(function earlyPostConfig() {
+          expect(spy).not.toHaveBeenCalled();
+        }, 0);
+      });
+    });
+
+    it("should retry on failure", async () => {
+      expect.assertions(1);
+      await hassTestRunner.configure({ hass: { RETRY_INTERVAL: 0 } }).run(({ lifecycle, hass }) => {
+        const responses = [
+          { text: "502 Bad Gateway" },
+          { text: "502 Bad Gateway" },
+          { text: "502 Bad Gateway" },
+          [],
+          [{ entity_id: "sensor.magic" } as ENTITY_STATE<ANY_ENTITY>],
+        ];
+        const spy = jest
+          .spyOn(hass.fetch, "getAllEntities")
+          // @ts-expect-error it happens
+          .mockImplementation(async () => responses.shift());
+
+        lifecycle.onBootstrap(() => expect(spy).toHaveBeenCalledTimes(5));
+      });
+    });
+  });
+});

package/src/testing/events.spec.ts

@@ -0,0 +1,78 @@
+import {
+  AREA_REGISTRY_UPDATED,
+  DEVICE_REGISTRY_UPDATED,
+  ENTITY_REGISTRY_UPDATED,
+  FLOOR_REGISTRY_UPDATED,
+  LABEL_REGISTRY_UPDATED,
+  ZONE_REGISTRY_UPDATED,
+} from "../helpers";
+import { hassTestRunner } from "../mock_assistant";
+
+describe("Events", () => {
+  afterEach(async () => {
+    await hassTestRunner.teardown();
+    jest.restoreAllMocks();
+  });
+
+  describe("Event Callbacks", () => {
+    it("should register callback for AREA_REGISTRY_UPDATED", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ event, hass }) => {
+        const spy = jest.spyOn(event, "on");
+        const callback = jest.fn();
+        hass.events.onAreaRegistryUpdate(callback);
+        expect(spy).toHaveBeenCalledWith(AREA_REGISTRY_UPDATED, callback);
+      });
+    });
+
+    it("should register callback for DEVICE_REGISTRY_UPDATED", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ event, hass }) => {
+        const spy = jest.spyOn(event, "on");
+        const callback = jest.fn();
+        hass.events.onDeviceRegistryUpdate(callback);
+        expect(spy).toHaveBeenCalledWith(DEVICE_REGISTRY_UPDATED, callback);
+      });
+    });
+
+    it("should register callback for ENTITY_REGISTRY_UPDATED", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ event, hass }) => {
+        const spy = jest.spyOn(event, "on");
+        const callback = jest.fn();
+        hass.events.onEntityRegistryUpdate(callback);
+        expect(spy).toHaveBeenCalledWith(ENTITY_REGISTRY_UPDATED, callback);
+      });
+    });
+
+    it("should register callback for FLOOR_REGISTRY_UPDATED", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ event, hass }) => {
+        const spy = jest.spyOn(event, "on");
+        const callback = jest.fn();
+        hass.events.onFloorRegistryUpdate(callback);
+        expect(spy).toHaveBeenCalledWith(FLOOR_REGISTRY_UPDATED, callback);
+      });
+    });
+
+    it("should register callback for LABEL_REGISTRY_UPDATED", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ event, hass }) => {
+        const spy = jest.spyOn(event, "on");
+        const callback = jest.fn();
+        hass.events.onLabelRegistryUpdate(callback);
+        expect(spy).toHaveBeenCalledWith(LABEL_REGISTRY_UPDATED, callback);
+      });
+    });
+
+    it("should register callback for ZONE_REGISTRY_UPDATED", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ event, hass }) => {
+        const spy = jest.spyOn(event, "on");
+        const callback = jest.fn();
+        hass.events.onZoneRegistryUpdate(callback);
+        expect(spy).toHaveBeenCalledWith(ZONE_REGISTRY_UPDATED, callback);
+      });
+    });
+  });
+});