@digital-alchemy/hass 24.9.4 → 24.9.5

package/src/mock_assistant/extensions/entity-registry.extension.ts

@@ -0,0 +1,41 @@
+import { TServiceParams } from "@digital-alchemy/core";
+
+import { TRawEntityIds } from "../../dynamic";
+import { EntityRegistryItem } from "../../helpers";
+
+export function MockEntityRegistryExtension({ mock_assistant, hass }: TServiceParams) {
+  let entityRegistry = new Map<TRawEntityIds, EntityRegistryItem<TRawEntityIds>>();
+
+  hass.entity.registry.list = async () => [...entityRegistry.values()];
+
+  const sendUpdate = () =>
+    mock_assistant.socket.sendMessage({
+      event: { event_type: "entity_registry_updated" },
+      type: "event",
+    });
+
+  mock_assistant.socket.onMessage<{ entity_id: TRawEntityIds }>(
+    "config/entity_registry/get",
+    message => {
+      mock_assistant.socket.sendMessage({
+        id: message.id,
+        result: entityRegistry.get(message.entity_id),
+        type: "result",
+      });
+    },
+  );
+
+  return {
+    /**
+     * does not imply sendUpdate
+     */
+    loadFixtures(incoming: EntityRegistryItem<TRawEntityIds>[]) {
+      entityRegistry = new Map(incoming.map(i => [i.entity_id, i]));
+    },
+
+    /**
+     * emit entity_registry_updated
+     */
+    sendUpdate,
+  };
+}

package/src/mock_assistant/extensions/entity.extension.ts

@@ -0,0 +1,114 @@
+import { deepExtend, InternalError, is, sleep, TServiceParams } from "@digital-alchemy/core";
+
+import { TRawEntityIds } from "../../dynamic";
+import { ENTITY_STATE, PICK_ENTITY } from "../../helpers";
+
+export function MockEntityExtension({
+  hass,
+  internal,
+  context,
+  logger,
+  config,
+  mock_assistant,
+}: TServiceParams) {
+  let entities = new Map<TRawEntityIds, ENTITY_STATE<TRawEntityIds>>();
+
+  const origGetAll = hass.fetch.getAllEntities;
+
+  hass.fetch.getAllEntities = async () => [...entities.values()];
+
+  function setupState(incoming: SetupStateOptions) {
+    if (internal.boot.completedLifecycleEvents.has("PreInit")) {
+      logger.error(`run [setupState] as part of the .setup command of your test`);
+      throw new InternalError(context, "LATE_SETUP", "Must call setupState before preInit");
+    }
+    const list = Object.keys(incoming) as PICK_ENTITY[];
+    list.forEach((key: PICK_ENTITY) => {
+      const data = entities.get(key);
+      entities.set(key, {
+        ...data,
+        state: incoming[key].state,
+      });
+    });
+  }
+
+  async function emitChange<ENTITY extends PICK_ENTITY>(
+    entity: ENTITY,
+    update: PartialUpdate<ENTITY>,
+  ) {
+    const old_state = entities.get(entity);
+    if (hass.socket.connectionState !== "connected") {
+      throw new InternalError(context, "EARLY_CHANGE", "Websocket does not identify as connected");
+    }
+    if (!old_state) {
+      throw new InternalError(
+        context,
+        "MISSING_ENTITY",
+        "Cannot find existing entity for old_state",
+      );
+    }
+    const new_state = deepExtend({}, old_state);
+    if ("state" in update) {
+      new_state.state = update.state;
+    }
+    if (!is.empty(update.attributes)) {
+      new_state.attributes = deepExtend(new_state.attributes, update.attributes);
+    }
+
+    mock_assistant.socket.sendMessage({
+      event: {
+        data: { new_state, old_state },
+        event_type: "state_changed",
+      },
+      type: "event",
+    });
+
+    // allow changes to propagate properly
+    await sleep(config.mock_assistant.EMIT_SLEEP);
+  }
+
+  return {
+    /**
+     *
+     */
+    emitChange,
+
+    /**
+     * @internal
+     */
+    loadFixtures(incoming: ENTITY_STATE<TRawEntityIds>[]) {
+      if (!is.empty(entities)) {
+        // this should not be possible, the dependency resolution order of tests SHOULD prevent
+        // if you get this error, let me know how
+        throw new InternalError(
+          context,
+          "FIXTURES_ALREADY_LOADED",
+          "There is data in the entity fixtures already, order of operations wrong",
+        );
+      }
+      entities = new Map(incoming.map(i => [i.entity_id, i]));
+    },
+
+    /**
+     * @internal
+     *
+     * restores code references, only used for testing internals
+     */
+    monkeyReset() {
+      hass.fetch.getAllEntities = origGetAll;
+    },
+
+    /**
+     * Does not emit update event
+     *
+     * Intended for test setup
+     */
+    setupState,
+  };
+}
+
+type PartialUpdate<ENTITY extends PICK_ENTITY> = Partial<
+  Pick<ENTITY_STATE<ENTITY>, "state" | "attributes">
+>;
+
+type SetupStateOptions = Partial<{ [ENTITY in PICK_ENTITY]: PartialUpdate<ENTITY> }>;

