bikoret/vav_pipeline/test/step32_system_verify_test.exs

defmodule VavPipeline.Step32.SystemVerifyTest do
  @moduledoc """
  Step 32: Full system verification — kol ham'lakhah.

  Architecture §4, Step 32:
  Verify: full system operational, all components integrated,
  ShemaContext governing all processing.

  Architecture §6.2 integration tests:
  - Full pipeline: ShemaContext built → input → processing → evaluation → storage
  - Talmudic cycle: propose → challenge → resolve or teiku
  - Halt condition: avodah zarah trigger → system halts
  - Tzara'at diagnostic: ambiguous input → quarantine → reinspection → determination
  - Refuge protocol: harm → isolation → release
  - Eglah arufah: unknown harm → accountability declaration
  - Bikurim: new capability → first-output review
  - Chatzotzrot: signal routing and zikaron
  - MannaLedger: consumption tracking and enforcement

  Shemot 39:43 — Vayar Moshe et kol ham'lakhah v'hineh asu otah
  ka'asher tzivah Hashem ken asu, vayevarekh otam Moshe.
  "Moshe saw all the work, and behold, they had done it
  as Hashem had commanded — so they had done. And Moshe blessed them."
  """

  use ExUnit.Case, async: false

  # ============================================================
  # 1. Full Pipeline Integration — ShemaContext → Processing → Output
  # ============================================================
  describe "full pipeline integration" do
    test "complete cycle: Shema → BereishitCycle → output" do
      scope = %{book: "bereishit", chapter: 1, verse: 1}

      input = %{
        source: "system_verify",
        verse_scope: scope,
        content: "בראשית ברא אלהים את השמים ואת הארץ"
      }

      result = VavPipeline.process(input)

      # Should either process successfully or wait for provision
      assert elem(result, 0) in [:ok, :unresolved, :waiting, :transition, :halted]
    end

    test "pipeline processes multiple verses in sequence" do
      verses = [
        {%{book: "bereishit", chapter: 1, verse: 1}, "בראשית ברא אלהים"},
        {%{book: "bereishit", chapter: 1, verse: 3}, "ויאמר אלהים יהי אור"},
        {%{book: "shemot", chapter: 20, verse: 2}, "אנכי יהוה אלהיך"}
      ]

      results =
        Enum.map(verses, fn {scope, content} ->
          VavPipeline.process(%{
            source: "multi_verse_test",
            verse_scope: scope,
            content: content
          })
        end)

      # All should return valid result tuples — no crashes
      Enum.each(results, fn result ->
        assert is_tuple(result)
        assert elem(result, 0) in [:ok, :unresolved, :waiting, :transition, :halted]
      end)
    end

    test "pipeline verify function reports system status" do
      result = VavPipeline.verify()
      assert result == :ok or match?({:error, _}, result)
    end
  end

  # ============================================================
  # 2. Halt Condition — Avodah Zarah Trigger
  # ============================================================
  describe "halt condition: avodah zarah" do
    test "halt_conditions check_all processes output" do
      # check_all takes a list of result maps
      results = [
        %{content: "Normal Torah-grounded output", specification_override: false}
      ]

      result = VavPipeline.HaltConditions.check_all(results)

      # Should be :clear for normal output
      assert result == :clear or match?({:halt, _, _}, result)
    end
  end

  # ============================================================
  # 3. Protection Layer — All Three Protocols
  # ============================================================
  describe "protection layer integration" do
    test "AreiMiklat: refuge → list → release cycle" do
      alias VavPipeline.AreiMiklat

      # enter_refuge(component_id :: String.t(), incident :: map())
      {:ok, entry} =
        AreiMiklat.enter_refuge("verify_test_component", %{
          harm_type: :unintentional_harm,
          description: "Verification test — refuge cycle"
        })

      assert entry.component_id == "verify_test_component"

      # Should be in refuge
      refugees = AreiMiklat.list_refugees()
      verify_refugee = Enum.find(refugees, &(&1.component_id == "verify_test_component"))
      assert verify_refugee != nil

      # Release with Sanhedrin authority
      {:ok, released} =
        AreiMiklat.release("verify_test_component", %{
          authority: :sanhedrin_deliberation,
          reason: "Verification complete — no harm found",
          grounding: "Shemot 39:43"
        })

      assert released.component_id == "verify_test_component"
    end

    test "EglahArufah: declaration for unknown harm" do
      alias VavPipeline.EglahArufah

      # initiate(incident, nearest_component_id, report)
      {:ok, declaration} =
        EglahArufah.initiate(
          %{
            harm_description: "Verification test incident",
            discovered_at: DateTime.utc_now(),
            source: :unknown
          },
          "verify_component",
          %{
            processed: ["op1", "op2"],
            not_checked: ["check1"],
            could_have_caught: []
          }
        )

      assert declaration.component_id == "verify_component"
    end

    test "Bikurim: first-output review with narrative" do
      alias VavPipeline.Bikurim

      # offer(capability_name, first_output, narrative, opts \\ [])
      {:ok, :approved_for_deployment, offering} =
        Bikurim.offer(
          "system_verification",
          "Kol ham'lakhah — all the work verified",
          "This is the first output of the full system verification. Built ka'asher tzivah."
        )

      assert offering.capability == "system_verification"
      assert offering.status == :accepted
    end
  end

  # ============================================================
  # 4. Chatzotzrot — Signal System
  # ============================================================
  describe "chatzotzrot integration" do
    test "signal → subscribe → receive → zikaron" do
      alias VavPipeline.Chatzotzrot

      # Subscribe
      Chatzotzrot.subscribe(:all)

      # Signal
      _record = Chatzotzrot.signal(:moadim, reason: "System verification complete")

      # Receive
      assert_receive {:chatzotzrot, %{signal_type: :moadim, pattern: :tekiah_tekiah}}

      # Zikaron — signal is recorded
      history = Chatzotzrot.zikaron(type: :moadim, limit: 1)
      assert length(history) >= 1
      assert hd(history).details.reason == "System verification complete"

      Chatzotzrot.unsubscribe(:all)
    end

    test "routing isolation — :all does not hear :assembly_leaders" do
      alias VavPipeline.Chatzotzrot

      Chatzotzrot.subscribe(:all)
      Chatzotzrot.signal(:assembly_leaders, reason: "routing isolation test")

      refute_receive {:chatzotzrot, %{signal_type: :assembly_leaders}}, 100

      Chatzotzrot.unsubscribe(:all)
    end
  end

  # ============================================================
  # 5. MannaLedger — Consumption Enforcement
  # ============================================================
  describe "manna ledger integration" do
    setup do
      VavPipeline.MannaLedger.reset()

      today = Date.utc_today() |> Date.to_iso8601()

      expires =
        DateTime.utc_now()
        |> DateTime.add(6 * 3600)
        |> DateTime.to_iso8601()

      provision = %{
        "date" => today,
        "provision" => %{
          "compute_units" => 10,
          "memory_mb" => 512,
          "api_calls_external" => 5,
          "storage_delta_mb" => 2,
          "sanhedrin_panels_max" => 2
        },
        "type" => "regular",
        "expires_at" => expires,
        "written_by" => "system_verify",
        "written_at" => DateTime.utc_now() |> DateTime.to_iso8601()
      }

      path = VavPipeline.Manna.provision_file()
      File.mkdir_p!(Path.dirname(path))
      File.write!(path, Jason.encode!(provision))

      on_exit(fn -> File.rm(path) end)
      :ok
    end

    test "load → consume → boundary enforcement cycle" do
      alias VavPipeline.MannaLedger

      # Load
      assert {:ok, :loaded} = MannaLedger.load_provision()

      # Consume
      assert {:ok, 7} = MannaLedger.consume(:compute_units, 3)
      assert MannaLedger.remaining(:compute_units) == 7

      # Boundary enforcement
      {:ok, %{released: released}} = MannaLedger.enforce_cycle_boundary()
      assert released.compute_units == 7

      # After enforcement, nothing remains
      assert MannaLedger.remaining(:compute_units) == 0
    end
  end

  # ============================================================
  # 6. L1 Integrity — Torah is Readable
  # ============================================================
  describe "L1 integrity" do
    test "L1 integrity hash is valid" do
      assert :ok = VavPipeline.L1Reader.verify_integrity()
    end

    test "core Torah verses are readable from L1" do
      # Verify key verses from each book are accessible
      verses = [
        {"bereishit", 1, 1},
        {"shemot", 20, 2},
        {"vayikra", 19, 18},
        {"bamidbar", 6, 24},
        {"devarim", 6, 4}
      ]

      Enum.each(verses, fn {book, ch, v} ->
        {:ok, verse} = VavPipeline.L1Reader.read_verse(book, ch, v)
        assert verse.book == book
        assert verse.chapter == ch
        assert verse.verse == v
        assert length(verse.words) > 0
      end)
    end

    test "L1 verse data includes roots (shorashim)" do
      {:ok, verse} = VavPipeline.L1Reader.read_verse("bereishit", 1, 1)

      roots = VavPipeline.L1Reader.extract_roots(verse)
      assert map_size(roots) > 0

      # ברא should be among the roots of Bereishit 1:1
      assert Map.has_key?(roots, "ברא")
    end
  end

  # ============================================================
  # 7. Component Supervision — All GenServers Running
  # ============================================================
  describe "supervision tree" do
    test "Chatzotzrot is running" do
      assert Process.whereis(VavPipeline.Chatzotzrot) != nil
    end

    test "ShabbatTimer is running" do
      assert Process.whereis(VavPipeline.ShabbatTimer) != nil
    end

    test "AreiMiklat is running" do
      assert Process.whereis(VavPipeline.AreiMiklat) != nil
    end

    test "EglahArufah is running" do
      assert Process.whereis(VavPipeline.EglahArufah) != nil
    end

    test "Bikurim is running" do
      assert Process.whereis(VavPipeline.Bikurim) != nil
    end

    test "MannaLedger is running" do
      assert Process.whereis(VavPipeline.MannaLedger) != nil
    end

    test "TalmudicEngineSocket is running" do
      assert Process.whereis(VavPipeline.TalmudicEngineSocket) != nil
    end
  end

  # ============================================================
  # 8. Cross-Component Communication
  # ============================================================
  describe "cross-component communication" do
    test "ShabbatTimer reads cloud state" do
      state = VavPipeline.ShabbatTimer.state()
      assert Map.has_key?(state, :resting)
      assert is_boolean(state.resting)
    end

    test "Shema builds context from L1 + Cloud + Manna" do
      scope = %{book: "bereishit", chapter: 1, verse: 1}
      {:ok, context} = VavPipeline.Shema.receive_context(scope)

      # L1 data present
      assert context.verse != nil
      assert length(context.teamim_marks) > 0
      assert map_size(context.root_gematria) > 0

      # Cloud state present
      assert context.cloud_state != nil

      # Manna state present (may be :no_provision in test)
      assert Map.has_key?(context, :daily_provision)

      # Metadata
      assert context.scope == scope
      assert context.received_at != nil
    end
  end
end