@digital-alchemy/hass 25.11.17-beta.0 → 25.11.27

package/src/testing/call-proxy.spec.mts

@@ -0,0 +1,241 @@
+import type { HassServiceDTO } from "../helpers/index.mts";
+import { hassTestRunner } from "../mock_assistant/index.mts";
+
+afterEach(async () => {
+  await hassTestRunner.teardown();
+  vi.restoreAllMocks();
+});
+
+describe("CallProxy", () => {
+  describe("pauseMessages", () => {
+    it("should return undefined when pauseMessages is true", async () => {
+      expect.assertions(2);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        hass.socket.pauseMessages = true;
+
+        lifecycle.onReady(async () => {
+          const result = await hass.call.switch.turn_on({
+            entity_id: "switch.porch_light",
+          });
+
+          expect(result).toBeUndefined();
+          const callServiceCalls = spy.mock.calls.filter(
+            call =>
+              call[0]?.type === "call_service" &&
+              call[0]?.domain === "switch" &&
+              call[0]?.service === "turn_on",
+          );
+          expect(callServiceCalls).toHaveLength(0);
+        });
+      });
+    });
+
+    it("should call sendMessage when pauseMessages is false", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+        hass.socket.pauseMessages = false;
+
+        lifecycle.onReady(async () => {
+          await hass.call.switch.turn_on({
+            entity_id: "switch.porch_light",
+          });
+
+          expect(spy).toHaveBeenCalledWith(
+            expect.objectContaining({
+              domain: "switch",
+              service: "turn_on",
+              service_data: {
+                entity_id: "switch.porch_light",
+              },
+              type: "call_service",
+            }),
+            true,
+          );
+        });
+      });
+    });
+  });
+
+  describe("return_response", () => {
+    it("should include return_response in payload when service has response.optional", async () => {
+      expect.assertions(1);
+      const mockServices: HassServiceDTO[] = [
+        {
+          domain: "switch",
+          services: {
+            turn_on: {
+              description: "Test service",
+              fields: {},
+              name: "turn_on",
+              response: { optional: true },
+            },
+          },
+        },
+      ];
+
+      await hassTestRunner.run(({ lifecycle, hass, mock_assistant }) => {
+        mock_assistant.services.loadFixtures(mockServices);
+        vi.spyOn(hass.fetch, "listServices").mockImplementation(async () => mockServices);
+
+        const spy = vi
+          .spyOn(hass.socket, "sendMessage")
+          .mockImplementation(async () => ({ response: { success: true } }));
+
+        lifecycle.onReady(async () => {
+          await hass.call.switch.turn_on({ entity_id: "switch.bedroom_lamp" });
+
+          expect(spy).toHaveBeenCalledWith(
+            expect.objectContaining({
+              domain: "switch",
+              return_response: true,
+              service: "turn_on",
+              type: "call_service",
+            }),
+            true,
+          );
+        });
+      });
+    });
+
+    it("should return response when service returns a response", async () => {
+      expect.assertions(1);
+      const mockServices: HassServiceDTO[] = [
+        {
+          domain: "switch",
+          services: {
+            turn_on: {
+              description: "Test service",
+              fields: {},
+              name: "turn_on",
+              response: { optional: true },
+            },
+          },
+        },
+      ];
+
+      await hassTestRunner.run(({ lifecycle, hass, mock_assistant }) => {
+        mock_assistant.services.loadFixtures(mockServices);
+        vi.spyOn(hass.fetch, "listServices").mockImplementation(async () => mockServices);
+
+        const mockResponse = { data: "test_response" };
+        vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => ({
+          response: mockResponse,
+        }));
+
+        lifecycle.onReady(async () => {
+          const result = await hass.call.switch.turn_on({ entity_id: "switch.bedroom_lamp" });
+          expect(result).toEqual(mockResponse);
+        });
+      });
+    });
+
+    it("should return undefined when service does not return a response", async () => {
+      expect.assertions(1);
+      const mockServices: HassServiceDTO[] = [
+        {
+          domain: "switch",
+          services: {
+            turn_on: {
+              description: "Test service",
+              fields: {},
+              name: "turn_on",
+              response: { optional: true },
+            },
+          },
+        },
+      ];
+
+      await hassTestRunner.run(({ lifecycle, hass, mock_assistant }) => {
+        mock_assistant.services.loadFixtures(mockServices);
+        vi.spyOn(hass.fetch, "listServices").mockImplementation(async () => mockServices);
+
+        vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => ({}));
+
+        lifecycle.onReady(async () => {
+          const result = await hass.call.switch.turn_on({ entity_id: "switch.bedroom_lamp" });
+          expect(result).toBeUndefined();
+        });
+      });
+    });
+  });
+
+  describe("early access", () => {
+    it("should call console.trace when accessed before load with LOG_LEVEL trace", async () => {
+      expect.assertions(1);
+      const traceSpy = vi.spyOn(console, "trace").mockImplementation(() => {});
+
+      await hassTestRunner.configure({ boilerplate: { LOG_LEVEL: "trace" } }).run(({ hass }) => {
+        hass.call.switch;
+      });
+      expect(traceSpy).toHaveBeenCalledWith(`hass.call`);
+    });
+
+    it("should not log error when accessed before load with LOG_LEVEL not trace", async () => {
+      expect.assertions(2);
+      await hassTestRunner
+        .configure({ boilerplate: { LOG_LEVEL: "warn" } })
+        .run(({ lifecycle, hass, internal }) => {
+          const logger = internal.boilerplate.logger.getBaseLogger();
+          const errorSpy = vi.spyOn(logger, "error").mockImplementation(() => {});
+          const traceSpy = vi.spyOn(console, "trace").mockImplementation(() => {});
+
+          // Access hass.call in onPreInit, which runs before onBootstrap (where services load)
+          hass.call.switch;
+
+          lifecycle.onReady(() => {
+            expect(errorSpy).not.toHaveBeenCalled();
+            expect(traceSpy).not.toHaveBeenCalled();
+          });
+        });
+    });
+  });
+
+  describe("proxy methods", () => {
+    it("should return true for has when domain exists", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          expect("switch" in hass.call).toBe(true);
+        });
+      });
+    });
+
+    it("should return false for has when domain does not exist", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          expect("nonexistent_domain" in hass.call).toBe(false);
+        });
+      });
+    });
+
+    it("should return ownKeys with all domain keys", async () => {
+      expect.assertions(2);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const keys = Object.keys(hass.call);
+          expect(keys).toContain("switch");
+          expect(keys.length).toBeGreaterThan(0);
+        });
+      });
+    });
+
+    it("should return false when trying to set a property", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          try {
+            // @ts-expect-error testing
+            hass.call.test_domain = {};
+          } catch {
+            // Some environments throw, others return false
+          }
+          // Verify the property was not set
+          expect("test_domain" in hass.call).toBe(false);
+        });
+      });
+    });
+  });
+});