package/src/mock_assistant/extensions/events.extension.ts

@@ -0,0 +1,37 @@
+import { sleep, TServiceParams } from "@digital-alchemy/core";
+
+import { ANY_ENTITY, ENTITY_STATE, EntityUpdateEvent } from "../../helpers";
+
+const SUPER_SHORT = 1;
+
+export function MockEvents({ mock_assistant, hass }: TServiceParams) {
+  let id = 1000;
+
+  async function emitEvent(event: string, data: object) {
+    id++;
+    await hass.socket.onMessage({
+      event: {
+        data,
+        event_type: event,
+      } as EntityUpdateEvent,
+      id: id,
+      type: "event",
+    });
+  }
+
+  async function emitEntityUpdate<ENTITY extends ANY_ENTITY>(
+    entity: ENTITY,
+    new_state: Partial<ENTITY_STATE<ENTITY>>,
+  ) {
+    const old_state = mock_assistant.fixtures.byId(entity);
+    new_state = mock_assistant.fixtures.replace(entity, new_state);
+    await emitEvent("state_changed", { new_state, old_state });
+    // help ensure all the async flows settle
+    await sleep(SUPER_SHORT);
+  }
+
+  return {
+    emitEntityUpdate,
+    emitEvent,
+  };
+}

package/src/mock_assistant/extensions/fetch.extension.ts

@@ -0,0 +1,3 @@
+export function MockFetchExtension() {
+  //
+}

package/src/mock_assistant/extensions/fixtures.extension.ts

@@ -0,0 +1,79 @@
+import { BootstrapException, is, TServiceParams } from "@digital-alchemy/core";
+import { existsSync, readFileSync } from "fs";
+
+import { ANY_ENTITY, ENTITY_STATE } from "../../helpers";
+import { ScannerCacheData } from "../helpers";
+
+type StateOptions = Partial<{
+  [entity in ANY_ENTITY]: Partial<ENTITY_STATE<entity>>;
+}>;
+
+// this naming pattern is confusing sometimes
+// don't think about it too much
+export function MockFixtures({
+  lifecycle,
+  config,
+  internal,
+  context,
+  mock_assistant,
+}: TServiceParams) {
+  // This file DELIBERATELY breaks some rules
+  // Setup actions that depend on config are not NORMALLY expected to run inside constructor
+
+  const { FIXTURES_FILE } = config.mock_assistant;
+  if (!existsSync(FIXTURES_FILE)) {
+    throw new BootstrapException(
+      context,
+      "MISSING_FIXTURES_FILE",
+      `${FIXTURES_FILE} does not exist`,
+    );
+  }
+  if (is.empty(config.hass.TOKEN)) {
+    // prevents throwing errors
+    internal.boilerplate.configuration.set("hass", "TOKEN", "--");
+  }
+  const data = JSON.parse(readFileSync(FIXTURES_FILE, "utf8")) as ScannerCacheData;
+  mock_assistant.device.loadFixtures(data.devices);
+  mock_assistant.floor.loadFixtures(data.floors);
+  mock_assistant.area.loadFixtures(data.areas);
+  mock_assistant.label.loadFixtures(data.labels);
+  mock_assistant.config.loadFixtures(data.config);
+  mock_assistant.entity.loadFixtures(data.entities);
+  mock_assistant.entity_registry.loadFixtures(data.entity_registry);
+  mock_assistant.services.loadFixtures(data.services);
+  // TODO zones are not currently included in fixtures
+  // more of a completion thing than them having any particular use
+  //
+  // mock_assistant.zone.set(data.);
+
+  function setState(options: StateOptions) {
+    lifecycle.onPreInit(() => {
+      const entities = Object.keys(options) as ANY_ENTITY[];
+      entities.forEach(i => replace(i, options[i]));
+    });
+  }
+
+  function byId(entity: ANY_ENTITY) {
+    return mock_assistant.fixtures.data.entities.find(i => i.entity_id === entity);
+  }
+
+  function replace<ENTITY extends ANY_ENTITY>(
+    entity: ENTITY,
+    new_state: Partial<ENTITY_STATE<ENTITY>>,
+  ): ENTITY_STATE<ENTITY> {
+    const old_state = byId(entity);
+    const { data } = mock_assistant.fixtures;
+    data.entities = data.entities.filter(i => i.entity_id !== entity);
+
+    const updated = { ...old_state, ...new_state } as ENTITY_STATE<ENTITY>;
+    mock_assistant.fixtures.data.entities.push(updated);
+    return updated;
+  }
+
+  return {
+    byId,
+    data,
+    replace,
+    setState,
+  };
+}

