towerops/test/towerops/equipment_test.exs

defmodule Towerops.EquipmentTest do
  use Towerops.DataCase

  alias Towerops.Equipment

  describe "equipment" do
    import Towerops.AccountsFixtures

    alias Towerops.Equipment.Equipment, as: EquipmentSchema

    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
        })

      %{organization: organization, site: site, user: user}
    end

    @valid_attrs %{
      name: "Router 1",
      ip_address: "192.168.1.1",
      description: "Main router",
      monitoring_enabled: true,
      check_interval_seconds: 300
    }
    @update_attrs %{
      name: "Updated Router",
      ip_address: "192.168.1.2",
      description: "Updated",
      monitoring_enabled: false
    }
    @invalid_attrs %{name: nil, ip_address: nil}

    test "list_site_equipment/1 returns all equipment for a site", %{site: site} do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))
      assert Equipment.list_site_equipment(site.id) == [equipment]
    end

    test "list_organization_equipment/1 returns all equipment for an organization", %{
      organization: organization,
      site: site
    } do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))
      result = Equipment.list_organization_equipment(organization.id)
      assert length(result) == 1
      assert hd(result).id == equipment.id
    end

    test "list_monitored_equipment/0 returns only equipment with monitoring enabled", %{
      site: site
    } do
      {:ok, monitored} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))

      {:ok, _not_monitored} =
        Equipment.create_equipment(%{
          name: "Not Monitored",
          ip_address: "192.168.1.3",
          site_id: site.id,
          monitoring_enabled: false
        })

      result = Equipment.list_monitored_equipment()
      assert length(result) == 1
      assert hd(result).id == monitored.id
    end

    test "get_equipment!/1 returns the equipment with given id", %{site: site} do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))
      assert Equipment.get_equipment!(equipment.id).id == equipment.id
    end

    test "get_site_equipment!/2 returns equipment for specific site", %{site: site} do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))

      assert Equipment.get_site_equipment!(site.id, equipment.id).id == equipment.id
    end

    test "create_equipment/1 with valid data creates equipment", %{site: site} do
      attrs = Map.put(@valid_attrs, :site_id, site.id)
      assert {:ok, %EquipmentSchema{} = equipment} = Equipment.create_equipment(attrs)
      assert equipment.name == "Router 1"
      assert equipment.ip_address == "192.168.1.1"
      assert equipment.status == :unknown
      assert equipment.monitoring_enabled == true
      assert equipment.check_interval_seconds == 300
    end

    test "create_equipment/1 with valid IPv6 address", %{site: site} do
      attrs = Map.put(@valid_attrs, :ip_address, "2001:0db8:85a3::8a2e:0370:7334")
      attrs = Map.put(attrs, :site_id, site.id)
      assert {:ok, %EquipmentSchema{}} = Equipment.create_equipment(attrs)
    end

    test "create_equipment/1 with invalid IP address returns error", %{site: site} do
      attrs = Map.put(@valid_attrs, :ip_address, "invalid-ip")
      attrs = Map.put(attrs, :site_id, site.id)
      assert {:error, changeset} = Equipment.create_equipment(attrs)
      assert "must be a valid IPv4 or IPv6 address" in errors_on(changeset).ip_address
    end

    test "create_equipment/1 with invalid data returns error changeset" do
      assert {:error, %Ecto.Changeset{}} = Equipment.create_equipment(@invalid_attrs)
    end

    test "update_equipment/2 with valid data updates the equipment", %{site: site} do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))

      assert {:ok, %EquipmentSchema{} = equipment} =
               Equipment.update_equipment(equipment, @update_attrs)

      assert equipment.name == "Updated Router"
      assert equipment.ip_address == "192.168.1.2"
      assert equipment.monitoring_enabled == false
    end

    test "update_equipment/2 with invalid data returns error changeset", %{site: site} do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))

      assert {:error, %Ecto.Changeset{}} =
               Equipment.update_equipment(equipment, @invalid_attrs)

      assert Equipment.get_equipment!(equipment.id).name == equipment.name
    end

    test "delete_equipment/1 deletes the equipment", %{site: site} do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))
      assert {:ok, %EquipmentSchema{}} = Equipment.delete_equipment(equipment)
      assert_raise Ecto.NoResultsError, fn -> Equipment.get_equipment!(equipment.id) end
    end

    test "change_equipment/1 returns an equipment changeset", %{site: site} do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))
      assert %Ecto.Changeset{} = Equipment.change_equipment(equipment)
    end

    test "update_equipment_status/2 updates status and timestamps", %{site: site} do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))

      assert {:ok, updated} = Equipment.update_equipment_status(equipment, :up)
      assert updated.status == :up
      assert updated.last_checked_at
      assert updated.last_status_change_at
    end

    test "update_equipment_status/2 only updates last_checked_at if status unchanged", %{
      site: site
    } do
      {:ok, equipment} = Equipment.create_equipment(Map.put(@valid_attrs, :site_id, site.id))
      {:ok, equipment} = Equipment.update_equipment_status(equipment, :up)
      first_change_at = equipment.last_status_change_at
      first_checked_at = equipment.last_checked_at

      # Sleep for over a second to ensure timestamps differ
      Process.sleep(1100)
      {:ok, updated} = Equipment.update_equipment_status(equipment, :up)
      # Status change timestamp should not change
      assert updated.last_status_change_at == first_change_at
      # But checked_at should be updated
      assert DateTime.after?(updated.last_checked_at, first_checked_at)
    end
  end
end