@digital-alchemy/hass 25.3.2 → 25.5.2

package/src/testing/area.spec.mts

@@ -1,187 +1,200 @@
 import { sleep } from "@digital-alchemy/core";
+import { subscribe } from "diagnostics_channel";
 
 import { AREA_REGISTRY_UPDATED, AreaDetails } from "../helpers/index.mts";
 import { hassTestRunner, INTERNAL_MESSAGE } from "../mock_assistant/index.mts";
 import { TAreaId } from "../user.mts";
 
-describe("Area", () => {
-  const EXAMPLE_AREA = {
-    area_id: "empty_area" as TAreaId,
-    floor_id: null,
-    icon: null,
-    labels: [],
-    name: "Empty Area",
-    picture: null,
-  } as AreaDetails;
-
-  afterEach(async () => {
-    await hassTestRunner.teardown();
-    vi.restoreAllMocks();
+const EXAMPLE_AREA = {
+  area_id: "empty_area" as TAreaId,
+  floor_id: null,
+  icon: null,
+  labels: [],
+  name: "Empty Area",
+  picture: null,
+} as AreaDetails;
+
+afterEach(async () => {
+  await hassTestRunner.teardown();
+  vi.restoreAllMocks();
+});
+
+describe("Lifecycle", () => {
+  it("should force values to be available before ready", async () => {
+    expect.assertions(1);
+
+    const app = await hassTestRunner.run(({ mock_assistant, lifecycle, hass }) => {
+      const spy = vi.fn();
+      mock_assistant.socket.connection.on(INTERNAL_MESSAGE, spy);
+      lifecycle.onReady(async () => {
+        await hass.area.list();
+        expect(spy).toHaveBeenCalledWith(
+          expect.objectContaining({ type: "config/area_registry/list" }),
+        );
+      }, -1);
+    });
+    await app.teardown();
   });
+});
 
-  describe("Lifecycle", () => {
-    it("should force values to be available before ready", async () => {
+describe("API", () => {
+  describe("Formatting", () => {
+    it("should call list properly", async () => {
       expect.assertions(1);
-
-      const app = await hassTestRunner.run(({ mock_assistant, lifecycle, hass }) => {
-        const spy = vi.fn();
-        mock_assistant.socket.connection.on(INTERNAL_MESSAGE, spy);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => []);
         lifecycle.onReady(async () => {
           await hass.area.list();
           expect(spy).toHaveBeenCalledWith(
             expect.objectContaining({ type: "config/area_registry/list" }),
           );
-        }, -1);
+        });
       });
-      await app.teardown();
     });
-  });
 
-  describe("API", () => {
-    describe("Formatting", () => {
-      it("should call list properly", async () => {
-        expect.assertions(1);
-        await hassTestRunner.run(({ lifecycle, hass }) => {
-          const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => []);
-          lifecycle.onReady(async () => {
-            await hass.area.list();
-            expect(spy).toHaveBeenCalledWith(
-              expect.objectContaining({ type: "config/area_registry/list" }),
-            );
+    it("should call update properly", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass, event }) => {
+        const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        lifecycle.onReady(async () => {
+          setImmediate(() => event.emit(AREA_REGISTRY_UPDATED));
+          await hass.area.update(EXAMPLE_AREA);
+
+          expect(spy).toHaveBeenCalledWith({
+            type: "config/area_registry/update",
+            ...EXAMPLE_AREA,
           });
         });
       });
+    });
 
-      it("should call update properly", async () => {
-        expect.assertions(1);
-        await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          const spy = vi
-            .spyOn(hass.socket, "sendMessage")
-            .mockImplementation(async () => undefined);
-          lifecycle.onReady(async () => {
-            setImmediate(() => event.emit(AREA_REGISTRY_UPDATED));
-            await hass.area.update(EXAMPLE_AREA);
-
-            expect(spy).toHaveBeenCalledWith({
-              type: "config/area_registry/update",
-              ...EXAMPLE_AREA,
-            });
+    it("should debounce updates properly", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        let counter = 0;
+        hass.events.onAreaRegistryUpdate(() => counter++);
+        lifecycle.onReady(async () => {
+          setImmediate(async () => {
+            hass.socket.socketEvents.emit("area_registry_updated");
+            await sleep(5);
+            hass.socket.socketEvents.emit("area_registry_updated");
+            await sleep(5);
+            hass.socket.socketEvents.emit("area_registry_updated");
+            await sleep(75);
+            hass.socket.socketEvents.emit("area_registry_updated");
           });
+          await sleep(200);
+          expect(counter).toBe(2);
         });
       });
+    });
 
-      it("should debounce updates properly", async () => {
-        expect.assertions(1);
-        await hassTestRunner.run(({ lifecycle, hass }) => {
-          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
-          let counter = 0;
-          hass.events.onAreaRegistryUpdate(() => counter++);
-          lifecycle.onReady(async () => {
-            setImmediate(async () => {
-              hass.socket.socketEvents.emit("area_registry_updated");
-              await sleep(5);
-              hass.socket.socketEvents.emit("area_registry_updated");
-              await sleep(5);
-              hass.socket.socketEvents.emit("area_registry_updated");
-              await sleep(75);
-              hass.socket.socketEvents.emit("area_registry_updated");
-            });
-            await sleep(200);
-            expect(counter).toBe(2);
+    it("should publish diagnostics on area registry update", async () => {
+      expect.assertions(1);
+      hassTestRunner.configure({ hass: { EMIT_DIAGNOSTICS: true } });
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        const spy = vi.fn();
+        subscribe(hass.diagnostics.area.registry_update.name, spy);
+        lifecycle.onReady(async () => {
+          setImmediate(async () => {
+            hass.socket.socketEvents.emit("area_registry_updated");
           });
+          await sleep(100);
+          expect(spy).toHaveBeenCalledWith(
+            expect.objectContaining({ ms: expect.any(Number) }),
+            hass.diagnostics.area.registry_update.name,
+          );
         });
       });
+    });
 
-      it("should call delete properly", async () => {
-        expect.assertions(1);
-
-        await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          const spy = vi
-            .spyOn(hass.socket, "sendMessage")
-            .mockImplementation(async () => undefined);
-          lifecycle.onReady(async () => {
-            setImmediate(() => event.emit(AREA_REGISTRY_UPDATED));
-            await hass.area.delete(EXAMPLE_AREA.area_id);
-
-            expect(spy).toHaveBeenCalledWith({
-              area_id: "empty_area",
-              type: "config/area_registry/delete",
-            });
+    it("should call delete properly", async () => {
+      expect.assertions(1);
+
+      await hassTestRunner.run(({ lifecycle, hass, event }) => {
+        const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        lifecycle.onReady(async () => {
+          setImmediate(() => event.emit(AREA_REGISTRY_UPDATED));
+          await hass.area.delete(EXAMPLE_AREA.area_id);
+
+          expect(spy).toHaveBeenCalledWith({
+            area_id: "empty_area",
+            type: "config/area_registry/delete",
           });
         });
       });
+    });
 
-      it("should call create properly", async () => {
-        expect.assertions(1);
-        await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          const spy = vi
-            .spyOn(hass.socket, "sendMessage")
-            .mockImplementation(async () => undefined);
-          lifecycle.onReady(async () => {
-            setImmediate(() => event.emit(AREA_REGISTRY_UPDATED));
-            await hass.area.create(EXAMPLE_AREA);
-
-            expect(spy).toHaveBeenCalledWith({
-              type: "config/area_registry/create",
-              ...EXAMPLE_AREA,
-            });
+    it("should call create properly", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass, event }) => {
+        const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        lifecycle.onReady(async () => {
+          setImmediate(() => event.emit(AREA_REGISTRY_UPDATED));
+          await hass.area.create(EXAMPLE_AREA);
+
+          expect(spy).toHaveBeenCalledWith({
+            type: "config/area_registry/create",
+            ...EXAMPLE_AREA,
           });
         });
       });
     });
+  });
 
-    describe("Order of operations", () => {
-      it("should wait for an update before returning when updating", async () => {
-        expect.assertions(1);
-        await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
-          lifecycle.onReady(async () => {
-            const response = hass.area.update(EXAMPLE_AREA);
-            let order = "";
-            setTimeout(() => {
-              order += "a";
-              event.emit(AREA_REGISTRY_UPDATED);
-            }, 5);
-            await response;
-            order += "b";
-            expect(order).toEqual("ab");
-          });
+  describe("Order of operations", () => {
+    it("should wait for an update before returning when updating", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass, event }) => {
+        vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        lifecycle.onReady(async () => {
+          const response = hass.area.update(EXAMPLE_AREA);
+          let order = "";
+          setTimeout(() => {
+            order += "a";
+            event.emit(AREA_REGISTRY_UPDATED);
+          }, 5);
+          await response;
+          order += "b";
+          expect(order).toEqual("ab");
         });
       });
+    });
 
-      it("should wait for an update before returning when deleting", async () => {
-        expect.assertions(1);
-        await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
-          lifecycle.onReady(async () => {
-            const response = hass.area.delete("example_area" as TAreaId);
-            let order = "";
-            setTimeout(() => {
-              order += "a";
-              event.emit(AREA_REGISTRY_UPDATED);
-            }, 5);
-            await response;
-            order += "b";
-            expect(order).toEqual("ab");
-          });
+    it("should wait for an update before returning when deleting", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass, event }) => {
+        vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        lifecycle.onReady(async () => {
+          const response = hass.area.delete("example_area" as TAreaId);
+          let order = "";
+          setTimeout(() => {
+            order += "a";
+            event.emit(AREA_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 }) => {
-          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
-          lifecycle.onReady(async () => {
-            const response = hass.area.create(EXAMPLE_AREA);
-            let order = "";
-            setTimeout(() => {
-              order += "a";
-              event.emit(AREA_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 }) => {
+        vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        lifecycle.onReady(async () => {
+          const response = hass.area.create(EXAMPLE_AREA);
+          let order = "";
+          setTimeout(() => {
+            order += "a";
+            event.emit(AREA_REGISTRY_UPDATED);
+          }, 5);
+          await response;
+          order += "b";
+          expect(order).toEqual("ab");
         });
       });
     });

package/src/testing/device.spec.mts

@@ -1,3 +1,5 @@
+import { subscribe } from "node:diagnostics_channel";
+
 import { sleep } from "@digital-alchemy/core";
 
 import { DeviceDetails } from "../helpers/index.mts";
@@ -86,4 +88,24 @@ describe("Device", () => {
       });
     });
   });
+
+  it("should publish diagnostics on device registry update", async () => {
+    expect.assertions(1);
+    hassTestRunner.configure({ hass: { EMIT_DIAGNOSTICS: true } });
+    await hassTestRunner.run(({ lifecycle, hass }) => {
+      vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+      const spy = vi.fn();
+      subscribe(hass.diagnostics.device.registry_update.name, spy);
+      lifecycle.onReady(async () => {
+        setImmediate(async () => {
+          hass.socket.socketEvents.emit("device_registry_updated");
+        });
+        await sleep(100);
+        expect(spy).toHaveBeenCalledWith(
+          expect.objectContaining({ ms: expect.any(Number) }),
+          hass.diagnostics.device.registry_update.name,
+        );
+      });
+    });
+  });
 });

package/src/testing/entity.spec.mts

@@ -1,4 +1,7 @@
+import { subscribe } from "node:diagnostics_channel";
+
 import { sleep } from "@digital-alchemy/core";
+import dayjs from "dayjs";
 
 import { ENTITY_STATE } from "../index.mts";
 import { hassTestRunner } from "../mock_assistant/index.mts";
@@ -169,4 +172,202 @@ describe("Entity", () => {
       });
     });
   });
+
+  describe("Diagnostics", () => {
+    it("should publish diagnostics on history lookup", async () => {
+      expect.assertions(2);
+      await hassTestRunner
+        .configure({
+          hass: { EMIT_DIAGNOSTICS: true },
+        })
+        .run(({ lifecycle, hass }) => {
+          const spy = vi.fn();
+          subscribe(hass.diagnostics.entity.history_lookup.name, spy);
+
+          // Mock the socket response
+          const sendMessageSpy = vi.spyOn(hass.socket, "sendMessage").mockResolvedValue({
+            "sensor.magic": [
+              {
+                entity_id: "sensor.magic",
+                last_changed: "2024-01-01T00:00:00Z",
+                last_updated: "2024-01-01T00:00:00Z",
+                state: "test",
+              },
+            ],
+          });
+
+          lifecycle.onReady(async () => {
+            const now = new Date();
+            await hass.entity.history({
+              end_time: now.toISOString(),
+              entity_ids: ["sensor.magic"],
+              start_time: new Date(now.getTime() - 3600000).toISOString(), // 1 hour ago
+            });
+
+            expect(sendMessageSpy).toHaveBeenCalledWith(
+              expect.objectContaining({
+                entity_ids: ["sensor.magic"],
+                type: "history/history_during_period",
+              }),
+            );
+
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({
+                ms: expect.any(Number),
+                payload: expect.objectContaining({
+                  entity_ids: ["sensor.magic"],
+                }),
+                result: expect.objectContaining({
+                  "sensor.magic": expect.arrayContaining([
+                    expect.objectContaining({
+                      entity_id: "sensor.magic",
+                      state: "test",
+                    }),
+                  ]),
+                }),
+              }),
+              hass.diagnostics.entity.history_lookup.name,
+            );
+          });
+        });
+    });
+
+    it("should publish diagnostics on refresh entities", async () => {
+      expect.assertions(1);
+      await hassTestRunner
+        .configure({
+          hass: { EMIT_DIAGNOSTICS: true },
+        })
+        .run(({ lifecycle, hass }) => {
+          const spy = vi.fn();
+          subscribe(hass.diagnostics.entity.refresh_entities.name, spy);
+
+          lifecycle.onReady(async () => {
+            await hass.entity.refresh();
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({
+                emitUpdates: [],
+              }),
+              hass.diagnostics.entity.refresh_entities.name,
+            );
+          });
+        });
+    });
+
+    it("should publish diagnostics on entity update", async () => {
+      expect.assertions(1);
+      await hassTestRunner
+        .configure({
+          hass: { EMIT_DIAGNOSTICS: true },
+        })
+        .run(({ lifecycle, hass, mock_assistant }) => {
+          const spy = vi.fn();
+          subscribe(hass.diagnostics.entity.entity_updated.name, spy);
+
+          lifecycle.onReady(async () => {
+            await mock_assistant.events.emitEntityUpdate("sensor.magic", {
+              state: "test",
+            });
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({
+                entity_id: "sensor.magic",
+                new_state: expect.objectContaining({
+                  entity_id: "sensor.magic",
+                  state: "test",
+                }),
+                old_state: expect.objectContaining({
+                  entity_id: "sensor.magic",
+                  state: "unavailable",
+                }),
+              }),
+              hass.diagnostics.entity.entity_updated.name,
+            );
+          });
+        });
+    });
+
+    it("should publish diagnostics on entity remove", async () => {
+      expect.assertions(1);
+      await hassTestRunner
+        .configure({
+          hass: { EMIT_DIAGNOSTICS: true },
+        })
+        .run(({ lifecycle, hass }) => {
+          const spy = vi.fn();
+          subscribe(hass.diagnostics.entity.entity_remove.name, spy);
+
+          lifecycle.onReady(async () => {
+            // Directly call _entityUpdateReceiver with null new_state to trigger entity remove
+            hass.entity._entityUpdateReceiver("sensor.magic", null, {
+              attributes: {
+                friendly_name: "magic",
+                icon: "mdi:satellite-uplink",
+                restored: true,
+                supported_features: 0,
+              },
+              context: {
+                id: "test",
+                parent_id: null,
+                user_id: null,
+              },
+              entity_id: "sensor.magic",
+              last_changed: dayjs("2024-01-01T00:00:00Z"),
+              last_reported: dayjs("2024-01-01T00:00:00Z"),
+              last_updated: dayjs("2024-01-01T00:00:00Z"),
+              state: "test",
+            });
+
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({
+                entity_id: "sensor.magic",
+              }),
+              hass.diagnostics.entity.entity_remove.name,
+            );
+          });
+        });
+    });
+
+    it("should publish diagnostics on entity add", async () => {
+      expect.assertions(1);
+      await hassTestRunner
+        .configure({
+          hass: { EMIT_DIAGNOSTICS: true },
+        })
+        .run(({ lifecycle, hass }) => {
+          const spy = vi.fn();
+          subscribe(hass.diagnostics.entity.entity_add.name, spy);
+
+          lifecycle.onReady(async () => {
+            // Call _entityUpdateReceiver with null old_state to trigger entity add
+            const newState = {
+              attributes: {
+                friendly_name: "magic" as const,
+                icon: "mdi:satellite-uplink" as const,
+                restored: true as const,
+                supported_features: 0 as const,
+              },
+              context: {
+                id: "test",
+                parent_id: null as null,
+                user_id: null as null,
+              },
+              entity_id: "sensor.magic" as const,
+              last_changed: dayjs("2024-01-01T00:00:00Z"),
+              last_reported: dayjs("2024-01-01T00:00:00Z"),
+              last_updated: dayjs("2024-01-01T00:00:00Z"),
+              state: "test",
+            };
+
+            hass.entity._entityUpdateReceiver("sensor.magic", newState, null);
+
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({
+                entity_id: "sensor.magic",
+              }),
+              hass.diagnostics.entity.entity_add.name,
+            );
+          });
+        });
+    });
+  });
 });

package/src/testing/fetch.spec.mts

@@ -0,0 +1,54 @@
+import { subscribe } from "node:diagnostics_channel";
+
+import { hassTestRunner } from "../mock_assistant/index.mts";
+
+describe("Fetch", () => {
+  const BASE_URL = "http://homeassistant.local:8123";
+
+  afterEach(async () => {
+    await hassTestRunner.teardown();
+    vi.restoreAllMocks();
+  });
+
+  describe("API", () => {
+    describe("Diagnostics", () => {
+      it("should publish diagnostics on fetch operation", async () => {
+        expect.assertions(1);
+        hassTestRunner.configure({
+          hass: {
+            BASE_URL,
+            EMIT_DIAGNOSTICS: true,
+          },
+        });
+        await hassTestRunner.run(({ lifecycle, hass }) => {
+          const mockResponse = { data: "test response" };
+          vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
+            return {
+              text: async () => JSON.stringify(mockResponse),
+            } as unknown as Response;
+          });
+
+          const spy = vi.fn();
+          subscribe(hass.diagnostics.fetch.fetch.name, spy);
+
+          lifecycle.onPostConfig(() => {
+            hass.fetch._fetcher.base_url = BASE_URL;
+            hass.fetch._fetcher.base_headers = { Authorization: "Bearer test_token" };
+          });
+
+          lifecycle.onReady(async () => {
+            await hass.fetch.fetch({ url: "/api/test" });
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({
+                ms: expect.any(Number),
+                options: expect.objectContaining({ url: "/api/test" }),
+                out: mockResponse,
+              }),
+              hass.diagnostics.fetch.fetch.name,
+            );
+          });
+        });
+      });
+    });
+  });
+});

package/src/testing/floor.spec.mts

@@ -1,3 +1,5 @@
+import { subscribe } from "node:diagnostics_channel";
+
 import { sleep } from "@digital-alchemy/core";
 
 import { FLOOR_REGISTRY_UPDATED, FloorDetails } from "../helpers/index.mts";
@@ -103,6 +105,26 @@ describe("Floor", () => {
           });
         });
       });
+
+      it("should publish diagnostics on floor registry update", async () => {
+        expect.assertions(1);
+        hassTestRunner.configure({ hass: { EMIT_DIAGNOSTICS: true } });
+        await hassTestRunner.run(({ lifecycle, hass }) => {
+          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+          const spy = vi.fn();
+          subscribe(hass.diagnostics.floor.registry_update.name, spy);
+          lifecycle.onReady(async () => {
+            setImmediate(async () => {
+              hass.socket.socketEvents.emit("floor_registry_updated");
+            });
+            await sleep(100);
+            expect(spy).toHaveBeenCalledWith(
+              expect.objectContaining({ ms: expect.any(Number) }),
+              hass.diagnostics.floor.registry_update.name,
+            );
+          });
+        });
+      });
     });
 
     describe("Order of operations", () => {