@digital-alchemy/hass 24.11.2 → 24.11.4

package/src/testing/{events.spec.ts → events.spec.mts}

@@ -5,21 +5,21 @@ import {
   FLOOR_REGISTRY_UPDATED,
   LABEL_REGISTRY_UPDATED,
   ZONE_REGISTRY_UPDATED,
-} from "../helpers";
-import { hassTestRunner } from "../mock_assistant";
+} from "../helpers/index.mts";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("Events", () => {
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.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();
+        const spy = vi.spyOn(event, "on");
+        const callback = vi.fn();
         hass.events.onAreaRegistryUpdate(callback);
         expect(spy).toHaveBeenCalledWith(AREA_REGISTRY_UPDATED, callback);
       });
@@ -28,8 +28,8 @@ describe("Events", () => {
     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();
+        const spy = vi.spyOn(event, "on");
+        const callback = vi.fn();
         hass.events.onDeviceRegistryUpdate(callback);
         expect(spy).toHaveBeenCalledWith(DEVICE_REGISTRY_UPDATED, callback);
       });
@@ -38,8 +38,8 @@ describe("Events", () => {
     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();
+        const spy = vi.spyOn(event, "on");
+        const callback = vi.fn();
         hass.events.onEntityRegistryUpdate(callback);
         expect(spy).toHaveBeenCalledWith(ENTITY_REGISTRY_UPDATED, callback);
       });
@@ -48,8 +48,8 @@ describe("Events", () => {
     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();
+        const spy = vi.spyOn(event, "on");
+        const callback = vi.fn();
         hass.events.onFloorRegistryUpdate(callback);
         expect(spy).toHaveBeenCalledWith(FLOOR_REGISTRY_UPDATED, callback);
       });
@@ -58,8 +58,8 @@ describe("Events", () => {
     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();
+        const spy = vi.spyOn(event, "on");
+        const callback = vi.fn();
         hass.events.onLabelRegistryUpdate(callback);
         expect(spy).toHaveBeenCalledWith(LABEL_REGISTRY_UPDATED, callback);
       });
@@ -68,8 +68,8 @@ describe("Events", () => {
     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();
+        const spy = vi.spyOn(event, "on");
+        const callback = vi.fn();
         hass.events.onZoneRegistryUpdate(callback);
         expect(spy).toHaveBeenCalledWith(ZONE_REGISTRY_UPDATED, callback);
       });

package/src/testing/{fetch-api.spec.ts → fetch-api.spec.mts}

@@ -1,7 +1,8 @@
 import dayjs from "dayjs";
+import { MockInstance } from "vitest";
 
