@digital-alchemy/hass 24.9.3 → 24.9.5

package/src/testing/floor.spec.ts

@@ -0,0 +1,186 @@
+import { sleep } from "@digital-alchemy/core";
+
+import { TFloorId } from "../dynamic";
+import { FLOOR_REGISTRY_UPDATED, FloorDetails } from "../helpers";
+import { hassTestRunner } from "../mock_assistant";
+
+describe("Floor", () => {
+  const EXAMPLE_FLOOR = {
+    aliases: [],
+    floor_id: "upstairs",
+    icon: null,
+    level: 2,
+    name: "Upstairs",
+  } as unknown as FloorDetails;
+
+  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_FLOOR]);
+        lifecycle.onReady(async () => {
+          await hass.floor.list();
+          expect(spy).toHaveBeenCalledWith(
+            expect.objectContaining({ type: "config/floor_registry/list" }),
+          );
+        });
+      });
+    });
+  });
+
+  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.floor.list();
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({ type: "config/floor_registry/list" }),
+            );
+          });
+        });
+      });
+
+      it("should call update properly", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          const spy = jest
+            .spyOn(hass.socket, "sendMessage")
+            .mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            setImmediate(() => event.emit(FLOOR_REGISTRY_UPDATED));
+            await hass.floor.update(EXAMPLE_FLOOR);
+
+            expect(spy).toHaveBeenCalledWith({
+              type: "config/floor_registry/update",
+              ...EXAMPLE_FLOOR,
+            });
+          });
+        });
+      });
+
+      it("should call delete properly", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          const spy = jest
+            .spyOn(hass.socket, "sendMessage")
+            .mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            setImmediate(() => event.emit(FLOOR_REGISTRY_UPDATED));
+            await hass.floor.delete(EXAMPLE_FLOOR.floor_id);
+
+            expect(spy).toHaveBeenCalledWith({
+              floor_id: "upstairs",
+              type: "config/floor_registry/delete",
+            });
+          });
+        });
+      });
+
+      it("should call create properly", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          const spy = jest
+            .spyOn(hass.socket, "sendMessage")
+            .mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            setImmediate(() => event.emit(FLOOR_REGISTRY_UPDATED));
+            await hass.floor.create(EXAMPLE_FLOOR);
+
+            expect(spy).toHaveBeenCalledWith({
+              type: "config/floor_registry/create",
+              ...EXAMPLE_FLOOR,
+            });
+          });
+        });
+      });
+    });
+
+    describe("Order of operations", () => {
+      it("should wait for an update before returning when updating", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            const response = hass.floor.update(EXAMPLE_FLOOR);
+            let order = "";
+            setTimeout(() => {
+              order += "a";
+              event.emit(FLOOR_REGISTRY_UPDATED);
+            }, 5);
+            await response;
+            order += "b";
+            expect(order).toEqual("ab");
+          });
+        });
+      });
+
+      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.onFloorRegistryUpdate(() => counter++);
+          lifecycle.onReady(async () => {
+            setImmediate(async () => {
+              hass.socket.socketEvents.emit("floor_registry_updated");
+              await sleep(5);
+              hass.socket.socketEvents.emit("floor_registry_updated");
+              await sleep(5);
+              hass.socket.socketEvents.emit("floor_registry_updated");
+              await sleep(75);
+              hass.socket.socketEvents.emit("floor_registry_updated");
+            });
+            await sleep(200);
+            expect(counter).toBe(2);
+          });
+        });
+      });
+
+      it("should wait for an update before returning when deleting", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            const response = hass.floor.delete("example_floor" as TFloorId);
+            let order = "";
+            setTimeout(() => {
+              order += "a";
+              event.emit(FLOOR_REGISTRY_UPDATED);
+            }, 5);
+            await response;
+            order += "b";
+            expect(order).toEqual("ab");
+          });
+        });
+      });
+
+      it("should wait for an update before returning when creating", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            const response = hass.floor.create(EXAMPLE_FLOOR);
+            let order = "";
+            setTimeout(() => {
+              order += "a";
+              event.emit(FLOOR_REGISTRY_UPDATED);
+            }, 5);
+            await response;
+            order += "b";
+            expect(order).toEqual("ab");
+          });
+        });
+      });
+    });
+  });
+});

