miravo 0.6.0 → 0.6.2

package/src/commands/start.test.ts

@@ -1,480 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { resolve } from "node:path";
-import { createTmpFileUtils } from "@miravo/core/test-tmp-utils";
-import type { DiscoveredTemplate, MiravoTemplate } from "@miravo/shared";
-import { resetExitCode, runCliCommand, withEnvVar } from "./cli-test-setup.ts";
-
-const { writeTmpFile, cleanupTmpDir } = createTmpFileUtils(
-  resolve(import.meta.dir, ".tmp-test-start"),
-);
-const builtinTemplatesDir = resolve(import.meta.dir, "..", "..", "..", "content", "templates");
-const stressTemplatesDir = resolve(
-  import.meta.dir,
-  "..",
-  "..",
-  "..",
-  "..",
-  "tests",
-  "fixtures",
-  "stress",
-);
-const BUILTIN_TEMPLATE_PATHS = [
-  resolve(builtinTemplatesDir, "smart-factory.miravo.yaml"),
-  resolve(builtinTemplatesDir, "water-treatment.miravo.yaml"),
-  resolve(builtinTemplatesDir, "commercial-building.miravo.yaml"),
-  resolve(builtinTemplatesDir, "backup-power.miravo.yaml"),
-  resolve(stressTemplatesDir, "stress-5k.miravo.yaml"),
-  resolve(stressTemplatesDir, "stress-10k.miravo.yaml"),
-  resolve(stressTemplatesDir, "stress-50k.miravo.yaml"),
-  resolve(stressTemplatesDir, "stress-100k.miravo.yaml"),
-];
-
-beforeEach(resetExitCode);
-afterEach(async () => {
-  resetExitCode();
-  await cleanupTmpDir();
-});
-
-const MINIMAL_MODEL = `schema_version: "2"
-model:
-  name: test-sensor
-members:
-  temperature:
-    kind: variable
-    data_type: Double
-    access: read
-    unit: degC
-    generator:
-      type: noise
-      center: 25
-      stddev: 2
-`;
-
-const MINIMAL_TEMPLATE = (modelName: string) => `kind: MiravoTemplate
-version: "1"
-name: test-template
-areas:
-  - name: area1
-    lines:
-      - name: line1
-        twins:
-          - model: ${modelName}
-            count: 1
-`;
-
-function discoveredTemplate(id: string, name: string, description?: string): DiscoveredTemplate {
-  return {
-    path: `/tmp/${id}.miravo.yaml`,
-    id,
-    name,
-    ...(description !== undefined ? { description } : {}),
-    areaCount: 1,
-    twinAssignmentCount: 1,
-    inlineModelCount: 0,
-    uniqueModelCount: 2,
-    modelNames: ["model-a", "model-b"],
-    totalTwinCount: 5,
-  };
-}
-
-describe("miravo start", () => {
-  // We test the internal logic by importing the createProgram and
-  // using Commander's parseAsync with exitOverride to prevent process.exit
-
-  test("--template with nonexistent path sets exit code 1", async () => {
-    await runCliCommand(["start", "--template", "/nonexistent/path.miravo.yaml"]);
-    expect(process.exitCode).toBe(1);
-  });
-
-  test("--dry-run validates and exits without starting engine", async () => {
-    const modelPath = await writeTmpFile("test-sensor.twin.yaml", MINIMAL_MODEL);
-    const modelDir = resolve(modelPath, "..");
-    const templatePath = await writeTmpFile("test.miravo.yaml", MINIMAL_TEMPLATE("test-sensor"));
-
-    await runCliCommand([
-      "start",
-      "--template",
-      templatePath,
-      "--models-dir",
-      modelDir,
-      "--name",
-      "test-sim",
-      "--dry-run",
-    ]);
-
-    // Dry-run should not set error exit code (stays at 0 baseline)
-    expect(process.exitCode).toBe(0);
-  });
-
-  test("invalid template YAML sets exit code 1", async () => {
-    const templatePath = await writeTmpFile("bad.miravo.yaml", "not: valid: yaml: [");
-    await runCliCommand(["start", "--template", templatePath]);
-    expect(process.exitCode).toBe(1);
-  });
-
-  test("invalid MIRAVO_MQTT_PORT env var sets exit code 1", async () => {
-    await withEnvVar("MIRAVO_MQTT_PORT", "abc", async () => {
-      await runCliCommand(["start", "--dry-run"]);
-      expect(process.exitCode).toBe(1);
-    });
-  });
-
-  test("invalid MIRAVO_ADMIN_PORT env var sets exit code 1", async () => {
-    await withEnvVar("MIRAVO_ADMIN_PORT", "NaN", async () => {
-      await runCliCommand(["start", "--dry-run"]);
-      expect(process.exitCode).toBe(1);
-    });
-  });
-
-  test.each(
-    BUILTIN_TEMPLATE_PATHS,
-  )("built-in template dry-run succeeds: %s", async (templatePath) => {
-    await runCliCommand(["start", "--template", templatePath, "--dry-run"]);
-    expect(process.exitCode).toBe(0);
-  });
-});
-
-function createTemplateWithNamespace(namespace?: MiravoTemplate["namespace"]): MiravoTemplate {
-  return {
-    kind: "MiravoTemplate",
-    version: "1",
-    name: "test-template",
-    namespace,
-    areas: [
-      {
-        name: "area1",
-        lines: [
-          {
-            name: "line1",
-            twins: [{ model: "test-sensor", count: 1, variation: 0 }],
-          },
-        ],
-      },
-    ],
-  };
-}
-
-describe("resolveSimulationName", () => {
-  test("priority: --name > MIRAVO_NAME > namespace", async () => {
-    const { resolveSimulationName } = await import("./start/index.ts");
-    const template = createTemplateWithNamespace({ enterprise: "acme", site: "site-a" });
-
-    expect(
-      resolveSimulationName({
-        template,
-        cliName: "cli-name",
-        envName: "env-name",
-      }),
-    ).toBe("cli-name");
-    expect(resolveSimulationName({ template, envName: "env-name" })).toBe("env-name");
-    expect(resolveSimulationName({ template })).toBe("acme-site-a");
-  });
-
-  test("uses flat namespace prefix when ISA-95 site is not present", async () => {
-    const { resolveSimulationName } = await import("./start/index.ts");
-    const template = createTemplateWithNamespace({ prefix: "flat-prefix" });
-    expect(resolveSimulationName({ template })).toBe("flat-prefix");
-  });
-
-  test("throws when template has no namespace and no explicit name", async () => {
-    const { resolveSimulationName } = await import("./start/index.ts");
-    const template = createTemplateWithNamespace();
-
-    expect(() => resolveSimulationName({ template })).toThrow("Template has no namespace.");
-  });
-
-  test("rejects invalid names with special characters", async () => {
-    const { resolveSimulationName } = await import("./start/index.ts");
-    const template = createTemplateWithNamespace({ prefix: "valid" });
-
-    expect(() => resolveSimulationName({ template, cliName: "UPPER-CASE" })).toThrow(
-      "Invalid simulation name",
-    );
-
-    expect(() => resolveSimulationName({ template, cliName: "has spaces" })).toThrow(
-      "Invalid simulation name",
-    );
-
-    expect(() => resolveSimulationName({ template, cliName: "-leading-hyphen" })).toThrow(
-      "Invalid simulation name",
-    );
-  });
-
-  test("accepts single-character name", async () => {
-    const { resolveSimulationName } = await import("./start/index.ts");
-    const template = createTemplateWithNamespace({ prefix: "x" });
-    expect(resolveSimulationName({ template })).toBe("x");
-  });
-});
-
-describe("resolveProtocolBootPlans", () => {
-  test("preserves restored adapter state when no explicit protocol overrides are provided", async () => {
-    const { resolveProtocolBootPlans } = await import("./start/index.ts");
-
-    expect(
-      resolveProtocolBootPlans({
-        options: {},
-        optionSources: {},
-        restoredFromPersistence: true,
-      }),
-    ).toEqual([
-      { name: "mqtt", shouldEnable: true, overrideRestore: false },
-      { name: "opcua", shouldEnable: false, overrideRestore: false },
-      { name: "modbus", shouldEnable: false, overrideRestore: false },
-    ]);
-  });
-
-  test("applies boot defaults when no persisted snapshot was restored", async () => {
-    const { resolveProtocolBootPlans } = await import("./start/index.ts");
-
-    expect(
-      resolveProtocolBootPlans({
-        options: {},
-        optionSources: {},
-        restoredFromPersistence: false,
-      }),
-    ).toEqual([
-      { name: "mqtt", shouldEnable: true, overrideRestore: true },
-      { name: "opcua", shouldEnable: false, overrideRestore: true },
-      { name: "modbus", shouldEnable: false, overrideRestore: true },
-    ]);
-  });
-
-  test("treats explicit MQTT disable as authoritative over persisted state", async () => {
-    const { resolveProtocolBootPlans } = await import("./start/index.ts");
-
-    expect(
-      resolveProtocolBootPlans({
-        options: { mqtt: false },
-        optionSources: { mqtt: "cli" },
-        restoredFromPersistence: true,
-      }),
-    ).toContainEqual({ name: "mqtt", shouldEnable: false, overrideRestore: true });
-  });
-
-  test("treats explicit CLI MQTT config overrides as authoritative over persisted config", async () => {
-    const { resolveProtocolBootPlans } = await import("./start/index.ts");
-
-    expect(
-      resolveProtocolBootPlans({
-        options: { mqttPort: 1884 },
-        optionSources: { mqttPort: "cli" },
-        restoredFromPersistence: true,
-      }),
-    ).toContainEqual({ name: "mqtt", shouldEnable: true, overrideRestore: true });
-  });
-
-  test("does not treat env fallback config as authoritative over persisted MQTT state", async () => {
-    const { resolveProtocolBootPlans } = await import("./start/index.ts");
-
-    expect(
-      resolveProtocolBootPlans({
-        options: {},
-        optionSources: {},
-        restoredFromPersistence: true,
-      }),
-    ).toContainEqual({ name: "mqtt", shouldEnable: true, overrideRestore: false });
-  });
-
-  test("treats explicit OPC UA enable as authoritative over persisted state", async () => {
-    const { resolveProtocolBootPlans } = await import("./start/index.ts");
-
-    expect(
-      resolveProtocolBootPlans({
-        options: { opcua: true },
-        optionSources: { opcua: "cli" },
-        restoredFromPersistence: true,
-      }),
-    ).toContainEqual({ name: "opcua", shouldEnable: true, overrideRestore: true });
-  });
-
-  test("does not treat ignored OPC UA config flags as persisted-state overrides", async () => {
-    const { resolveProtocolBootPlans } = await import("./start/index.ts");
-
-    expect(
-      resolveProtocolBootPlans({
-        options: { opcuaPort: 4841 },
-        optionSources: { opcuaPort: "cli" },
-        restoredFromPersistence: true,
-      }),
-    ).toContainEqual({ name: "opcua", shouldEnable: false, overrideRestore: false });
-  });
-});
-
-describe("resolveDetachAdapterConfigs", () => {
-  test("uses template adapter configs when no CLI/env overrides are provided", async () => {
-    const { resolveDetachAdapterConfigs } = await import("./start/index.ts");
-
-    const template = createTemplateWithNamespace({ prefix: "factory" });
-    const withProtocols: MiravoTemplate = {
-      ...template,
-      protocols: {
-        mqtt: { port: 1889, embedded: true, retain: false, metadata: "base" },
-        opcua: { port: 4851, host: "127.0.0.1", security: "none" },
-        modbus: { port: 1602, host: "127.0.0.1" },
-      },
-    };
-
-    expect(
-      resolveDetachAdapterConfigs({
-        template: withProtocols,
-        simulationName: "factory-sim",
-        mqtt: { enabled: true, portOverride: undefined, overrides: {} },
-        opcua: {
-          enabled: true,
-          portOverride: undefined,
-          hostOverride: undefined,
-          writeBudgetOverride: undefined,
-        },
-        modbus: { enabled: true, portOverride: undefined, hostOverride: undefined },
-      }),
-    ).toEqual({
-      mqtt: { port: 1889, host: "0.0.0.0", embedded: true },
-      opcua: { port: 4851, host: "127.0.0.1" },
-      modbus: { port: 1602, host: "127.0.0.1" },
-    });
-  });
-
-  test("CLI/env overrides take precedence over template values", async () => {
-    const { resolveDetachAdapterConfigs } = await import("./start/index.ts");
-
-    const template = createTemplateWithNamespace({ prefix: "factory" });
-    const withProtocols: MiravoTemplate = {
-      ...template,
-      protocols: {
-        mqtt: { port: 1889, embedded: true, retain: false, metadata: "base" },
-        opcua: { port: 4851, host: "127.0.0.1", security: "none" },
-        modbus: { port: 1602, host: "127.0.0.1" },
-      },
-    };
-
-    expect(
-      resolveDetachAdapterConfigs({
-        template: withProtocols,
-        simulationName: "factory-sim",
-        mqtt: {
-          enabled: true,
-          portOverride: 1999,
-          overrides: { host: "0.0.0.0" },
-        },
-        opcua: {
-          enabled: true,
-          portOverride: 4852,
-          hostOverride: "0.0.0.0",
-          writeBudgetOverride: undefined,
-        },
-        modbus: { enabled: true, portOverride: 1702, hostOverride: "0.0.0.0" },
-      }),
-    ).toEqual({
-      mqtt: { port: 1999, host: "0.0.0.0", embedded: true },
-      opcua: { port: 4852, host: "0.0.0.0" },
-      modbus: { port: 1702, host: "0.0.0.0" },
-    });
-  });
-
-  test("returns disabled placeholders when adapters are disabled", async () => {
-    const { resolveDetachAdapterConfigs } = await import("./start/index.ts");
-    const template = createTemplateWithNamespace({ prefix: "factory" });
-
-    expect(
-      resolveDetachAdapterConfigs({
-        template,
-        simulationName: "factory-sim",
-        mqtt: { enabled: false, portOverride: 1999, overrides: { host: "0.0.0.0" } },
-        opcua: {
-          enabled: false,
-          portOverride: 4852,
-          hostOverride: "0.0.0.0",
-          writeBudgetOverride: 4096,
-        },
-        modbus: { enabled: false, portOverride: 1702, hostOverride: "0.0.0.0" },
-      }),
-    ).toEqual({
-      mqtt: { port: undefined, host: undefined, embedded: false },
-      opcua: { port: undefined, host: undefined },
-      modbus: { port: undefined, host: undefined },
-    });
-  });
-
-  test("marks external MQTT mode as non-embedded for detach conflict checks", async () => {
-    const { resolveDetachAdapterConfigs } = await import("./start/index.ts");
-    const template = createTemplateWithNamespace({ prefix: "factory" });
-
-    expect(
-      resolveDetachAdapterConfigs({
-        template,
-        simulationName: "factory-sim",
-        mqtt: {
-          enabled: true,
-          portOverride: undefined,
-          overrides: { mode: "external", url: "mqtt://broker.example.com:1883" },
-        },
-        opcua: {
-          enabled: false,
-          portOverride: undefined,
-          hostOverride: undefined,
-          writeBudgetOverride: undefined,
-        },
-        modbus: { enabled: false, portOverride: undefined, hostOverride: undefined },
-      }).mqtt.embedded,
-    ).toBe(false);
-  });
-});
-
-describe("error context aggregation", () => {
-  test("normalizeErrorContext redacts high-cardinality fragments", async () => {
-    const { normalizeErrorContext } = await import("./start/index.ts");
-
-    expect(normalizeErrorContext('generator="rpm" instance="pump-001" tick=42')).toBe(
-      'generator="rpm" instance="*" tick=*',
-    );
-    expect(normalizeErrorContext('spawn:unknown-parameter model="pump-model"')).toBe(
-      'spawn:unknown-parameter model="*"',
-    );
-  });
-
-  test("incrementErrorContextCount caps unique keys and accumulates in overflow bucket", async () => {
-    const { incrementErrorContextCount } = await import("./start/index.ts");
-    const counts = new Map<string, number>();
-
-    for (let i = 0; i < 256; i++) {
-      incrementErrorContextCount(counts, `context-${i}`);
-    }
-
-    incrementErrorContextCount(counts, "context-256");
-    incrementErrorContextCount(counts, "context-257");
-
-    expect(counts.size).toBe(257);
-    expect(counts.get("__overflow__")).toBe(2);
-    expect(counts.get("context-0")).toBe(1);
-  });
-});
-
-describe("template picker choices", () => {
-  test("buildBuiltinTemplateChoices renders tree labels directly in select options", async () => {
-    const { buildBuiltinTemplateChoices } = await import("./start/index.ts");
-    const choices = buildBuiltinTemplateChoices([
-      discoveredTemplate("stress-50k", "Stress Benchmark 50K"),
-      discoveredTemplate("water-treatment", "Water Treatment Plant"),
-      discoveredTemplate(
-        "smart-factory",
-        "Smart Factory Production Line",
-        "Discrete manufacturing line",
-      ),
-      discoveredTemplate("stress-10k", "Stress Benchmark 10K"),
-    ]);
-
-    expect(choices.map((choice) => choice.label)).toEqual([
-      "Industrial Scenarios",
-      "  \u251C\u2500 Smart Factory Production Line",
-      "  \u2514\u2500 Water Treatment Plant",
-      "Stress & Benchmark",
-      "  \u251C\u2500 Stress Benchmark 10K",
-      "  \u2514\u2500 Stress Benchmark 50K",
-    ]);
-    expect(choices[0]?.disabled).toBe(true);
-    expect(choices[1]?.disabled).toBeUndefined();
-    expect(choices[1]?.hint).toContain("Discrete manufacturing line");
-    expect(choices[4]?.hint).toContain("stress-10k");
-  });
-});

package/src/commands/status.test.ts

@@ -1,20 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { findCliCommand, resetExitCode } from "./cli-test-setup.ts";
-
-beforeEach(resetExitCode);
-afterEach(resetExitCode);
-
-describe("miravo status", () => {
-  test("sets exit code 1 with invalid admin URL", async () => {
-    const { program } = await findCliCommand("status");
-    program.exitOverride();
-
-    try {
-      await program.parseAsync(["node", "miravo", "status", "--admin-url", "not-a-url"]);
-    } catch {
-      // Expected
-    }
-
-    expect(process.exitCode).toBe(1);
-  });
-});