package/src/mock_assistant/extensions/floor.extension.ts

@@ -0,0 +1,64 @@
+import { TServiceParams } from "@digital-alchemy/core";
+
+import { TFloorId } from "../../dynamic";
+import { FloorDetails } from "../../helpers";
+
+export function MockFloorExtension({ mock_assistant }: TServiceParams) {
+  let floors = new Map<TFloorId, FloorDetails>();
+
+  mock_assistant.socket.onMessage("config/floor_registry/list", message => {
+    mock_assistant.socket.sendMessage({
+      id: message.id,
+      result: [...floors.values()],
+      type: "result",
+    });
+  });
+
+  mock_assistant.socket.onMessage<{ floor_id: TFloorId }>(
+    "config/floor_registry/delete",
+    message => {
+      floors.delete(message.floor_id);
+      sendUpdate();
+      mock_assistant.socket.sendMessage({
+        id: message.id,
+        result: null,
+        type: "result",
+      });
+    },
+  );
+
+  mock_assistant.socket.onMessage<FloorDetails>("config/floor_registry/create", message => {
+    message.floor_id = message.name as TFloorId;
+    floors.set(message.floor_id as TFloorId, message);
+    sendUpdate();
+    mock_assistant.socket.sendMessage({
+      id: message.id,
+      result: null,
+      type: "result",
+    });
+  });
+  mock_assistant.socket.onMessage<FloorDetails>("config/floor_registry/update", message => {
+    floors.set(message.floor_id as TFloorId, message);
+    sendUpdate();
+    mock_assistant.socket.sendMessage({
+      id: message.id,
+      result: null,
+      type: "result",
+    });
+  });
+
+  const sendUpdate = () =>
+    mock_assistant.socket.sendMessage({
+      event: { event_type: "floor_registry_updated" },
+      type: "event",
+    });
+
+  return {
+    /**
+     * @internal
+     */
+    loadFixtures(incoming: FloorDetails[]) {
+      floors = new Map(incoming.map(i => [i.floor_id, i]));
+    },
+  };
+}

package/src/mock_assistant/extensions/index.ts

@@ -0,0 +1,12 @@
+export * from "./area.extension";
+export * from "./config.extension";
+export * from "./device.extension";
+export * from "./entity.extension";
+export * from "./entity-registry.extension";
+export * from "./events.extension";
+export * from "./fixtures.extension";
+export * from "./floor.extension";
+export * from "./label.extension";
+export * from "./services.extension";
+export * from "./websocket-api.extension";
+export * from "./zone.extension";

package/src/mock_assistant/extensions/label.extension.ts

@@ -0,0 +1,64 @@
+import { TServiceParams } from "@digital-alchemy/core";
+
+import { TLabelId } from "../../dynamic";
+import { LabelDefinition } from "../../helpers";
+
+export function MockLabelExtension({ mock_assistant }: TServiceParams) {
+  let labels = new Map<TLabelId, LabelDefinition>();
+
+  mock_assistant.socket.onMessage("config/label_registry/list", message => {
+    mock_assistant.socket.sendMessage({
+      id: message.id,
+      result: [...labels.values()],
+      type: "result",
+    });
+  });
+
+  mock_assistant.socket.onMessage<{ label_id: TLabelId }>(
+    "config/label_registry/delete",
+    message => {
+      labels.delete(message.label_id);
+      sendUpdate();
+      mock_assistant.socket.sendMessage({
+        id: message.id,
+        result: null,
+        type: "result",
+      });
+    },
+  );
+
+  mock_assistant.socket.onMessage<LabelDefinition>("config/label_registry/create", message => {
+    message.label_id = message.name as TLabelId;
+    labels.set(message.label_id as TLabelId, message);
+    sendUpdate();
+    mock_assistant.socket.sendMessage({
+      id: message.id,
+      result: null,
+      type: "result",
+    });
+  });
+  mock_assistant.socket.onMessage<LabelDefinition>("config/label_registry/update", message => {
+    labels.set(message.label_id as TLabelId, message);
+    sendUpdate();
+    mock_assistant.socket.sendMessage({
+      id: message.id,
+      result: null,
+      type: "result",
+    });
+  });
+
+  const sendUpdate = () =>
+    mock_assistant.socket.sendMessage({
+      event: { event_type: "label_registry_updated" },
+      type: "event",
+    });
+
+  return {
+    /**
+     * @internal
+     */
+    loadFixtures(incoming: LabelDefinition[]) {
+      labels = new Map(incoming.map(i => [i.label_id, i]));
+    },
+  };
+}

