@digital-alchemy/hass 24.9.3 → 24.9.4

package/dist/mock_assistant/mock-assistant.module.d.ts

@@ -1,16 +1,169 @@
-import { Events, Fixtures } from "./extensions";
+import { MockAreaExtension, MockConfig, MockDeviceExtension, MockEntityExtension, MockEntityRegistryExtension, MockEvents, MockFixtures, MockFloorExtension, MockLabelExtension, MockServices, MockWebsocketAPI, MockZoneExtension } from "./extensions";
 export declare const LIB_MOCK_ASSISTANT: import("@digital-alchemy/core").LibraryDefinition<{
-    events: typeof Events;
-    fixtures: typeof Fixtures;
+    area: typeof MockAreaExtension;
+    config: typeof MockConfig;
+    device: typeof MockDeviceExtension;
+    entity: typeof MockEntityExtension;
+    entity_registry: typeof MockEntityRegistryExtension;
+    events: typeof MockEvents;
+    fixtures: typeof MockFixtures;
+    floor: typeof MockFloorExtension;
+    label: typeof MockLabelExtension;
+    services: typeof MockServices;
+    socket: typeof MockWebsocketAPI;
+    zone: typeof MockZoneExtension;
 }, {
+    EMIT_SLEEP: {
+        default: number;
+        description: string;
+        type: "number";
+    };
     FIXTURES_FILE: {
         default: string;
         description: any[];
         type: "string";
     };
+    PASS_AUTH: {
+        default: true;
+        description: string;
+        type: "boolean";
+    };
 }>;
 declare module "@digital-alchemy/core" {
     interface LoadedModules {
         mock_assistant: typeof LIB_MOCK_ASSISTANT;
     }
 }
+/**
+ * @internal
+ *
+ * Make your own
+ */
+export declare const createTestRunner: () => import("@digital-alchemy/core").iTestRunner<{
+    area: typeof import("..").Area;
+    backup: typeof import("..").Backup;
+    call: typeof import("..").CallProxy;
+    configure: typeof import("..").Configure;
+    device: typeof import("..").Device;
+    entity: typeof import("..").EntityManager;
+    events: typeof import("..").Events;
+    fetch: typeof import("..").FetchAPI;
+    floor: typeof import("..").Floor;
+    idBy: typeof import("..").IDByExtension;
+    internals: typeof import("..").FetchInternals;
+    label: typeof import("..").Label;
+    refBy: typeof import("..").ReferenceExtension;
+    registry: typeof import("..").Registry;
+    socket: typeof import("..").WebsocketAPI;
+    zone: typeof import("..").Zone;
+}, {
+    BASE_URL: {
+        default: string;
+        description: string;
+        type: "string";
+    };
+    EVENT_DEBOUNCE_MS: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    EXPECT_RESPONSE_AFTER: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    RETRY_INTERVAL: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    SOCKET_AVG_DURATION: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    SOCKET_CRASH_REQUESTS_PER_SEC: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    SOCKET_WARN_REQUESTS_PER_SEC: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    TOKEN: {
+        description: string;
+        required: true;
+        type: "string";
+    };
+    VALIDATE_CONFIGURATION: {
+        default: false;
+        description: string;
+        type: "boolean";
+    };
+}>;
+export declare const hassTestRunner: import("@digital-alchemy/core").iTestRunner<{
+    area: typeof import("..").Area;
+    backup: typeof import("..").Backup;
+    call: typeof import("..").CallProxy;
+    configure: typeof import("..").Configure;
+    device: typeof import("..").Device;
+    entity: typeof import("..").EntityManager;
+    events: typeof import("..").Events;
+    fetch: typeof import("..").FetchAPI;
+    floor: typeof import("..").Floor;
+    idBy: typeof import("..").IDByExtension;
+    internals: typeof import("..").FetchInternals;
+    label: typeof import("..").Label;
+    refBy: typeof import("..").ReferenceExtension;
+    registry: typeof import("..").Registry;
+    socket: typeof import("..").WebsocketAPI;
+    zone: typeof import("..").Zone;
+}, {
+    BASE_URL: {
+        default: string;
+        description: string;
+        type: "string";
+    };
+    EVENT_DEBOUNCE_MS: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    EXPECT_RESPONSE_AFTER: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    RETRY_INTERVAL: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    SOCKET_AVG_DURATION: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    SOCKET_CRASH_REQUESTS_PER_SEC: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    SOCKET_WARN_REQUESTS_PER_SEC: {
+        default: number;
+        description: string;
+        type: "number";
+    };
+    TOKEN: {
+        description: string;
+        required: true;
+        type: "string";
+    };
+    VALIDATE_CONFIGURATION: {
+        default: false;
+        description: string;
+        type: "boolean";
+    };
+}>;

