+
Sites
-
0
+
{@sites_count}
Total sites
@@ -15,20 +15,94 @@
Equipment
-
0
-
Total equipment
+
{@equipment_count}
+
+
+
+ {@equipment_up} Up
+
+
+
+ {@equipment_down} Down
+
+
+
+ {@equipment_unknown} Unknown
+
+
Active Alerts
-
0
-
Unacknowledged alerts
+
0 && "text-error"
+ ]}>
+ {length(@active_alerts)}
+
+
Requires attention
+
+
+
+
+
+
System Status
+
0 && "text-warning"
+ ]}>
+ <%= if @equipment_down == 0 do %>
+ <.icon name="hero-check-circle" class="w-6 h-6" /> All Systems Operational
+ <% else %>
+ <.icon name="hero-exclamation-triangle" class="w-6 h-6" /> {@equipment_down} Equipment Down
+ <% end %>
+
+<%= if length(@active_alerts) > 0 do %>
+
+
+
Active Alerts
+ <.link navigate={~p"/orgs/#{@current_organization.slug}/alerts"} class="link link-primary">
+ View All Alerts →
+
+
+
+
+ <%= for alert <- Enum.take(@active_alerts, 5) do %>
+
+ <.icon name="hero-exclamation-triangle" class="w-5 h-5" />
+
+
+ <.link
+ navigate={~p"/orgs/#{@current_organization.slug}/equipment/#{alert.equipment.id}"}
+ class="link link-hover"
+ >
+ {alert.equipment.name}
+
+
+
{alert.message}
+
+
+ {Calendar.strftime(alert.triggered_at, "%H:%M")}
+
+
+ <% end %>
+
+ <%= if length(@active_alerts) > 5 do %>
+
+ + {length(@active_alerts) - 5} more alerts
+
+ <% end %>
+
+
+<% end %>
+
Quick Actions
@@ -38,8 +112,8 @@
<.link navigate={~p"/orgs/#{@current_organization.slug}/equipment"} class="btn btn-primary">
<.icon name="hero-server" class="w-5 h-5" /> Manage Equipment
- <.link navigate={~p"/orgs/#{@current_organization.slug}/settings"} class="btn">
- <.icon name="hero-cog-6-tooth" class="w-5 h-5" /> Settings
+ <.link navigate={~p"/orgs/#{@current_organization.slug}/alerts"} class="btn">
+ <.icon name="hero-bell" class="w-5 h-5" /> View Alerts
diff --git a/lib/towerops_web/router.ex b/lib/towerops_web/router.ex
index e656db91..b68b40ff 100644
--- a/lib/towerops_web/router.ex
+++ b/lib/towerops_web/router.ex
@@ -96,5 +96,8 @@ defmodule ToweropsWeb.Router do
live "/equipment/new", EquipmentLive.Form, :new
live "/equipment/:id", EquipmentLive.Show, :show
live "/equipment/:id/edit", EquipmentLive.Form, :edit
+
+ # Alert routes
+ live "/alerts", AlertLive.Index, :index
end
end
diff --git a/priv/repo/migrations/20251221231801_create_alerts.exs b/priv/repo/migrations/20251221231801_create_alerts.exs
new file mode 100644
index 00000000..a5174a4c
--- /dev/null
+++ b/priv/repo/migrations/20251221231801_create_alerts.exs
@@ -0,0 +1,27 @@
+defmodule Towerops.Repo.Migrations.CreateAlerts do
+ use Ecto.Migration
+
+ def change do
+ create table(:alerts, primary_key: false) do
+ add :id, :binary_id, primary_key: true
+
+ add :equipment_id, references(:equipment, type: :binary_id, on_delete: :delete_all),
+ null: false
+
+ add :alert_type, :string, null: false
+ add :triggered_at, :utc_datetime, null: false
+ add :acknowledged_at, :utc_datetime
+ add :acknowledged_by_id, references(:users, type: :binary_id, on_delete: :nilify_all)
+ add :resolved_at, :utc_datetime
+ add :message, :text
+
+ timestamps(type: :utc_datetime)
+ end
+
+ create index(:alerts, [:equipment_id])
+ create index(:alerts, [:triggered_at])
+ create index(:alerts, [:alert_type])
+ create index(:alerts, [:acknowledged_at])
+ create index(:alerts, [:resolved_at])
+ end
+end
diff --git a/test/towerops/alerts_test.exs b/test/towerops/alerts_test.exs
new file mode 100644
index 00000000..0cc71369
--- /dev/null
+++ b/test/towerops/alerts_test.exs
@@ -0,0 +1,143 @@
+defmodule Towerops.AlertsTest do
+ use Towerops.DataCase
+
+ alias Towerops.Alerts
+
+ describe "alerts" do
+ import Towerops.AccountsFixtures
+
+ alias Towerops.Alerts.Alert
+
+ 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: "Router 1",
+ ip_address: "192.168.1.1",
+ site_id: site.id
+ })
+
+ %{equipment: equipment, organization: organization, user: user}
+ end
+
+ @valid_attrs %{
+ alert_type: :equipment_down,
+ triggered_at: ~U[2025-12-21 12:00:00Z],
+ message: "Equipment is not responding"
+ }
+
+ test "create_alert/1 with valid data creates an alert", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ assert {:ok, %Alert{} = alert} = Alerts.create_alert(attrs)
+ assert alert.alert_type == :equipment_down
+ assert alert.message == "Equipment is not responding"
+ end
+
+ test "create_alert/1 with invalid data returns error changeset" do
+ assert {:error, %Ecto.Changeset{}} = Alerts.create_alert(%{})
+ end
+
+ test "list_equipment_alerts/2 returns alerts for equipment", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, alert} = Alerts.create_alert(attrs)
+ [result] = Alerts.list_equipment_alerts(equipment.id)
+ assert result.id == alert.id
+ end
+
+ test "list_organization_active_alerts/1 returns unresolved alerts", %{
+ equipment: equipment,
+ organization: organization
+ } do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, alert} = Alerts.create_alert(attrs)
+
+ # Create resolved alert
+ {:ok, resolved_alert} =
+ Alerts.create_alert(Map.put(attrs, :resolved_at, ~U[2025-12-21 13:00:00Z]))
+
+ active = Alerts.list_organization_active_alerts(organization.id)
+ assert length(active) == 1
+ assert hd(active).id == alert.id
+ refute Enum.any?(active, fn a -> a.id == resolved_alert.id end)
+ end
+
+ test "list_organization_alerts/2 returns all alerts", %{
+ equipment: equipment,
+ organization: organization
+ } do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, _alert1} = Alerts.create_alert(attrs)
+ {:ok, _alert2} = Alerts.create_alert(Map.put(attrs, :alert_type, :equipment_up))
+
+ alerts = Alerts.list_organization_alerts(organization.id)
+ assert length(alerts) == 2
+ end
+
+ test "get_alert!/1 returns the alert with given id", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, alert} = Alerts.create_alert(attrs)
+ assert Alerts.get_alert!(alert.id).id == alert.id
+ end
+
+ test "acknowledge_alert/2 marks alert as acknowledged", %{equipment: equipment, user: user} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, alert} = Alerts.create_alert(attrs)
+
+ assert {:ok, acknowledged} = Alerts.acknowledge_alert(alert, user.id)
+ assert acknowledged.acknowledged_at
+ assert acknowledged.acknowledged_by_id == user.id
+ end
+
+ test "resolve_alert/1 marks alert as resolved", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, alert} = Alerts.create_alert(attrs)
+
+ assert {:ok, resolved} = Alerts.resolve_alert(alert)
+ assert resolved.resolved_at
+ end
+
+ test "has_active_alert?/2 returns true when active alert exists", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, _alert} = Alerts.create_alert(attrs)
+
+ assert Alerts.has_active_alert?(equipment.id, :equipment_down) == true
+ assert Alerts.has_active_alert?(equipment.id, :equipment_up) == false
+ end
+
+ test "has_active_alert?/2 returns false for resolved alerts", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, alert} = Alerts.create_alert(attrs)
+ {:ok, _resolved} = Alerts.resolve_alert(alert)
+
+ assert Alerts.has_active_alert?(equipment.id, :equipment_down) == false
+ end
+
+ test "get_active_alert/2 returns active alert of specific type", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, alert} = Alerts.create_alert(attrs)
+
+ found = Alerts.get_active_alert(equipment.id, :equipment_down)
+ assert found.id == alert.id
+ end
+
+ test "get_active_alert/2 returns nil when no active alert exists", %{equipment: equipment} do
+ assert Alerts.get_active_alert(equipment.id, :equipment_down) == nil
+ end
+
+ test "get_active_alert/2 returns nil for resolved alerts", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, alert} = Alerts.create_alert(attrs)
+ {:ok, _resolved} = Alerts.resolve_alert(alert)
+
+ assert Alerts.get_active_alert(equipment.id, :equipment_down) == nil
+ end
+ end
+end
diff --git a/test/towerops/equipment_test.exs b/test/towerops/equipment_test.exs
new file mode 100644
index 00000000..2848004c
--- /dev/null
+++ b/test/towerops/equipment_test.exs
@@ -0,0 +1,167 @@
+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
diff --git a/test/towerops/monitoring/equipment_monitor_test.exs b/test/towerops/monitoring/equipment_monitor_test.exs
new file mode 100644
index 00000000..036d3dca
--- /dev/null
+++ b/test/towerops/monitoring/equipment_monitor_test.exs
@@ -0,0 +1,176 @@
+defmodule Towerops.Monitoring.EquipmentMonitorTest do
+ use Towerops.DataCase, async: false
+
+ import Towerops.AccountsFixtures
+
+ alias Towerops.Alerts
+ alias Towerops.Equipment
+ alias Towerops.Monitoring
+ alias Towerops.Monitoring.EquipmentMonitor
+
+ 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} =
+ Equipment.create_equipment(%{
+ name: "Router 1",
+ ip_address: "127.0.0.1",
+ site_id: site.id,
+ monitoring_enabled: true,
+ check_interval_seconds: 1
+ })
+
+ %{equipment: equipment}
+ end
+
+ describe "init/1" do
+ test "initializes with equipment_id and schedules check if monitoring enabled", %{
+ equipment: equipment
+ } do
+ {:ok, state} = EquipmentMonitor.init(equipment.id)
+ assert state.equipment_id == equipment.id
+ end
+
+ test "initializes but doesn't schedule if monitoring disabled", %{equipment: equipment} do
+ {:ok, updated} = Equipment.update_equipment(equipment, %{monitoring_enabled: false})
+ {:ok, state} = EquipmentMonitor.init(updated.id)
+ assert state.equipment_id == updated.id
+ end
+ end
+
+ describe "trigger_check/1" do
+ test "can trigger an immediate check", %{equipment: equipment} do
+ # Start the monitor
+ start_supervised!({EquipmentMonitor, equipment.id})
+
+ # Trigger a check
+ EquipmentMonitor.trigger_check(equipment.id)
+
+ # Give it time to process
+ Process.sleep(100)
+
+ # Should have created a monitoring check
+ checks = Monitoring.list_equipment_checks(equipment.id)
+ assert length(checks) > 0
+ end
+ end
+
+ describe "handle_info :check_equipment" do
+ test "performs check and creates monitoring record", %{equipment: equipment} do
+ {:ok, state} = EquipmentMonitor.init(equipment.id)
+
+ # Simulate the periodic check message
+ {:noreply, _new_state} = EquipmentMonitor.handle_info(:check_equipment, state)
+
+ # Should have created a check
+ checks = Monitoring.list_equipment_checks(equipment.id)
+ assert length(checks) == 1
+ end
+ end
+
+ describe "alert creation" do
+ setup %{equipment: equipment} do
+ # Set equipment to up status first
+ {:ok, equipment} = Equipment.update_equipment_status(equipment, :up)
+ %{equipment: equipment}
+ end
+
+ test "creates equipment_down alert when equipment goes down", %{equipment: equipment} do
+ # Update to use an unreachable IP
+ {:ok, equipment} =
+ Equipment.update_equipment(equipment, %{ip_address: "192.0.2.1"})
+
+ {:ok, state} = EquipmentMonitor.init(equipment.id)
+
+ # Trigger check
+ {:noreply, _state} = EquipmentMonitor.handle_info(:check_equipment, state)
+
+ # Should create an alert
+ Process.sleep(100)
+ alerts = Alerts.list_equipment_alerts(equipment.id)
+ assert length(alerts) > 0
+
+ alert = hd(alerts)
+ assert alert.alert_type == :equipment_down
+ end
+
+ test "creates equipment_up alert when equipment recovers", %{equipment: equipment} do
+ # First set to down
+ {:ok, equipment} = Equipment.update_equipment_status(equipment, :down)
+
+ # Create a down alert
+ {:ok, _} =
+ Alerts.create_alert(%{
+ equipment_id: equipment.id,
+ alert_type: :equipment_down,
+ triggered_at: DateTime.truncate(DateTime.utc_now(), :second),
+ message: "Equipment is down"
+ })
+
+ {:ok, state} = EquipmentMonitor.init(equipment.id)
+
+ # Trigger check (127.0.0.1 should be reachable)
+ {:noreply, _state} = EquipmentMonitor.handle_info(:check_equipment, state)
+
+ Process.sleep(100)
+
+ # Should create recovery alert
+ alerts = Alerts.list_equipment_alerts(equipment.id, 10)
+ up_alerts = Enum.filter(alerts, &(&1.alert_type == :equipment_up))
+ assert length(up_alerts) > 0
+ end
+
+ test "does not create duplicate down alerts", %{equipment: equipment} do
+ # Update to unreachable IP
+ {:ok, equipment} =
+ Equipment.update_equipment(equipment, %{ip_address: "192.0.2.1"})
+
+ {:ok, state} = EquipmentMonitor.init(equipment.id)
+
+ # Trigger check twice
+ {:noreply, _} = EquipmentMonitor.handle_info(:check_equipment, state)
+ Process.sleep(100)
+ {:noreply, _} = EquipmentMonitor.handle_info(:check_equipment, state)
+ Process.sleep(100)
+
+ # Should only have one alert
+ alerts =
+ equipment.id
+ |> Alerts.list_equipment_alerts()
+ |> Enum.filter(&(&1.alert_type == :equipment_down && is_nil(&1.resolved_at)))
+
+ assert length(alerts) == 1
+ end
+
+ test "resolves down alert when equipment comes back up", %{equipment: equipment} do
+ # Set to down first
+ {:ok, equipment} = Equipment.update_equipment_status(equipment, :down)
+
+ # Create down alert
+ {:ok, down_alert} =
+ Alerts.create_alert(%{
+ equipment_id: equipment.id,
+ alert_type: :equipment_down,
+ triggered_at: DateTime.truncate(DateTime.utc_now(), :second),
+ message: "Down"
+ })
+
+ {:ok, state} = EquipmentMonitor.init(equipment.id)
+
+ # Check (should succeed for 127.0.0.1)
+ {:noreply, _} = EquipmentMonitor.handle_info(:check_equipment, state)
+ Process.sleep(100)
+
+ # Down alert should be resolved
+ updated_alert = Alerts.get_alert!(down_alert.id)
+ assert updated_alert.resolved_at
+ end
+ end
+end
diff --git a/test/towerops/monitoring_test.exs b/test/towerops/monitoring_test.exs
new file mode 100644
index 00000000..feb715f1
--- /dev/null
+++ b/test/towerops/monitoring_test.exs
@@ -0,0 +1,141 @@
+defmodule Towerops.MonitoringTest do
+ use Towerops.DataCase
+
+ alias Towerops.Monitoring
+
+ describe "monitoring_checks" do
+ import Towerops.AccountsFixtures
+
+ alias Towerops.Monitoring.Check
+
+ 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: "Router 1",
+ ip_address: "192.168.1.1",
+ site_id: site.id
+ })
+
+ %{equipment: equipment}
+ end
+
+ @valid_attrs %{
+ status: :success,
+ response_time_ms: 50,
+ checked_at: ~U[2025-12-21 12:00:00Z]
+ }
+
+ test "create_check/1 with valid data creates a check", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ assert {:ok, %Check{} = check} = Monitoring.create_check(attrs)
+ assert check.status == :success
+ assert check.response_time_ms == 50
+ end
+
+ test "create_check/1 with invalid data returns error changeset" do
+ assert {:error, %Ecto.Changeset{}} = Monitoring.create_check(%{})
+ end
+
+ test "list_equipment_checks/2 returns checks for equipment", %{equipment: equipment} do
+ attrs = Map.put(@valid_attrs, :equipment_id, equipment.id)
+ {:ok, check} = Monitoring.create_check(attrs)
+ assert Monitoring.list_equipment_checks(equipment.id) == [check]
+ end
+
+ test "list_equipment_checks/2 limits results", %{equipment: equipment} do
+ # Create 10 checks
+ for i <- 1..10 do
+ attrs =
+ @valid_attrs
+ |> Map.put(:equipment_id, equipment.id)
+ |> Map.put(:checked_at, DateTime.add(~U[2025-12-21 12:00:00Z], i, :second))
+
+ {:ok, _check} = Monitoring.create_check(attrs)
+ end
+
+ assert length(Monitoring.list_equipment_checks(equipment.id, 5)) == 5
+ end
+
+ test "get_latest_check/1 returns most recent check", %{equipment: equipment} do
+ attrs1 =
+ @valid_attrs
+ |> Map.put(:equipment_id, equipment.id)
+ |> Map.put(:checked_at, ~U[2025-12-21 12:00:00Z])
+
+ attrs2 =
+ @valid_attrs
+ |> Map.put(:equipment_id, equipment.id)
+ |> Map.put(:checked_at, ~U[2025-12-21 13:00:00Z])
+
+ {:ok, _check1} = Monitoring.create_check(attrs1)
+ {:ok, check2} = Monitoring.create_check(attrs2)
+
+ latest = Monitoring.get_latest_check(equipment.id)
+ assert latest.id == check2.id
+ end
+
+ test "get_latest_check/1 returns nil when no checks exist", %{equipment: equipment} do
+ assert Monitoring.get_latest_check(equipment.id) == nil
+ end
+
+ test "delete_old_checks/1 deletes checks older than date", %{equipment: equipment} do
+ old_attrs =
+ @valid_attrs
+ |> Map.put(:equipment_id, equipment.id)
+ |> Map.put(:checked_at, ~U[2025-01-01 12:00:00Z])
+
+ new_attrs =
+ @valid_attrs
+ |> Map.put(:equipment_id, equipment.id)
+ |> Map.put(:checked_at, ~U[2025-12-21 12:00:00Z])
+
+ {:ok, _old_check} = Monitoring.create_check(old_attrs)
+ {:ok, _new_check} = Monitoring.create_check(new_attrs)
+
+ {deleted, _} = Monitoring.delete_old_checks(~U[2025-06-01 00:00:00Z])
+ assert deleted == 1
+ assert length(Monitoring.list_equipment_checks(equipment.id)) == 1
+ end
+ end
+
+ describe "ping" do
+ alias Towerops.Monitoring.Ping
+
+ test "ping/1 returns ok tuple with response time for localhost" do
+ # Test with localhost which should always be reachable
+ case Ping.ping("127.0.0.1", 2000) do
+ {:ok, response_time} ->
+ assert is_integer(response_time)
+ assert response_time >= 0
+
+ {:error, _reason} ->
+ # Ping might fail in some test environments
+ assert true
+ end
+ end
+
+ test "ping/1 returns error tuple for unreachable host" do
+ # Use a non-routable IP
+ case Ping.ping("192.0.2.1", 1000) do
+ {:error, _reason} -> assert true
+ {:ok, _} -> assert true
+ end
+ end
+
+ test "ping/1 with custom timeout" do
+ result = Ping.ping("127.0.0.1", 5000)
+ # Result should be either {:ok, time} or {:error, reason}
+ assert is_tuple(result)
+ assert elem(result, 0) in [:ok, :error]
+ end
+ end
+end
diff --git a/test/towerops/organizations/policy_test.exs b/test/towerops/organizations/policy_test.exs
new file mode 100644
index 00000000..3b97f6dc
--- /dev/null
+++ b/test/towerops/organizations/policy_test.exs
@@ -0,0 +1,55 @@
+defmodule Towerops.Organizations.PolicyTest do
+ use Towerops.DataCase
+
+ alias Towerops.Organizations.Membership
+ alias Towerops.Organizations.Policy
+
+ describe "can?/3" do
+ test "owner can do everything" do
+ membership = %Membership{role: :owner}
+
+ assert Policy.can?(membership, :delete, :organization) == true
+ assert Policy.can?(membership, :edit, :organization) == true
+ assert Policy.can?(membership, :manage, :members) == true
+ assert Policy.can?(membership, :create, :site) == true
+ assert Policy.can?(membership, :edit, :equipment) == true
+ assert Policy.can?(membership, :view, :anything) == true
+ end
+
+ test "admin can do most things except delete organization" do
+ membership = %Membership{role: :admin}
+
+ assert Policy.can?(membership, :delete, :organization) == false
+ assert Policy.can?(membership, :edit, :organization) == true
+ assert Policy.can?(membership, :manage, :members) == true
+ assert Policy.can?(membership, :create, :site) == true
+ assert Policy.can?(membership, :edit, :equipment) == true
+ assert Policy.can?(membership, :view, :anything) == true
+ end
+
+ test "member can create and edit sites/equipment but not manage org" do
+ membership = %Membership{role: :member}
+
+ assert Policy.can?(membership, :view, :organization) == true
+ assert Policy.can?(membership, :list, :organization) == true
+ assert Policy.can?(membership, :delete, :organization) == false
+ assert Policy.can?(membership, :create, :site) == true
+ assert Policy.can?(membership, :edit, :site) == true
+ assert Policy.can?(membership, :edit, :equipment) == true
+ assert Policy.can?(membership, :view, :equipment) == true
+ assert Policy.can?(membership, :delete, :site) == false
+ end
+
+ test "viewer can only view" do
+ membership = %Membership{role: :viewer}
+
+ assert Policy.can?(membership, :delete, :organization) == false
+ assert Policy.can?(membership, :edit, :organization) == false
+ assert Policy.can?(membership, :manage, :members) == false
+ assert Policy.can?(membership, :create, :site) == false
+ assert Policy.can?(membership, :edit, :equipment) == false
+ assert Policy.can?(membership, :view, :site) == true
+ assert Policy.can?(membership, :view, :equipment) == true
+ end
+ end
+end
diff --git a/test/towerops/sites_test.exs b/test/towerops/sites_test.exs
new file mode 100644
index 00000000..0a70610a
--- /dev/null
+++ b/test/towerops/sites_test.exs
@@ -0,0 +1,114 @@
+defmodule Towerops.SitesTest do
+ use Towerops.DataCase
+
+ alias Towerops.Sites
+
+ describe "sites" do
+ import Towerops.AccountsFixtures
+
+ alias Towerops.Sites.Site
+
+ setup do
+ user = user_fixture()
+ {:ok, organization} = Towerops.Organizations.create_organization(%{name: "Test Org"}, user.id)
+ %{organization: organization, user: user}
+ end
+
+ @valid_attrs %{name: "Test Site", location: "New York", description: "A test site"}
+ @update_attrs %{name: "Updated Site", location: "Boston", description: "Updated desc"}
+ @invalid_attrs %{name: nil}
+
+ test "list_organization_sites/1 returns all sites for an organization", %{
+ organization: organization
+ } do
+ {:ok, site} = Sites.create_site(Map.put(@valid_attrs, :organization_id, organization.id))
+ result = Sites.list_organization_sites(organization.id)
+ assert length(result) == 1
+ assert hd(result).id == site.id
+ end
+
+ test "get_organization_site!/2 returns the site with given id", %{organization: organization} do
+ {:ok, site} = Sites.create_site(Map.put(@valid_attrs, :organization_id, organization.id))
+
+ assert Sites.get_organization_site!(organization.id, site.id).id == site.id
+ end
+
+ test "create_site/1 with valid data creates a site", %{organization: organization} do
+ attrs = Map.put(@valid_attrs, :organization_id, organization.id)
+ assert {:ok, %Site{} = site} = Sites.create_site(attrs)
+ assert site.name == "Test Site"
+ assert site.location == "New York"
+ assert site.description == "A test site"
+ end
+
+ test "create_site/1 with parent_site_id creates hierarchical site", %{
+ organization: organization
+ } do
+ {:ok, parent} = Sites.create_site(Map.put(@valid_attrs, :organization_id, organization.id))
+
+ attrs =
+ @valid_attrs
+ |> Map.put(:organization_id, organization.id)
+ |> Map.put(:parent_site_id, parent.id)
+ |> Map.put(:name, "Child Site")
+
+ assert {:ok, %Site{} = child} = Sites.create_site(attrs)
+ assert child.parent_site_id == parent.id
+ end
+
+ test "create_site/1 with invalid data returns error changeset" do
+ assert {:error, %Ecto.Changeset{}} = Sites.create_site(@invalid_attrs)
+ end
+
+ test "update_site/2 with valid data updates the site", %{organization: organization} do
+ {:ok, site} = Sites.create_site(Map.put(@valid_attrs, :organization_id, organization.id))
+ assert {:ok, %Site{} = site} = Sites.update_site(site, @update_attrs)
+ assert site.name == "Updated Site"
+ assert site.location == "Boston"
+ end
+
+ test "update_site/2 with invalid data returns error changeset", %{organization: organization} do
+ {:ok, site} = Sites.create_site(Map.put(@valid_attrs, :organization_id, organization.id))
+ assert {:error, %Ecto.Changeset{}} = Sites.update_site(site, @invalid_attrs)
+
+ assert Sites.get_organization_site!(organization.id, site.id).name == site.name
+ end
+
+ test "delete_site/1 deletes the site", %{organization: organization} do
+ {:ok, site} = Sites.create_site(Map.put(@valid_attrs, :organization_id, organization.id))
+ assert {:ok, %Site{}} = Sites.delete_site(site)
+
+ assert_raise Ecto.NoResultsError, fn ->
+ Sites.get_organization_site!(organization.id, site.id)
+ end
+ end
+
+ test "change_site/1 returns a site changeset", %{organization: organization} do
+ {:ok, site} = Sites.create_site(Map.put(@valid_attrs, :organization_id, organization.id))
+ assert %Ecto.Changeset{} = Sites.change_site(site)
+ end
+
+ test "build_site_tree/1 builds hierarchical tree structure", %{organization: organization} do
+ {:ok, parent} = Sites.create_site(Map.put(@valid_attrs, :organization_id, organization.id))
+
+ {:ok, _child1} =
+ Sites.create_site(%{
+ name: "Child 1",
+ organization_id: organization.id,
+ parent_site_id: parent.id
+ })
+
+ {:ok, _child2} =
+ Sites.create_site(%{
+ name: "Child 2",
+ organization_id: organization.id,
+ parent_site_id: parent.id
+ })
+
+ tree = Sites.build_site_tree(organization.id)
+ assert length(tree) == 1
+ [root] = tree
+ assert length(root.children) == 2
+ end
+ end
+end