package/src/testing/id-by.spec.ts

@@ -0,0 +1,140 @@
+import { PICK_ENTITY } from "../helpers";
+import { hassTestRunner } from "../mock_assistant";
+
+describe("ID By", () => {
+  afterEach(async () => {
+    await hassTestRunner.teardown();
+    jest.restoreAllMocks();
+  });
+
+  describe("area", () => {
+    it("find entities by area", async () => {
+      expect.assertions(2);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const bedroom = hass.idBy.area("bedroom");
+          const kitchen = hass.idBy.area("kitchen");
+          expect(bedroom.length).toBe(2);
+          expect(kitchen.length).toBe(1);
+        });
+      });
+    });
+
+    it("finds entities only related by device", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          // merges 1 from direct area, 2 via device
+          // ignores 2 from the device assigned to another area
+          const list = hass.idBy.area("test") as PICK_ENTITY[];
+          const expected = [
+            "sensor.sun_next_dusk",
+            "climate.hallway_thermostat",
+            "binary_sensor.garage_door",
+          ] as PICK_ENTITY[];
+          expect(expected.every(expected => list.includes(expected))).toBe(true);
+        });
+      });
+    });
+
+    it("find entities by area limiting by domain", async () => {
+      expect.assertions(2);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const bedroom = hass.idBy.area("bedroom", "light");
+          const kitchen = hass.idBy.area("kitchen", "light");
+          expect(bedroom.length).toBe(1);
+          expect(kitchen.length).toBe(0);
+        });
+      });
+    });
+  });
+
+  describe("label", () => {
+    it("find entities by label", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const synapse = hass.idBy.label("synapse");
+          expect(synapse.length).toBe(7);
+        });
+      });
+    });
+
+    it("find entities by label limiting by domain", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const synapse = hass.idBy.label("synapse", "light");
+          expect(synapse.length).toBe(0);
+        });
+      });
+    });
+  });
+
+  describe("device", () => {
+    it("find entities by device", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const synapse = hass.idBy.device("308e39cf50a9fc6c30b4110724ed1f2e");
+          expect(synapse.length).toBe(9);
+        });
+      });
+    });
+
+    it("find entities by device limiting by domain", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const synapse = hass.idBy.device("308e39cf50a9fc6c30b4110724ed1f2e", "light");
+          expect(synapse.length).toBe(0);
+        });
+      });
+    });
+  });
+
+  describe("platform", () => {
+    it("find entities by platform", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const synapse = hass.idBy.platform("synapse");
+          expect(synapse.length).toBe(7);
+        });
+      });
+    });
+
+    it("find entities by platform limiting by domain", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const synapse = hass.idBy.platform("synapse", "light");
+          expect(synapse.length).toBe(0);
+        });
+      });
+    });
+  });
+
+  describe("floor", () => {
+    it("find entities by floor", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const synapse = hass.idBy.floor("downstairs");
+          expect(synapse.length).toBe(3);
+        });
+      });
+    });
+
+    it("find entities by floor limiting by domain", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const synapse = hass.idBy.floor("downstairs", "light");
+          expect(synapse.length).toBe(0);
+        });
+      });
+    });
+  });
+});

package/src/testing/label.spec.ts

