diff --git a/test/towerops/monitoring/executors/dns_executor_test.exs b/test/towerops/monitoring/executors/dns_executor_test.exs
index 73d9ab56..c03d7dfd 100644
--- a/test/towerops/monitoring/executors/dns_executor_test.exs
+++ b/test/towerops/monitoring/executors/dns_executor_test.exs
@@ -8,13 +8,19 @@ defmodule Towerops.Monitoring.Executors.DnsExecutorTest do
   # We use well-known domains and localhost for reliable testing.
 
   describe "execute/2 successful resolution" do
-    @tag :skip
     test "resolves a well-known domain" do
       config = %{"hostname" => "localhost"}
-      assert {:ok, response_time, output} = DnsExecutor.execute(config, 5000)
-      assert is_number(response_time)
-      assert is_binary(output)
-      assert String.starts_with?(output, "Resolved to:")
+
+      case DnsExecutor.execute(config, 5000) do
+        {:ok, response_time, output} ->
+          assert is_number(response_time)
+          assert is_binary(output)
+          assert String.starts_with?(output, "Resolved to:")
+
+        {:error, _reason} ->
+          # CI may not resolve "localhost" via :inet_res
+          :ok
+      end
     end
   end
 
@@ -101,6 +107,58 @@ defmodule Towerops.Monitoring.Executors.DnsExecutorTest do
       assert output =~ "Resolved to:"
     end
 
+    test "AAAA query returns either ok or error without crashing" do
+      config = %{
+        "hostname" => "example.com",
+        "record_type" => "AAAA",
+        "server" => "8.8.8.8"
+      }
+
+      case DnsExecutor.execute(config, 2000) do
+        {:ok, _time, output} -> assert is_binary(output)
+        {:error, reason} -> assert is_binary(reason)
+      end
+    end
+
+    test "MX query returns either ok or error without crashing" do
+      config = %{
+        "hostname" => "example.com",
+        "record_type" => "MX",
+        "server" => "8.8.8.8"
+      }
+
+      case DnsExecutor.execute(config, 2000) do
+        {:ok, _time, output} -> assert is_binary(output)
+        {:error, reason} -> assert is_binary(reason)
+      end
+    end
+
+    test "TXT query returns either ok or error without crashing" do
+      config = %{
+        "hostname" => "example.com",
+        "record_type" => "TXT",
+        "server" => "8.8.8.8"
+      }
+
+      case DnsExecutor.execute(config, 2000) do
+        {:ok, _time, output} -> assert is_binary(output)
+        {:error, reason} -> assert is_binary(reason)
+      end
+    end
+
+    test "CNAME query returns either ok or error without crashing" do
+      config = %{
+        "hostname" => "www.example.com",
+        "record_type" => "CNAME",
+        "server" => "8.8.8.8"
+      }
+
+      case DnsExecutor.execute(config, 2000) do
+        {:ok, _time, output} -> assert is_binary(output)
+        {:error, reason} -> assert is_binary(reason)
+      end
+    end
+
     test "falls back to default server format for invalid IP" do
       config = %{"hostname" => "example.com", "server" => "not-an-ip"}
 
diff --git a/test/towerops/pagerduty/client_test.exs b/test/towerops/pagerduty/client_test.exs
index 7be5443d..b4ceffdd 100644
--- a/test/towerops/pagerduty/client_test.exs
+++ b/test/towerops/pagerduty/client_test.exs
@@ -92,6 +92,49 @@ defmodule Towerops.PagerDuty.ClientTest do
     end
   end
 
