towerops/test/towerops/monitoring/supervisor_test.exs

defmodule Towerops.Monitoring.SupervisorTest do
  use Towerops.DataCase, async: false

  import Towerops.AccountsFixtures

  alias Towerops.Monitoring.Supervisor, as: MonitoringSupervisor

  setup do
    user = user_fixture()
    {:ok, organization} = Towerops.Organizations.create_organization(%{name: "Test Org"}, user.id)

    {:ok, site} =
      Towerops.Sites.create_site(%{
        name: "Test Site",
        organization_id: organization.id
      })

    {:ok, equipment} =
      Towerops.Equipment.create_equipment(%{
        name: "Test Router",
        ip_address: "192.168.1.1",
        site_id: site.id,
        monitoring_enabled: true
      })

    {:ok, snmp_equipment} =
      Towerops.Equipment.create_equipment(%{
        name: "SNMP Router",
        ip_address: "192.168.1.2",
        site_id: site.id,
        snmp_enabled: true,
        snmp_version: "2c",
        snmp_community: "public",
        snmp_port: 161
      })

    %{equipment: equipment, snmp_equipment: snmp_equipment}
  end

  describe "start_monitor/1" do
    test "starts a monitor for equipment", %{equipment: equipment} do
      # Start the monitor
      result = MonitoringSupervisor.start_monitor(equipment.id)

      # Should return {:ok, pid} or {:error, {:already_started, pid}}
      case result do
        {:ok, pid} ->
          assert is_pid(pid)
          assert Process.alive?(pid)
          # Cleanup
          MonitoringSupervisor.stop_monitor(equipment.id)

        {:error, {:already_started, pid}} ->
          assert is_pid(pid)
          # Already started is acceptable
          MonitoringSupervisor.stop_monitor(equipment.id)

        other ->
          flunk("Unexpected result: #{inspect(other)}")
      end
    end

    test "returns error when starting duplicate monitor", %{equipment: equipment} do
      # Start the first monitor
      {:ok, _pid} = MonitoringSupervisor.start_monitor(equipment.id)

      # Try to start another for the same equipment
      result = MonitoringSupervisor.start_monitor(equipment.id)

      case result do
        {:error, {:already_started, pid}} ->
          assert is_pid(pid)

        {:error, reason} ->
          # Other errors are acceptable (e.g., already registered)
          assert reason

        other ->
          flunk("Expected error, got: #{inspect(other)}")
      end

      # Cleanup
      MonitoringSupervisor.stop_monitor(equipment.id)
    end
  end

  describe "stop_monitor/1" do
    test "stops a running monitor", %{equipment: equipment} do
      # Start the monitor first
      {:ok, pid} = MonitoringSupervisor.start_monitor(equipment.id)
      assert Process.alive?(pid)

      # Stop it
      result = MonitoringSupervisor.stop_monitor(equipment.id)
      assert result == :ok

      # Give it a moment to shut down
      Process.sleep(50)

      # Verify it's stopped
      refute Process.alive?(pid)
    end

    test "returns :ok when stopping non-existent monitor" do
      fake_id = Ecto.UUID.generate()
      result = MonitoringSupervisor.stop_monitor(fake_id)
      assert result == :ok
    end
  end

  describe "start_snmp_poller/1" do
    test "starts an SNMP poller for equipment", %{snmp_equipment: equipment} do
      # Start the SNMP poller
      result = MonitoringSupervisor.start_snmp_poller(equipment.id)

      # Should return {:ok, pid} or {:error, {:already_started, pid}}
      case result do
        {:ok, pid} ->
          assert is_pid(pid)
          assert Process.alive?(pid)
          # Cleanup
          MonitoringSupervisor.stop_snmp_poller(equipment.id)

        {:error, {:already_started, pid}} ->
          assert is_pid(pid)
          # Already started is acceptable
          MonitoringSupervisor.stop_snmp_poller(equipment.id)

        other ->
          flunk("Unexpected result: #{inspect(other)}")
      end
    end

    test "returns error when starting duplicate poller", %{snmp_equipment: equipment} do
      # Start the first poller
      {:ok, _pid} = MonitoringSupervisor.start_snmp_poller(equipment.id)

      # Try to start another for the same equipment
      result = MonitoringSupervisor.start_snmp_poller(equipment.id)

      case result do
        {:error, {:already_started, pid}} ->
          assert is_pid(pid)

        {:error, reason} ->
          # Other errors are acceptable
          assert reason

        other ->
          flunk("Expected error, got: #{inspect(other)}")
      end

      # Cleanup
      MonitoringSupervisor.stop_snmp_poller(equipment.id)
    end
  end

  describe "stop_snmp_poller/1" do
    test "stops a running SNMP poller", %{snmp_equipment: equipment} do
      # Start the poller first
      {:ok, pid} = MonitoringSupervisor.start_snmp_poller(equipment.id)
      assert Process.alive?(pid)

      # Stop it
      result = MonitoringSupervisor.stop_snmp_poller(equipment.id)
      assert result == :ok

      # Give it a moment to shut down
      Process.sleep(50)

      # Verify it's stopped
      refute Process.alive?(pid)
    end

    test "returns :ok when stopping non-existent poller" do
      fake_id = Ecto.UUID.generate()
      result = MonitoringSupervisor.stop_snmp_poller(fake_id)
      assert result == :ok
    end
  end

  describe "start_all_monitors/0" do
    test "starts monitors for all monitored equipment", %{equipment: equipment} do
      # Make sure equipment has monitoring enabled
      {:ok, _} = Towerops.Equipment.update_equipment(equipment, %{monitoring_enabled: true})

      # Start all monitors
      result = MonitoringSupervisor.start_all_monitors()
      assert result == :ok

      # Give monitors time to start
      Process.sleep(100)

      # Verify monitor was started
      case Registry.lookup(Towerops.Monitoring.Registry, equipment.id) do
        [{pid, _}] ->
          assert is_pid(pid)
          assert Process.alive?(pid)
          # Cleanup
          MonitoringSupervisor.stop_monitor(equipment.id)

        [] ->
          # It's ok if it didn't start (maybe monitoring is disabled in test)
          assert true
      end
    end
  end

  describe "start_all_snmp_pollers/0" do
    test "starts pollers for all SNMP-enabled equipment", %{snmp_equipment: equipment} do
      # Make sure equipment has SNMP enabled
      {:ok, _} =
        Towerops.Equipment.update_equipment(equipment, %{
          snmp_enabled: true,
          snmp_version: "2c",
          snmp_community: "public"
        })

      # Start all pollers
      result = MonitoringSupervisor.start_all_snmp_pollers()
      assert result == :ok

      # Give pollers time to start
      Process.sleep(100)

      # Verify poller was started (may or may not be running depending on equipment state)
      case Registry.lookup(Towerops.Snmp.PollerRegistry, equipment.id) do
        [{pid, _}] ->
          assert is_pid(pid)
          # Cleanup
          MonitoringSupervisor.stop_snmp_poller(equipment.id)

        [] ->
          # It's ok if it didn't start
          assert true
      end
    end
  end
end