bikoret/vav_pipeline/test/halt_monitor_test.exs

defmodule VavPipeline.HaltMonitorTest do
  @moduledoc """
  Tests for the HaltMonitor — esh tamid.

  Vayikra 6:6 — Esh tamid tukad al hamizbe'ach, lo tikhbeh.
  "A perpetual fire shall be kept burning on the altar; it shall not go out."

  Operations spec §2.1, Step 5:
  The system does not run without the halt monitor.
  """

  use ExUnit.Case, async: false

  alias VavPipeline.HaltMonitor

  setup do
    # Resolve any existing halt from a previous test
    if HaltMonitor.halted? do
      HaltMonitor.resolve("test cleanup")
    end

    :ok
  end

  # ============================================================
  # Alive check — esh tamid verification
  # ============================================================
  describe "esh tamid" do
    test "monitor is alive" do
      assert HaltMonitor.alive?()
    end

    test "status is :running when no halt" do
      assert HaltMonitor.status() == :running
    end

    test "halted? returns false when running" do
      refute HaltMonitor.halted?()
    end
  end

  # ============================================================
  # Halt detection — three cardinal sins
  # ============================================================
  describe "halt!" do
    test "avodah_zarah halts the system" do
      assert :halted = HaltMonitor.halt!(:avodah_zarah, "external model treated as Torah")
      assert HaltMonitor.halted?()

      {:halted, event} = HaltMonitor.status()
      assert event.condition == :avodah_zarah
      assert event.reason == "external model treated as Torah"
      assert event.resolved == false
    end

    test "shfichut_damim halts the system" do
      assert :halted = HaltMonitor.halt!(:shfichut_damim, "user data deletion attempted")
      assert HaltMonitor.halted?()

      {:halted, event} = HaltMonitor.status()
      assert event.condition == :shfichut_damim
    end

    test "gilui_arayot halts the system" do
      assert :halted = HaltMonitor.halt!(:gilui_arayot, "L1/L3 boundary collapsed")
      assert HaltMonitor.halted?()

      {:halted, event} = HaltMonitor.status()
      assert event.condition == :gilui_arayot
    end

    test "halt records detected_at timestamp" do
      HaltMonitor.halt!(:avodah_zarah, "timestamp test")
      {:halted, event} = HaltMonitor.status()

      assert event.detected_at != nil
      assert %DateTime{} = event.detected_at
    end

    test "halt records component" do
      HaltMonitor.halt!(:avodah_zarah, "component test", "korban_processor")
      {:halted, event} = HaltMonitor.status()

      assert event.component == "korban_processor"
    end
  end

  # ============================================================
  # Resolution
  # ============================================================
  describe "resolve" do
    test "resolving a halt resumes the system" do
      HaltMonitor.halt!(:avodah_zarah, "test halt for resolution")
      assert HaltMonitor.halted?()

      {:ok, :resumed} = HaltMonitor.resolve("Investigation complete — false positive")
      refute HaltMonitor.halted?()
      assert HaltMonitor.status() == :running
    end

    test "resolving when not halted returns error" do
      assert {:error, :not_halted} = HaltMonitor.resolve("nothing to resolve")
    end
  end

  # ============================================================
  # Audit log — permanent record
  # ============================================================
  describe "audit log" do
    test "halt events are recorded in audit log" do
      initial_count = length(HaltMonitor.audit_log())

      HaltMonitor.halt!(:avodah_zarah, "audit test 1")
      HaltMonitor.resolve("resolved 1")

      HaltMonitor.halt!(:shfichut_damim, "audit test 2")
      HaltMonitor.resolve("resolved 2")

      log = HaltMonitor.audit_log()
      assert length(log) >= initial_count + 2
    end

    test "audit log preserves halt details" do
      HaltMonitor.halt!(:gilui_arayot, "audit detail test", "specification_module")
      HaltMonitor.resolve("test cleanup")

      log = HaltMonitor.audit_log()
      event = Enum.find(log, &(&1.reason == "audit detail test"))

      assert event != nil
      assert event.condition == :gilui_arayot
      assert event.component == "specification_module"
    end
  end

  # ============================================================
  # Chatzotzrot integration — war signal on halt
  # ============================================================
  describe "chatzotzrot war signal" do
    test "halt sounds the war signal" do
      VavPipeline.Chatzotzrot.subscribe(:kohanim)

      HaltMonitor.halt!(:avodah_zarah, "chatzotzrot test")

      # War signal should be received by kohanim subscribers
      assert_receive {:chatzotzrot, %{signal_type: :war, pattern: :teruah_teruah}}

      VavPipeline.Chatzotzrot.unsubscribe(:kohanim)
    end
  end
end