package/src/mock_assistant/extensions/services.extension.ts

@@ -0,0 +1,25 @@
+import { TServiceParams } from "@digital-alchemy/core";
+
+import { HassServiceDTO } from "../../helpers";
+
+export function MockServices({ hass }: TServiceParams) {
+  let services: HassServiceDTO[];
+
+  const origList = hass.fetch.listServices;
+  hass.fetch.listServices = async () => services;
+
+  return {
+    /**
+     * @internal
+     */
+    loadFixtures(incoming: HassServiceDTO[]) {
+      services = incoming;
+    },
+    /**
+     * @internal
+     */
+    monkeyReset() {
+      hass.fetch.listServices = origList;
+    },
+  };
+}

package/src/mock_assistant/extensions/websocket-api.extension.ts

@@ -0,0 +1,84 @@
+import { START, TBlackHole, TServiceParams } from "@digital-alchemy/core";
+import EventEmitter from "events";
+import { PartialDeep, WritableDeep } from "type-fest";
+import WS from "ws";
+
+import { SocketMessageDTO } from "../../helpers";
+
+const CONNECTION_CLOSED = 0;
+// const CONNECTION_OPEN = 1;
+// const CONNECTION_FAILED = 2;
+const UNLIMITED = 0;
+
+export const INTERNAL_MESSAGE = "INTERNAL_MESSAGE";
+
+export function MockWebsocketAPI({ hass, config, lifecycle }: TServiceParams) {
+  const connection = new EventEmitter() as WritableDeep<WS>;
+  connection.setMaxListeners(UNLIMITED);
+  lifecycle.onShutdownStart(() => {
+    connection.removeAllListeners();
+  });
+
+  connection.readyState = CONNECTION_CLOSED;
+  let id = START;
+  connection.close = () => {
+    connection.readyState = CONNECTION_CLOSED;
+  };
+  // connection.send = (...data) =>
+
+  hass.socket.createConnection = () => {
+    setImmediate(() => {
+      if (!config.mock_assistant.PASS_AUTH) {
+        return;
+      }
+      sendMessage({ type: "auth_ok" });
+    });
+    return connection;
+  };
+
+  connection.send = (data: string) => {
+    const payload = JSON.parse(data) as { type: string; id: number };
+    connection.emit(INTERNAL_MESSAGE, payload);
+    switch (payload.type) {
+      case "ping": {
+        sendMessage({ id: id++, type: "pong" });
+        return;
+      }
+      case "auth": {
+        return;
+      }
+      default: {
+        setImmediate(() => {
+          sendMessage({
+            id: payload.id,
+            result: null,
+            type: "result",
+          });
+        });
+      }
+    }
+  };
+
+  function sendMessage(data: PartialDeep<SocketMessageDTO>) {
+    setImmediate(() => {
+      connection.emit("message", JSON.stringify(data));
+    });
+  }
+
+  return {
+    connection: connection as WS,
+    onMessage<DATA extends object>(
+      type: string,
+      callback: (data: DATA & MessageData) => TBlackHole,
+    ) {
+      connection.on(INTERNAL_MESSAGE, (data: DATA & MessageData) => {
+        if (data.type === type) {
+          callback(data as DATA & MessageData);
+        }
+      });
+    },
+    sendMessage,
+  };
+}
+
+type MessageData = { id: number; type: string };

package/src/mock_assistant/extensions/zone.extension.ts