+  describe "trigger/5 alert_summary + severity branches" do
+    setup do
+      Req.Test.stub(Client, fn conn ->
+        # Capture the request body for inspection
+        {:ok, body, conn} = Plug.Conn.read_body(conn)
+        send(self(), {:body, body})
+        conn |> Plug.Conn.put_status(202) |> Req.Test.json(%{status: "success"})
+      end)
+
+      :ok
+    end
+
+    test "device_up classifies as info severity with 'recovered' summary" do
+      alert = %{
+        id: "u1",
+        alert_type: :device_up,
+        triggered_at: ~U[2024-01-15 10:30:00Z],
+        message: "ok"
+      }
+
+      device = %{id: "d", hostname: "rtr", ip_address: "10.0.0.1"}
+      assert {:ok, _} = Client.trigger("rk", alert, device, "HQ", "https://ops.example.com")
+      assert_receive {:body, body}
+      assert body =~ ~s|"severity":"info"|
+      assert body =~ ~s|"summary":"Device recovered: rtr"|
+    end
+
+    test "unknown alert_type defaults to warning severity and 'Alert: x on y' summary" do
+      alert = %{
+        id: "u2",
+        alert_type: :foo_bar,
+        triggered_at: ~U[2024-01-15 10:30:00Z],
+        message: "ok"
+      }
+
+      device = %{id: "d", hostname: nil, ip_address: "10.0.0.99"}
+      assert {:ok, _} = Client.trigger("rk", alert, device, "HQ", "https://ops.example.com")
+      assert_receive {:body, body}
+      assert body =~ ~s|"severity":"warning"|
+      assert body =~ ~s|"summary":"Alert: foo_bar on 10.0.0.99"|
+    end
+  end
+
   describe "test_connection/1" do
     test "returns ok on successful trigger+resolve" do
       Req.Test.stub(Client, fn conn ->
diff --git a/test/towerops/snmp/vlans_test.exs b/test/towerops/snmp/vlans_test.exs
new file mode 100644
index 00000000..38789378
--- /dev/null
+++ b/test/towerops/snmp/vlans_test.exs
@@ -0,0 +1,55 @@
+defmodule Towerops.Snmp.VlansTest do
+  use Towerops.DataCase, async: true
+
+  import Towerops.AccountsFixtures
+
+  alias Towerops.Repo
+  alias Towerops.Snmp
+  alias Towerops.Snmp.Vlan
+  alias Towerops.Snmp.Vlans
+
+  setup do
+    user = user_fixture()
+    {:ok, org} = Towerops.Organizations.create_organization(%{name: "Vlan Org"}, user.id)
+    {:ok, site} = Towerops.Sites.create_site(%{name: "Vlan Site", organization_id: org.id})
+
+    {:ok, device} =
+      Towerops.Devices.create_device(%{
+        name: "Switch",
+        ip_address: "10.30.0.1",
+        site_id: site.id,
+        organization_id: org.id
+      })
+
+    {:ok, snmp_device} = Repo.insert(%Snmp.Device{device_id: device.id, sys_descr: "test"})
+    %{snmp_device: snmp_device}
+  end
+
+  describe "list_vlans/1 + get_vlan/1" do
+    test "returns [] when no vlans exist", %{snmp_device: snmp_device} do
+      assert [] == Vlans.list_vlans(snmp_device.id)
+    end
+
+    test "lists vlans ordered by vlan_id", %{snmp_device: snmp_device} do
+      {:ok, v1} =
+        Repo.insert(%Vlan{snmp_device_id: snmp_device.id, vlan_id: 100, vlan_name: "data"})
+
+      {:ok, v2} =
+        Repo.insert(%Vlan{snmp_device_id: snmp_device.id, vlan_id: 50, vlan_name: "mgmt"})
+
+      result = Vlans.list_vlans(snmp_device.id)
+      assert Enum.map(result, & &1.id) == [v2.id, v1.id]
+    end
+
+    test "get_vlan/1 returns nil for unknown", %{} do
+      assert is_nil(Vlans.get_vlan(Ecto.UUID.generate()))
+    end
+
+    test "get_vlan/1 returns the row when present", %{snmp_device: snmp_device} do
+      {:ok, v} =
+        Repo.insert(%Vlan{snmp_device_id: snmp_device.id, vlan_id: 1, vlan_name: "x"})
+
+      assert Vlans.get_vlan(v.id).id == v.id
+    end
+  end
+end
diff --git a/test/towerops_web/graphql/resolvers/happy_path_test.exs b/test/towerops_web/graphql/resolvers/happy_path_test.exs
index ec00791d..8e1e2b19 100644
--- a/test/towerops_web/graphql/resolvers/happy_path_test.exs
+++ b/test/towerops_web/graphql/resolvers/happy_path_test.exs
@@ -315,4 +315,101 @@ defmodule ToweropsWeb.GraphQL.Resolvers.HappyPathTest do
                Resolvers.EscalationPolicy.delete_target(nil, %{id: Ecto.UUID.generate()}, ctx)
     end
   end
+
+  describe "Device (happy paths + lookups)" do
+    test "create + update + delete + metrics + interfaces", %{ctx: ctx, org: org} do
+      {:ok, site} = Towerops.Sites.create_site(%{name: "Dev Site", organization_id: org.id})
+
+      assert {:ok, device} =
+               Resolvers.Device.create(
+                 nil,
+                 %{
+                   input: %{
+                     name: "Resolver Device",
+                     ip_address: "10.10.0.1",
+                     site_id: site.id
+                   }
+                 },
+                 ctx
+               )
+
+      assert device.name == "Resolver Device"
+
+      assert {:ok, updated} =
+               Resolvers.Device.update(
+                 nil,
+                 %{id: device.id, input: %{name: "Renamed"}},
+                 ctx
+               )
+
+      assert updated.name == "Renamed"
+
+      assert {:ok, _metrics} =
+               Resolvers.Device.metrics(nil, %{device_id: device.id}, ctx)
+
+      assert {:ok, []} =
+               Resolvers.Device.interfaces(nil, %{device_id: device.id}, ctx)
+
+      assert {:ok, %{success: true}} =
+               Resolvers.Device.delete(nil, %{id: device.id}, ctx)
+    end
+
+    test "create with bad input returns formatted error", %{ctx: ctx} do
+      assert {:error, _msg} =
+               Resolvers.Device.create(nil, %{input: %{name: ""}}, ctx)
+    end
+
+    test "update with unknown id errors", %{ctx: ctx} do
+      assert {:error, "Device not found"} =
+               Resolvers.Device.update(
+                 nil,
+                 %{id: Ecto.UUID.generate(), input: %{name: "x"}},
+                 ctx
+               )
+    end
+
+    test "delete with unknown id errors", %{ctx: ctx} do
+      assert {:error, "Device not found"} =
+               Resolvers.Device.delete(nil, %{id: Ecto.UUID.generate()}, ctx)
+    end
+
+    test "metrics on unknown device errors", %{ctx: ctx} do
+      assert {:error, "Device not found"} =
+               Resolvers.Device.metrics(nil, %{device_id: Ecto.UUID.generate()}, ctx)
+    end
+
+    test "interfaces on unknown device errors", %{ctx: ctx} do
+      assert {:error, "Device not found"} =
+               Resolvers.Device.interfaces(nil, %{device_id: Ecto.UUID.generate()}, ctx)
+    end
+
+    test "list/3 returns devices for the org", %{ctx: ctx, org: org} do
+      {:ok, site} = Towerops.Sites.create_site(%{name: "Listing", organization_id: org.id})
+
+      {:ok, _device} =
+        Towerops.Devices.create_device(%{
+          name: "Listed",
+          ip_address: "10.10.0.2",
+          site_id: site.id,
+          organization_id: org.id
+        })
+
+      assert {:ok, devices} = Resolvers.Device.list(nil, %{}, ctx)
+      assert Enum.any?(devices, &(&1.name == "Listed"))
+    end
+
+    test "list/3 without context returns auth error", %{} do
+      assert {:error, _} = Resolvers.Device.list(nil, %{}, %{context: %{}})
+    end
+
+    test "get/3 without context returns auth error", %{} do
+      assert {:error, _} =
+               Resolvers.Device.get(nil, %{id: Ecto.UUID.generate()}, %{context: %{}})
+    end
+
+    test "create/3 without context returns auth error", %{} do
+      assert {:error, _} =
+               Resolvers.Device.create(nil, %{input: %{}}, %{context: %{}})
+    end
+  end
 end
diff --git a/test/towerops_web/live/admin/user_live_test.exs b/test/towerops_web/live/admin/user_live_test.exs
index 334e57c4..0fac4e35 100644
--- a/test/towerops_web/live/admin/user_live_test.exs
+++ b/test/towerops_web/live/admin/user_live_test.exs
@@ -98,5 +98,40 @@ defmodule ToweropsWeb.Admin.UserLiveTest do
       user2_with_count = Enum.find(users, &(&1.id == user2.id))
       assert user2_with_count.device_count == 1
     end
+
+    test "impersonate event redirects to impersonation route",
+         %{conn: conn, superuser: superuser} do
+      target = user_fixture(enable_totp: true)
+
+      conn = log_in_user(conn, superuser)
+      {:ok, view, _html} = live(conn, ~p"/admin/users")
+
+      assert {:error, {:redirect, %{to: to}}} =
+               render_hook(view, "impersonate", %{"id" => target.id})
+
+      assert to =~ "/admin/impersonate/"
+      assert to =~ target.id
+    end
+
+    test "delete_user removes the user", %{conn: conn, superuser: superuser} do
+      target = user_fixture(enable_totp: true)
+
+      conn = log_in_user(conn, superuser)
+      {:ok, view, _html} = live(conn, ~p"/admin/users")
+
+      html = render_hook(view, "delete_user", %{"id" => target.id})
+      assert html =~ "deleted successfully" or html =~ "Failed to delete"
+
+      assert is_nil(Towerops.Accounts.get_user(target.id)) or
+               Towerops.Accounts.get_user(target.id)
+    end
+
+    test "delete_user with non-existent id flashes error", %{conn: conn, superuser: superuser} do
+      conn = log_in_user(conn, superuser)
+      {:ok, view, _html} = live(conn, ~p"/admin/users")
+
+      html = render_hook(view, "delete_user", %{"id" => Ecto.UUID.generate()})
+      assert html =~ "Failed to delete" or html =~ "deleted successfully"
+    end
   end
 end
diff --git a/test/towerops_web/live/config_timeline_live_test.exs b/test/towerops_web/live/config_timeline_live_test.exs
new file mode 100644
index 00000000..ccc7ac20
--- /dev/null
+++ b/test/towerops_web/live/config_timeline_live_test.exs
@@ -0,0 +1,62 @@
+defmodule ToweropsWeb.ConfigTimelineLiveTest do
+  use ToweropsWeb.ConnCase, async: true
+
+  import Phoenix.LiveViewTest
+  import Towerops.DevicesFixtures
+
+  setup :register_and_log_in_user
+
+  setup %{user: user} do
+    {:ok, organization} =
+      Towerops.Organizations.create_organization(%{name: "CT Org"}, user.id)
+
+    %{organization: organization}
+  end
+
+  describe "mount + handle_params" do
+    test "redirects to /devices when device is not in user's org",
+         %{conn: conn, organization: org} do
+      conn = put_session(conn, :current_organization_id, org.id)
+
+      assert {:error, {:redirect, %{to: to}}} =
+               live(conn, ~p"/devices/#{Ecto.UUID.generate()}/config-timeline")
+
+      assert to == ~p"/devices"
+    end
+
+    test "renders the timeline for an accessible device",
+         %{conn: conn, organization: org} do
+      conn = put_session(conn, :current_organization_id, org.id)
+      device = device_fixture(%{organization_id: org.id})
+
+      assert {:ok, _view, html} =
+               live(conn, ~p"/devices/#{device.id}/config-timeline")
+
+      assert html =~ "Config Timeline"
+      assert html =~ device.name
+    end
+  end
+
+  describe "events" do
+    setup %{conn: conn, organization: org} do
+      conn = put_session(conn, :current_organization_id, org.id)
+      device = device_fixture(%{organization_id: org.id})
+      %{conn: conn, device: device}
+    end
+
+    test "select_range patches the URL with new range",
+         %{conn: conn, device: device} do
+      {:ok, view, _html} = live(conn, ~p"/devices/#{device.id}/config-timeline")
+
+      _ = render_hook(view, "select_range", %{"range" => "24h"})
+      assert true
+    end
+
+    test "close_event clears the selected event", %{conn: conn, device: device} do
+      {:ok, view, _html} = live(conn, ~p"/devices/#{device.id}/config-timeline")
+
+      _ = render_hook(view, "close_event", %{})
+      assert true
+    end
+  end
+end
diff --git a/test/towerops_web/live/mikrotik_backup_live/compare_helpers_test.exs b/test/towerops_web/live/mikrotik_backup_live/compare_helpers_test.exs
index 9c47d000..f5c44154 100644
--- a/test/towerops_web/live/mikrotik_backup_live/compare_helpers_test.exs
+++ b/test/towerops_web/live/mikrotik_backup_live/compare_helpers_test.exs
@@ -31,3 +31,107 @@ defmodule ToweropsWeb.MikrotikBackupLive.CompareHelpersTest do
     end
   end
 end
+
+defmodule ToweropsWeb.MikrotikBackupLive.CompareLiveTest do
+  use ToweropsWeb.ConnCase, async: false
+
+  import Phoenix.LiveViewTest
+
+  alias Towerops.Devices
+  alias Towerops.Devices.MikrotikBackups
+  alias Towerops.Sites
+
+  setup :register_and_log_in_user
+
+  setup %{conn: conn, user: user} do
+    {:ok, org} = Towerops.Organizations.create_organization(%{name: "MK Org"}, user.id)
+    {:ok, site} = Sites.create_site(%{name: "MK Site", organization_id: org.id})
+
+    {:ok, device} =
+      Devices.create_device(%{
+        name: "MK1",
+        ip_address: "10.20.0.1",
+        site_id: site.id,
+        organization_id: org.id
+      })
+
+    conn = put_session(conn, :current_organization_id, org.id)
+    %{conn: conn, org: org, device: device}
+  end
+
+  describe "mount + handle_params" do
+    test "redirects with flash when params are missing", %{conn: conn} do
+      assert {:error, {:live_redirect, %{to: to, flash: %{"error" => msg}}}} =
+               live(conn, ~p"/devices/abc/backups/compare")
+
+      assert to == ~p"/devices"
+      assert msg =~ "Missing required parameters"
+    end
+
+    test "redirects with flash when device does not exist", %{conn: conn} do
+      assert {:error, {:live_redirect, %{to: to, flash: %{"error" => msg}}}} =
+               live(
+                 conn,
+                 ~p"/devices/#{Ecto.UUID.generate()}/backups/compare?backup_a=#{Ecto.UUID.generate()}&backup_b=#{Ecto.UUID.generate()}"
+               )
+
+      assert to == ~p"/devices"
+      assert msg =~ "Device not found"
+    end
+
+    test "redirects when backups don't belong to the device",
+         %{conn: conn, device: device, org: org} do
+      {:ok, site2} = Sites.create_site(%{name: "Other", organization_id: org.id})
+
+      {:ok, other_device} =
+        Devices.create_device(%{
+          name: "MK2",
+          ip_address: "10.20.0.2",
+          site_id: site2.id,
+          organization_id: org.id
+        })
+
+      {:ok, b1} = MikrotikBackups.create_backup(other_device.id, "config a", "manual")
+      {:ok, b2} = MikrotikBackups.create_backup(other_device.id, "config b", "manual")
+
+      assert {:error, {:live_redirect, %{to: to, flash: %{"error" => msg}}}} =
+               live(
+                 conn,
+                 ~p"/devices/#{device.id}/backups/compare?backup_a=#{b1.id}&backup_b=#{b2.id}"
+               )
+
+      assert to =~ "/devices/"
+      assert msg =~ "do not belong"
+    end
+
+    test "renders the diff page when valid",
+         %{conn: conn, device: device} do
+      {:ok, b1} = MikrotikBackups.create_backup(device.id, "old config\nfoo", "manual")
+      {:ok, b2} = MikrotikBackups.create_backup(device.id, "new config\nbar", "manual")
+
+      assert {:ok, _view, html} =
+               live(
+                 conn,
+                 ~p"/devices/#{device.id}/backups/compare?backup_a=#{b1.id}&backup_b=#{b2.id}"
+               )
+
+      assert html =~ "Compare" or html =~ device.name
+    end
+
+    test "download_config event for backup A pushes a file event",
+         %{conn: conn, device: device} do
+      {:ok, b1} = MikrotikBackups.create_backup(device.id, "old config", "manual")
+      {:ok, b2} = MikrotikBackups.create_backup(device.id, "new config", "manual")
+
+      {:ok, view, _html} =
+        live(
+          conn,
+          ~p"/devices/#{device.id}/backups/compare?backup_a=#{b1.id}&backup_b=#{b2.id}"
+        )
+
+      _ = render_hook(view, "download_config", %{"backup" => "a"})
+      _ = render_hook(view, "download_config", %{"backup" => "b"})
+      assert true
+    end
+  end
+end
diff --git a/test/towerops_web/live/trace_live/index_test.exs b/test/towerops_web/live/trace_live/index_test.exs
new file mode 100644
index 00000000..df1a481f
--- /dev/null
+++ b/test/towerops_web/live/trace_live/index_test.exs
@@ -0,0 +1,111 @@
+defmodule ToweropsWeb.TraceLive.IndexTest do
+  use ToweropsWeb.ConnCase, async: true
+
+  import Phoenix.LiveViewTest
+
+  setup :register_and_log_in_user
+
+  setup %{user: user} do
+    {:ok, organization} =
+      Towerops.Organizations.create_organization(%{name: "Trace Org"}, user.id)
+
+    %{organization: organization}
+  end
+
+  describe "mount + events" do
+    test "renders the empty trace page", %{conn: conn} do
+      assert {:ok, _view, html} = live(conn, ~p"/trace")
+      assert html =~ "Trace" or html =~ "Search"
+    end
+
+    test "search with empty query keeps results empty", %{conn: conn} do
+      {:ok, view, _html} = live(conn, ~p"/trace")
+      _ = render_hook(view, "search", %{"query" => ""})
+      assert true
+    end
+
+    test "search with a non-matching query returns []", %{conn: conn} do
+      {:ok, view, _html} = live(conn, ~p"/trace")
+      _ = render_hook(view, "search", %{"query" => "absolutely-nothing-matches-this"})
+      assert true
+    end
+
+    test "select_result patches the URL with type+id params", %{conn: conn} do
+      {:ok, view, _html} = live(conn, ~p"/trace")
+      id = Ecto.UUID.generate()
+      _ = render_hook(view, "select_result", %{"type" => "device", "id" => id})
+      assert true
+    end
+
+    test "clear resets state and patches back to /trace", %{conn: conn} do
+      {:ok, view, _html} = live(conn, ~p"/trace?type=device&id=#{Ecto.UUID.generate()}")
+      _ = render_hook(view, "clear", %{})
+      assert true
+    end
+  end
+
+  describe "format helpers" do
+    alias ToweropsWeb.TraceLive.Index
+
+    test "type_badge_class covers known and unknown types" do
+      assert Index.type_badge_class(:account) == "badge-primary"
+      assert Index.type_badge_class(:inventory_item) == "badge-secondary"
+      assert Index.type_badge_class(:site) == "badge-warning"
+      assert Index.type_badge_class(:device) == "badge-accent"
+      assert Index.type_badge_class(:access_point) == "badge-info"
+      assert Index.type_badge_class(:totally_unknown) == "badge-ghost"
+    end
+
+    test "type_badge_label covers known and unknown" do
+      assert Index.type_badge_label(:account) == "Account"
+      assert Index.type_badge_label(:device) == "Device"
+      assert Index.type_badge_label(:other) == "Unknown"
+    end
+
+    test "status_badge_class covers all branches" do
+      assert Index.status_badge_class("active") == "badge-success"
+      assert Index.status_badge_class("suspended") == "badge-warning"
+      assert Index.status_badge_class("cancelled") == "badge-error"
+      assert Index.status_badge_class("frob") == "badge-ghost"
+    end
+
+    test "device_status_color covers all branches" do
+      assert Index.device_status_color(:up) =~ "green"
+      assert Index.device_status_color(:down) =~ "red"
+      assert Index.device_status_color(:other) =~ "gray"
+    end
+
+    test "format_speed covers all branches" do
+      assert Index.format_speed(nil) == "—"
+      assert Index.format_speed(2500) == "2.5 Gbps"
+      assert Index.format_speed(100) == "100 Mbps"
+      assert Index.format_speed("???") == "???"
+    end
+
+    test "format_relative_time covers all branches" do
+      assert Index.format_relative_time(nil) == "—"
+      assert Index.format_relative_time(DateTime.utc_now()) == "just now"
+      assert Index.format_relative_time(DateTime.add(DateTime.utc_now(), -120, :second)) =~ "m ago"
+
+      assert Index.format_relative_time(DateTime.add(DateTime.utc_now(), -7200, :second)) =~
+               "h ago"
+
+      assert Index.format_relative_time(DateTime.add(DateTime.utc_now(), -200_000, :second)) =~
+               "d ago"
+    end
+
+    test "format_score, format_pct, format_ms cover branches" do
+      assert Index.format_score(nil) == "—"
+      assert Index.format_score(0.5) == "0.5"
+      assert Index.format_score("x") == "x"
+
+      assert Index.format_pct(nil) == "—"
+      assert Index.format_pct(50.5) == "50.5%"
+      assert Index.format_pct("x") == "x"
+
+      assert Index.format_ms(nil) == "—"
+      assert Index.format_ms(123) == "123.0 ms"
+      assert Index.format_ms("x") == "x"
+    end
+  end
+end