pikasTech-HWLAB/scripts/src/dev-m4-agent-loop-smoke-lib.test.mjs

import assert from "node:assert/strict";
import test from "node:test";

import {
  classifyCloudApiLiveReadiness,
  publicDbLiveSummary,
  publicRuntimeDurabilitySummary,
  runtimeDurabilityFromHealth
} from "./dev-m4-agent-loop-smoke-lib.mjs";

test("M4 live readiness classifies durable adapter query blocker after DB live is ready", () => {
  const payload = {
    db: {
      ready: true,
      connected: true,
      liveConnected: true,
      liveDbEvidence: true,
      status: "ok"
    },
    runtime: {
      adapter: "postgres",
      durable: false,
      durableRequested: true,
      ready: false,
      status: "blocked",
      blocker: "runtime_durable_adapter_query_blocked",
      reason: "durable runtime read query is blocked",
      liveRuntimeEvidence: false,
      connection: {
        queryAttempted: true,
        queryResult: "query_blocked"
      },
      migration: {
        checked: true,
        ready: false,
        missing: true,
        requiredMigrationId: "0001_cloud_core_skeleton"
      }
    },
    readiness: {
      durability: {
        blockedLayer: "durability_query",
        requiredEvidence: "runtime_adapter_schema_migration_read_query"
      }
    }
  };

  const classification = classifyCloudApiLiveReadiness(payload);
  assert.equal(classification.blocked, true);
  assert.equal(classification.blockerScope, "runtime-durable-adapter");
  assert.equal(classification.blockedClassification, "runtime_durable_adapter_query_blocked");
  assert.match(classification.blockerSummary, /0001_cloud_core_skeleton/u);
  assert.match(classification.evidenceSuffix, /runtime_durable_adapter_query_blocked/u);

  const runtime = runtimeDurabilityFromHealth(payload);
  assert.equal(runtime.blocker, "runtime_durable_adapter_query_blocked");
  assert.equal(runtime.migration.checked, true);
  assert.equal(runtime.migration.ready, false);
  assert.equal(runtime.queryResult, "query_blocked");
});

test("M4 live readiness keeps DB live blocker when DB is not connected", () => {
  const classification = classifyCloudApiLiveReadiness({
    db: {
      ready: false,
      connected: false,
      liveDbEvidence: false,
      status: "degraded"
    },
    runtime: {
      adapter: "postgres",
      durableRequested: true,
      blocker: "runtime_durable_adapter_query_blocked"
    }
  });

  assert.equal(classification.blockerScope, "db-live");
  assert.equal(classification.blockedClassification, "DB live");
});

test("public DB live summary preserves DB pass fields apart from durable adapter blocker", () => {
  const summary = publicDbLiveSummary({
    db: {
      status: "ok",
      connected: true,
      liveConnected: true,
      ready: true,
      configReady: true,
      connectionChecked: true,
      endpointSource: "secret-url-host",
      liveDbEvidence: true,
      evidence: "live_db_tcp_connection_ready"
    },
    runtime: {
      adapter: "postgres",
      durable: false,
      ready: false,
      blocker: "runtime_durable_adapter_query_blocked"
    }
  });

  assert.equal(summary.status, "ok");
  assert.equal(summary.connected, true);
  assert.equal(summary.liveConnected, true);
  assert.equal(summary.ready, true);
  assert.equal(summary.configReady, true);
  assert.equal(summary.connectionChecked, true);
  assert.equal(summary.endpointSource, "secret-url-host");
  assert.equal(summary.liveDbEvidence, true);
  assert.equal(summary.evidence, "live_db_tcp_connection_ready");
});

test("public runtime durability summary preserves durable adapter fields separately from DB live", () => {
  const summary = publicRuntimeDurabilitySummary({
    db: {
      ready: true,
      connected: true,
      liveConnected: true,
      liveDbEvidence: true
    },
    runtime: {
      adapter: "postgres",
      durable: false,
      durableRequested: true,
      ready: false,
      status: "blocked",
      blocker: "runtime_durable_adapter_query_blocked",
      liveRuntimeEvidence: false,
      connection: {
        queryAttempted: true,
        queryResult: "query_blocked"
      },
      migration: {
        checked: false,
        ready: false,
        missing: true,
        requiredMigrationId: "0001_cloud_core_skeleton"
      },
      durabilityContract: {
        blockedLayer: "durability_query",
        requiredEvidence: "runtime_adapter_schema_migration_read_query"
      }
    }
  });

  assert.equal(summary.adapter, "postgres");
  assert.equal(summary.durableRequested, true);
  assert.equal(summary.durable, false);
  assert.equal(summary.ready, false);
  assert.equal(summary.liveRuntimeEvidence, false);
  assert.equal(summary.blocker, "runtime_durable_adapter_query_blocked");
  assert.equal(summary.blockedLayer, "durability_query");
  assert.equal(summary.requiredEvidence, "runtime_adapter_schema_migration_read_query");
  assert.equal(summary.queryAttempted, true);
  assert.equal(summary.queryResult, "query_blocked");
  assert.equal(summary.migration.requiredMigrationId, "0001_cloud_core_skeleton");
});