@@ -0,0 +1,65 @@
+import { TServiceParams } from "@digital-alchemy/core";
+
+import { TZoneId } from "../../dynamic";
+import { ZoneDetails } from "../../helpers";
+
+export function MockZoneExtension({ mock_assistant }: TServiceParams) {
+  let zones = new Map<TZoneId, ZoneDetails>();
+
+  mock_assistant.socket.onMessage("config/zone_registry/list", message => {
+    mock_assistant.socket.sendMessage({
+      id: message.id,
+      result: [...zones.values()],
+      type: "result",
+    });
+  });
+
+  mock_assistant.socket.onMessage<{ zone_id: TZoneId }>("config/zone_registry/delete", message => {
+    zones.delete(message.zone_id);
+    sendUpdate();
+    mock_assistant.socket.sendMessage({
+      id: message.id,
+      result: null,
+      type: "result",
+    });
+  });
+
+  mock_assistant.socket.onMessage<ZoneDetails>(
+    "config/zone_registry/create",
+    (message: ZoneDetails) => {
+      message.id = message.name as TZoneId;
+      zones.set(message.id as TZoneId, message);
+      sendUpdate();
+      mock_assistant.socket.sendMessage({
+        id: message.id,
+        result: null,
+        type: "result",
+      });
+    },
+  );
+
+  mock_assistant.socket.onMessage<ZoneDetails>("config/zone_registry/update", message => {
+    zones.set(message.id as TZoneId, message);
+    sendUpdate();
+    mock_assistant.socket.sendMessage({
+      id: message.id,
+      result: null,
+      type: "result",
+    });
+  });
+
+  const sendUpdate = () =>
+    mock_assistant.socket.sendMessage({
+      event: { event_type: "zone_registry_updated" },
+      type: "event",
+    });
+
+  return {
+    /**
+     * @internal
+     */
+    loadFixtures(incoming: ZoneDetails[]) {
+      zones = new Map(incoming.map(i => [i.id, i]));
+    },
+  };
+}

package/src/mock_assistant/helpers/fixtures.ts

@@ -0,0 +1,22 @@
+import {
+  ANY_ENTITY,
+  AreaDetails,
+  DeviceDetails,
+  ENTITY_STATE,
+  EntityRegistryItem,
+  FloorDetails,
+  HassConfig,
+  HassServiceDTO as HassServiceDefinition,
+  LabelDefinition,
+} from "../../helpers";
+
+export type ScannerCacheData = {
+  areas: AreaDetails[];
+  config: HassConfig;
+  devices: DeviceDetails[];
+  entities: ENTITY_STATE<ANY_ENTITY>[];
+  entity_registry: EntityRegistryItem<ANY_ENTITY>[];
+  floors: FloorDetails[];
+  labels: LabelDefinition[];
+  services: HassServiceDefinition[];
+};

package/src/mock_assistant/helpers/index.ts

@@ -0,0 +1 @@
+export * from "./fixtures";

package/src/mock_assistant/index.ts

@@ -0,0 +1,3 @@
+export * from "./extensions";
+export * from "./helpers";
+export * from "./mock-assistant.module";

package/src/mock_assistant/main.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { CreateApplication, TServiceParams } from "@digital-alchemy/core";
+import { writeFileSync } from "fs";
+import { join } from "path";
+import { cwd } from "process";
+
+import { LIB_HASS } from "..";
+import { ScannerCacheData } from "./helpers";
+
+const writeFixtures = CreateApplication({
+  configuration: {
+    FIXTURES_FILE: {
+      default: join(cwd(), "fixtures.json"),
+      description: [],
+      type: "string",
+    },
+  },
+  libraries: [LIB_HASS],
+  name: "mock_assistant",
+  services: {
+    Write({ hass, lifecycle, config }: TServiceParams) {
+      lifecycle.onReady(async () => {
+        writeFileSync(
+          config.mock_assistant.FIXTURES_FILE,
+          JSON.stringify(
+            {
+              areas: hass.area.current,
+              config: await hass.fetch.getConfig(),
+              devices: hass.device.current,
+              entities: hass.entity.listEntities().map(i => hass.entity.getCurrentState(i)),
+              entity_registry: hass.entity.registry.current,
+              floors: hass.floor.current,
+              labels: hass.label.current,
+              services: await hass.fetch.listServices(),
+            } as ScannerCacheData,
+            undefined,
+            "  ",
+          ),
+          "utf8",
+        );
+        process.exit();
+      });
+    },
+  },
+});
+setImmediate(async () => writeFixtures.bootstrap());