Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

20.1 KB
Raw Blame
defmodule PlausibleWeb.Live.TeamManagementTest do
  use PlausibleWeb.ConnCase, async: false
  use Bamboo.Test, shared: true

  import Phoenix.LiveViewTest

  def team_general_path(), do: ~p"/settings/team/general"
  @subject_prefix if ee?(), do: "[Plausible Analytics] ", else: "[Plausible CE] "

  describe "/settings/team/general" do
    setup [:create_user, :log_in, :create_team, :setup_team]

    test "renders team management section", %{conn: conn} do
      resp =
        conn
        |> get(team_general_path())
        |> html_response(200)
        |> text()

      assert resp =~ "Add or remove team members and adjust their roles"

      refute element_exists?(resp, ~s|button[phx-click="save-team-layout"]|)
    end

    test "renders existing guests under Guest divider", %{conn: conn, team: team, user: user} do
      site = new_site(team: team)
      add_guest(site, role: :viewer, user: new_user(name: "Mr Guest", email: "[email protected]"))

      resp =
        conn
        |> get(team_general_path())
        |> html_response(200)

      assert element_exists?(resp, "#guests-hr")

      assert find(resp, "#{member_el()}:first-of-type") |> text() =~ "#{user.email}"
      assert find(resp, "#{guest_el()}:first-of-type") |> text() =~ "[email protected]"
    end

    test "role switcher forms opt out of automatic recovery after a reconnect", %{
      conn: conn,
      team: team,
      user: user
    } do
      site = new_site(team: team)
      add_member(team, role: :viewer)
      invite_member(team, "[email protected]", role: :editor, inviter: user)
      add_guest(site, role: :viewer, user: new_user(email: "[email protected]"))

      resp =
        conn
        |> get(team_general_path())
        |> html_response(200)

      assert elem_count(resp, ~s|form[id^="role-form-"][phx-auto-recover="ignore"]|) == 4
    end

    test "disables changing the role of a pending guest invitation, but not removing it", %{
      conn: conn,
      team: team,
      user: user
    } do
      site = new_site(team: team)
      invite_guest(site, "[email protected]", role: :viewer, inviter: user)
      add_guest(site, role: :viewer, user: new_user(email: "[email protected]"))

      resp =
        conn
        |> get(team_general_path())
        |> html_response(200)

      assert text_of_attr(resp, role_dropdown_el("[email protected]"), "data-disabled") ==
               "true"

      refute attr_defined?(resp, remove_button_el("[email protected]"), "disabled")

      refute attr_defined?(resp, role_dropdown_el("[email protected]"), "data-disabled")
    end

    test "does not render Guest divider when no guests found", %{conn: conn} do
      resp =
        conn
        |> get(team_general_path())
        |> html_response(200)

      refute element_exists?(resp, "#guests-hr")
      refute element_exists?(resp, "#guest-list")
    end
  end

  on_ee do
    describe "live - SSO user" do
      setup [
        :create_user,
        :create_team,
        :setup_sso,
        :provision_sso_user,
        :log_in,
        :setup_team
      ]

      test "fails to save layout with SSO user updated to owner with Force SSO but without 2FA",
           %{
             conn: conn,
             team: team,
             user: user,
             sso_integration: integration
           } do
        {:ok, user, _} = Plausible.Auth.TOTP.initiate(user)
        {:ok, _user, _} = Plausible.Auth.TOTP.enable(user, :skip_verify)
        {:ok, team} = Plausible.Auth.SSO.set_force_sso(team, :all_but_owners)
        member = add_member(team, role: :viewer)

        {:ok, _, _, _member} =
          new_identity(member.name, member.email, integration)
          |> Plausible.Auth.SSO.provision_user()

        {:ok, _, _, user} =
          new_identity(user.name, user.email, integration)
          |> Plausible.Auth.SSO.provision_user()

        {:ok, conn: conn} = log_in(%{conn: conn, user: user})
        conn = set_current_team(conn, team)

        lv = get_liveview(conn)

        html = render(lv)

        self_row = "#member-row-#{:erlang.phash2(user.email)}"
        member_row = "#member-row-#{:erlang.phash2(member.email)}"

        assert text_of_element(html, "#{self_row} #{role_el()}") == "Owner"
        assert text_of_element(html, self_row) =~ "You (SSO)"

        assert text_of_element(html, "#{member_row} #{role_el()}") == "Viewer"
        assert text_of_element(html, member_row) =~ "SSO"

        change_role(lv, member.email, "owner")
        html = render(lv)

        assert html =~ "User must have 2FA enabled to become an owner"
      end
    end
  end

  describe "live" do
    setup [:create_user, :log_in, :create_team, :setup_team]

    test "renders member, immediately delivers invitation", %{conn: conn, user: user, team: team} do
      {lv, html} = get_liveview(conn, with_html?: true)
      member_row1 = find(html, "#{member_el()}:nth-of-type(1)") |> text()
      assert member_row1 =~ "#{user.name}"
      assert member_row1 =~ "#{user.email}"
      assert member_row1 =~ "You"

      add_invite(lv, "[email protected]", "admin")

      html = render(lv)

      assert text(html) =~ "[email protected] has been invited"

      member_row1 = find(html, "#{member_el()}:nth-of-type(1)") |> text()
      assert member_row1 =~ "[email protected]"
      assert member_row1 =~ "Pending invitation"

      member_row2 = find(html, "#{member_el()}:nth-of-type(2)") |> text()
      assert member_row2 =~ "#{user.name}"
      assert member_row2 =~ "#{user.email}"

      assert_email_delivered_with(
        to: [nil: "[email protected]"],
        subject: @subject_prefix <> "You've been invited to \"#{team.name}\" team"
      )
    end

    test "allows updating membership role in place", %{conn: conn, team: team, user: user} do
      member2 = add_member(team, role: :admin)
      lv = get_liveview(conn)

      html = render(lv)

      self_row = "#member-row-#{:erlang.phash2(user.email)}"
      member2_row = "#member-row-#{:erlang.phash2(member2.email)}"

      assert text_of_element(html, "#{self_row} #{role_el()}") == "Owner"
      assert text_of_element(html, "#{member2_row} #{role_el()}") == "Admin"

      change_role(lv, member2.email, "viewer")
      html = render(lv)

      assert text_of_element(html, "#{member2_row} #{role_el()}") == "Viewer"
      assert text(html) =~ "#{member2.email}'s role has been changed to Viewer"

      assert_no_emails_delivered()

      assert_team_membership(member2, team, :viewer)
    end

    test "allows updating guest membership so it moves sections", %{conn: conn, team: team} do
      site = new_site(team: team)
      add_guest(site, role: :viewer, user: new_user(name: "Mr Guest", email: "[email protected]"))

      lv = get_liveview(conn)

      html = render(lv)

      assert elem_count(html, member_el()) == 1

      assert text_of_element(html, "#{guest_el()}:first-of-type #{role_el()}") ==
               "Guest"

      change_role(lv, "[email protected]", "viewer")
      html = render(lv)

      assert elem_count(html, member_el()) == 2
      refute element_exists?(html, "#guest-list")
    end

    @tag :ee_only
    test "fails to save layout with limits breached", %{conn: conn, team: team} do
      insert(:growth_subscription, team: team)

      lv = get_liveview(conn)
      add_invite(lv, "[email protected]", "admin")
      add_invite(lv, "[email protected]", "admin")
      add_invite(lv, "[email protected]", "admin")
      add_invite(lv, "[email protected]", "admin")

      assert lv |> render() |> text() =~ "Your account is limited to 3 team members"
      assert Enum.count(Plausible.Teams.Invitations.pending_team_invitations_for(team)) == 3
    end

    test "fails to invite an e-mail belonging to an existing team member (e.g. yourself)", %{
      conn: conn,
      user: user
    } do
      lv = get_liveview(conn)
      add_invite(lv, user.email, "admin")

      assert lv |> render() |> text() =~
               "Error! Make sure the e-mail is valid and not already taken by an existing member or invitation"
    end

    test "fails to invite an e-mail that already has a pending invitation", %{
      conn: conn,
      user: user,
      team: team
    } do
      invitation = invite_member(team, "[email protected]", inviter: user, role: :viewer)

      lv = get_liveview(conn)
      add_invite(lv, "[email protected]", "admin")

      assert lv |> render() |> text() =~
               "Error! Make sure the e-mail is valid and not already taken by an existing member or invitation"

      assert Plausible.Repo.reload!(invitation).role == :viewer
    end

    test "fails to invite a guest's e-mail", %{conn: conn, team: team} do
      site = new_site(team: team)
      add_guest(site, role: :viewer, user: new_user(email: "[email protected]"))

      lv = get_liveview(conn)
      add_invite(lv, "[email protected]", "admin")

      assert lv |> render() |> text() =~
               "This e-mail belongs to a guest. Please change their role below"

      assert [] =
               team
               |> Plausible.Teams.Invitations.pending_team_invitations_for()
               |> Enum.filter(&(&1.role != :guest))
    end

    test "fails to invite an e-mail with a pending guest invitation", %{
      conn: conn,
      user: user,
      team: team
    } do
      site = new_site(team: team)
      invite_guest(site, "[email protected]", role: :viewer, inviter: user)

      lv = get_liveview(conn)
      add_invite(lv, "[email protected]", "admin")

      assert lv |> render() |> text() =~
               "This e-mail is already invited as a guest. To invite them to the team, please delete the guest invitation first."

      assert [%{role: :guest}] = Plausible.Teams.Invitations.pending_team_invitations_for(team)
    end

    test "allows updating a pending invitation's role in place", %{
      conn: conn,
      user: user,
      team: team
    } do
      invitation = invite_member(team, "[email protected]", inviter: user, role: :viewer)

      lv = get_liveview(conn)
      change_role(lv, "[email protected]", "editor")

      assert lv |> render() |> text() =~
               "The invitation for [email protected] now has the Editor role"

      assert Plausible.Repo.reload!(invitation).role == :editor
      assert_no_emails_delivered()
    end

    test "shows a success message after removing a member", %{conn: conn, team: team} do
      member = add_member(team, role: :viewer)

      lv = get_liveview(conn)
      remove_member(lv, member.email)

      assert lv |> render() |> text() =~ "#{member.email} has been removed from the team"
    end

    test "shows a success message after removing a pending invitation", %{
      conn: conn,
      user: user,
      team: team
    } do
      invite_member(team, "[email protected]", inviter: user, role: :viewer)

      lv = get_liveview(conn)
      remove_member(lv, "[email protected]")

      assert lv |> render() |> text() =~ "The invitation for [email protected] has been removed"
    end

    @tag :ee_only
    test "allows removing any type of entry (EE)", %{
      conn: conn,
      user: user,
      team: team
    } do
      member2 = add_member(team, role: :admin)
      _invitation = invite_member(team, "[email protected]", inviter: user, role: :viewer)

      site = new_site(team: team)

      guest =
        add_guest(site,
          role: :viewer,
          user: new_user(name: "Mr Guest", email: "[email protected]")
        )

      lv = get_liveview(conn)
      add_invite(lv, "[email protected]", "admin")

      html = render(lv)

      assert elem_count(html, member_el()) == 4
      assert elem_count(html, guest_el()) == 1

      pending_email = "[email protected]"
      sent_email = "[email protected]"

      pending = text_of_element(html, "#member-row-#{:erlang.phash2(pending_email)}")
      sent = text_of_element(html, "#member-row-#{:erlang.phash2(sent_email)}")
      owner = text_of_element(html, "#member-row-#{:erlang.phash2(user.email)}")
      admin = text_of_element(html, "#member-row-#{:erlang.phash2(member2.email)}")

      guest_member = find(html, "#{guest_el()}:first-of-type") |> text()

      assert pending =~ "Pending invitation"
      assert sent =~ "Pending invitation"
      assert owner =~ "Owner"
      assert admin != ""
      assert guest_member =~ "Guest"

      remove_member(lv, pending_email)
      remove_member(lv, sent_email)
      remove_member(lv, member2.email)

      # remove guest
      remove_member(lv, guest.email)

      html = render(lv) |> text()

      refute html =~ "Pending invitation"
      refute html =~ "Guest"

      html = render(lv)

      assert elem_count(html, member_el()) == 1
      refute element_exists?(html, "#guest-list")

      assert_email_delivered_with(
        to: [nil: "[email protected]"],
        subject: @subject_prefix <> "You've been invited to \"#{team.name}\" team"
      )

      assert_email_delivered_with(
        to: [nil: member2.email],
        subject: @subject_prefix <> "Your access to \"#{team.name}\" team has been revoked"
      )

      assert_email_delivered_with(
        to: [nil: guest.email],
        subject: @subject_prefix <> "Your access to \"#{team.name}\" team has been revoked"
      )

      assert_no_emails_delivered()
    end

    @tag :ce_build_only
    test "allows removing any type of entry (CE)", %{
      conn: conn,
      user: user,
      team: team
    } do
      member2 = add_member(team, role: :admin)
      _invitation = invite_member(team, "[email protected]", inviter: user, role: :viewer)

      site = new_site(team: team)

      guest =
        add_guest(site,
          role: :viewer,
          user: new_user(name: "Mr Guest", email: "[email protected]")
        )

      lv = get_liveview(conn)

      html = render(lv)

      assert elem_count(html, member_el()) == 3
      assert elem_count(html, guest_el()) == 1

      sent_email = "[email protected]"

      sent = text_of_element(html, "#member-row-#{:erlang.phash2(sent_email)}")
      owner = text_of_element(html, "#member-row-#{:erlang.phash2(user.email)}")
      admin = text_of_element(html, "#member-row-#{:erlang.phash2(member2.email)}")

      guest_member = find(html, "#{guest_el()}:first-of-type") |> text()

      assert sent =~ "Pending invitation"
      assert owner =~ "Owner"
      assert admin != ""
      assert guest_member =~ "Guest"

      remove_member(lv, sent_email)
      remove_member(lv, member2.email)

      # remove guest
      remove_member(lv, guest.email)

      html = render(lv) |> text()

      refute html =~ "Pending invitation"
      refute html =~ "Guest"

      html = render(lv)

      assert elem_count(html, member_el()) == 1
      refute element_exists?(html, "#guest-list")

      assert_email_delivered_with(
        to: [nil: member2.email],
        subject: @subject_prefix <> "Your access to \"#{team.name}\" team has been revoked"
      )

      assert_email_delivered_with(
        to: [nil: guest.email],
        subject: @subject_prefix <> "Your access to \"#{team.name}\" team has been revoked"
      )

      assert_no_emails_delivered()
    end

    test "guest->owner promotion",
         %{
           conn: conn,
           user: user,
           team: team
         } do
      site = new_site(team: team)

      member2 =
        add_guest(site,
          role: :viewer,
          user: new_user(name: "Mr Guest", email: "[email protected]")
        )

      lv = get_liveview(conn)

      change_role(lv, member2.email, "owner")
      html = render(lv)

      refute html =~ "Error!"

      assert_team_membership(user, team, :owner)
      assert_team_membership(member2, team, :owner)

      assert_email_delivered_with(
        to: [nil: member2.email],
        subject: @subject_prefix <> "Welcome to \"#{team.name}\" team"
      )
    end

    test "multiple-owners",
         %{
           conn: conn,
           team: team,
           user: user
         } do
      member2 = add_member(team, role: :admin)

      lv = get_liveview(conn)

      change_role(lv, member2.email, "owner")
      html = render(lv)

      refute html =~ "Error!"

      assert_team_membership(user, team, :owner)
      assert_team_membership(member2, team, :owner)
    end

    test "remove member items carry data-confirm for both self and others", %{
      conn: conn,
      team: team,
      user: user
    } do
      member2 = add_member(team, role: :owner)

      lv = get_liveview(conn)
      html = render(lv)

      assert attr_defined?(html, "##{:erlang.phash2(user.email)}-remove", "data-confirm")
      assert attr_defined?(html, "##{:erlang.phash2(member2.email)}-remove", "data-confirm")
    end

    test "self-demotion role items carry data-confirm-message, others do not", %{
      conn: conn,
      team: team,
      user: user
    } do
      # Second owner is required so the current user's own dropdown is not disabled
      member2 = add_member(team, role: :owner)

      lv = get_liveview(conn)
      html = render(lv)

      my_hash = :erlang.phash2(user.email)
      other_hash = :erlang.phash2(member2.email)

      for role <- ~w(editor billing viewer) do
        assert attr_defined?(html, "#option-#{my_hash}-#{role}", "data-confirm-message"),
               "expected data-confirm-message on self #{role} item"

        refute attr_defined?(html, "#option-#{other_hash}-#{role}", "data-confirm-message"),
               "expected no data-confirm-message on other member #{role} item"
      end

      for role <- ~w(owner admin) do
        refute attr_defined?(html, "#option-#{my_hash}-#{role}", "data-confirm-message"),
               "expected no data-confirm-message on self #{role} item"
      end
    end

    test "removes self, redirecting away from team", %{conn: conn, team: team, user: user} do
      _owner2 = add_member(team, role: :owner)

      lv = get_liveview(conn)

      remove_member(lv, user.email)

      flash = assert_redirect(lv, "/sites?__team=none")
      assert flash["success"] == "You have left the team"
      assert {:error, :not_a_member} = Plausible.Teams.Memberships.team_role(team, user)
    end

    test "demotes self to billing, redirecting to team general", %{
      conn: conn,
      team: team,
      user: user
    } do
      _owner2 = add_member(team, role: :owner)

      lv = get_liveview(conn)

      change_role(lv, user.email, "billing")

      assert_redirect(lv, "/settings/team/general?__team=#{team.identifier}")
    end

    test "demotes self to viewer, redirecting to team general", %{
      conn: conn,
      team: team,
      user: user
    } do
      _owner2 = add_member(team, role: :owner)

      lv = get_liveview(conn)

      change_role(lv, user.email, "viewer")

      assert_redirect(lv, "/settings/team/general?__team=#{team.identifier}")
    end

    test "billing role is supported",
         %{
           conn: conn,
           team: team
         } do
      member2 = add_member(team, role: :admin)

      lv = get_liveview(conn)

      change_role(lv, member2.email, "billing")
      assert_team_membership(member2, team, :billing)
    end

    test "demotes self to editor, redirecting to team general", %{
      conn: conn,
      team: team,
      user: user
    } do
      _owner2 = add_member(team, role: :owner)

      lv = get_liveview(conn)

      change_role(lv, user.email, "editor")

      assert_redirect(lv, "/settings/team/general?__team=#{team.identifier}")
    end
  end

  defp change_role(lv, email, role) do
    lv
    |> element(~s|#role-form-#{:erlang.phash2(email)}|)
    |> render_change(%{"role" => role})
  end

  defp remove_member(lv, email) do
    lv
    |> element(~s|##{:erlang.phash2(email)}-remove|)
    |> render_click()
  end

  defp add_invite(lv, email, role) do
    lv
    |> element("#team-layout-form")
    |> render_submit(%{
      "input-email" => email,
      "input-role" => role
    })
  end

  defp get_liveview(conn, opts \\ []) do
    conn = assign(conn, :live_module, PlausibleWeb.Live.TeamManagement)
    {:ok, lv, html} = live(conn, team_general_path())

    if Keyword.get(opts, :with_html?) do
      {lv, html}
    else
      lv
    end
  end

  defp member_el() do
    ~s|#member-list div[data-test-kind="member"]|
  end

  defp guest_el() do
    ~s|#guest-list div[data-test-kind="guest"]|
  end

  defp role_el() do
    ~s|[data-testid="role"]|
  end

  defp role_dropdown_el(email) do
    ~s|[id="role-dropdown-#{email}"]|
  end

  defp remove_button_el(email) do
    ~s|[id="#{:erlang.phash2(email)}-remove"]|
  end
end