package/dist/mock_assistant/mock-assistant.module.js

@@ -1,22 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIB_MOCK_ASSISTANT = void 0;
-const core_1 = require("@digital-alchemy/core");
-const path_1 = require("path");
-const process_1 = require("process");
-const extensions_1 = require("./extensions");
-exports.LIB_MOCK_ASSISTANT = (0, core_1.CreateLibrary)({
+import { CreateLibrary, createModule, SINGLE } from "@digital-alchemy/core";
+import { join } from "path";
+import { cwd } from "process";
+import { LIB_HASS } from "..";
+import { MockAreaExtension, MockConfig, MockDeviceExtension, MockEntityExtension, MockEntityRegistryExtension, MockEvents, MockFixtures, MockFloorExtension, MockLabelExtension, MockServices, MockWebsocketAPI, MockZoneExtension, } from "./extensions";
+export const LIB_MOCK_ASSISTANT = CreateLibrary({
     configuration: {
+        EMIT_SLEEP: {
+            default: SINGLE,
+            description: "Time in ms to wait after emitting entity update events",
+            type: "number",
+        },
         FIXTURES_FILE: {
-            default: (0, path_1.join)((0, process_1.cwd)(), "fixtures.json"),
+            default: join(cwd(), "fixtures.json"),
             description: [],
             type: "string",
         },
+        PASS_AUTH: {
+            default: true,
+            description: "Auto pass for auth challenges",
+            type: "boolean",
+        },
     },
+    depends: [LIB_HASS],
     name: "mock_assistant",
+    priorityInit: [
+        "socket",
+        "floor",
+        "device",
+        "area",
+        "label",
+        "config",
+        "entity",
+        "entity_registry",
+        "services",
+        "fixtures",
+    ],
     services: {
-        events: extensions_1.Events,
-        fixtures: extensions_1.Fixtures,
+        area: MockAreaExtension,
+        config: MockConfig,
+        device: MockDeviceExtension,
+        entity: MockEntityExtension,
+        entity_registry: MockEntityRegistryExtension,
+        events: MockEvents,
+        fixtures: MockFixtures,
+        floor: MockFloorExtension,
+        label: MockLabelExtension,
+        services: MockServices,
+        socket: MockWebsocketAPI,
+        zone: MockZoneExtension,
     },
 });
+/**
+ * @internal
+ *
+ * Make your own
+ */
+export const createTestRunner = () => createModule
+    .fromLibrary(LIB_HASS)
+    .extend()
+    .toTest()
+    .configure({
+    boilerplate: { IS_TEST: true },
+})
+    .appendLibrary(LIB_MOCK_ASSISTANT);
+export const hassTestRunner = createTestRunner();
 //# sourceMappingURL=mock-assistant.module.js.map

package/dist/mock_assistant/mock-assistant.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"mock-assistant.module.js","sourceRoot":"","sources":["../../src/mock_assistant/mock-assistant.module.ts"],"names":[],"mappings":";;;AAAA,gDAAsD;AACtD,+BAA4B;AAC5B,qCAA8B;AAE9B,6CAAgD;AAEnC,QAAA,kBAAkB,GAAG,IAAA,oBAAa,EAAC;IAC9C,aAAa,EAAE;QACb,aAAa,EAAE;YACb,OAAO,EAAE,IAAA,WAAI,EAAC,IAAA,aAAG,GAAE,EAAE,eAAe,CAAC;YACrC,WAAW,EAAE,EAAE;YACf,IAAI,EAAE,QAAQ;SACf;KACF;IACD,IAAI,EAAE,gBAAgB;IACtB,QAAQ,EAAE;QACR,MAAM,EAAE,mBAAM;QACd,QAAQ,EAAE,qBAAQ;KACnB;CACF,CAAC,CAAC"}
+{"version":3,"file":"mock-assistant.module.js","sourceRoot":"","sources":["../../src/mock_assistant/mock-assistant.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAE9B,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAC9B,OAAO,EACL,iBAAiB,EACjB,UAAU,EACV,mBAAmB,EACnB,mBAAmB,EACnB,2BAA2B,EAC3B,UAAU,EACV,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AAEtB,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAAC;IAC9C,aAAa,EAAE;QACb,UAAU,EAAE;YACV,OAAO,EAAE,MAAM;YACf,WAAW,EAAE,wDAAwD;YACrE,IAAI,EAAE,QAAQ;SACf;QACD,aAAa,EAAE;YACb,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,eAAe,CAAC;YACrC,WAAW,EAAE,EAAE;YACf,IAAI,EAAE,QAAQ;SACf;QACD,SAAS,EAAE;YACT,OAAO,EAAE,IAAI;YACb,WAAW,EAAE,+BAA+B;YAC5C,IAAI,EAAE,SAAS;SAChB;KACF;IACD,OAAO,EAAE,CAAC,QAAQ,CAAC;IACnB,IAAI,EAAE,gBAAgB;IACtB,YAAY,EAAE;QACZ,QAAQ;QACR,OAAO;QACP,QAAQ;QACR,MAAM;QACN,OAAO;QACP,QAAQ;QACR,QAAQ;QACR,iBAAiB;QACjB,UAAU;QACV,UAAU;KACX;IACD,QAAQ,EAAE;QACR,IAAI,EAAE,iBAAiB;QACvB,MAAM,EAAE,UAAU;QAClB,MAAM,EAAE,mBAAmB;QAC3B,MAAM,EAAE,mBAAmB;QAC3B,eAAe,EAAE,2BAA2B;QAC5C,MAAM,EAAE,UAAU;QAClB,QAAQ,EAAE,YAAY;QACtB,KAAK,EAAE,kBAAkB;QACzB,KAAK,EAAE,kBAAkB;QACzB,QAAQ,EAAE,YAAY;QACtB,MAAM,EAAE,gBAAgB;QACxB,IAAI,EAAE,iBAAiB;KACxB;CACF,CAAC,CAAC;AAQH;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,EAAE,CACnC,YAAY;KACT,WAAW,CAAC,QAAQ,CAAC;KACrB,MAAM,EAAE;KACR,MAAM,EAAE;KACR,SAAS,CAAC;IACT,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE;CAC/B,CAAC;KACD,aAAa,CAAC,kBAAkB,CAAC,CAAC;AAEvC,MAAM,CAAC,MAAM,cAAc,GAAG,gBAAgB,EAAE,CAAC"}

package/dist/quickboot.module.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuickBoot = QuickBoot;
-const core_1 = require("@digital-alchemy/core");
-const _1 = require(".");
+import { CreateApplication } from "@digital-alchemy/core";
+import { LIB_HASS } from ".";
 /**
  * Use from the node command line to probe apis
  * Not for normal application usage
  */
-async function QuickBoot(name) {
+export async function QuickBoot(name) {
     let out;
-    const app = (0, core_1.CreateApplication)({
-        libraries: [_1.LIB_HASS],
+    const app = CreateApplication({
+        libraries: [LIB_HASS],
         // @ts-expect-error fake app, name used for loading credentials
         name,
         services: {

package/dist/quickboot.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"quickboot.module.js","sourceRoot":"","sources":["../src/quickboot.module.ts"],"names":[],"mappings":";;AAQA,8BAcC;AAtBD,gDAA0E;AAE1E,wBAA6B;AAE7B;;;GAGG;AACI,KAAK,UAAU,SAAS,CAAC,IAAY;IAC1C,IAAI,GAAmB,CAAC;IACxB,MAAM,GAAG,GAAG,IAAA,wBAAiB,EAAC;QAC5B,SAAS,EAAE,CAAC,WAAQ,CAAC;QACrB,+DAA+D;QAC/D,IAAI;QACJ,QAAQ,EAAE;YACR,MAAM,CAAC,MAAsB;gBAC3B,GAAG,GAAG,MAAM,CAAC;YACf,CAAC;SACF;KACF,CAAC,CAAC;IACH,MAAM,GAAG,CAAC,SAAS,EAAE,CAAC;IACtB,OAAO,GAAG,CAAC;AACb,CAAC"}
+{"version":3,"file":"quickboot.module.js","sourceRoot":"","sources":["../src/quickboot.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAkB,MAAM,uBAAuB,CAAC;AAE1E,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC;AAE7B;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,IAAY;IAC1C,IAAI,GAAmB,CAAC;IACxB,MAAM,GAAG,GAAG,iBAAiB,CAAC;QAC5B,SAAS,EAAE,CAAC,QAAQ,CAAC;QACrB,+DAA+D;QAC/D,IAAI;QACJ,QAAQ,EAAE;YACR,MAAM,CAAC,MAAsB;gBAC3B,GAAG,GAAG,MAAM,CAAC;YACf,CAAC;SACF;KACF,CAAC,CAAC;IACH,MAAM,GAAG,CAAC,SAAS,EAAE,CAAC;IACtB,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/testing/area.spec.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@digital-alchemy/core");
-const helpers_1 = require("../helpers");
-const mock_assistant_1 = require("../mock_assistant");
+import { sleep } from "@digital-alchemy/core";
+import { AREA_REGISTRY_UPDATED } from "../helpers";
+import { hassTestRunner, INTERNAL_MESSAGE } from "../mock_assistant";
 describe("Area", () => {
-    let application;
     const EXAMPLE_AREA = {
         area_id: "empty_area",
         floor_id: null,
@@ -14,241 +11,156 @@ describe("Area", () => {
         picture: null,
     };
     afterEach(async () => {
-        if (application) {
-            await application.teardown();
-            application = undefined;
-        }
+        await hassTestRunner.teardown();
         jest.restoreAllMocks();
     });
     describe("Lifecycle", () => {
         it("should force values to be available before ready", async () => {
             expect.assertions(1);
-            application = (0, mock_assistant_1.CreateTestingApplication)({
-                Test({ lifecycle, hass }) {
-                    const spy = jest
-                        .spyOn(hass.socket, "sendMessage")
-                        .mockImplementation(async () => [EXAMPLE_AREA]);
-                    lifecycle.onReady(async () => {
-                        await hass.area.list();
-                        expect(spy).toHaveBeenCalledWith(expect.objectContaining({ type: "config/area_registry/list" }));
-                    });
-                },
+            const app = await hassTestRunner.run(({ mock_assistant, lifecycle, hass }) => {
+                const spy = jest.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 application.bootstrap((0, mock_assistant_1.SILENT_BOOT)({
-                hass: {
-                    AUTO_CONNECT_SOCKET: false,
-                    AUTO_SCAN_CALL_PROXY: false,
-                },
-            }));
+            await app.teardown();
         });
     });
     describe("API", () => {
         describe("Formatting", () => {
             it("should call list properly", async () => {
                 expect.assertions(1);
-                application = (0, mock_assistant_1.CreateTestingApplication)({
-                    Test({ lifecycle, hass }) {
-                        const spy = jest
-                            .spyOn(hass.socket, "sendMessage")
-                            .mockImplementation(async () => []);
-                        lifecycle.onReady(async () => {
-                            await hass.area.list();
-                            expect(spy).toHaveBeenCalledWith(expect.objectContaining({ type: "config/area_registry/list" }));
-                        });
-                    },
+                await hassTestRunner.run(({ lifecycle, hass }) => {
+                    const spy = jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => []);
+                    lifecycle.onReady(async () => {
+                        await hass.area.list();
+                        expect(spy).toHaveBeenCalledWith(expect.objectContaining({ type: "config/area_registry/list" }));
+                    });
                 });
-                await application.bootstrap((0, mock_assistant_1.SILENT_BOOT)({
-                    hass: {
-                        AUTO_CONNECT_SOCKET: false,
-                        AUTO_SCAN_CALL_PROXY: false,
-                    },
-                }));
             });
             it("should call update properly", async () => {
                 expect.assertions(1);
-                application = (0, mock_assistant_1.CreateTestingApplication)({
-                    Test({ lifecycle, hass, event }) {
-                        const spy = jest
-                            .spyOn(hass.socket, "sendMessage")
-                            .mockImplementation(async () => undefined);
-                        lifecycle.onReady(async () => {
-                            setImmediate(() => event.emit(helpers_1.AREA_REGISTRY_UPDATED));
-                            await hass.area.update(EXAMPLE_AREA);
-                            expect(spy).toHaveBeenCalledWith({
-                                type: "config/area_registry/update",
-                                ...EXAMPLE_AREA,
-                            });
+                await hassTestRunner.run(({ lifecycle, hass, event }) => {
+                    const spy = jest
+                        .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,
                         });
-                    },
+                    });
                 });
-                await application.bootstrap((0, mock_assistant_1.SILENT_BOOT)({
-                    hass: {
-                        AUTO_CONNECT_SOCKET: false,
-                        AUTO_SCAN_CALL_PROXY: false,
-                    },
-                }));
             });
             it("should debounce updates properly", async () => {
                 expect.assertions(1);
-                application = (0, mock_assistant_1.CreateTestingApplication)({
-                    Test({ lifecycle, hass }) {
-                        jest
-                            .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 (0, core_1.sleep)(5);
-                                hass.socket.socketEvents.emit("area_registry_updated");
-                                await (0, core_1.sleep)(5);
-                                hass.socket.socketEvents.emit("area_registry_updated");
-                                await (0, core_1.sleep)(75);
-                                hass.socket.socketEvents.emit("area_registry_updated");
-                            });
-                            await (0, core_1.sleep)(200);
-                            expect(counter).toBe(2);
+                await hassTestRunner.run(({ lifecycle, hass }) => {
+                    jest.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);
+                    });
                 });
-                await application.bootstrap((0, mock_assistant_1.SILENT_BOOT)({
-                    hass: {
-                        AUTO_CONNECT_SOCKET: false,
-                        AUTO_SCAN_CALL_PROXY: false,
-                    },
-                }));
             });
             it("should call delete properly", async () => {
                 expect.assertions(1);
-                application = (0, mock_assistant_1.CreateTestingApplication)({
-                    Test({ lifecycle, hass, event }) {
-                        const spy = jest
-                            .spyOn(hass.socket, "sendMessage")
-                            .mockImplementation(async () => undefined);
-                        lifecycle.onReady(async () => {
-                            setImmediate(() => event.emit(helpers_1.AREA_REGISTRY_UPDATED));
-                            await hass.area.delete(EXAMPLE_AREA.area_id);
-                            expect(spy).toHaveBeenCalledWith({
-                                area_id: "empty_area",
-                                type: "config/area_registry/delete",
-                            });
+                await hassTestRunner.run(({ lifecycle, hass, event }) => {
+                    const spy = jest
+                        .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",
                         });
-                    },
+                    });
                 });
-                await application.bootstrap((0, mock_assistant_1.SILENT_BOOT)({
-                    hass: {
-                        AUTO_CONNECT_SOCKET: false,
-                        AUTO_SCAN_CALL_PROXY: false,
-                    },
-                }));
             });
             it("should call create properly", async () => {
                 expect.assertions(1);
-                application = (0, mock_assistant_1.CreateTestingApplication)({
-                    Test({ lifecycle, hass, event }) {
-                        const spy = jest
-                            .spyOn(hass.socket, "sendMessage")
-                            .mockImplementation(async () => undefined);
-                        lifecycle.onReady(async () => {
-                            setImmediate(() => event.emit(helpers_1.AREA_REGISTRY_UPDATED));
-                            await hass.area.create(EXAMPLE_AREA);
-                            expect(spy).toHaveBeenCalledWith({
-                                type: "config/area_registry/create",
-                                ...EXAMPLE_AREA,
-                            });
+                await hassTestRunner.run(({ lifecycle, hass, event }) => {
+                    const spy = jest
+                        .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,
                         });
-                    },
+                    });
                 });
-                await application.bootstrap((0, mock_assistant_1.SILENT_BOOT)({
-                    hass: {
-                        AUTO_CONNECT_SOCKET: false,
-                        AUTO_SCAN_CALL_PROXY: false,
-                    },
-                }));
             });
         });
         describe("Order of operations", () => {
             it("should wait for an update before returning when updating", async () => {
                 expect.assertions(1);
-                application = (0, mock_assistant_1.CreateTestingApplication)({
-                    Test({ lifecycle, hass, event }) {
-                        jest
-                            .spyOn(hass.socket, "sendMessage")
-                            .mockImplementation(async () => undefined);
-                        lifecycle.onReady(async () => {
-                            const response = hass.area.update(EXAMPLE_AREA);
-                            let order = "";
-                            setTimeout(() => {
-                                order += "a";
-                                event.emit(helpers_1.AREA_REGISTRY_UPDATED);
-                            }, 5);
-                            await response;
-                            order += "b";
-                            expect(order).toEqual("ab");
-                        });
-                    },
+                await hassTestRunner.run(({ lifecycle, hass, event }) => {
+                    jest.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");
+                    });
                 });
-                await application.bootstrap((0, mock_assistant_1.SILENT_BOOT)({
-                    hass: {
-                        AUTO_CONNECT_SOCKET: false,
-                        AUTO_SCAN_CALL_PROXY: false,
-                    },
-                }));
             });
             it("should wait for an update before returning when deleting", async () => {
                 expect.assertions(1);
-                application = (0, mock_assistant_1.CreateTestingApplication)({
-                    Test({ lifecycle, hass, event }) {
-                        jest
-                            .spyOn(hass.socket, "sendMessage")
-                            .mockImplementation(async () => undefined);
-                        lifecycle.onReady(async () => {
-                            const response = hass.area.delete("example_area");
-                            let order = "";
-                            setTimeout(() => {
-                                order += "a";
-                                event.emit(helpers_1.AREA_REGISTRY_UPDATED);
-                            }, 5);
-                            await response;
-                            order += "b";
-                            expect(order).toEqual("ab");
-                        });
-                    },
+                await hassTestRunner.run(({ lifecycle, hass, event }) => {
+                    jest.spyOn(hass.socket, "sendMessage").mockImplementation(async () => undefined);
+                    lifecycle.onReady(async () => {
+                        const response = hass.area.delete("example_area");
+                        let order = "";
+                        setTimeout(() => {
+                            order += "a";
+                            event.emit(AREA_REGISTRY_UPDATED);
+                        }, 5);
+                        await response;
+                        order += "b";
+                        expect(order).toEqual("ab");
+                    });
                 });
-                await application.bootstrap((0, mock_assistant_1.SILENT_BOOT)({
-                    hass: {
-                        AUTO_CONNECT_SOCKET: false,
-                        AUTO_SCAN_CALL_PROXY: false,
-                    },
-                }));
             });
             it("should wait for an update before returning when creating", async () => {
                 expect.assertions(1);
-                application = (0, mock_assistant_1.CreateTestingApplication)({
-                    Test({ lifecycle, hass, event }) {
-                        jest
-                            .spyOn(hass.socket, "sendMessage")
-                            .mockImplementation(async () => undefined);
-                        lifecycle.onReady(async () => {
-                            const response = hass.area.create(EXAMPLE_AREA);
-                            let order = "";
-                            setTimeout(() => {
-                                order += "a";
-                                event.emit(helpers_1.AREA_REGISTRY_UPDATED);
-                            }, 5);
-                            await response;
-                            order += "b";
-                            expect(order).toEqual("ab");
-                        });
-                    },
+                await hassTestRunner.run(({ lifecycle, hass, event }) => {
+                    jest.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");
+                    });
                 });
-                await application.bootstrap((0, mock_assistant_1.SILENT_BOOT)({
-                    hass: {
-                        AUTO_CONNECT_SOCKET: false,
-                        AUTO_SCAN_CALL_PROXY: false,
-                    },
-                }));
             });
         });
     });