miravo 0.6.0 → 0.6.2

package/src/lib/le/le-apply.test.ts

@@ -1,591 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ProtocolName } from "@miravo/shared";
-import {
-  type ApplyDesiredState,
-  type ApplyOptions,
-  buildApplyPlan,
-  type DesiredDevice,
-  executePlan,
-} from "./le-apply.ts";
-import type { LEDevice, LEDeviceHub } from "./le-devicehub.ts";
-import type { LEDigitalTwins } from "./le-digital-twins.ts";
-
-interface TestStaticAttributeWrite {
-  readonly ModelID?: string;
-  readonly InstanceID?: string;
-  readonly Key: string;
-  readonly Value: string;
-}
-
-interface TestInstanceStaticAttributeUpdate {
-  readonly ID: string;
-  readonly ModelID?: string | null;
-  readonly InstanceID?: string | null;
-  readonly Key: string;
-  readonly Value: string;
-}
-
-function createDesiredState(deviceName: string): ApplyDesiredState {
-  const device: DesiredDevice = {
-    instanceId: "pump-001",
-    modelName: "pump",
-    protocol: "mqtt" satisfies ProtocolName,
-    deviceName,
-    browsePath: "area/line/pump-001",
-    endpoint: { host: "127.0.0.1", port: 1883 },
-    properties: [],
-    tags: [
-      {
-        name: "rpm",
-        tagName: "rpm",
-        valueType: "float32",
-        properties: [],
-        unsPath: "area/line/pump-001/rpm",
-        access: "read",
-      },
-    ],
-  };
-  return { devices: [device], models: [], instances: [] };
-}
-
-function createApplyOptions(scope: readonly ("devices" | "models" | "instances")[]): ApplyOptions {
-  return {
-    templateId: "smart-factory",
-    targetHost: "le.example.local",
-    sourceHostname: "miravo.local",
-    scope,
-    filters: {},
-    ifUnmanaged: "skip",
-    dryRun: true,
-  };
-}
-
-function createHubMock(devices: readonly LEDevice[]): LEDeviceHub {
-  return {
-    async listDevices() {
-      return devices;
-    },
-    async resolveDriverByName() {
-      return { ID: "driver-1", Name: "MQTT Client" };
-    },
-  } as unknown as LEDeviceHub;
-}
-
-function createDigitalTwinsMock(): LEDigitalTwins {
-  return {
-    async listModels() {
-      return [];
-    },
-    async listInstances() {
-      return [];
-    },
-  } as unknown as LEDigitalTwins;
-}
-
-function createUnmanagedDevice(name: string): LEDevice {
-  return {
-    ID: "dev-1",
-    Name: name,
-    DriverID: "driver-1",
-    Properties: [],
-    MetaData: [{ Name: "owner", Value: "external" }],
-    Description: "External device",
-  };
-}
-
-function createManagedDevice(name: string, protocol: ProtocolName): LEDevice {
-  return {
-    ID: "dev-1",
-    Name: name,
-    DriverID: `driver-${protocol}`,
-    Properties: [],
-    MetaData: [
-      { Name: "miravo_managed", Value: "true" },
-      { Name: "miravo_template", Value: "smart-factory" },
-      { Name: "miravo_instance", Value: "pump-001" },
-      { Name: "miravo_model", Value: "pump" },
-      { Name: "miravo_protocol", Value: protocol },
-    ],
-    Description: "Miravo managed device",
-  };
-}
-
-describe("buildApplyPlan protocol change handling", () => {
-  test("emits replace when managed device protocol changes", async () => {
-    const desired: ApplyDesiredState = {
-      devices: [
-        {
-          instanceId: "pump-001",
-          modelName: "pump",
-          protocol: "mqtt" satisfies ProtocolName,
-          deviceName: "pump-001",
-          browsePath: "area/line/pump-001",
-          endpoint: { host: "127.0.0.1", port: 1883 },
-          properties: [],
-          tags: [],
-        },
-      ],
-      models: [],
-      instances: [],
-    };
-    const opts = createApplyOptions(["devices"]);
-    const hub = createHubMock([createManagedDevice("pump-001", "opcua")]);
-    const dt = createDigitalTwinsMock();
-
-    const { plan } = await buildApplyPlan(hub, dt, desired, opts);
-
-    const entry = plan.entries.find((e) => e.resourceType === "device");
-    expect(entry?.action).toBe("replace");
-    expect(entry?.protocol).toBe("mqtt");
-  });
-
-  test("emits update when managed device protocol is unchanged", async () => {
-    const desired = createDesiredState("pump-001"); // mqtt
-    const opts = createApplyOptions(["devices"]);
-    const hub = createHubMock([createManagedDevice("pump-001", "mqtt")]);
-    const dt = createDigitalTwinsMock();
-
-    const { plan } = await buildApplyPlan(hub, dt, desired, opts);
-
-    const entry = plan.entries.find((e) => e.resourceType === "device");
-    expect(entry?.action).toBe("update");
-  });
-
-  test("blocks replace when new protocol driver is not found on LE", async () => {
-    const desired: ApplyDesiredState = {
-      devices: [
-        {
-          instanceId: "pump-001",
-          modelName: "pump",
-          protocol: "mqtt" satisfies ProtocolName,
-          deviceName: "pump-001",
-          browsePath: "area/line/pump-001",
-          endpoint: { host: "127.0.0.1", port: 1883 },
-          properties: [],
-          tags: [],
-        },
-      ],
-      models: [],
-      instances: [],
-    };
-    const opts = createApplyOptions(["devices"]);
-    const hub: LEDeviceHub = {
-      async listDevices() {
-        return [createManagedDevice("pump-001", "opcua")];
-      },
-      async resolveDriverByName() {
-        throw new Error("driver not found");
-      },
-    } as unknown as LEDeviceHub;
-    const dt = createDigitalTwinsMock();
-
-    const { plan } = await buildApplyPlan(hub, dt, desired, opts);
-
-    const entry = plan.entries.find((e) => e.resourceType === "device");
-    expect(entry?.action).toBe("blocked");
-  });
-});
-
-describe("buildApplyPlan unmanaged device handling", () => {
-  test("skips device planning when unmanaged device is skipped with --if-unmanaged=skip", async () => {
-    const desired = createDesiredState("pump-001");
-    const opts = createApplyOptions(["devices"]);
-    const hub = createHubMock([createUnmanagedDevice("pump-001")]);
-    const dt = createDigitalTwinsMock();
-
-    const { plan } = await buildApplyPlan(hub, dt, desired, opts);
-
-    expect(plan.entries.find((entry) => entry.resourceType === "device")).toBeUndefined();
-  });
-
-  test("blocks device for unmanaged device when policy is fail", async () => {
-    const desired = createDesiredState("pump-001");
-    const opts = { ...createApplyOptions(["devices"]), ifUnmanaged: "fail" as const };
-    const hub = createHubMock([createUnmanagedDevice("pump-001")]);
-    const dt = createDigitalTwinsMock();
-
-    const { plan } = await buildApplyPlan(hub, dt, desired, opts);
-
-    expect(plan.entries).toHaveLength(1);
-    expect(plan.entries[0]).toMatchObject({
-      action: "blocked",
-      resourceType: "device",
-      name: "pump-001",
-    });
-  });
-});
-
-describe("buildApplyPlan model handling", () => {
-  test("blocks model update when LE has duplicate model names", async () => {
-    const desired: ApplyDesiredState = {
-      devices: [],
-      models: [{ name: "AC-INDUCTION-MOTOR", leDtJson: { mock: true } }],
-      instances: [],
-    };
-    const opts = createApplyOptions(["models"]);
-    const hub = createHubMock([]);
-    const dt: LEDigitalTwins = {
-      async listModels() {
-        return [
-          {
-            ID: "model-1",
-            Name: "AC-INDUCTION-MOTOR",
-            Description: "",
-            Version: 1,
-          },
-          {
-            ID: "model-2",
-            Name: "AC-INDUCTION-MOTOR",
-            Description: "",
-            Version: 1,
-          },
-        ];
-      },
-      async listInstances() {
-        return [];
-      },
-    } as unknown as LEDigitalTwins;
-
-    const { plan } = await buildApplyPlan(hub, dt, desired, opts);
-    expect(plan.entries).toHaveLength(1);
-    expect(plan.entries[0]).toMatchObject({
-      action: "blocked",
-      resourceType: "model",
-      name: "AC-INDUCTION-MOTOR",
-    });
-    expect(plan.entries[0]?.blockReason).toContain("duplicate DT models");
-  });
-});
-
-describe("executePlan model idempotency", () => {
-  test("model create resolves markers in imported DT JSON", async () => {
-    const desired: ApplyDesiredState = {
-      devices: [],
-      models: [
-        {
-          name: "PUMP",
-          leDtJson: [
-            {
-              staticAttributes: [
-                { key: "miravo_managed", value: "false" },
-                { key: "miravo_template", value: "__miravo_placeholder__" },
-                { key: "miravo_model", value: "__miravo_placeholder__" },
-                { key: "miravo_instance", value: "__miravo_placeholder__" },
-              ],
-            },
-          ],
-        },
-      ],
-      instances: [],
-    };
-    const opts = createApplyOptions(["models"]);
-    const hub = createHubMock([]);
-    const importedPayloads: unknown[] = [];
-
-    const dt: LEDigitalTwins = {
-      async listModels() {
-        return [];
-      },
-      async listInstances() {
-        return [];
-      },
-      async importModel(payload: unknown) {
-        importedPayloads.push(payload);
-        return true;
-      },
-    } as unknown as LEDigitalTwins;
-
-    const { plan, snapshot } = await buildApplyPlan(hub, dt, desired, opts);
-    expect(plan.entries[0]?.action).toBe("create");
-
-    const result = await executePlan(hub, dt, plan, desired, opts, snapshot);
-
-    expect(result.applied).toBe(1);
-    expect(result.failed).toBe(0);
-    expect(importedPayloads).toHaveLength(1);
-    expect(importedPayloads[0]).toEqual([
-      {
-        staticAttributes: [
-          { key: "miravo_managed", value: "true" },
-          { key: "miravo_template", value: "smart-factory" },
-          { key: "miravo_model", value: "PUMP" },
-          { key: "miravo_instance", value: "__miravo_placeholder__" },
-        ],
-      },
-    ]);
-  });
-
-  test("model update skips import when model already exists (prevents duplicates)", async () => {
-    const desired: ApplyDesiredState = {
-      devices: [],
-      models: [{ name: "PUMP", leDtJson: { model: true } }],
-      instances: [],
-    };
-    const opts = createApplyOptions(["models"]);
-    const hub = createHubMock([]);
-    let importCalled = false;
-
-    const dt: LEDigitalTwins = {
-      async listModels() {
-        return [{ ID: "existing-model-1", Name: "PUMP", Description: "", Version: 1 }];
-      },
-      async listInstances() {
-        return [];
-      },
-      async importModel() {
-        importCalled = true;
-        return true;
-      },
-    } as unknown as LEDigitalTwins;
-
-    const { plan, snapshot } = await buildApplyPlan(hub, dt, desired, opts);
-    expect(plan.entries[0]?.action).toBe("update");
-
-    const result = await executePlan(hub, dt, plan, desired, opts, snapshot);
-
-    expect(result.applied).toBe(1);
-    expect(result.failed).toBe(0);
-    expect(importCalled).toBe(false);
-  });
-});
-
-describe("executePlan marker failure accounting", () => {
-  test("updates instance markers through transactional instance update", async () => {
-    const desired: ApplyDesiredState = {
-      devices: [],
-      models: [
-        {
-          name: "HOT-WATER-BOILER",
-          leDtJson: { model: "payload" },
-        },
-      ],
-      instances: [
-        {
-          instanceId: "boiler-qa-001",
-          modelName: "hot-water-boiler",
-          dtInstanceName: "boiler-qa-001",
-          dtModelName: "HOT-WATER-BOILER",
-          boundDeviceName: "boiler-qa-001",
-          browsePath: "area/line/boiler-qa-001",
-        },
-      ],
-    };
-    const opts = createApplyOptions(["models", "instances"]);
-    const hub = createHubMock([]);
-    const staticAttrCreates: TestStaticAttributeWrite[][] = [];
-    const instanceStaticAttrUpdates: {
-      instanceId: string;
-      attrs: TestInstanceStaticAttributeUpdate[];
-    }[] = [];
-
-    const dt: LEDigitalTwins = {
-      async listModels() {
-        return [
-          {
-            ID: "model-created",
-            Name: "HOT-WATER-BOILER",
-            Description: "",
-            Version: 1,
-          },
-        ];
-      },
-      async listInstances() {
-        return [];
-      },
-      async importModel() {
-        return true;
-      },
-      async createStaticAttributes(attrs: readonly TestStaticAttributeWrite[]) {
-        staticAttrCreates.push([...attrs]);
-        return [];
-      },
-      async listStaticAttributes(opts: { modelId?: string; instanceId?: string }) {
-        if (opts.instanceId === "inst-created") {
-          return [
-            {
-              ID: "attr-managed",
-              ModelID: "00000000-0000-0000-0000-000000000000",
-              InstanceID: "inst-created",
-              Key: "miravo_managed",
-              Value: "true",
-            },
-            {
-              ID: "attr-template",
-              ModelID: "00000000-0000-0000-0000-000000000000",
-              InstanceID: "inst-created",
-              Key: "miravo_template",
-              Value: "__miravo_placeholder__",
-            },
-            {
-              ID: "attr-model",
-              ModelID: "00000000-0000-0000-0000-000000000000",
-              InstanceID: "inst-created",
-              Key: "miravo_model",
-              Value: "__miravo_placeholder__",
-            },
-            {
-              ID: "attr-instance",
-              ModelID: "00000000-0000-0000-0000-000000000000",
-              InstanceID: "inst-created",
-              Key: "miravo_instance",
-              Value: "__miravo_placeholder__",
-            },
-            {
-              ID: "attr-uns-path",
-              ModelID: "00000000-0000-0000-0000-000000000000",
-              InstanceID: "inst-created",
-              Key: "uns_path",
-              Value: "__miravo_placeholder__",
-            },
-          ];
-        }
-        return [];
-      },
-      async createInstance(input: {
-        ModelID: string;
-        Name: string;
-        Topic: string;
-        Interval: number;
-        FlatHierarchy?: boolean;
-      }) {
-        return {
-          ID: "inst-created",
-          ModelID: input.ModelID,
-          Name: input.Name,
-          Topic: input.Topic,
-          Interval: input.Interval,
-          FlatHierarchy: null,
-          Version: 1,
-        };
-      },
-      async listParameters() {
-        return [{ ID: "param-device", OwnerID: "inst-created", Name: "device", Value: "" }];
-      },
-      async updateInstanceStaticAttributes(
-        instanceId: string,
-        attrs: readonly TestInstanceStaticAttributeUpdate[],
-      ) {
-        instanceStaticAttrUpdates.push({ instanceId, attrs: [...attrs] });
-      },
-      async setInstanceParameters() {},
-    } as unknown as LEDigitalTwins;
-
-    const { plan, snapshot } = await buildApplyPlan(hub, dt, desired, opts);
-    const result = await executePlan(hub, dt, plan, desired, opts, snapshot);
-
-    expect(result.applied).toBe(3);
-    expect(result.failed).toBe(0);
-    expect(staticAttrCreates).toHaveLength(0);
-    expect(instanceStaticAttrUpdates).toHaveLength(1);
-    expect(instanceStaticAttrUpdates[0]?.instanceId).toBe("inst-created");
-    expect(instanceStaticAttrUpdates[0]?.attrs).toEqual([
-      {
-        ID: "attr-managed",
-        ModelID: "00000000-0000-0000-0000-000000000000",
-        InstanceID: "inst-created",
-        Key: "miravo_managed",
-        Value: "true",
-      },
-      {
-        ID: "attr-template",
-        ModelID: "00000000-0000-0000-0000-000000000000",
-        InstanceID: "inst-created",
-        Key: "miravo_template",
-        Value: "smart-factory",
-      },
-      {
-        ID: "attr-model",
-        ModelID: "00000000-0000-0000-0000-000000000000",
-        InstanceID: "inst-created",
-        Key: "miravo_model",
-        Value: "hot-water-boiler",
-      },
-      {
-        ID: "attr-instance",
-        ModelID: "00000000-0000-0000-0000-000000000000",
-        InstanceID: "inst-created",
-        Key: "miravo_instance",
-        Value: "boiler-qa-001",
-      },
-      {
-        ID: "attr-uns-path",
-        ModelID: "00000000-0000-0000-0000-000000000000",
-        InstanceID: "inst-created",
-        Key: "uns_path",
-        Value: "area/line/boiler-qa-001",
-      },
-    ]);
-  });
-
-  test("returns partial failure when instance placeholder attrs are missing", async () => {
-    const desired: ApplyDesiredState = {
-      devices: [],
-      models: [{ name: "HOT-WATER-BOILER", leDtJson: { model: "payload" } }],
-      instances: [
-        {
-          instanceId: "boiler-qa-001",
-          modelName: "hot-water-boiler",
-          dtInstanceName: "boiler-qa-001",
-          dtModelName: "HOT-WATER-BOILER",
-          boundDeviceName: "boiler-qa-001",
-          browsePath: "area/line/boiler-qa-001",
-        },
-      ],
-    };
-    const opts = createApplyOptions(["models", "instances"]);
-    const hub = createHubMock([]);
-
-    const dt: LEDigitalTwins = {
-      async listModels() {
-        return [
-          {
-            ID: "model-created",
-            Name: "HOT-WATER-BOILER",
-            Description: "",
-            Version: 1,
-          },
-        ];
-      },
-      async listInstances() {
-        return [];
-      },
-      async importModel() {
-        return true;
-      },
-      async createStaticAttributes() {
-        return [];
-      },
-      async listStaticAttributes() {
-        return [];
-      },
-      async createInstance(input: {
-        ModelID: string;
-        Name: string;
-        Topic: string;
-        Interval: number;
-        FlatHierarchy?: boolean;
-      }) {
-        return {
-          ID: "inst-created",
-          ModelID: input.ModelID,
-          Name: input.Name,
-          Topic: input.Topic,
-          Interval: input.Interval,
-          FlatHierarchy: null,
-          Version: 1,
-        };
-      },
-      async listParameters() {
-        return [{ ID: "param-device", OwnerID: "inst-created", Name: "device", Value: "" }];
-      },
-      async setInstanceParameters() {},
-    } as unknown as LEDigitalTwins;
-
-    const { plan, snapshot } = await buildApplyPlan(hub, dt, desired, opts);
-    const result = await executePlan(hub, dt, plan, desired, opts, snapshot);
-
-    expect(result.applied).toBe(3);
-    expect(result.failed).toBe(1);
-    expect(result.error).toBeUndefined();
-  });
-});