@@ -0,0 +1,186 @@
+import { sleep } from "@digital-alchemy/core";
+
+import { TLabelId } from "../dynamic";
+import { LABEL_REGISTRY_UPDATED, LabelDefinition } from "../helpers";
+import { hassTestRunner } from "../mock_assistant";
+
+describe("Label", () => {
+  const EXAMPLE_LABEL = {
+    color: "accent",
+    description: "test",
+    icon: "mdi:brain",
+    label_id: "synapse",
+    name: "synapse",
+  } as unknown as LabelDefinition;
+
+  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_LABEL]);
+        lifecycle.onReady(async () => {
+          await hass.label.list();
+          expect(spy).toHaveBeenCalledWith(
+            expect.objectContaining({ type: "config/label_registry/list" }),
+          );
+        });
+      });
+    });
+  });
+
+  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.label.list();
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({ type: "config/label_registry/list" }),
+            );
+          });
+        });
+      });
+
+      it("should call update properly", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          const spy = jest
+            .spyOn(hass.socket, "sendMessage")
+            .mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            setImmediate(() => event.emit(LABEL_REGISTRY_UPDATED));
+            await hass.label.update(EXAMPLE_LABEL);
+
+            expect(spy).toHaveBeenCalledWith({
+              type: "config/label_registry/update",
+              ...EXAMPLE_LABEL,
+            });
+          });
+        });
+      });
+
+      it("should call delete properly", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          const spy = jest
+            .spyOn(hass.socket, "sendMessage")
+            .mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            setImmediate(() => event.emit(LABEL_REGISTRY_UPDATED));
+            await hass.label.delete(EXAMPLE_LABEL.label_id);
+
+            expect(spy).toHaveBeenCalledWith({
+              label_id: "synapse",
+              type: "config/label_registry/delete",
+            });
+          });
+        });
+      });
+
+      it("should call create properly", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          const spy = jest
+            .spyOn(hass.socket, "sendMessage")
+            .mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            setImmediate(() => event.emit(LABEL_REGISTRY_UPDATED));
+            await hass.label.create(EXAMPLE_LABEL);
+
+            expect(spy).toHaveBeenCalledWith({
+              type: "config/label_registry/create",
+              ...EXAMPLE_LABEL,
+            });
+          });
+        });
+      });
+    });
+
+    describe("Order of operations", () => {
+      it("should wait for an update before returning when updating", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            const response = hass.label.update(EXAMPLE_LABEL);
+            let order = "";
+            setTimeout(() => {
+              order += "a";
+              event.emit(LABEL_REGISTRY_UPDATED);
+            }, 5);
+            await response;
+            order += "b";
+            expect(order).toEqual("ab");
+          });
+        });
+      });
+
+      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.onLabelRegistryUpdate(() => counter++);
+          lifecycle.onReady(async () => {
+            setImmediate(async () => {
+              hass.socket.socketEvents.emit("label_registry_updated");
+              await sleep(5);
+              hass.socket.socketEvents.emit("label_registry_updated");
+              await sleep(5);
+              hass.socket.socketEvents.emit("label_registry_updated");
+              await sleep(75);
+              hass.socket.socketEvents.emit("label_registry_updated");
+            });
+            await sleep(200);
+            expect(counter).toBe(2);
+          });
+        });
+      });
+
+      it("should wait for an update before returning when deleting", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            const response = hass.label.delete("example_label" as TLabelId);
+            let order = "";
+            setTimeout(() => {
+              order += "a";
+              event.emit(LABEL_REGISTRY_UPDATED);
+            }, 5);
+            await response;
+            order += "b";
+            expect(order).toEqual("ab");
+          });
+        });
+      });
+
+      it("should wait for an update before returning when creating", async () => {
+        expect.assertions(1);
+        await hassTestRunner.run(({ lifecycle, hass, event }) => {
+          jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+          lifecycle.onReady(async () => {
+            const response = hass.label.create(EXAMPLE_LABEL);
+            let order = "";
+            setTimeout(() => {
+              order += "a";
+              event.emit(LABEL_REGISTRY_UPDATED);
+            }, 5);
+            await response;
+            order += "b";
+            expect(order).toEqual("ab");
+          });
+        });
+      });
+    });
+  });
+});