package/src/testing/config.spec.mts

@@ -1,4 +1,5 @@
-import { env } from "process";
+import { env } from "node:process";
+
 import type { MockInstance } from "vitest";
 
 import type { ConfigEntry, HassServiceDTO } from "../helpers/index.mts";

package/src/testing/conversation.spec.mts

@@ -18,7 +18,7 @@ describe("Conversation Service", () => {
         },
       ];
 
-      await hassTestRunner.run(({ lifecycle, hass }) => {
+      await hassTestRunner.bootLibrariesFirst().run(({ lifecycle, hass }) => {
         const spy = vi
           .spyOn(hass.socket, "sendMessage")
           .mockImplementation(async () => ({ agents: mockAgents }));

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

@@ -137,6 +137,56 @@ describe("enabled entities", () => {
       });
     });
   });
+
+  describe("unique_id", () => {
+    it("find entity by unique_id without platform", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const entity = hass.idBy.unique_id(
+            "e1806fdc93296bbd5ab42967003cd38729ff9ba6cfeefc3e15a03ad01ac894fe",
+          );
+          expect(entity).toBe("sensor.magic");
+        });
+      });
+    });
+
+    it("find entity by unique_id with matching platform", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const entity = hass.idBy.unique_id(
+            "e1806fdc93296bbd5ab42967003cd38729ff9ba6cfeefc3e15a03ad01ac894fe",
+            "synapse",
+          );
+          expect(entity).toBe("sensor.magic");
+        });
+      });
+    });
+
+    it("find entity by unique_id with non-matching platform", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const entity = hass.idBy.unique_id(
+            "e1806fdc93296bbd5ab42967003cd38729ff9ba6cfeefc3e15a03ad01ac894fe",
+            "sun",
+          );
+          expect(entity).toBeUndefined();
+        });
+      });
+    });
+
+    it("find entity by unique_id with different platform", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass }) => {
+        lifecycle.onReady(() => {
+          const entity = hass.idBy.unique_id("5622d76001a335e3ea893c4d60d31b3d-next_dawn", "sun");
+          expect(entity).toBe("sensor.sun_next_dawn");
+        });
+      });
+    });
+  });
 });
 
 describe("disabled entities", () => {

package/src/testing/ref-by.spec.mts

@@ -174,7 +174,7 @@ describe("References", () => {
   describe("functionality", () => {
     describe("operators", () => {
       it("has", async () => {
-        expect.assertions(16);
+        expect.assertions(18);
         await hassTestRunner.run(({ lifecycle, hass }) => {
           lifecycle.onReady(() => {
             const entity = hass.refBy.id("switch.bedroom_lamp");
@@ -184,7 +184,9 @@ describe("References", () => {
               "attributes",
               "entity_id",
               "history",
-              "last",
+              "last_changed",
+              "last_reported",
+              "last_updated",
               "nextState",
               "once",
               "onStateFor",
@@ -219,7 +221,6 @@ describe("References", () => {
               "last_updated",
               "context",
               "history",
-              "last",
               "nextState",
               "once",
               "onStateFor",

package/src/testing/websocket.spec.mts

@@ -271,6 +271,39 @@ describe("Websocket", () => {
     });
   });
 
+  describe("Auth Message Handlers", () => {
+    it("should handle auth_invalid message and exit", async () => {
+      expect.assertions(3);
+      const exitSpy = vi
+        .spyOn(process, "exit")
+        // @ts-expect-error testing
+        .mockImplementation(() => {});
+
+      await hassTestRunner.run(({ lifecycle, hass, logger }) => {
+        const fatalSpy = vi.spyOn(logger, "fatal").mockImplementation(() => {});
+
+        lifecycle.onReady(async () => {
+          const message = {
+            id: 1,
+            type: "auth_invalid" as const,
+          };
+
+          await hass.socket.onMessage(message);
+
+          expect(exitSpy).toHaveBeenCalled();
+          expect(hass.socket.connectionState).toBe("invalid");
+          expect(fatalSpy).toHaveBeenCalledWith(
+            expect.objectContaining({
+              message,
+              name: expect.any(Function),
+            }),
+            "received auth invalid {connecting} => {invalid}",
+          );
+        });
+      });
+    });
+  });
+
   describe("Subscription Registry", () => {
     it("should prevent duplicate subscriptions", async () => {
       expect.assertions(1);