@digital-alchemy/hass 24.11.2 → 24.11.3

package/src/{extensions/fetch-api.extension.ts → services/fetch-api.service.mts}

@@ -2,6 +2,8 @@ import { DOWN, is, NO_CHANGE, SECOND, TServiceParams, UP } from "@digital-alchem
 import dayjs, { Dayjs } from "dayjs";
 import { lt } from "semver";
 
+import { MIN_SUPPORTED_HASS_VERSION } from "../helpers/constants.mts";
+import { FetchArguments, FilteredFetchArguments, TFetchBody } from "../helpers/fetch.mts";
 import {
   ALL_SERVICE_DOMAINS,
   ANY_ENTITY,
@@ -9,18 +11,14 @@ import {
   CalendarFetchOptions,
   CheckConfigResult,
   ENTITY_STATE,
-  FetchArguments,
-  FilteredFetchArguments,
   HassConfig,
   HassServiceDTO,
   HomeAssistantServerLogItem,
-  MIN_SUPPORTED_HASS_VERSION,
   PICK_SERVICE,
   PICK_SERVICE_PARAMETERS,
   PostConfigPriorities,
   RawCalendarEvent,
-  TFetchBody,
-} from "..";
+} from "../helpers/index.mts";
 
 type SendBody<STATE extends string | number = string, ATTRIBUTES extends object = object> = {
   attributes?: ATTRIBUTES;

package/src/{extensions/floor.extension.ts → services/floor.service.mts}

@@ -1,13 +1,13 @@
 import { debounce, TServiceParams } from "@digital-alchemy/core";
 
-import { TFloorId } from "../dynamic";
+import { TFloorId } from "../dynamic.mts";
 import {
   EARLY_ON_READY,
   FLOOR_REGISTRY_UPDATED,
   FloorCreate,
   FloorDetails,
   HassFloorService,
-} from "../helpers";
+} from "../helpers/index.mts";
 
 export function Floor({
   hass,

package/src/{extensions/id-by.extension.ts → services/id-by.service.mts}

@@ -8,7 +8,7 @@ import {
   TPlatformId,
   TUniqueId,
   TUniqueIDMapping,
-} from "../dynamic";
+} from "../dynamic.mts";
 import {
   ALL_DOMAINS,
   ANY_ENTITY,
@@ -20,7 +20,7 @@ import {
   PICK_FROM_FLOOR,
   PICK_FROM_LABEL,
   PICK_FROM_PLATFORM,
-} from "../helpers";
+} from "../helpers/index.mts";
 
 const check = <RAW extends ANY_ENTITY>(raw: RAW[], domains: ALL_DOMAINS[]) => {
   if (!is.empty(domains)) {

package/src/services/index.mts

@@ -0,0 +1,16 @@
+export * from "./area.service.mts";
+export * from "./backup.service.mts";
+export * from "./call-proxy.service.mts";
+export * from "./config.service.mts";
+export * from "./device.service.mts";
+export * from "./entity.service.mts";
+export * from "./events.service.mts";
+export * from "./fetch-api.service.mts";
+export * from "./floor.service.mts";
+export * from "./id-by.service.mts";
+export * from "./internal.service.mts";
+export * from "./label.service.mts";
+export * from "./reference.service.mts";
+export * from "./registry.service.mts";
+export * from "./websocket-api.service.mts";
+export * from "./zone.service.mts";

package/src/{extensions/internal.extension.ts → services/internal.service.mts}

@@ -12,7 +12,7 @@ import {
   FetchWith,
   MaybeHttpError,
   TFetchBody,
-} from "../helpers";
+} from "../helpers/index.mts";
 
 const streamPipeline = promisify(pipeline);
 

package/src/{extensions/label.extension.ts → services/label.service.mts}

@@ -1,13 +1,13 @@
 import { debounce, TServiceParams } from "@digital-alchemy/core";
 
-import { TLabelId } from "../dynamic";
+import { TLabelId } from "../dynamic.mts";
 import {
   EARLY_ON_READY,
   HassLabelService,
   LABEL_REGISTRY_UPDATED,
   LabelDefinition,
   LabelOptions,
-} from "../helpers";
+} from "../helpers/index.mts";
 
 export function Label({
   hass,

package/src/{extensions/reference.extension.ts → services/reference.service.mts}

@@ -2,7 +2,6 @@ import { DOWN, is, NONE, sleep, TAnyFunction, TServiceParams, UP } from "@digita
 import dayjs, { Dayjs } from "dayjs";
 import { Get } from "type-fest";
 
-import { SERVICE_LIST_UPDATED, SOCKET_CONNECTED } from "..";
 import {
   TAreaId,
   TDeviceId,
@@ -12,7 +11,7 @@ import {
   TRawDomains,
   TUniqueId,
   TUniqueIDMapping,
-} from "../dynamic";
+} from "../dynamic.mts";
 import {
   ALL_SERVICE_DOMAINS,
   ANY_ENTITY,
@@ -27,7 +26,9 @@ import {
   PICK_FROM_LABEL,
   PICK_FROM_PLATFORM,
   RemoveCallback,
-} from "../helpers";
+} from "../helpers/index.mts";
+import { SERVICE_LIST_UPDATED } from "./config.service.mts";
+import { SOCKET_CONNECTED } from "./websocket-api.service.mts";
 
 /**
  * ## Overview
@@ -147,7 +148,7 @@ export function ReferenceService({
       if (loaded && !force) {
         return;
       }
-      // Not gonna build types for this, and ts-expect-error fails in jest
+      // Not gonna build types for this, and ts-expect-error fails in vi
       // This is a weird hack for an obscure feature, so sue me
       //
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment

package/src/{extensions/registry.extension.ts → services/registry.service.mts}

@@ -7,7 +7,7 @@ import {
   ManifestItem,
   UpdateCoreOptions,
   ZoneDetails,
-} from "../helpers";
+} from "../helpers/index.mts";
 
 export function Registry({ hass }: TServiceParams): HassRegistryService {
   async function ManifestList() {

package/src/{extensions/websocket-api.extension.ts → services/websocket-api.service.mts}

@@ -18,7 +18,7 @@ import {
   OnHassEventOptions,
   SocketMessageDTO,
   SocketSubscribeOptions,
-} from "..";
+} from "../index.mts";
 
 const CONNECTION_OPEN = 1;
 const CLEANUP_INTERVAL = 5;

package/src/{extensions/zone.extension.ts → services/zone.service.mts}

@@ -7,7 +7,7 @@ import {
   ZONE_REGISTRY_UPDATED,
   ZoneDetails,
   ZoneOptions,
-} from "../helpers";
+} from "../helpers/index.mts";
 
 export function Zone({
   config,

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

@@ -1,8 +1,8 @@
 import { sleep } from "@digital-alchemy/core";
 
-import { TAreaId } from "../dynamic";
-import { AREA_REGISTRY_UPDATED, AreaDetails } from "../helpers";
-import { hassTestRunner, INTERNAL_MESSAGE } from "../mock_assistant";
+import { TAreaId } from "../dynamic.mts";
+import { AREA_REGISTRY_UPDATED, AreaDetails } from "../helpers/index.mts";
+import { hassTestRunner, INTERNAL_MESSAGE } from "../mock_assistant/index.mts";
 
 describe("Area", () => {
   const EXAMPLE_AREA = {
@@ -16,7 +16,7 @@ describe("Area", () => {
 
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("Lifecycle", () => {
@@ -24,7 +24,7 @@ describe("Area", () => {
       expect.assertions(1);
 
       const app = await hassTestRunner.run(({ mock_assistant, lifecycle, hass }) => {
-        const spy = jest.fn();
+        const spy = vi.fn();
         mock_assistant.socket.connection.on(INTERNAL_MESSAGE, spy);
         lifecycle.onReady(async () => {
           await hass.area.list();
@@ -42,7 +42,7 @@ describe("Area", () => {
       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.area.list();
             expect(spy).toHaveBeenCalledWith(
@@ -55,7 +55,7 @@ describe("Area", () => {
       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 () => {
@@ -73,7 +73,7 @@ describe("Area", () => {
       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.onAreaRegistryUpdate(() => counter++);
           lifecycle.onReady(async () => {
@@ -96,7 +96,7 @@ describe("Area", () => {
         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 () => {
@@ -114,7 +114,7 @@ describe("Area", () => {
       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 () => {
@@ -134,7 +134,7 @@ describe("Area", () => {
       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.area.update(EXAMPLE_AREA);
             let order = "";
@@ -152,7 +152,7 @@ describe("Area", () => {
       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.area.delete("example_area" as TAreaId);
             let order = "";
@@ -170,7 +170,7 @@ describe("Area", () => {
       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.area.create(EXAMPLE_AREA);
             let order = "";

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

@@ -1,19 +1,19 @@
 import { SINGLE } from "@digital-alchemy/core";
 
-import { BackupResponse } from "../helpers";
-import { hassTestRunner } from "../mock_assistant";
+import { BackupResponse } from "../helpers/index.mts";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("Backup", () => {
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   it("should format removes properly", async () => {
     expect.assertions(1);
     await hassTestRunner.run(({ lifecycle, hass }) => {
       lifecycle.onReady(async () => {
-        const spy = jest.spyOn(hass.socket, "sendMessage");
+        const spy = vi.spyOn(hass.socket, "sendMessage");
         await hass.backup.remove("test");
         expect(spy).toHaveBeenCalledWith(
           expect.objectContaining({
@@ -29,7 +29,7 @@ describe("Backup", () => {
     expect.assertions(1);
     await hassTestRunner.run(({ lifecycle, hass }) => {
       lifecycle.onReady(async () => {
-        const spy = jest.spyOn(hass.socket, "sendMessage");
+        const spy = vi.spyOn(hass.socket, "sendMessage");
         await hass.backup.list();
         expect(spy).toHaveBeenCalledWith(
           expect.objectContaining({
@@ -44,9 +44,7 @@ describe("Backup", () => {
     expect.assertions(1);
     await hassTestRunner.run(({ lifecycle, hass }) => {
       lifecycle.onReady(async () => {
-        const spy = jest
-          .spyOn(hass.socket, "sendMessage")
-          .mockImplementation(async () => undefined);
+        const spy = vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
         await hass.backup.download("test", "/foo/bar");
         expect(spy).toHaveBeenCalledWith(
           expect.objectContaining({
@@ -64,8 +62,8 @@ describe("Backup", () => {
       lifecycle.onReady(async () => {
         const path = "/test/thing";
         const destination = "/foo/bar";
-        jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => ({ path }));
-        const spy = jest.spyOn(hass.fetch, "download").mockImplementation(async () => undefined);
+        vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => ({ path }));
+        const spy = vi.spyOn(hass.fetch, "download").mockImplementation(async () => undefined);
         await hass.backup.download("test", destination);
         expect(spy).toHaveBeenCalledWith(destination, expect.objectContaining({ url: path }));
       });
@@ -78,8 +76,8 @@ describe("Backup", () => {
       lifecycle.onReady(async () => {
         const path = "/test/thing";
         const destination = "/foo/bar";
-        jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => ({ path }));
-        const spy = jest.spyOn(hass.fetch, "download").mockImplementation(async () => undefined);
+        vi.spyOn(hass.socket, "sendMessage").mockImplementation(async () => ({ path }));
+        const spy = vi.spyOn(hass.fetch, "download").mockImplementation(async () => undefined);
         await hass.backup.download("test", destination);
         expect(spy).toHaveBeenCalledWith(destination, expect.objectContaining({ url: path }));
       });
@@ -90,13 +88,13 @@ describe("Backup", () => {
     expect.assertions(1);
     await hassTestRunner.configure({ hass: { RETRY_INTERVAL: 0 } }).run(({ lifecycle, hass }) => {
       lifecycle.onReady(async () => {
-        const spy = jest.spyOn(hass.socket, "sendMessage");
+        const spy = vi.spyOn(hass.socket, "sendMessage");
         const responses = [
           { backing_up: true, backups: [] },
           { backing_up: false, backups: [] },
         ] as BackupResponse[];
 
-        jest.spyOn(hass.backup, "list").mockImplementation(async () => responses.shift());
+        vi.spyOn(hass.backup, "list").mockImplementation(async () => responses.shift());
 
         await hass.backup.generate();
         expect(spy).not.toHaveBeenCalledWith({ type: "backup/generate" });
@@ -108,14 +106,14 @@ describe("Backup", () => {
     expect.assertions(1);
     await hassTestRunner.configure({ hass: { RETRY_INTERVAL: 0 } }).run(({ lifecycle, hass }) => {
       lifecycle.onReady(async () => {
-        const spy = jest.spyOn(hass.socket, "sendMessage");
+        const spy = vi.spyOn(hass.socket, "sendMessage");
         const responses = [
           { backing_up: false, backups: [] },
           { backing_up: true, backups: [] },
           { backing_up: false, backups: [] },
         ] as BackupResponse[];
 
-        jest.spyOn(hass.backup, "list").mockImplementation(async () => responses.shift());
+        vi.spyOn(hass.backup, "list").mockImplementation(async () => responses.shift());
 
         await hass.backup.generate();
         expect(spy).toHaveBeenCalledWith(expect.objectContaining({ type: "backup/generate" }));
@@ -145,9 +143,7 @@ describe("Backup", () => {
         ] as BackupResponse[];
         const length = responses.length;
 
-        const spy = jest
-          .spyOn(hass.backup, "list")
-          .mockImplementation(async () => responses.shift());
+        const spy = vi.spyOn(hass.backup, "list").mockImplementation(async () => responses.shift());
 
         await hass.backup.generate();
         expect(spy).toHaveBeenCalledTimes(length - SINGLE);

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

@@ -1,6 +1,7 @@
 import { env } from "process";
+import { MockInstance } from "vitest";
 
-import { hassTestRunner } from "../mock_assistant";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 const TOKEN = "DEFAULTS";
 
@@ -13,7 +14,7 @@ describe("Config", () => {
 
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("Auto", () => {
@@ -88,7 +89,7 @@ describe("Config", () => {
     // # Should not exit if not set
     it("should not exit if not set", async () => {
       expect.assertions(1);
-      const exitSpy = jest
+      const exitSpy = vi
         .spyOn(process, "exit")
         // @ts-expect-error testing
         .mockImplementation(() => {});
@@ -103,11 +104,11 @@ describe("Config", () => {
 
     // # Should info log on success
     it("should info log on success", async () => {
-      const exitSpy = jest
+      const exitSpy = vi
         .spyOn(process, "exit")
         // @ts-expect-error testing
         .mockImplementation(() => {});
-      let spy: jest.SpyInstance;
+      let spy: MockInstance;
 
       await hassTestRunner
         .configure({
@@ -115,10 +116,10 @@ describe("Config", () => {
         })
         .run(({ internal, hass }) => {
           const logger = internal.boilerplate.logger.getBaseLogger();
-          spy = jest.spyOn(logger, "info").mockImplementation(() => {});
-          jest
-            .spyOn(hass.fetch, "checkCredentials")
-            .mockImplementation(async () => ({ message: "ok" }));
+          spy = vi.spyOn(logger, "info").mockImplementation(() => {});
+          vi.spyOn(hass.fetch, "checkCredentials").mockImplementation(async () => ({
+            message: "ok",
+          }));
         });
 
       expect(exitSpy).toHaveBeenCalledWith(1);
@@ -127,8 +128,8 @@ describe("Config", () => {
 
     // # Should error log on bad token
     it("should error log on bad token", async () => {
-      let spy: jest.SpyInstance;
-      const exitSpy = jest
+      let spy: MockInstance;
+      const exitSpy = vi
         .spyOn(process, "exit")
         // @ts-expect-error testing
         .mockImplementation(() => {});
@@ -137,9 +138,8 @@ describe("Config", () => {
         .configure({ hass: { TOKEN: "TEST", VALIDATE_CONFIGURATION: true } })
         .run(({ internal, hass }) => {
           const logger = internal.boilerplate.logger.getBaseLogger();
-          spy = jest.spyOn(logger, "error").mockImplementation(() => {});
-          jest
-            .spyOn(hass.fetch, "checkCredentials")
+          spy = vi.spyOn(logger, "error").mockImplementation(() => {});
+          vi.spyOn(hass.fetch, "checkCredentials")
             // anything that isn't the success works
             .mockImplementation(async () => ({ message: "big_bad_error" }));
         });
@@ -155,22 +155,21 @@ describe("Config", () => {
     // # Should error log on bad url
     it("should error log on bad url", async () => {
       const error = new Error("BOOM");
-      let spy: jest.SpyInstance;
-      const exitSpy = jest
+      let spy: MockInstance;
+      const exitSpy = vi
         .spyOn(process, "exit")
         // @ts-expect-error testing
         .mockImplementation(() => {});
-      jest.spyOn(console, "log").mockImplementation(() => {});
+      vi.spyOn(console, "log").mockImplementation(() => {});
 
-      jest.spyOn(console, "error").mockImplementation(() => {});
+      vi.spyOn(console, "error").mockImplementation(() => {});
 
       await hassTestRunner
         .configure({ hass: { TOKEN: "TEST", VALIDATE_CONFIGURATION: true } })
         .run(({ internal, hass }) => {
           const logger = internal.boilerplate.logger.getBaseLogger();
-          spy = jest.spyOn(logger, "error").mockImplementation(() => {});
-          jest
-            .spyOn(hass.fetch, "checkCredentials")
+          spy = vi.spyOn(logger, "error").mockImplementation(() => {});
+          vi.spyOn(hass.fetch, "checkCredentials")
             // anything that isn't the success works
             .mockImplementation(async () => {
               throw error;

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

@@ -1,7 +1,7 @@
 import { sleep } from "@digital-alchemy/core";
 
-import { DeviceDetails } from "../helpers";
-import { hassTestRunner } from "../mock_assistant";
+import { DeviceDetails } from "../helpers/index.mts";
+import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("Device", () => {
   const EXAMPLE_DEVICE = {
@@ -26,14 +26,14 @@ describe("Device", () => {
 
   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_DEVICE]);
         lifecycle.onReady(async () => {
@@ -49,7 +49,7 @@ describe("Device", () => {
   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.onDeviceRegistryUpdate(() => counter++);
       lifecycle.onReady(async () => {
@@ -73,7 +73,7 @@ describe("Device", () => {
       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.device.list();
             expect(spy).toHaveBeenCalledWith(

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

@@ -1,21 +1,21 @@
 import { sleep } from "@digital-alchemy/core";
 
-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("Entity", () => {
   afterEach(async () => {
     await hassTestRunner.teardown();
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe("API", () => {
     describe("Updates", () => {
-      xit("should debounce updates properly", async () => {
+      it.skip("should debounce updates properly", async () => {
         expect.assertions(1);
         await new Promise<void>(async done => {
           await hassTestRunner.run(({ hass }) => {
-            const spy = jest.fn();
+            const spy = vi.fn();
             hass.events.onEntityRegistryUpdate(spy);
             hass.socket.onConnect(async () => {
               setImmediate(async () => {
@@ -41,7 +41,7 @@ describe("Entity", () => {
           lifecycle.onReady(() => {
             const old_state = hass.entity.getCurrentState("sensor.magic");
             const new_state = { ...old_state, state: "test" };
-            const spy = jest.spyOn(event, "emit");
+            const spy = vi.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);
@@ -138,7 +138,7 @@ describe("Entity", () => {
     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);
+        const spy = vi.spyOn(hass.entity, "refresh").mockImplementation(async () => undefined);
 
         lifecycle.onPostConfig(function latePostConfig() {
           expect(spy).toHaveBeenCalled();
@@ -159,7 +159,7 @@ describe("Entity", () => {
           [],
           [{ entity_id: "sensor.magic" } as ENTITY_STATE<ANY_ENTITY>],
         ];
-        const spy = jest
+        const spy = vi
           .spyOn(hass.fetch, "getAllEntities")
           // @ts-expect-error it happens
           .mockImplementation(async () => responses.shift());