Skip to content

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

[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.ex
index 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) do
with :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)
end
end
@@ -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) do
Repo.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 do
String.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 do
Teams.Invitations.invite(team, invitee_email, role, inviter)
end
end
-
- defp do_invite(_team, _inviter, _invitee_email, role, _opts) do
- raise "Invalid role passed: #{inspect(role)}"
- end
end
diff --git a/lib/plausible/teams/invitations/update_role.ex b/lib/plausible/teams/invitations/update_role.ex
new file mode 100644
index 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
+end
diff --git a/lib/plausible/teams/memberships/update_role.ex b/lib/plausible/teams/memberships/update_role.ex
index 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 do
alias Plausible.Teams
alias 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) do
new_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 do
team_membership.user.email
|> PlausibleWeb.Email.guest_to_team_member_promotion(
team,
@@ -71,14 +66,6 @@ defmodule Plausible.Teams.Memberships.UpdateRole do
end
end
- 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 do
if Memberships.owners_count(team) > 1 do
:ok
@@ -89,47 +76,6 @@ defmodule Plausible.Teams.Memberships.UpdateRole do
defp 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: :ok
diff --git a/lib/plausible/teams/team_role_permissions.ex b/lib/plausible/teams/team_role_permissions.ex
new file mode 100644
index 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
+end
diff --git a/test/plausible/teams/invitations/invite_to_team_test.exs b/test/plausible/teams/invitations/invite_to_team_test.exs
index 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 do
end
end
- describe "invite_all/3,4" do
+ describe "invite_all/3" do
test "creates invitations with a role per entry, without sending e-mails" do
inviter = new_user()
invitee = new_user()
@@ -364,14 +364,28 @@ defmodule Plausible.Teams.Invitations.InviteToTeamTest do
end
end
- test "raises on invalid role" do
+ test "raises for an invalid role" do
inviter = 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]")
end
end
diff --git a/test/plausible/teams/invitations/update_role_test.exs b/test/plausible/teams/invitations/update_role_test.exs
new file mode 100644
index 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
+end
diff --git a/test/plausible/teams/memberships/update_role_test.exs b/test/plausible/teams/memberships/update_role_test.exs
index 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 do
assert_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" do
user = new_user()
_site = new_site(owner: user)
@@ -55,19 +42,6 @@ defmodule Plausible.Teams.Memberships.UpdateRoleTest do
assert_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" do
user = new_user()
owner = new_user()
@@ -82,23 +56,6 @@ defmodule Plausible.Teams.Memberships.UpdateRoleTest do
assert_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" do
user = new_user()
owner = new_user()
diff --git a/test/plausible/teams/team_role_permissions_test.exs b/test/plausible/teams/team_role_permissions_test.exs
new file mode 100644
index 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