mitgliederverwaltung/test/mv_web/user_live/index_test.exs

defmodule MvWeb.UserLive.IndexTest do
  use MvWeb.ConnCase, async: true
  import Phoenix.LiveViewTest

  describe "basic functionality" do
    @tag :slow
    test "displays users in a table", %{conn: conn} do
      # Create test users
      _user1 = create_test_user(%{email: "alice@example.com", oidc_id: "alice123"})
      _user2 = create_test_user(%{email: "bob@example.com", oidc_id: "bob456"})

      conn = conn_with_oidc_user(conn)
      {:ok, _view, html} = live(conn, "/users")

      assert html =~ "alice@example.com"
      assert html =~ "bob@example.com"
    end
  end

  describe "sorting functionality" do
    setup do
      # Create users with different emails for sorting tests
      user_a = create_test_user(%{email: "alpha@example.com", oidc_id: "alpha"})
      user_z = create_test_user(%{email: "zulu@example.com", oidc_id: "zulu"})
      user_m = create_test_user(%{email: "mike@example.com", oidc_id: "mike"})

      %{users: [user_a, user_z, user_m]}
    end

    @tag :slow
    test "initially sorts by email ascending", %{conn: conn} do
      conn = conn_with_oidc_user(conn)
      {:ok, _view, html} = live(conn, "/users")

      # Should show ascending indicator (up arrow)
      assert html =~ "hero-chevron-up"
      assert html =~ ~s(aria-sort="ascending")

      # Test actual sort order: alpha should appear before mike, mike before zulu
      alpha_pos = html |> :binary.match("alpha@example.com") |> elem(0)
      mike_pos = html |> :binary.match("mike@example.com") |> elem(0)
      zulu_pos = html |> :binary.match("zulu@example.com") |> elem(0)

      assert alpha_pos < mike_pos, "alpha@example.com should appear before mike@example.com"
      assert mike_pos < zulu_pos, "mike@example.com should appear before zulu@example.com"
    end

    @tag :slow
    test "can sort email descending by clicking sort button", %{conn: conn} do
      conn = conn_with_oidc_user(conn)
      {:ok, view, _html} = live(conn, "/users")

      # Click on email sort button and get rendered result
      html = view |> element("button[phx-value-field='email']") |> render_click()

      # Should now show descending indicator (down arrow)
      assert html =~ "hero-chevron-down"
      assert html =~ ~s(aria-sort="descending")

      # Test actual sort order reversed: zulu should now appear before mike, mike before alpha
      alpha_pos = html |> :binary.match("alpha@example.com") |> elem(0)
      mike_pos = html |> :binary.match("mike@example.com") |> elem(0)
      zulu_pos = html |> :binary.match("zulu@example.com") |> elem(0)

      assert zulu_pos < mike_pos,
             "zulu@example.com should appear before mike@example.com when sorted desc"

      assert mike_pos < alpha_pos,
             "mike@example.com should appear before alpha@example.com when sorted desc"
    end
  end

  describe "checkbox selection functionality" do
    setup do
      user1 = create_test_user(%{email: "user1@example.com", oidc_id: "user1"})
      user2 = create_test_user(%{email: "user2@example.com", oidc_id: "user2"})
      %{users: [user1, user2]}
    end

    @tag :slow
    test "select all automatically checks when all individual users are selected", %{
      conn: conn,
      users: [user1, user2]
    } do
      conn = conn_with_oidc_user(conn)
      {:ok, view, _html} = live(conn, "/users")

      # Initially nothing should be checked
      refute view
             |> element("input[type='checkbox'][name='select_all'][checked]")
             |> has_element?()

      # Select first user
      view |> element("input[type='checkbox'][name='#{user1.id}']") |> render_click()
      # Select all should still not be checked (only 1 of 2+ users selected)
      refute view
             |> element("input[type='checkbox'][name='select_all'][checked]")
             |> has_element?()

      # Select second user
      html = view |> element("input[type='checkbox'][name='#{user2.id}']") |> render_click()

      # Now select all should be automatically checked (all individual users are selected)
      # Note: This test might need adjustment based on actual implementation
      # The logic depends on whether authenticated user is included in the count
      assert html =~ "Email"
      assert html =~ to_string(user1.email)
      assert html =~ to_string(user2.email)
    end
  end

  describe "delete functionality" do
    test "can delete a user", %{conn: conn} do
      _user = create_test_user(%{email: "delete-me@example.com"})
      conn = conn_with_oidc_user(conn)
      {:ok, view, _html} = live(conn, "/users")

      # Confirm user is displayed
      assert render(view) =~ "delete-me@example.com"

      # Click the first delete button to test the functionality
      view |> element("tbody tr:first-child a[data-confirm]") |> render_click()

      # The page should still render (basic functionality test)
      html = render(view)
      # Table header should still be there
      assert html =~ "Email"
    end

    test "shows delete confirmation", %{conn: conn} do
      _user = create_test_user(%{email: "confirm-delete@example.com"})
      conn = conn_with_oidc_user(conn)
      {:ok, _view, html} = live(conn, "/users")

      # Check that delete link has confirmation attribute
      assert html =~ ~s(data-confirm="Are you sure?")
    end
  end

  describe "edge cases" do
    test "handles empty user list gracefully", %{conn: conn} do
      # Don't create any users besides the authenticated one
      conn = conn_with_oidc_user(conn)
      {:ok, _view, html} = live(conn, "/users")

      # Should still show the table structure
      assert html =~ "Email"
    end

    test "handles users with missing OIDC ID", %{conn: conn} do
      _user = create_test_user(%{email: "no-oidc@example.com", oidc_id: nil})
      conn = conn_with_oidc_user(conn)
      {:ok, _view, html} = live(conn, "/users")

      assert html =~ "no-oidc@example.com"
      # Should handle nil OIDC ID gracefully
    end

    test "handles very long email addresses", %{conn: conn} do
      long_email = "very.long.email.address.that.might.break.layouts@example.com"
      _user = create_test_user(%{email: long_email})
      conn = conn_with_oidc_user(conn)
      {:ok, _view, html} = live(conn, "/users")

      assert html =~ long_email
    end
  end

  describe "system actor user" do
    test "does not show system actor user in list", %{conn: conn} do
      # Ensure system actor exists (e.g. via get_system_actor in conn_with_oidc_user)
      _system_actor = Mv.Helpers.SystemActor.get_system_actor()
      system_email = Mv.Helpers.SystemActor.system_user_email()

      conn = conn_with_oidc_user(conn)
      {:ok, _view, html} = live(conn, "/users")

      refute html =~ system_email,
             "System actor user (#{system_email}) must not appear in the user list"
    end

    test "destroying system actor user returns error", %{current_user: current_user} do
      system_actor = Mv.Helpers.SystemActor.get_system_actor()

      assert {:error, %Ash.Error.Invalid{}} =
               Ash.destroy(system_actor, domain: Mv.Accounts, actor: current_user)
    end
  end

  describe "member linking display" do
    @tag :slow
    test "displays linked member name in user list", %{conn: conn} do
      system_actor = Mv.Helpers.SystemActor.get_system_actor()

      # Create member
      {:ok, member} =
        Mv.Membership.create_member(
          %{
            first_name: "Alice",
            last_name: "Johnson",
            email: "alice@example.com"
          },
          actor: system_actor
        )

      # Create user linked to member
      user = create_test_user(%{email: "user@example.com"})

      {:ok, _updated_user} =
        Mv.Accounts.update_user(user, %{member: %{id: member.id}}, actor: system_actor)

      # Create another user without member
      _unlinked_user = create_test_user(%{email: "unlinked@example.com"})

      conn = conn_with_oidc_user(conn)
      {:ok, _view, html} = live(conn, "/users")

      # Should show linked member name
      assert html =~ "Alice Johnson"
      # Should show user email
      assert html =~ "user@example.com"
      # Should show unlinked user
      assert html =~ "unlinked@example.com"
      # Should show "No member linked" or similar for unlinked user
      assert html =~ "No member linked"
    end
  end
end