Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
[Step 2]: Rework team layout persist (#6779)
RobertJoonas2a02ec240231
diff --git a/lib/plausible/teams/invitations/invite_to_team.ex b/lib/plausible/teams/invitations/invite_to_team.exindex 22e43ef182..3492165c78 100644--- a/lib/plausible/teams/invitations/invite_to_team.ex+++ b/lib/plausible/teams/invitations/invite_to_team.ex@@ -47,13 +47,12 @@ defmodule Plausible.Teams.Invitations.InviteToTeam do@spec invite_all(Teams.Team.t(),Plausible.Auth.User.t(),- [invite_entry()],- Keyword.t()+ [invite_entry()]) ::{:ok, [Teams.Invitation.t()]} | {:error, any()}- def invite_all(team, inviter, entries, opts \\ []) do+ def invite_all(team, inviter, entries) dowith :ok <- validate_emails(Enum.map(entries, & &1.email)) do- do_invite_all(Repo.preload(team, [:owners]), inviter, entries, opts)+ do_invite_all(Repo.preload(team, [:owners]), inviter, entries)endend@@ -71,10 +70,10 @@ defmodule Plausible.Teams.Invitations.InviteToTeam do|> Teams.Invitations.send_invitation_email(invitee)end- defp do_invite_all(team, inviter, entries, opts) do+ defp do_invite_all(team, inviter, entries) doRepo.transact(fn ->Enum.reduce_while(entries, {:ok, []}, fn entry, {:ok, invitations} ->- case do_invite(team, inviter, entry.email, entry.role, opts) do+ case do_invite(team, inviter, entry.email, entry.role) do{:ok, invitation} -> {:cont, {:ok, invitations ++ [invitation]}}{:error, _} = error -> {:halt, error}end@@ -95,8 +94,9 @@ defmodule Plausible.Teams.Invitations.InviteToTeam doString.contains?(email, "@") and String.contains?(email, ".")end- defp do_invite(team, inviter, invitee_email, role, opts) when role in @valid_roles do- with :ok <- Teams.Invitations.check_invitation_permissions(team, inviter, role, opts),+ defp do_invite(team, inviter, invitee_email, role) do+ with :ok <-+ Teams.TeamRolePermissions.ensure_can_grant_for_invitation(team, inviter, nil, role),:ok <- Teams.Invitations.check_team_member_limit(team, role, invitee_email),invitee = Plausible.Auth.find_user_by(email: invitee_email),:ok <- Teams.Invitations.ensure_new_membership(team, invitee, role),@@ -104,8 +104,4 @@ defmodule Plausible.Teams.Invitations.InviteToTeam doTeams.Invitations.invite(team, invitee_email, role, inviter)endend-- defp do_invite(_team, _inviter, _invitee_email, role, _opts) do- raise "Invalid role passed: #{inspect(role)}"- endenddiff --git a/lib/plausible/teams/invitations/update_role.ex b/lib/plausible/teams/invitations/update_role.exnew file mode 100644index 0000000000..c152aaac27--- /dev/null+++ b/lib/plausible/teams/invitations/update_role.ex@@ -0,0 +1,39 @@+defmodule Plausible.Teams.Invitations.UpdateRole do+ @moduledoc """+ Service for changing the role of a pending team invitation.++ This edits an invitation that already exists, so no e-mail is sent and+ the invitation keeps its original expiry.++ Guest invitations can't be promoted to team invitations this way because+ otherwise the link in the invitation e-mail would stop working.+ """++ alias Plausible.{Repo, Teams}++ @spec update(Teams.Team.t(), String.t(), atom(), Plausible.Auth.User.t()) ::+ {:ok, Teams.Invitation.t()}+ | {:error,+ :permission_denied+ | :invitation_not_found+ | :guest_invitation+ | Ecto.Changeset.t()}+ def update(%Teams.Team{} = team, invitation_id, new_role, current_user) do+ with {:ok, invitation} <- Teams.Invitations.get_team_invitation(team, invitation_id),+ :ok <- ensure_team_invitation(invitation),+ :ok <-+ Teams.TeamRolePermissions.ensure_can_grant_for_invitation(+ team,+ current_user,+ invitation,+ new_role+ ) do+ invitation+ |> Ecto.Changeset.change(role: new_role)+ |> Repo.update()+ end+ end++ defp ensure_team_invitation(%Teams.Invitation{role: :guest}), do: {:error, :guest_invitation}+ defp ensure_team_invitation(%Teams.Invitation{}), do: :ok+enddiff --git a/lib/plausible/teams/memberships/update_role.ex b/lib/plausible/teams/memberships/update_role.exindex e1aa9bcacd..736cc33732 100644--- a/lib/plausible/teams/memberships/update_role.ex+++ b/lib/plausible/teams/memberships/update_role.ex@@ -9,26 +9,21 @@ defmodule Plausible.Teams.Memberships.UpdateRole doalias Plausible.Teamsalias Plausible.Teams.Memberships- def update(nil, _, _, _), do: {:error, :permission_denied}-- def update(team, user_id, new_role_str, current_user) do+ def update(%Teams.Team{} = team, user_id, new_role_str, current_user) donew_role = String.to_existing_atom(new_role_str)- with :ok <- check_valid_role(new_role),- {:ok, team_membership} <- Memberships.get_team_membership(team, user_id),- {:ok, current_user_role} <- Memberships.team_role(team, current_user),- granting_to_self? = team_membership.user_id == current_user.id,+ with {:ok, team_membership} <- Memberships.get_team_membership(team, user_id),:ok <-- check_can_grant_role(- current_user_role,- team_membership.role,- new_role,- granting_to_self?+ Teams.TeamRolePermissions.ensure_can_grant_for_member(+ team,+ current_user,+ team_membership,+ new_role),:ok <- check_owner_can_get_demoted(team, team_membership.role, new_role),team_membership = Repo.preload(team_membership, :user),:ok <- check_can_promote_to_owner(team, team_membership.user, new_role) do- if team_membership.role == :guest and new_role != :guest do+ if team_membership.role == :guest doteam_membership.user.email|> PlausibleWeb.Email.guest_to_team_member_promotion(team,@@ -71,14 +66,6 @@ defmodule Plausible.Teams.Memberships.UpdateRole doendend- defp check_valid_role(role) do- if role in (Teams.Membership.roles() -- [:guest]) do- :ok- else- {:error, :invalid_role}- end- end-defp check_owner_can_get_demoted(team, :owner, new_role) when new_role != :owner doif Memberships.owners_count(team) > 1 do:ok@@ -89,47 +76,6 @@ defmodule Plausible.Teams.Memberships.UpdateRole dodefp check_owner_can_get_demoted(_team, _current_role, _new_role), do: :ok- defp check_can_grant_role(user_role, _from_role, to_role, true) do- if can_grant_role_to_self?(user_role, to_role) do- :ok- else- {:error, :permission_denied}- end- end-- defp check_can_grant_role(user_role, from_role, to_role, false) do- if can_grant_role_to_other?(user_role, from_role, to_role) do- :ok- else- {:error, :permission_denied}- end- end-- defp can_grant_role_to_self?(:owner, :admin), do: true- defp can_grant_role_to_self?(:owner, :editor), do: true- defp can_grant_role_to_self?(:owner, :viewer), do: true- defp can_grant_role_to_self?(:owner, :billing), do: true- defp can_grant_role_to_self?(:admin, :editor), do: true- defp can_grant_role_to_self?(:admin, :viewer), do: true- defp can_grant_role_to_self?(:admin, :billing), do: true- defp can_grant_role_to_self?(_, _), do: false-- defp can_grant_role_to_other?(:owner, _, _), do: true- defp can_grant_role_to_other?(:admin, :admin, :admin), do: true- defp can_grant_role_to_other?(:admin, :admin, :editor), do: true- defp can_grant_role_to_other?(:admin, :admin, :viewer), do: true- defp can_grant_role_to_other?(:admin, :admin, :billing), do: true- defp can_grant_role_to_other?(:admin, :editor, :admin), do: true- defp can_grant_role_to_other?(:admin, :editor, :editor), do: true- defp can_grant_role_to_other?(:admin, :editor, :viewer), do: true- defp can_grant_role_to_other?(:admin, :editor, :billing), do: true- defp can_grant_role_to_other?(:admin, :viewer, :admin), do: true- defp can_grant_role_to_other?(:admin, :viewer, :editor), do: true- defp can_grant_role_to_other?(:admin, :viewer, :viewer), do: true- defp can_grant_role_to_other?(:admin, :viewer, :billing), do: true- defp can_grant_role_to_other?(:admin, :billing, :billing), do: true- defp can_grant_role_to_other?(_, _, _), do: false-defp maybe_prune_guest_memberships(%Teams.Membership{role: :guest}),do: :okdiff --git a/lib/plausible/teams/team_role_permissions.ex b/lib/plausible/teams/team_role_permissions.exnew file mode 100644index 0000000000..051abc3ef2--- /dev/null+++ b/lib/plausible/teams/team_role_permissions.ex@@ -0,0 +1,125 @@+defmodule Plausible.Teams.TeamRolePermissions do+ @moduledoc """+ Rules for who is allowed to give which team role to whom.++ Split into two independent questions: whose role the granter may change+ at all (`ensure_can_change_role/3`), and which roles they may give+ (`ensure_can_grant_role/2`). A change is allowed when both pass.++ Rules that depend on the team's state rather than on who's asking (the+ last owner can't be demoted, owners need 2FA when the team enforces it,+ etc) should stay in the services that make the change.+ """++ alias Plausible.Auth+ alias Plausible.Teams+ alias Plausible.Teams.Membership++ @roles Membership.roles()+ @assignable_roles List.delete(@roles, :guest)+ @assignable_by_admins List.delete(@assignable_roles, :owner)++ @types [:membership, :invitation]++ @type assignable_role() :: :owner | :admin | :editor | :viewer | :billing++ @doc """+ Checks whether `granter` may change `membership`'s role to `to_role`.++ Changing your own role follows the same rules as changing the role of+ someone who has the same role as you.+ """+ @spec ensure_can_grant_for_member(+ Teams.Team.t(),+ Auth.User.t(),+ Membership.t(),+ assignable_role()+ ) :: :ok | {:error, :permission_denied}+ def ensure_can_grant_for_member(team, granter, %Membership{} = membership, to_role) do+ with {:ok, granter_role} <- get_granter_role(team, granter),+ :ok <- ensure_can_change_role(:membership, granter_role, membership.role) do+ ensure_can_grant_role(granter_role, to_role)+ end+ end++ @doc """+ Checks whether `granter` may give a team invitation the role `to_role`.+ `invitation` is the pending invitation being changed, or `nil` when a new+ invitation is being created.+ """+ @spec ensure_can_grant_for_invitation(+ Teams.Team.t(),+ Auth.User.t(),+ Teams.Invitation.t() | nil,+ assignable_role()+ ) :: :ok | {:error, :permission_denied}+ def ensure_can_grant_for_invitation(team, granter, invitation, to_role) do+ with {:ok, granter_role} <- get_granter_role(team, granter),+ :ok <- ensure_can_change_role(:invitation, granter_role, invitation_role(invitation)) do+ ensure_can_grant_role(granter_role, to_role)+ end+ end++ @doc """+ Checks whether someone with `granter_role` may change the role of a membership+ or an invitation. `current_role` is `nil` when a new invitation is being+ created.+ """+ @spec ensure_can_change_role(+ :membership | :invitation,+ Membership.role(),+ Membership.role() | nil+ ) ::+ :ok | {:error, :permission_denied}+ def ensure_can_change_role(type, granter_role, current_role)++ def ensure_can_change_role(type, _granter_role, _current_role) when type not in @types,+ do: raise(ArgumentError, "unknown type: #{inspect(type)}")++ def ensure_can_change_role(_type, :owner, _current_role), do: :ok++ # Creating a new invitation: there's nobody whose role would change yet+ def ensure_can_change_role(:invitation, :admin, nil), do: :ok++ def ensure_can_change_role(_type, :admin, current_role)+ when current_role in [:admin, :editor, :viewer],+ do: :ok++ # Admins can't change a billing member's role: billing members have access to+ # the subscription, which admins don't. A pending billing invitation doesn't+ # give access to anything yet, so admins can change it like any other+ # non-owner invitation.+ def ensure_can_change_role(:invitation, :admin, :billing), do: :ok++ def ensure_can_change_role(_type, _granter_role, _current_role),+ do: {:error, :permission_denied}++ @doc """+ Checks whether someone with `granter_role` may give anyone the role `to_role`.+ A role that can't be assigned (anything other than owner, admin, editor,+ viewer or billing) raises an `ArgumentError`, whoever is asking.+ """+ @spec ensure_can_grant_role(Membership.role(), assignable_role()) ::+ :ok | {:error, :permission_denied}+ def ensure_can_grant_role(granter_role, to_role)++ def ensure_can_grant_role(_granter_role, to_role) when to_role not in @assignable_roles,+ do: raise(ArgumentError, "invalid role: #{inspect(to_role)}")++ def ensure_can_grant_role(:owner, _to_role), do: :ok+ def ensure_can_grant_role(:admin, to_role) when to_role in @assignable_by_admins, do: :ok++ def ensure_can_grant_role(_granter_role, _to_role),+ do: {:error, :permission_denied}++ defp invitation_role(nil), do: nil+ defp invitation_role(%Teams.Invitation{role: role}), do: role++ # Not being a member of the team counts as not having permission+ defp get_granter_role(team, granter) do+ case Teams.Memberships.team_role(team, granter) do+ {:ok, granter_role} -> {:ok, granter_role}+ {:error, :not_a_member} -> {:error, :permission_denied}+ end+ end+enddiff --git a/test/plausible/teams/invitations/invite_to_team_test.exs b/test/plausible/teams/invitations/invite_to_team_test.exsindex d96799513b..2195dcc890 100644--- a/test/plausible/teams/invitations/invite_to_team_test.exs+++ b/test/plausible/teams/invitations/invite_to_team_test.exs@@ -217,7 +217,7 @@ defmodule Plausible.Teams.Invitations.InviteToTeamTest doendend- describe "invite_all/3,4" do+ describe "invite_all/3" dotest "creates invitations with a role per entry, without sending e-mails" doinviter = new_user()invitee = new_user()@@ -364,14 +364,28 @@ defmodule Plausible.Teams.Invitations.InviteToTeamTest doendend- test "raises on invalid role" do+ test "raises for an invalid role" doinviter = new_user()_site = new_site(owner: inviter)team = team_of(inviter)- assert_raise RuntimeError, ~r/Invalid role/, fn ->+ assert_raise ArgumentError, "invalid role: :guest", fn ->InviteToTeam.invite_all(team, inviter, [%{email: "[email protected]", role: :guest}])end++ refute Repo.get_by(Teams.Invitation, team_id: team.id, email: "[email protected]")+ end++ test "returns error when the inviter isn't allowed to give the role" do+ owner = new_user()+ _site = new_site(owner: owner)+ team = team_of(owner)+ admin = add_member(team, role: :admin)++ assert {:error, :permission_denied} =+ InviteToTeam.invite_all(team, admin, [%{email: "[email protected]", role: :owner}])++ refute Repo.get_by(Teams.Invitation, team_id: team.id, email: "[email protected]")endenddiff --git a/test/plausible/teams/invitations/update_role_test.exs b/test/plausible/teams/invitations/update_role_test.exsnew file mode 100644index 0000000000..e9e0a555fc--- /dev/null+++ b/test/plausible/teams/invitations/update_role_test.exs@@ -0,0 +1,66 @@+defmodule Plausible.Teams.Invitations.UpdateRoleTest do+ use Plausible.DataCase, async: true+ use Bamboo.Test++ alias Plausible.Teams+ alias Plausible.Teams.Invitations.UpdateRole++ describe "update/4" do+ setup [:create_user, :create_team]++ test "changes the role of a pending team invitation without sending an e-mail", %{+ user: owner,+ team: team+ } do+ invitation = invite_member(team, "[email protected]", role: :viewer, inviter: owner)++ assert {:ok, %Teams.Invitation{role: :editor}} =+ UpdateRole.update(team, invitation.invitation_id, :editor, owner)++ updated = Repo.reload!(invitation)+ assert updated.role == :editor+ assert updated.inserted_at == invitation.inserted_at+ assert_no_emails_delivered()+ end++ test "returns error for a guest invitation and leaves it unchanged", %{+ user: owner,+ team: team+ } do+ site = new_site(team: team)+ guest_invitation = invite_guest(site, "[email protected]", role: :viewer, inviter: owner)+ team_invitation = guest_invitation.team_invitation++ assert {:error, :guest_invitation} =+ UpdateRole.update(team, team_invitation.invitation_id, :editor, owner)++ team_invitation = team_invitation |> Repo.reload!() |> Repo.preload(:guest_invitations)+ assert team_invitation.role == :guest+ assert [_] = team_invitation.guest_invitations+ end++ test "returns error when the invitation belongs to another team", %{user: owner, team: team} do+ other_owner = new_user()+ {:ok, other_team} = Plausible.Teams.get_or_create(other_owner)++ invitation =+ invite_member(other_team, "[email protected]", role: :viewer, inviter: other_owner)++ assert {:error, :invitation_not_found} =+ UpdateRole.update(team, invitation.invitation_id, :editor, owner)+ end++ test "returns error when the granter isn't allowed to make the change", %{+ user: owner,+ team: team+ } do+ admin = add_member(team, role: :admin)+ invitation = invite_member(team, "[email protected]", role: :owner, inviter: owner)++ assert {:error, :permission_denied} =+ UpdateRole.update(team, invitation.invitation_id, :viewer, admin)++ assert Repo.reload!(invitation).role == :owner+ end+ end+enddiff --git a/test/plausible/teams/memberships/update_role_test.exs b/test/plausible/teams/memberships/update_role_test.exsindex 060b754709..19651ff688 100644--- a/test/plausible/teams/memberships/update_role_test.exs+++ b/test/plausible/teams/memberships/update_role_test.exs@@ -19,19 +19,6 @@ defmodule Plausible.Teams.Memberships.UpdateRoleTest doassert_team_membership(collaborator, team, :viewer)end- test "owner can promote another member to owner" do- user = new_user()- _site = new_site(owner: user)- team = team_of(user)- collaborator = add_member(team, role: :editor)- assert_team_membership(collaborator, team, :editor)-- assert {:ok, _} = UpdateRole.update(team, collaborator.id, "owner", user)-- assert_team_membership(collaborator, team, :owner)- assert_no_emails_delivered()- end-test "can demote self when an owner" douser = new_user()_site = new_site(owner: user)@@ -55,19 +42,6 @@ defmodule Plausible.Teams.Memberships.UpdateRoleTest doassert_no_emails_delivered()end- test "can demote self when an admin" do- user = new_user()- owner = new_user()- _site = new_site(owner: owner)- team = team_of(owner)- _admin = add_member(team, user: user, role: :admin)-- assert {:ok, _} = UpdateRole.update(team, user.id, "viewer", user)-- assert_team_membership(user, team, :viewer)- assert_no_emails_delivered()- end-test "admin can't update role of an owner" douser = new_user()owner = new_user()@@ -82,23 +56,6 @@ defmodule Plausible.Teams.Memberships.UpdateRoleTest doassert_no_emails_delivered()end- for role <- Plausible.Teams.Membership.roles() -- [:owner, :admin] do- test "#{role} can't update role of a member" do- user = new_user()- owner = new_user()- _site = new_site(owner: owner)- team = team_of(owner)- _member = add_member(team, user: user, role: unquote(role))- another_member = add_member(team, role: :viewer)-- assert {:error, :permission_denied} =- UpdateRole.update(team, another_member.id, "editor", user)-- assert_team_membership(another_member, team, :viewer)- assert_no_emails_delivered()- end- end-test "guest->member promotion sends out an e-mail" douser = new_user()owner = new_user()diff --git a/test/plausible/teams/team_role_permissions_test.exs b/test/plausible/teams/team_role_permissions_test.exsnew file mode 100644index 0000000000..f270188823--- /dev/null+++ b/test/plausible/teams/team_role_permissions_test.exs@@ -0,0 +1,295 @@+defmodule Plausible.Teams.TeamRolePermissionsTest do+ use Plausible.DataCase, async: true++ alias Plausible.Teams.TeamRolePermissions++ @roles Plausible.Teams.Membership.roles()+ @assignable_roles List.delete(@roles, :guest)++ @as %{+ owner: "an owner",+ admin: "an admin",+ editor: "an editor",+ viewer: "a viewer",+ billing: "a billing member",+ guest: "a guest"+ }++ describe "ensure_can_change_role/3" do+ test "raises for an unknown type" do+ assert_raise ArgumentError, "unknown type: :unknown", fn ->+ TeamRolePermissions.ensure_can_change_role(:unknown, :owner, :viewer)+ end+ end+ end++ describe "ensure_can_change_role/3 for members" do+ for current_role <- @roles do+ test "as an owner, I can change the role of #{@as[current_role]}" do+ assert :ok =+ TeamRolePermissions.ensure_can_change_role(+ :membership,+ :owner,+ unquote(current_role)+ )+ end+ end++ for current_role <- [:admin, :editor, :viewer] do+ test "as an admin, I can change the role of #{@as[current_role]}" do+ assert :ok =+ TeamRolePermissions.ensure_can_change_role(+ :membership,+ :admin,+ unquote(current_role)+ )+ end+ end++ for current_role <- [:owner, :billing, :guest] do+ test "as an admin, I cannot change the role of #{@as[current_role]}" do+ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_change_role(+ :membership,+ :admin,+ unquote(current_role)+ )+ end+ end++ for granter_role <- [:editor, :viewer, :billing, :guest] do+ test "as #{@as[granter_role]}, I cannot change anyone's role" do+ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_change_role(+ :membership,+ unquote(granter_role),+ :viewer+ )+ end+ end+ end++ describe "ensure_can_change_role/3 for invitations" do+ for granter_role <- [:owner, :admin] do+ test "as #{@as[granter_role]}, I can create an invitation" do+ assert :ok =+ TeamRolePermissions.ensure_can_change_role(+ :invitation,+ unquote(granter_role),+ nil+ )+ end+ end++ for current_role <- @roles do+ test "as an owner, I can change the role of a pending #{current_role} invitation" do+ assert :ok =+ TeamRolePermissions.ensure_can_change_role(+ :invitation,+ :owner,+ unquote(current_role)+ )+ end+ end++ for current_role <- [:admin, :editor, :viewer, :billing] do+ test "as an admin, I can change the role of a pending #{current_role} invitation" do+ assert :ok =+ TeamRolePermissions.ensure_can_change_role(+ :invitation,+ :admin,+ unquote(current_role)+ )+ end+ end++ for current_role <- [:owner, :guest] do+ test "as an admin, I cannot change the role of a pending #{current_role} invitation" do+ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_change_role(+ :invitation,+ :admin,+ unquote(current_role)+ )+ end+ end++ for granter_role <- [:editor, :viewer, :billing, :guest] do+ test "as #{@as[granter_role]}, I cannot create or change invitations" do+ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_change_role(+ :invitation,+ unquote(granter_role),+ nil+ )++ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_change_role(+ :invitation,+ unquote(granter_role),+ :viewer+ )+ end+ end+ end++ describe "ensure_can_grant_role/2" do+ for to_role <- @assignable_roles do+ test "as an owner, I can grant the #{to_role} role" do+ assert :ok = TeamRolePermissions.ensure_can_grant_role(:owner, unquote(to_role))+ end+ end++ for to_role <- [:admin, :editor, :viewer, :billing] do+ test "as an admin, I can grant the #{to_role} role" do+ assert :ok = TeamRolePermissions.ensure_can_grant_role(:admin, unquote(to_role))+ end+ end++ test "as an admin, I cannot grant the owner role" do+ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_grant_role(:admin, :owner)+ end++ for granter_role <- [:editor, :viewer, :billing, :guest] do+ test "as #{@as[granter_role]}, I cannot grant any role" do+ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_grant_role(unquote(granter_role), :viewer)+ end+ end++ for granter_role <- @roles do+ test "as #{@as[granter_role]}, I cannot grant the guest role" do+ assert_raise ArgumentError, "invalid role: :guest", fn ->+ TeamRolePermissions.ensure_can_grant_role(unquote(granter_role), :guest)+ end+ end+ end++ test "as an owner, I cannot grant an invalid role" do+ assert_raise ArgumentError, "invalid role: :unknown", fn ->+ TeamRolePermissions.ensure_can_grant_role(:owner, :unknown)+ end+ end++ test "as an owner, I cannot grant a role given as a string" do+ assert_raise ArgumentError, ~s(invalid role: "admin"), fn ->+ TeamRolePermissions.ensure_can_grant_role(:owner, "admin")+ end+ end+ end++ describe "ensure_can_grant_for_member/4" do+ setup [:create_user, :create_team]++ test "allows a change the granter's role permits", %{user: owner, team: team} do+ member = add_member(team, role: :viewer)+ membership = get_membership(team, member)++ assert :ok =+ TeamRolePermissions.ensure_can_grant_for_member(team, owner, membership, :editor)+ end++ test "denies a change the granter's role doesn't permit", %{user: owner, team: team} do+ admin = add_member(team, role: :admin)+ membership = get_membership(team, owner)++ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_grant_for_member(team, admin, membership, :viewer)+ end++ for invalid_role <- [:guest, :unknown, "admin"] do+ test "raises for an invalid role (#{inspect(invalid_role)})", %{+ user: owner,+ team: team+ } do+ member = add_member(team, role: :viewer)+ membership = get_membership(team, member)++ assert_raise ArgumentError, fn ->+ TeamRolePermissions.ensure_can_grant_for_member(+ team,+ owner,+ membership,+ unquote(invalid_role)+ )+ end+ end+ end++ test "returns permission error when the granter is not a member of the team", %{team: team} do+ member = add_member(team, role: :viewer)+ membership = get_membership(team, member)+ outsider = new_user()++ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_grant_for_member(+ team,+ outsider,+ membership,+ :editor+ )+ end+ end++ describe "ensure_can_grant_for_invitation/4" do+ setup [:create_user, :create_team]++ test "allows a role the granter's role permits", %{team: team} do+ admin = add_member(team, role: :admin)++ assert :ok = TeamRolePermissions.ensure_can_grant_for_invitation(team, admin, nil, :editor)+ end++ test "denies a role the granter's role doesn't permit", %{team: team} do+ admin = add_member(team, role: :admin)++ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_grant_for_invitation(team, admin, nil, :owner)+ end++ test "takes the current role of a pending invitation into account", %{+ user: owner,+ team: team+ } do+ admin = add_member(team, role: :admin)+ invitation = invite_member(team, "[email protected]", role: :owner, inviter: owner)++ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_grant_for_invitation(+ team,+ admin,+ invitation,+ :viewer+ )+ end++ for invalid_role <- [:guest, :unknown, "admin"] do+ test "raises for an invalid role (#{inspect(invalid_role)})", %{+ user: owner,+ team: team+ } do+ assert_raise ArgumentError, fn ->+ TeamRolePermissions.ensure_can_grant_for_invitation(+ team,+ owner,+ nil,+ unquote(invalid_role)+ )+ end+ end+ end++ test "returns permission error when the granter is not a member of the team", %{team: team} do+ outsider = new_user()++ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_grant_for_invitation(team, outsider, nil, :viewer)+ end+ end++ defp get_membership(team, user) do+ {:ok, membership} = Plausible.Teams.Memberships.get_team_membership(team, user.id)+ membership+ end+end