-import { HassConfig } from "../helpers";
-import { hassTestRunner } from "../mock_assistant";
+import { HassConfig } from "../helpers/index.mts";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("FetchAPI", () => {
   const BASE_URL = "http://homeassistant.some.domain:9123";
@@ -20,7 +21,7 @@ describe("FetchAPI", () => {
 
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("Meta", () => {
@@ -28,7 +29,7 @@ describe("FetchAPI", () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
         lifecycle.onReady(async () => {
-          const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+          const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
             return {
               text: () => "[]",
             } as unknown as Response;
@@ -54,7 +55,7 @@ describe("FetchAPI", () => {
     it("should format calendarSearch properly", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "[]",
           } as unknown as Response;
@@ -78,7 +79,7 @@ describe("FetchAPI", () => {
     it("should format callService properly", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "{}",
           } as unknown as Response;
@@ -103,7 +104,7 @@ describe("FetchAPI", () => {
     it("should format checkConfig properly", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "{}",
           } as unknown as Response;
@@ -122,14 +123,14 @@ describe("FetchAPI", () => {
 
     // TODO: this results in an open handle
     // not sure why
-    xit("exits for low version at boot", async () => {
+    it.skip("exits for low version at boot", async () => {
       expect.assertions(2);
-      const exitSpy = jest.spyOn(process, "exit");
+      const exitSpy = vi.spyOn(process, "exit");
 
       // .mockImplementation(() => {
       //   throw new Error("EXPECTED TESTING ERROR");
       // });
-      jest.spyOn(console, "error").mockImplementation(() => undefined);
+      vi.spyOn(console, "error").mockImplementation(() => undefined);
       try {
         await hassTestRunner.run(({ lifecycle, mock_assistant }) => {
           lifecycle.onPreInit(() => {
@@ -146,14 +147,14 @@ describe("FetchAPI", () => {
     // TODO: Need a way to make this pass without breaking all other tests
     it.skip("passes for valid version", async () => {
       expect.assertions(2);
-      let mock: jest.SpyInstance;
-      let exitSpy: jest.SpyInstance;
+      let mock: MockInstance;
+      let exitSpy: MockInstance;
       try {
         await hassTestRunner.run(({ hass }) => {
-          mock = jest
+          mock = vi
             .spyOn(hass.fetch, "getConfig")
             .mockImplementation(async () => ({ version: "2024.4.1" }) as HassConfig);
-          exitSpy = jest.spyOn(process, "exit").mockImplementation(() => {
+          exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
             throw new Error("EXPECTED TESTING ERROR");
           });
         });
@@ -166,7 +167,7 @@ describe("FetchAPI", () => {
     it("should format fetchEntityCustomizations properly", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "{}",
           } as unknown as Response;
@@ -186,7 +187,7 @@ describe("FetchAPI", () => {
     it("should format fetchEntityHistory properly", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "{}",
           } as unknown as Response;
@@ -207,7 +208,7 @@ describe("FetchAPI", () => {
       expect.assertions(1);
       const body = { magic: true };
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "{}",
           } as unknown as Response;
@@ -230,7 +231,7 @@ describe("FetchAPI", () => {
       await hassTestRunner.run(({ lifecycle, hass, mock_assistant }) => {
         lifecycle.onReady(async () => {
           mock_assistant.entity.monkeyReset();
-          const spy = jest.spyOn(hass.fetch, "fetch").mockImplementation(async () => []);
+          const spy = vi.spyOn(hass.fetch, "fetch").mockImplementation(async () => []);
           await hass.fetch.getAllEntities();
           expect(spy).toHaveBeenCalledWith({ url: "/api/states" });
         });
@@ -241,7 +242,7 @@ describe("FetchAPI", () => {
     //   expect.assertions(1);
     //   application = CreateTestingApplication({
     //     Test({ lifecycle, hass }: TServiceParams) {
-    //       const spy = jest.spyOn(global, "fetch").mockImplementation(async () => {
+    //       const spy = vi.spyOn(global, "fetch").mockImplementation(async () => {
     //         return {
     //           text: () => "{}",
     //         } as unknown as Response;
@@ -276,7 +277,7 @@ describe("FetchAPI", () => {
     it("should format getLogs properly", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "[]",
           } as unknown as Response;
@@ -296,7 +297,7 @@ describe("FetchAPI", () => {
     it("should format getRawLogs properly", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "{}",
           } as unknown as Response;
@@ -317,7 +318,7 @@ describe("FetchAPI", () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass, mock_assistant }) => {
         lifecycle.onReady(async () => {
-          const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+          const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
             return {
               text: () => "{}",
             } as unknown as Response;
@@ -337,7 +338,7 @@ describe("FetchAPI", () => {
     it("should format updateEntity properly", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "{}",
           } as unknown as Response;
@@ -369,7 +370,7 @@ describe("FetchAPI", () => {
         magic: true,
       };
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "{}",
           } as unknown as Response;
@@ -390,7 +391,7 @@ describe("FetchAPI", () => {
     it("should format checkCredentials properly", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest.spyOn(globalThis, "fetch").mockImplementation(async () => {
+        const spy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
           return {
             text: () => "{}",
           } as unknown as Response;

package/src/testing/{fixtures.spec.ts → fixtures.spec.mts}

@@ -1,6 +1,6 @@
 import { v4 } from "uuid";
 
-import { createTestRunner } from "../mock_assistant";
+import { createTestRunner } from "../mock_assistant/index.mts";
 
 describe("Fixtures", () => {
   let runner: ReturnType<typeof createTestRunner>;
@@ -9,7 +9,7 @@ describe("Fixtures", () => {
   });
   afterEach(async () => {
     await runner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("Entity setup", () => {
@@ -130,7 +130,7 @@ describe("Fixtures", () => {
         })
         .run(async ({ hass, mock_assistant }) => {
           const entity = hass.refBy.id("switch.porch_light");
-          const spy = jest.fn();
+          const spy = vi.fn();
           entity.onUpdate(spy);
           await mock_assistant.entity.emitChange("switch.porch_light", { state: "off" });
           expect(spy).toHaveBeenCalled();
@@ -148,7 +148,7 @@ describe("Fixtures", () => {
         })
         .run(async ({ hass, mock_assistant }) => {
           const entity = hass.refBy.id("switch.porch_light");
-          const spy = jest.fn();
+          const spy = vi.fn();
           entity.onUpdate(spy);
           await mock_assistant.entity.emitChange("switch.porch_light", { state: "on" });
           expect(spy).toHaveBeenCalled();

package/src/testing/{floor.spec.ts → floor.spec.mts}

@@ -1,8 +1,8 @@
 import { sleep } from "@digital-alchemy/core";
 
-import { TFloorId } from "../dynamic";
-import { FLOOR_REGISTRY_UPDATED, FloorDetails } from "../helpers";
-import { hassTestRunner } from "../mock_assistant";
+import { TFloorId } from "../dynamic.mts";
+import { FLOOR_REGISTRY_UPDATED, FloorDetails } from "../helpers/index.mts";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("Floor", () => {
   const EXAMPLE_FLOOR = {
@@ -15,14 +15,14 @@ describe("Floor", () => {
 
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("Lifecycle", () => {
     it("should force values to be available before ready", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest
+        const spy = vi
           .spyOn(hass.socket, "sendMessage")
           .mockImplementation(async () => [EXAMPLE_FLOOR]);
         lifecycle.onReady(async () => {
@@ -40,7 +40,7 @@ describe("Floor", () => {
       it("should call list properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass }) => {
-          const spy = jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => []);
+          const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => []);
           lifecycle.onReady(async () => {
             await hass.floor.list();
             expect(spy).toHaveBeenCalledWith(
@@ -53,7 +53,7 @@ describe("Floor", () => {
       it("should call update properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          const spy = jest
+          const spy = vi
             .spyOn(hass.socket, "sendMessage")
             .mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
@@ -71,7 +71,7 @@ describe("Floor", () => {
       it("should call delete properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          const spy = jest
+          const spy = vi
             .spyOn(hass.socket, "sendMessage")
             .mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
@@ -89,7 +89,7 @@ describe("Floor", () => {
       it("should call create properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          const spy = jest
+          const spy = vi
             .spyOn(hass.socket, "sendMessage")
             .mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
@@ -109,7 +109,7 @@ describe("Floor", () => {
       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);
+          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
             const response = hass.floor.update(EXAMPLE_FLOOR);
             let order = "";
@@ -127,7 +127,7 @@ describe("Floor", () => {
       it("should debounce updates properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass }) => {
-          jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
           let counter = 0;
           hass.events.onFloorRegistryUpdate(() => counter++);
           lifecycle.onReady(async () => {
@@ -149,7 +149,7 @@ describe("Floor", () => {
       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);
+          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
             const response = hass.floor.delete("example_floor" as TFloorId);
             let order = "";
@@ -167,7 +167,7 @@ describe("Floor", () => {
       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);
+          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
             const response = hass.floor.create(EXAMPLE_FLOOR);
             let order = "";

package/src/testing/{id-by.spec.ts → id-by.spec.mts}

@@ -1,10 +1,10 @@
-import { PICK_ENTITY } from "../helpers";
-import { hassTestRunner } from "../mock_assistant";
+import { PICK_ENTITY } from "../helpers/index.mts";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("ID By", () => {
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("area", () => {

package/src/testing/{label.spec.ts → label.spec.mts}

@@ -1,8 +1,8 @@
 import { sleep } from "@digital-alchemy/core";
 
-import { TLabelId } from "../dynamic";
-import { LABEL_REGISTRY_UPDATED, LabelDefinition } from "../helpers";
-import { hassTestRunner } from "../mock_assistant";
+import { TLabelId } from "../dynamic.mts";
+import { LABEL_REGISTRY_UPDATED, LabelDefinition } from "../helpers/index.mts";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("Label", () => {
   const EXAMPLE_LABEL = {
@@ -15,14 +15,14 @@ describe("Label", () => {
 
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("Lifecycle", () => {
     it("should force values to be available before ready", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest
+        const spy = vi
           .spyOn(hass.socket, "sendMessage")
           .mockImplementation(async () => [EXAMPLE_LABEL]);
         lifecycle.onReady(async () => {
@@ -40,7 +40,7 @@ describe("Label", () => {
       it("should call list properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass }) => {
-          const spy = jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => []);
+          const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => []);
           lifecycle.onReady(async () => {
             await hass.label.list();
             expect(spy).toHaveBeenCalledWith(
@@ -53,7 +53,7 @@ describe("Label", () => {
       it("should call update properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          const spy = jest
+          const spy = vi
             .spyOn(hass.socket, "sendMessage")
             .mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
@@ -71,7 +71,7 @@ describe("Label", () => {
       it("should call delete properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          const spy = jest
+          const spy = vi
             .spyOn(hass.socket, "sendMessage")
             .mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
@@ -89,7 +89,7 @@ describe("Label", () => {
       it("should call create properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass, event }) => {
-          const spy = jest
+          const spy = vi
             .spyOn(hass.socket, "sendMessage")
             .mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
@@ -109,7 +109,7 @@ describe("Label", () => {
       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);
+          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
             const response = hass.label.update(EXAMPLE_LABEL);
             let order = "";
@@ -127,7 +127,7 @@ describe("Label", () => {
       it("should debounce updates properly", async () => {
         expect.assertions(1);
         await hassTestRunner.run(({ lifecycle, hass }) => {
-          jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
           let counter = 0;
           hass.events.onLabelRegistryUpdate(() => counter++);
           lifecycle.onReady(async () => {
@@ -149,7 +149,7 @@ describe("Label", () => {
       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);
+          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
             const response = hass.label.delete("example_label" as TLabelId);
             let order = "";
@@ -167,7 +167,7 @@ describe("Label", () => {
       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);
+          vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
           lifecycle.onReady(async () => {
             const response = hass.label.create(EXAMPLE_LABEL);
             let order = "";

package/src/testing/{ref-by.spec.ts → ref-by.spec.mts}

@@ -1,12 +1,12 @@
 import dayjs from "dayjs";
 
-import { ANY_ENTITY, ENTITY_STATE } from "../helpers";
-import { hassTestRunner } from "../mock_assistant";
+import { ANY_ENTITY, ENTITY_STATE } from "../helpers/index.mts";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("References", () => {
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("loading", function () {
@@ -281,7 +281,7 @@ describe("References", () => {
         await hassTestRunner.run(({ lifecycle, hass }) => {
           lifecycle.onReady(async () => {
             const result = [] as ENTITY_STATE<ANY_ENTITY>[];
-            const spy = jest
+            const spy = vi
               .spyOn(hass.fetch, "fetchEntityHistory")
               .mockImplementation(async () => result);
             const from = new Date();

package/src/testing/{websocket.spec.ts → websocket.spec.mts}

@@ -1,9 +1,9 @@
-import { hassTestRunner } from "../mock_assistant";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("Websocket", () => {
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("API Interactions", () => {
@@ -21,9 +21,7 @@ describe("Websocket", () => {
     it("should emit a socket message with subscribeEvents", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass, context }) => {
-        const spy = jest
-          .spyOn(hass.socket, "sendMessage")
-          .mockImplementation(async () => undefined);
+        const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
         lifecycle.onReady(async () => {
           await hass.socket.subscribe({
             context,
@@ -43,9 +41,7 @@ describe("Websocket", () => {
     it("should emit a socket message with fireEvent", async () => {
       expect.assertions(1);
       await hassTestRunner.run(({ lifecycle, hass }) => {
-        const spy = jest
-          .spyOn(hass.socket, "sendMessage")
-          .mockImplementation(async () => undefined);
+        const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
         lifecycle.onReady(async () => {
           const data = { example: "data" };
           await hass.socket.fireEvent("test_event", data);

package/src/testing/{workflow.spec.ts → workflow.spec.mts}

@@ -1,7 +1,7 @@
 import { CronExpression, SECOND, sleep } from "@digital-alchemy/core";
 import dayjs from "dayjs";
 
-import { hassTestRunner } from "../mock_assistant";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("Workflows", () => {
   beforeAll(() => {
@@ -35,7 +35,7 @@ describe("Workflows", () => {
 
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("Event and Response", () => {
@@ -43,8 +43,8 @@ describe("Workflows", () => {
       expect.assertions(2);
       await hassTestRunner.run(({ mock_assistant, hass, lifecycle }) => {
         lifecycle.onReady(async () => {
-          const turnOn = jest.spyOn(hass.call.switch, "turn_on");
-          const turnOff = jest.spyOn(hass.call.switch, "turn_off");
+          const turnOn = vi.spyOn(hass.call.switch, "turn_on");
+          const turnOff = vi.spyOn(hass.call.switch, "turn_off");
           await mock_assistant.events.emitEntityUpdate("sensor.magic", {
             state: "test",
           });
@@ -66,7 +66,7 @@ describe("Workflows", () => {
           },
         });
         lifecycle.onReady(async () => {
-          const turnOn = jest.spyOn(hass.call.switch, "turn_on");
+          const turnOn = vi.spyOn(hass.call.switch, "turn_on");
           await mock_assistant.events.emitEntityUpdate("sensor.magic", {
             state: "here",
           });
@@ -87,7 +87,7 @@ describe("Workflows", () => {
           },
         });
         lifecycle.onReady(async () => {
-          const turnOn = jest.spyOn(hass.call.switch, "turn_on");
+          const turnOn = vi.spyOn(hass.call.switch, "turn_on");
           await mock_assistant.events.emitEntityUpdate("sensor.magic", {
             state: "here",
           });
@@ -101,21 +101,21 @@ describe("Workflows", () => {
 
   describe("Timers", () => {
     beforeEach(() => {
-      jest.useFakeTimers();
+      vi.useFakeTimers();
     });
 
     afterEach(() => {
-      jest.useRealTimers();
+      vi.useRealTimers();
     });
 
     it("should run at 3PM", async () => {
       expect.assertions(1);
-      jest.setSystemTime(dayjs("2024-01-01 19:59:59").toDate());
-      jest.runOnlyPendingTimersAsync();
+      vi.setSystemTime(dayjs("2024-01-01 19:59:59").toDate());
+      vi.runOnlyPendingTimersAsync();
       await hassTestRunner.run(({ hass, lifecycle }) => {
         lifecycle.onReady(() => {
-          const turnOn = jest.spyOn(hass.call.switch, "turn_on");
-          jest.advanceTimersByTime(2 * SECOND);
+          const turnOn = vi.spyOn(hass.call.switch, "turn_on");
+          vi.advanceTimersByTime(2 * SECOND);
           expect(turnOn).toHaveBeenCalledWith({
             entity_id: "switch.bedroom_lamp",
           });