Fix and refactor invitation logic (#3376)

* Make membership creation and role updates more explicit in terms of changesets

* Extract invitation accept flow logic and refactor it slightly

* Improve acceptation logic

* Update moduledoc

* Improve SiteLocker API and add typespecs

* Stop naming function not returning a boolean like a predicate

* Refactor rest of invitation actions and safeguard against rogue requests

* Update code docs slightly

* Extend `Billing.check_needs_update/1` tests

* Parametrize selfhost flag and toggle SiteLocker logic on it

* Add tests for newly extracted services

* Add test case and a fix for locking site on grace period ended

* Make invitation controller tests async as there's no more env patching

* Add test cases for self-invites and fix one bug

* Add and refactor tests for rejecting and removing invitations

* Prevent issuing ownership transfer to existing owner

* Improve name of the test

* Improve `Billing.check_needs_to_upgrade/1` return value

* Improve `Billing.SiteLocker.update_sites_for/1` and its tests

* Fix typos

Co-authored-by: hq1 <hq@mtod.org>

* Make invitation removal and rejection resilient to races

---------

Co-authored-by: hq1 <hq@mtod.org>
pull/3382/head r2023.10.02-198
Adrian Gruntkowski 3 years ago committed by GitHub
parent 082ec91c63
commit e67850c11d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -73,17 +73,22 @@ defmodule Plausible.Billing do
end
end
def needs_to_upgrade?(%Plausible.Auth.User{trial_expiry_date: nil}), do: {true, :no_trial}
@spec check_needs_to_upgrade(Plausible.Auth.User.t()) ::
{:needs_to_upgrade, :no_trial | :no_active_subscription | :grace_period_ended}
| :no_upgrade_needed
def check_needs_to_upgrade(%Plausible.Auth.User{trial_expiry_date: nil}) do
{:needs_to_upgrade, :no_trial}
end
def needs_to_upgrade?(user) do
def check_needs_to_upgrade(user) do
user = Plausible.Users.with_subscription(user)
trial_is_over = Timex.before?(user.trial_expiry_date, Timex.today())
subscription_active = subscription_is_active?(user.subscription)
cond do
trial_is_over && !subscription_active -> {true, :no_active_subscription}
Plausible.Auth.GracePeriod.expired?(user) -> {true, :grace_period_ended}
true -> false
trial_is_over && !subscription_active -> {:needs_to_upgrade, :no_active_subscription}
Plausible.Auth.GracePeriod.expired?(user) -> {:needs_to_upgrade, :grace_period_ended}
true -> :no_upgrade_needed
end
end
@ -260,34 +265,14 @@ defmodule Plausible.Billing do
end
end
defp check_lock_status(user) do
Plausible.Billing.SiteLocker.check_sites_for(user)
user
end
defp maybe_adjust_api_key_limits(user) do
plan =
Repo.get_by(Plausible.Billing.EnterprisePlan,
user_id: user.id,
paddle_plan_id: user.subscription.paddle_plan_id
)
if plan do
user_id = user.id
api_keys = from(key in Plausible.Auth.ApiKey, where: key.user_id == ^user_id)
Repo.update_all(api_keys, set: [hourly_request_limit: plan.hourly_api_request_limit])
end
user
end
def paddle_api(), do: Application.fetch_env!(:plausible, :paddle_api)
defp active_subscription_query(user_id) do
from s in Subscription,
from(s in Subscription,
where: s.user_id == ^user_id and s.status == "active",
order_by: [desc: s.inserted_at],
limit: 1
)
end
defp after_subscription_update(subscription) do
@ -298,7 +283,23 @@ defmodule Plausible.Billing do
user
|> maybe_remove_grace_period()
|> check_lock_status()
|> tap(&Plausible.Billing.SiteLocker.update_sites_for/1)
|> maybe_adjust_api_key_limits()
end
defp maybe_adjust_api_key_limits(user) do
plan =
Repo.get_by(Plausible.Billing.EnterprisePlan,
user_id: user.id,
paddle_plan_id: user.subscription.paddle_plan_id
)
if plan do
user_id = user.id
api_keys = from(key in Plausible.Auth.ApiKey, where: key.user_id == ^user_id)
Repo.update_all(api_keys, set: [hourly_request_limit: plan.hourly_api_request_limit])
end
user
end
end

@ -1,33 +1,58 @@
defmodule Plausible.Billing.SiteLocker do
use Plausible.Repo
def check_sites_for(user) do
@type update_opt() :: {:send_email?, boolean()}
@type lock_reason() ::
:grace_period_ended_now
| :grace_period_ended_already
| :no_trial
| :no_active_subscription
@spec update_sites_for(Plausible.Auth.User.t(), [update_opt()]) ::
{:locked, lock_reason()} | :unlocked
def update_sites_for(user, opts \\ []) do
send_email? = Keyword.get(opts, :send_email?, true)
user = Plausible.Users.with_subscription(user)
case Plausible.Billing.needs_to_upgrade?(user) do
{true, :grace_period_ended} ->
case Plausible.Billing.check_needs_to_upgrade(user) do
{:needs_to_upgrade, :grace_period_ended} ->
set_lock_status_for(user, true)
if !user.grace_period.is_over do
send_grace_period_end_email(user)
Plausible.Auth.GracePeriod.end_changeset(user) |> Repo.update()
if user.grace_period.is_over != true do
user
|> Plausible.Auth.GracePeriod.end_changeset()
|> Repo.update!()
if send_email? do
send_grace_period_end_email(user)
end
{:locked, :grace_period_ended_now}
else
{:locked, :grace_period_ended_already}
end
{true, _} ->
{:needs_to_upgrade, reason} ->
set_lock_status_for(user, true)
{:locked, reason}
_ ->
:no_upgrade_needed ->
set_lock_status_for(user, false)
:unlocked
end
end
@spec set_lock_status_for(Plausible.Auth.User.t(), boolean()) :: {:ok, non_neg_integer()}
def set_lock_status_for(user, status) do
site_ids =
Repo.all(
from s in Plausible.Site.Membership,
from(s in Plausible.Site.Membership,
where: s.user_id == ^user.id,
where: s.role == :owner,
select: s.site_id
)
)
site_q =
@ -36,10 +61,14 @@ defmodule Plausible.Billing.SiteLocker do
where: s.id in ^site_ids
)
Repo.update_all(site_q, set: [locked: status])
{num_updated, _} = Repo.update_all(site_q, set: [locked: status])
{:ok, num_updated}
end
defp send_grace_period_end_email(user) do
@spec send_grace_period_end_email(Plausible.Auth.User.t()) :: Plausible.Mailer.result()
def send_grace_period_end_email(user) do
user = Repo.preload(user, :subscription)
{_, last_cycle} = Plausible.Billing.last_two_billing_cycles(user)
{_, last_cycle_usage} = Plausible.Billing.last_two_billing_months_usage(user)
suggested_plan = Plausible.Billing.Plans.suggest(user, last_cycle_usage)

@ -2,7 +2,9 @@ defmodule Plausible.Mailer do
use Bamboo.Mailer, otp_app: :plausible
require Logger
@spec send(Bamboo.Email.t()) :: :ok | {:error, :hard_bounce} | {:error, :unknown_error}
@type result() :: :ok | {:error, :hard_bounce} | {:error, :unknown_error}
@spec send(Bamboo.Email.t()) :: result()
def send(email) do
case deliver_now(email) do
{:ok, _email} -> :ok

@ -2,6 +2,8 @@ defmodule Plausible.Site.Membership do
use Ecto.Schema
import Ecto.Changeset
@type t() :: %__MODULE__{}
schema "site_memberships" do
field :role, Ecto.Enum, values: [:owner, :admin, :viewer]
belongs_to :site, Plausible.Site
@ -10,9 +12,15 @@ defmodule Plausible.Site.Membership do
timestamps()
end
def changeset(schema, attrs) do
schema
|> cast(attrs, [:user_id, :site_id, :role])
|> validate_required([:user_id, :site_id])
def new(site, user) do
%__MODULE__{}
|> change()
|> put_assoc(:site, site)
|> put_assoc(:user, user)
end
def set_role(changeset, role) do
changeset
|> cast(%{role: role}, [:role])
end
end

@ -0,0 +1,11 @@
defmodule Plausible.Site.Memberships do
@moduledoc """
API for site memberships and invitations
"""
alias Plausible.Site.Memberships
defdelegate accept_invitation(invitation_id, user), to: Memberships.AcceptInvitation
defdelegate reject_invitation(invitation_id, user), to: Memberships.RejectInvitation
defdelegate remove_invitation(invitation_id, site), to: Memberships.RemoveInvitation
end

@ -0,0 +1,163 @@
defmodule Plausible.Site.Memberships.AcceptInvitation do
@moduledoc """
Service for accepting invitations, including ownership transfers.
Accepting invitation accounts for the fact that it's possible
that accepting user has an existing membership for the site and
acts permissively to not unnecessarily disrupt the flow while
also maintaining integrity of site memberships. This also applies
to cases where users update their email address between issuing
the invitation and accepting it.
"""
import Ecto.Query, only: [from: 2]
alias Ecto.Multi
alias Plausible.Auth
alias Plausible.Billing
alias Plausible.Memberships.Invitations
alias Plausible.Repo
alias Plausible.Site
alias Plausible.Site.Memberships.Invitations
require Logger
@spec accept_invitation(String.t(), Auth.User.t(), Keyword.t()) ::
{:ok, Site.Membership.t()} | {:error, :invitation_not_found | Ecto.Changeset.t()}
def accept_invitation(invitation_id, user, opts \\ []) do
selfhost? = Keyword.get(opts, :selfhost?, Plausible.Release.selfhost?())
with {:ok, invitation} <- Invitations.find_for_user(invitation_id, user) do
membership = get_or_create_membership(invitation, user)
multi =
if invitation.role == :owner do
add_and_transfer_ownership(invitation, membership, user, selfhost?)
else
add(invitation, membership, user)
end
case Repo.transaction(multi) do
{:ok, changes} ->
if changes[:site_locker] == {:locked, :grace_period_ended_now} do
Billing.SiteLocker.send_grace_period_end_email(changes.user)
end
notify_invitation_accepted(invitation)
membership = Repo.preload(changes.membership, [:site, :user])
{:ok, membership}
{:error, _operation, error, _changes} ->
{:error, error}
end
end
end
defp add_and_transfer_ownership(invitation, membership, user, selfhost?) do
multi =
Multi.new()
|> downgrade_previous_owner(invitation.site, user)
|> maybe_end_trial_of_new_owner(user, selfhost?)
|> Multi.insert_or_update(:membership, membership)
|> Multi.delete(:invitation, invitation)
if selfhost? do
multi
else
Multi.run(multi, :site_locker, fn _, %{user: updated_user} ->
{:ok, Billing.SiteLocker.update_sites_for(updated_user, send_email?: false)}
end)
end
end
# If there's an existing membership, we DO NOT change the role
# to avoid accidental role downgrade.
defp add(invitation, membership, _user) do
if membership.data.id do
Multi.new()
|> Multi.put(:membership, membership.data)
|> Multi.delete(:invitation, invitation)
else
Multi.new()
|> Multi.insert(:membership, membership)
|> Multi.delete(:invitation, invitation)
end
end
defp get_or_create_membership(invitation, user) do
case Repo.get_by(Site.Membership, user_id: user.id, site_id: invitation.site.id) do
nil -> Site.Membership.new(invitation.site, user)
membership -> membership
end
|> Site.Membership.set_role(invitation.role)
end
# If the new owner is the same as old owner, we do not downgrade them
# to avoid leaving site without an owner!
defp downgrade_previous_owner(multi, site, new_owner) do
new_owner_id = new_owner.id
previous_owner =
Repo.one(
from(
sm in Site.Membership,
where: sm.site_id == ^site.id,
where: sm.role == :owner
)
)
case previous_owner do
%{user_id: ^new_owner_id} ->
Multi.put(multi, :previous_owner_membership, previous_owner)
nil ->
Logger.warn(
"Transferring ownership from a site with no owner: #{site.domain} " <>
", new owner ID: #{new_owner_id}"
)
Multi.put(multi, :previous_owner_membership, nil)
previous_owner ->
Multi.update(
multi,
:previous_owner_membership,
Site.Membership.set_role(previous_owner, :admin)
)
end
end
# If the new owner is the same as the old owner, it's a no-op
defp maybe_end_trial_of_new_owner(multi, new_owner, selfhost?) do
new_owner_id = new_owner.id
cond do
selfhost? ->
Multi.put(multi, :user, new_owner)
Billing.on_trial?(new_owner) or is_nil(new_owner.trial_expiry_date) ->
Multi.update(multi, :user, fn
%{previous_owner_membership: %{user_id: ^new_owner_id}} ->
Ecto.Changeset.change(new_owner)
_ ->
Auth.User.end_trial(new_owner)
end)
true ->
Multi.put(multi, :user, new_owner)
end
end
defp notify_invitation_accepted(%Auth.Invitation{role: :owner} = invitation) do
PlausibleWeb.Email.ownership_transfer_accepted(invitation)
|> Plausible.Mailer.send()
end
defp notify_invitation_accepted(invitation) do
PlausibleWeb.Email.invitation_accepted(invitation)
|> Plausible.Mailer.send()
end
end

@ -0,0 +1,45 @@
defmodule Plausible.Site.Memberships.Invitations do
@moduledoc false
import Ecto.Query, only: [from: 2]
alias Plausible.Auth
alias Plausible.Repo
@spec find_for_user(String.t(), Auth.User.t()) ::
{:ok, Auth.Invitation.t()} | {:error, :invitation_not_found}
def find_for_user(invitation_id, user) do
invitation =
Auth.Invitation
|> Repo.get_by(invitation_id: invitation_id, email: user.email)
|> Repo.preload([:site, :inviter])
if invitation do
{:ok, invitation}
else
{:error, :invitation_not_found}
end
end
@spec find_for_site(String.t(), Plausible.Site.t()) ::
{:ok, Auth.Invitation.t()} | {:error, :invitation_not_found}
def find_for_site(invitation_id, site) do
invitation =
Auth.Invitation
|> Repo.get_by(invitation_id: invitation_id, site_id: site.id)
|> Repo.preload([:site, :inviter])
if invitation do
{:ok, invitation}
else
{:error, :invitation_not_found}
end
end
@spec delete_invitation(Auth.Invitation.t()) :: :ok
def delete_invitation(invitation) do
Repo.delete_all(from(i in Auth.Invitation, where: i.id == ^invitation.id))
:ok
end
end

@ -0,0 +1,29 @@
defmodule Plausible.Site.Memberships.RejectInvitation do
@moduledoc """
Service for rejecting invitations.
"""
alias Plausible.Auth
alias Plausible.Site.Memberships.Invitations
@spec reject_invitation(String.t(), Auth.User.t()) ::
{:ok, Auth.Invitation.t()} | {:error, :invitation_not_found}
def reject_invitation(invitation_id, user) do
with {:ok, invitation} <- Invitations.find_for_user(invitation_id, user) do
Invitations.delete_invitation(invitation)
notify_invitation_rejected(invitation)
{:ok, invitation}
end
end
defp notify_invitation_rejected(%Auth.Invitation{role: :owner} = invitation) do
PlausibleWeb.Email.ownership_transfer_rejected(invitation)
|> Plausible.Mailer.send()
end
defp notify_invitation_rejected(invitation) do
PlausibleWeb.Email.invitation_rejected(invitation)
|> Plausible.Mailer.send()
end
end

@ -0,0 +1,18 @@
defmodule Plausible.Site.Memberships.RemoveInvitation do
@moduledoc """
Service for removing invitations.
"""
alias Plausible.Auth
alias Plausible.Site.Memberships.Invitations
@spec remove_invitation(String.t(), Plausible.Site.t()) ::
{:ok, Auth.Invitation.t()} | {:error, :invitation_not_found}
def remove_invitation(invitation_id, site) do
with {:ok, invitation} <- Invitations.find_for_site(invitation_id, site) do
Invitations.delete_invitation(invitation)
{:ok, invitation}
end
end
end

@ -6,6 +6,7 @@ defmodule Plausible.Sites do
@type invite_error() ::
Ecto.Changeset.t()
| :already_a_member
| :transfer_to_self
| {:over_limit, non_neg_integer()}
| :forbidden
@ -28,14 +29,8 @@ defmodule Plausible.Sites do
if Quota.within_limit?(usage, limit), do: {:ok, usage}, else: {:error, limit}
end)
|> Ecto.Multi.insert(:site, site_changeset)
|> Ecto.Multi.run(:site_membership, fn repo, %{site: site} ->
membership_changeset =
Site.Membership.changeset(%Site.Membership{}, %{
site_id: site.id,
user_id: user.id
})
repo.insert(membership_changeset)
|> Ecto.Multi.insert(:site_membership, fn %{site: site} ->
Site.Membership.new(site, user)
end)
|> maybe_start_trial(user)
|> Repo.transaction()
@ -91,6 +86,7 @@ defmodule Plausible.Sites do
with :ok <- check_invitation_permissions(site, inviter, role, opts),
:ok <- check_team_member_limit(site, role),
invitee <- Plausible.Auth.find_user_by(email: invitee_email),
:ok <- ensure_transfer_valid(site, invitee, role),
:ok <- ensure_new_membership(site, invitee, role),
%Ecto.Changeset{} = changeset <- Plausible.Auth.Invitation.new(attrs),
{:ok, invitation} <- Repo.insert(changeset) do
@ -131,6 +127,18 @@ defmodule Plausible.Sites do
Plausible.Mailer.send(email)
end
defp ensure_transfer_valid(site, invitee, :owner) do
if invitee && role(invitee.id, site) == :owner do
{:error, :transfer_to_self}
else
:ok
end
end
defp ensure_transfer_valid(_site, _invitee, _role) do
:ok
end
defp ensure_new_membership(_site, _invitee, :owner) do
:ok
end

@ -1,136 +1,54 @@
defmodule PlausibleWeb.InvitationController do
use PlausibleWeb, :controller
use Plausible.Repo
alias Ecto.Multi
alias Plausible.Auth.Invitation
alias Plausible.Site.Membership
plug PlausibleWeb.RequireAccountPlug
@require_owner [:remove_invitation]
plug PlausibleWeb.AuthorizeSiteAccess,
[:owner, :admin] when action in @require_owner
plug PlausibleWeb.AuthorizeSiteAccess, [:owner, :admin] when action in [:remove_invitation]
def accept_invitation(conn, %{"invitation_id" => invitation_id}) do
invitation =
Repo.get_by(Invitation, invitation_id: invitation_id)
|> Repo.preload([:site, :inviter])
if invitation do
user = conn.assigns[:current_user]
existing_membership = Repo.get_by(Membership, user_id: user.id, site_id: invitation.site.id)
multi =
if invitation.role == :owner do
Multi.new()
|> downgrade_previous_owner(invitation.site)
|> maybe_end_trial_of_new_owner(user)
else
Multi.new()
end
membership_changeset =
(existing_membership ||
%Membership{user_id: user.id, site_id: invitation.site.id})
|> Membership.changeset(%{role: invitation.role})
multi =
multi
|> Multi.insert_or_update(:membership, membership_changeset)
|> Multi.delete(:invitation, invitation)
case Repo.transaction(multi) do
{:ok, changes} ->
updated_user = Map.get(changes, :user, user)
notify_invitation_accepted(invitation)
Plausible.Billing.SiteLocker.check_sites_for(updated_user)
conn
|> put_flash(:success, "You now have access to #{invitation.site.domain}")
|> redirect(to: "/#{URI.encode_www_form(invitation.site.domain)}")
{:error, _operation, _value, _changes} ->
conn
|> put_flash(:error, "Something went wrong, please try again")
|> redirect(to: "/sites")
end
else
conn
|> put_flash(:error, "Invitation missing or already accepted")
|> redirect(to: "/sites")
end
end
defp downgrade_previous_owner(multi, site) do
prev_owner =
from(
sm in Plausible.Site.Membership,
where: sm.site_id == ^site.id,
where: sm.role == :owner
)
Multi.update_all(multi, :prev_owner, prev_owner, set: [role: :admin])
end
defp maybe_end_trial_of_new_owner(multi, new_owner) do
if Application.get_env(:plausible, :is_selfhost) do
multi
else
end_trial_of_new_owner(multi, new_owner)
end
end
defp end_trial_of_new_owner(multi, new_owner) do
if Plausible.Billing.on_trial?(new_owner) || is_nil(new_owner.trial_expiry_date) do
Ecto.Multi.update(multi, :user, Plausible.Auth.User.end_trial(new_owner))
else
multi
case Plausible.Site.Memberships.accept_invitation(invitation_id, conn.assigns.current_user) do
{:ok, membership} ->
conn
|> put_flash(:success, "You now have access to #{membership.site.domain}")
|> redirect(to: "/#{URI.encode_www_form(membership.site.domain)}")
{:error, :invitation_not_found} ->
conn
|> put_flash(:error, "Invitation missing or already accepted")
|> redirect(to: "/sites")
{:error, _} ->
conn
|> put_flash(:error, "Something went wrong, please try again")
|> redirect(to: "/sites")
end
end
def reject_invitation(conn, %{"invitation_id" => invitation_id}) do
invitation =
Repo.get_by!(Invitation, invitation_id: invitation_id)
|> Repo.preload([:site, :inviter])
Repo.delete!(invitation)
notify_invitation_rejected(invitation)
conn
|> put_flash(:success, "You have rejected the invitation to #{invitation.site.domain}")
|> redirect(to: "/sites")
end
defp notify_invitation_accepted(%Invitation{role: :owner} = invitation) do
PlausibleWeb.Email.ownership_transfer_accepted(invitation)
|> Plausible.Mailer.send()
end
defp notify_invitation_accepted(invitation) do
PlausibleWeb.Email.invitation_accepted(invitation)
|> Plausible.Mailer.send()
end
defp notify_invitation_rejected(%Invitation{role: :owner} = invitation) do
PlausibleWeb.Email.ownership_transfer_rejected(invitation)
|> Plausible.Mailer.send()
end
defp notify_invitation_rejected(invitation) do
PlausibleWeb.Email.invitation_rejected(invitation)
|> Plausible.Mailer.send()
case Plausible.Site.Memberships.reject_invitation(invitation_id, conn.assigns.current_user) do
{:ok, invitation} ->
conn
|> put_flash(:success, "You have rejected the invitation to #{invitation.site.domain}")
|> redirect(to: "/sites")
{:error, :invitation_not_found} ->
conn
|> put_flash(:error, "Invitation missing or already accepted")
|> redirect(to: "/sites")
end
end
def remove_invitation(conn, %{"invitation_id" => invitation_id}) do
invitation =
Repo.get_by!(Invitation, invitation_id: invitation_id, site_id: conn.assigns[:site].id)
|> Repo.preload(:site)
Repo.delete!(invitation)
conn
|> put_flash(:success, "You have removed the invitation for #{invitation.email}")
|> redirect(to: Routes.site_path(conn, :settings_people, invitation.site.domain))
case Plausible.Site.Memberships.remove_invitation(invitation_id, conn.assigns.site) do
{:ok, invitation} ->
conn
|> put_flash(:success, "You have removed the invitation for #{invitation.email}")
|> redirect(to: Routes.site_path(conn, :settings_people, invitation.site.domain))
{:error, :invitation_not_found} ->
conn
|> put_flash(:error, "Invitation missing or already removed")
|> redirect(to: Routes.site_path(conn, :settings_people, conn.assigns.site.domain))
end
end
end

@ -104,6 +104,13 @@ defmodule PlausibleWeb.Site.MembershipController do
|> put_flash(:success, "Site transfer request has been sent to #{email}")
|> redirect(to: Routes.site_path(conn, :settings_people, site.domain))
{:error, :transfer_to_self} ->
conn
|> put_flash(:ttl, :timer.seconds(5))
|> put_flash(:error_title, "Transfer error")
|> put_flash(:error, "Can't transfer ownership to existing owner")
|> redirect(to: Routes.site_path(conn, :settings_people, site.domain))
{:error, changeset} ->
errors = Plausible.ChangesetHelpers.traverse_errors(changeset)
@ -149,7 +156,8 @@ defmodule PlausibleWeb.Site.MembershipController do
if can_grant_role? do
membership =
membership
|> Membership.changeset(%{role: new_role})
|> Ecto.Changeset.change()
|> Membership.set_role(new_role)
|> Repo.update!()
redirect_target =

@ -45,7 +45,7 @@ defmodule PlausibleWeb.SiteController do
sites: sites,
visitors: visitors,
pagination: pagination,
needs_to_upgrade: user_owns_sites && Plausible.Billing.needs_to_upgrade?(user)
needs_to_upgrade: user_owns_sites && Plausible.Billing.check_needs_to_upgrade(user)
)
end

@ -1,6 +1,6 @@
<div x-data="{selectedInvitation: null, invitationOpen: false, invitations: <%= Enum.map(@invitations, &({&1.invitation_id, &1})) |> Enum.into(%{}) |> Jason.encode! %>}" @keydown.escape.window="invitationOpen = false" class="container pt-6">
<%= if @needs_to_upgrade == {true, :no_active_subscription} do %>
<%= if @needs_to_upgrade == {:needs_to_upgrade, :no_active_subscription} do %>
<div class="rounded-md bg-yellow-100 p-4">
<div class="flex">
<div class="flex-shrink-0">

@ -8,7 +8,7 @@ defmodule Plausible.Workers.LockSites do
users = Repo.all(from u in Plausible.Auth.User, preload: [subscription: ^subscription_q])
for user <- users do
Plausible.Billing.SiteLocker.check_sites_for(user)
Plausible.Billing.SiteLocker.update_sites_for(user)
end
:ok

@ -125,30 +125,36 @@ defmodule Plausible.BillingTest do
end
end
describe "needs_to_upgrade?" do
describe "check_needs_to_upgrade" do
test "is false for a trial user" do
user = insert(:user)
refute Billing.needs_to_upgrade?(user)
assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
end
test "is true for a user with an expired trial" do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
assert Billing.needs_to_upgrade?(user)
assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_active_subscription}
end
test "is true for a user with empty trial expiry date" do
user = insert(:user, trial_expiry_date: nil)
assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_trial}
end
test "is false for a user with an expired trial but an active subscription" do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription, user: user)
refute Billing.needs_to_upgrade?(user)
assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
end
test "is false for a user with a cancelled subscription IF the billing cycle isn't completed yet" do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription, user: user, status: "deleted", next_bill_date: Timex.today())
refute Billing.needs_to_upgrade?(user)
assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
end
test "is true for a user with a cancelled subscription IF the billing cycle is complete" do
@ -160,14 +166,23 @@ defmodule Plausible.BillingTest do
next_bill_date: Timex.shift(Timex.today(), days: -1)
)
assert Billing.needs_to_upgrade?(user)
assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_active_subscription}
end
test "is false for a deleted subscription if not next_bill_date specified" do
test "is true for a deleted subscription if no next_bill_date specified" do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription, user: user, status: "deleted", next_bill_date: nil)
assert Billing.needs_to_upgrade?(user)
assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_active_subscription}
end
test "is true for a user past their grace period" do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription, user: user, next_bill_date: Timex.today())
user = user |> Plausible.Auth.GracePeriod.end_changeset() |> Repo.update!()
assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :grace_period_ended}
end
end

@ -3,13 +3,19 @@ defmodule Plausible.Billing.SiteLockerTest do
use Bamboo.Test, shared: true
alias Plausible.Billing.SiteLocker
describe "check_sites_for/1" do
describe "update_sites_for/1" do
test "does not lock sites if user is on trial" do
user = insert(:user, trial_expiry_date: Timex.today())
site = insert(:site, locked: true, members: [user])
site =
insert(:site,
locked: true,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
SiteLocker.check_sites_for(user)
assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
@ -17,9 +23,16 @@ defmodule Plausible.Billing.SiteLockerTest do
test "does not lock if user has an active subscription" do
user = insert(:user)
insert(:subscription, status: "active", user: user)
site = insert(:site, locked: true, members: [user])
SiteLocker.check_sites_for(user)
site =
insert(:site,
locked: true,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
@ -27,9 +40,15 @@ defmodule Plausible.Billing.SiteLockerTest do
test "does not lock user who is past due" do
user = insert(:user)
insert(:subscription, status: "past_due", user: user)
site = insert(:site, members: [user])
SiteLocker.check_sites_for(user)
site =
insert(:site,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
@ -37,9 +56,15 @@ defmodule Plausible.Billing.SiteLockerTest do
test "does not lock user who cancelled subscription but it hasn't expired yet" do
user = insert(:user)
insert(:subscription, status: "deleted", user: user)
site = insert(:site, members: [user])
SiteLocker.check_sites_for(user)
site =
insert(:site,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
@ -54,15 +79,21 @@ defmodule Plausible.Billing.SiteLockerTest do
)
insert(:subscription, status: "active", user: user)
site = insert(:site, members: [user])
SiteLocker.check_sites_for(user)
site =
insert(:site,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
test "locks user who cancelled subscription and the cancelled subscription has expired" do
user = insert(:user)
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription,
status: "deleted",
@ -70,11 +101,16 @@ defmodule Plausible.Billing.SiteLockerTest do
user: user
)
site = insert(:site, members: [user])
site =
insert(:site,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
SiteLocker.check_sites_for(user)
assert SiteLocker.update_sites_for(user) == {:locked, :no_active_subscription}
refute Repo.reload!(site).locked
assert Repo.reload!(site).locked
end
test "locks all sites if user has active subscription but grace period has ended" do
@ -87,9 +123,15 @@ defmodule Plausible.Billing.SiteLockerTest do
)
insert(:subscription, status: "active", user: user)
site = insert(:site, members: [user])
SiteLocker.check_sites_for(user)
site =
insert(:site,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
assert SiteLocker.update_sites_for(user) == {:locked, :grace_period_ended_now}
assert Repo.reload!(site).locked
end
@ -104,9 +146,14 @@ defmodule Plausible.Billing.SiteLockerTest do
)
insert(:subscription, status: "active", user: user)
insert(:site, members: [user])
SiteLocker.check_sites_for(user)
insert(:site,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
assert SiteLocker.update_sites_for(user) == {:locked, :grace_period_ended_now}
assert_email_delivered_with(
to: [user],
@ -125,9 +172,14 @@ defmodule Plausible.Billing.SiteLockerTest do
)
insert(:subscription, status: "active", user: user)
insert(:site, members: [user])
SiteLocker.check_sites_for(user)
insert(:site,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
assert SiteLocker.update_sites_for(user) == {:locked, :grace_period_ended_now}
assert_email_delivered_with(
to: [user],
@ -135,7 +187,7 @@ defmodule Plausible.Billing.SiteLockerTest do
)
user = Repo.reload!(user)
SiteLocker.check_sites_for(user)
assert SiteLocker.update_sites_for(user) == {:locked, :grace_period_ended_already}
assert_no_emails_delivered()
end
@ -143,9 +195,29 @@ defmodule Plausible.Billing.SiteLockerTest do
test "locks all sites if user has no trial or active subscription" do
user = insert(:user, trial_expiry_date: Timex.today() |> Timex.shift(days: -1))
site = insert(:site, locked: true, members: [user])
site =
insert(:site,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
assert SiteLocker.update_sites_for(user) == {:locked, :no_active_subscription}
assert Repo.reload!(site).locked
end
test "locks sites for user with empty trial - shouldn't happen under normal circumstances" do
user = insert(:user, trial_expiry_date: nil)
site =
insert(:site,
memberships: [
build(:site_membership, user: user, role: :owner)
]
)
SiteLocker.check_sites_for(user)
assert SiteLocker.update_sites_for(user) == {:locked, :no_trial}
assert Repo.reload!(site).locked
end
@ -167,7 +239,7 @@ defmodule Plausible.Billing.SiteLockerTest do
]
)
SiteLocker.check_sites_for(user)
assert SiteLocker.update_sites_for(user) == {:locked, :no_active_subscription}
owner_site = Repo.reload!(owner_site)
viewer_site = Repo.reload!(viewer_site)

@ -0,0 +1,323 @@
defmodule Plausible.Site.Memberships.AcceptInvitationTest do
use Plausible.DataCase, async: true
use Bamboo.Test
alias Plausible.Site.Memberships.AcceptInvitation
describe "invitations" do
test "converts an invitation into a membership" do
inviter = insert(:user)
invitee = insert(:user)
site = insert(:site, members: [inviter])
invitation =
insert(:invitation,
site_id: site.id,
inviter: inviter,
email: invitee.email,
role: :admin
)
assert {:ok, membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, invitee)
assert membership.site_id == site.id
assert membership.user_id == invitee.id
assert membership.role == :admin
refute Repo.reload(invitation)
assert_email_delivered_with(
to: [nil: inviter.email],
subject:
"[Plausible Analytics] #{invitee.email} accepted your invitation to #{site.domain}"
)
end
test "does not degrade role when trying to invite self as an owner" do
site = insert(:site)
user = insert(:user)
membership = insert(:site_membership, user: user, site: site, role: :owner)
invitation =
insert(:invitation,
site_id: site.id,
inviter: user,
email: user.email,
role: :admin
)
assert {:ok, invited_membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, user)
assert invited_membership.id == membership.id
membership = Repo.reload!(membership)
assert membership.role == :owner
assert membership.site_id == site.id
assert membership.user_id == user.id
refute Repo.reload(invitation)
end
test "handles accepting invitation as already a member gracefully" do
inviter = insert(:user)
invitee = insert(:user)
site = insert(:site, members: [inviter])
existing_membership = insert(:site_membership, user: invitee, site: site, role: :admin)
invitation =
insert(:invitation,
site_id: site.id,
inviter: inviter,
email: invitee.email,
role: :viewer
)
assert {:ok, new_membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, invitee)
assert existing_membership.id == new_membership.id
assert existing_membership.user_id == new_membership.user_id
assert existing_membership.site_id == new_membership.site_id
assert existing_membership.role == new_membership.role
assert new_membership.role == :admin
refute Repo.reload(invitation)
end
test "returns an error on non-existent invitation" do
invitee = insert(:user)
assert {:error, :invitation_not_found} =
AcceptInvitation.accept_invitation("does_not_exist", invitee)
end
end
describe "ownership transfers" do
for {label, opts} <- [{"cloud", []}, {"selfhosted", [selfhost?: true]}] do
test "converts an ownership transfer into a membership on #{label} instance" do
site = insert(:site)
existing_owner = insert(:user)
existing_membership =
insert(:site_membership, user: existing_owner, site: site, role: :owner)
new_owner = insert(:user)
invitation =
insert(:invitation,
site_id: site.id,
inviter: existing_owner,
email: new_owner.email,
role: :owner
)
assert {:ok, new_membership} =
AcceptInvitation.accept_invitation(
invitation.invitation_id,
new_owner,
unquote(opts)
)
assert new_membership.site_id == site.id
assert new_membership.user_id == new_owner.id
assert new_membership.role == :owner
refute Repo.reload(invitation)
existing_membership = Repo.reload!(existing_membership)
assert existing_membership.user_id == existing_owner.id
assert existing_membership.site_id == site.id
assert existing_membership.role == :admin
assert_email_delivered_with(
to: [nil: existing_owner.email],
subject:
"[Plausible Analytics] #{new_owner.email} accepted the ownership transfer of #{site.domain}"
)
end
end
for role <- [:viewer, :admin] do
test "upgrades existing #{role} membership into an owner" do
site = insert(:site)
owner = insert(:user)
owner_membership = insert(:site_membership, user: owner, site: site, role: :owner)
new_owner = insert(:user)
new_owner_membership =
insert(:site_membership, user: new_owner, site: site, role: unquote(role))
invitation =
insert(:invitation,
site_id: site.id,
inviter: owner,
email: new_owner.email,
role: :owner
)
assert {:ok, membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
assert membership.id == new_owner_membership.id
assert membership.role == :owner
assert Repo.reload!(owner_membership).role == :admin
refute Repo.reload(invitation)
end
end
test "does note degrade or alter trial when accepting ownership transfer by self" do
site = insert(:site)
owner = insert(:user, trial_expiry_date: nil)
owner_membership = insert(:site_membership, user: owner, site: site, role: :owner)
invitation =
insert(:invitation,
site_id: site.id,
inviter: owner,
email: owner.email,
role: :owner
)
assert {:ok, membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, owner)
assert membership.id == owner_membership.id
assert membership.role == :owner
assert Repo.reload!(owner).trial_expiry_date == nil
refute Repo.reload(invitation)
end
test "locks the site if the new owner has no active subscription or trial" do
site = insert(:site, locked: false)
existing_owner = insert(:user)
insert(:site_membership, user: existing_owner, site: site, role: :owner)
new_owner = insert(:user, trial_expiry_date: Date.add(Date.utc_today(), -1))
invitation =
insert(:invitation,
site_id: site.id,
inviter: existing_owner,
email: new_owner.email,
role: :owner
)
assert {:ok, _membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
assert Repo.reload!(site).locked
end
test "does not lock the site or set trial expiry date if the instance is selfhosted" do
site = insert(:site, locked: false)
existing_owner = insert(:user)
insert(:site_membership, user: existing_owner, site: site, role: :owner)
new_owner = insert(:user, trial_expiry_date: nil)
invitation =
insert(:invitation,
site_id: site.id,
inviter: existing_owner,
email: new_owner.email,
role: :owner
)
assert {:ok, _membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner,
selfhost?: true
)
assert Repo.reload!(new_owner).trial_expiry_date == nil
refute Repo.reload!(site).locked
end
test "ends trial of the new owner immediately" do
site = insert(:site, locked: false)
existing_owner = insert(:user)
insert(:site_membership, user: existing_owner, site: site, role: :owner)
new_owner = insert(:user, trial_expiry_date: Date.add(Date.utc_today(), 7))
invitation =
insert(:invitation,
site_id: site.id,
inviter: existing_owner,
email: new_owner.email,
role: :owner
)
assert {:ok, _membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
assert Repo.reload!(new_owner).trial_expiry_date == Date.add(Date.utc_today(), -1)
assert Repo.reload!(site).locked
end
test "sets user's trial expiry date to yesterday if they don't have one" do
site = insert(:site, locked: false)
existing_owner = insert(:user)
insert(:site_membership, user: existing_owner, site: site, role: :owner)
new_owner = insert(:user, trial_expiry_date: nil)
invitation =
insert(:invitation,
site_id: site.id,
inviter: existing_owner,
email: new_owner.email,
role: :owner
)
assert {:ok, _membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
assert Repo.reload!(new_owner).trial_expiry_date == Date.add(Date.utc_today(), -1)
assert Repo.reload!(site).locked
end
test "ends grace period and sends an email about it if new owner is past grace period" do
site = insert(:site, locked: false)
existing_owner = insert(:user)
insert(:site_membership, user: existing_owner, site: site, role: :owner)
new_owner = insert(:user, trial_expiry_date: Date.add(Date.utc_today(), -1))
insert(:subscription, user: new_owner, next_bill_date: Timex.today())
new_owner =
new_owner
|> Plausible.Auth.GracePeriod.start_changeset(100)
|> then(fn changeset ->
grace_period =
changeset
|> get_field(:grace_period)
|> Map.put(:end_date, Date.add(Date.utc_today(), -1))
change(changeset, grace_period: grace_period)
end)
|> Repo.update!()
invitation =
insert(:invitation,
site_id: site.id,
inviter: existing_owner,
email: new_owner.email,
role: :owner
)
assert {:ok, _membership} =
AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
assert Repo.reload!(new_owner).grace_period.is_over
assert Repo.reload!(site).locked
assert_email_delivered_with(
to: [{"Jane Smith", new_owner.email}],
subject: "[Action required] Your Plausible dashboard is now locked"
)
end
end
end

@ -0,0 +1,58 @@
defmodule Plausible.Site.Memberships.RejectInvitationTest do
use Plausible.DataCase, async: true
use Bamboo.Test
alias Plausible.Site.Memberships.RejectInvitation
test "rejects invitation and sends email to inviter" do
inviter = insert(:user)
invitee = insert(:user)
site = insert(:site, members: [inviter])
invitation =
insert(:invitation,
site_id: site.id,
inviter: inviter,
email: invitee.email,
role: :admin
)
assert {:ok, rejected_invitation} =
RejectInvitation.reject_invitation(invitation.invitation_id, invitee)
assert rejected_invitation.id == invitation.id
refute Repo.reload(rejected_invitation)
assert_email_delivered_with(
to: [nil: inviter.email],
subject: "[Plausible Analytics] #{invitee.email} rejected your invitation to #{site.domain}"
)
end
test "returns error for non-existent invitation" do
invitee = insert(:user)
assert {:error, :invitation_not_found} =
RejectInvitation.reject_invitation("does_not_exist", invitee)
end
test "does not allow rejecting invitation by anyone other than invitee" do
inviter = insert(:user)
invitee = insert(:user)
other_user = insert(:user)
site = insert(:site, members: [inviter])
invitation =
insert(:invitation,
site_id: site.id,
inviter: inviter,
email: invitee.email,
role: :admin
)
assert {:error, :invitation_not_found} =
RejectInvitation.reject_invitation(invitation.invitation_id, other_user)
assert Repo.reload(invitation)
end
end

@ -0,0 +1,52 @@
defmodule Plausible.Site.Memberships.RemoveInvitationTest do
use Plausible.DataCase, async: true
alias Plausible.Site.Memberships.RemoveInvitation
test "removes invitation" do
inviter = insert(:user)
invitee = insert(:user)
site = insert(:site, members: [inviter])
invitation =
insert(:invitation,
site_id: site.id,
inviter: inviter,
email: invitee.email,
role: :admin
)
assert {:ok, removed_invitation} =
RemoveInvitation.remove_invitation(invitation.invitation_id, site)
assert removed_invitation.id == invitation.id
refute Repo.reload(removed_invitation)
end
test "returns error for non-existent invitation" do
site = insert(:site)
assert {:error, :invitation_not_found} =
RemoveInvitation.remove_invitation("does_not_exist", site)
end
test "does not allow removing invitation from another site" do
inviter = insert(:user)
invitee = insert(:user)
site = insert(:site, members: [inviter])
other_site = insert(:site, members: [inviter])
invitation =
insert(:invitation,
site_id: site.id,
inviter: inviter,
email: invitee.email,
role: :admin
)
assert {:error, :invitation_not_found} =
RemoveInvitation.remove_invitation(invitation.invitation_id, other_site)
assert Repo.reload(invitation)
end
end

@ -142,7 +142,7 @@ defmodule Plausible.SitesTest do
assert {:error, {:over_limit, 5}} = Sites.invite(site, inviter, invitee.email, :viewer)
end
test "sends ownership transfer email when invitee role is owner" do
test "sends ownership transfer email when inviter role is owner" do
inviter = insert(:user)
site = insert(:site, memberships: [build(:site_membership, user: inviter, role: :owner)])
@ -169,6 +169,36 @@ defmodule Plausible.SitesTest do
assert {:error, :forbidden} = Sites.invite(site, inviter, "vini@plausible.test", :owner)
end
test "allows ownership transfer to existing site members" do
inviter = insert(:user)
invitee = insert(:user)
site =
insert(:site,
memberships: [
build(:site_membership, user: inviter, role: :owner),
build(:site_membership, user: invitee, role: :viewer)
]
)
assert {:ok, %Plausible.Auth.Invitation{}} =
Sites.invite(site, inviter, invitee.email, :owner)
end
test "does not allow transferring ownership to existing owner" do
inviter = insert(:user, email: "vini@plausible.test")
site =
insert(:site,
memberships: [
build(:site_membership, user: inviter, role: :owner)
]
)
assert {:error, :transfer_to_self} =
Sites.invite(site, inviter, "vini@plausible.test", :owner)
end
test "does not check for limits when transferring ownership" do
inviter = insert(:user)

@ -47,7 +47,7 @@ defmodule PlausibleWeb.Api.ExternalStatsController.AuthTest do
test "locked site - returns 402", %{conn: conn, api_key: api_key, user: user} do
site = insert(:site, members: [user])
{1, _} = Plausible.Billing.SiteLocker.set_lock_status_for(user, true)
{:ok, 1} = Plausible.Billing.SiteLocker.set_lock_status_for(user, true)
conn
|> with_api_key(api_key)
@ -88,7 +88,7 @@ defmodule PlausibleWeb.Api.ExternalStatsController.AuthTest do
user: user
} do
site = insert(:site, members: [user])
{1, _} = Plausible.Billing.SiteLocker.set_lock_status_for(user, true)
{:ok, 1} = Plausible.Billing.SiteLocker.set_lock_status_for(user, true)
conn
|> with_api_key(api_key)

@ -1,5 +1,5 @@
defmodule PlausibleWeb.Site.InvitationControllerTest do
use PlausibleWeb.ConnCase
use PlausibleWeb.ConnCase, async: true
use Plausible.Repo
use Bamboo.Test
@ -53,43 +53,9 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
assert Phoenix.Flash.get(c2.assigns.flash, :error) ==
"Invitation missing or already accepted"
end
test "notifies the original inviter", %{conn: conn, user: user} do
inviter = insert(:user)
site = insert(:site)
invitation =
insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :admin)
post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
assert_email_delivered_with(
to: [nil: inviter.email],
subject: "[Plausible Analytics] #{user.email} accepted your invitation to #{site.domain}"
)
end
end
describe "POST /sites/invitations/:invitation_id/accept - ownership transfer" do
test "notifies the original inviter with a different email", %{
conn: conn,
user: user
} do
inviter = insert(:user)
site = insert(:site)
invitation =
insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :owner)
post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
assert_email_delivered_with(
to: [nil: inviter.email],
subject:
"[Plausible Analytics] #{user.email} accepted the ownership transfer of #{site.domain}"
)
end
test "downgrades previous owner to admin", %{conn: conn, user: user} do
old_owner = insert(:user)
site = insert(:site, members: [old_owner])
@ -111,116 +77,10 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
assert new_owner_membership.role == :owner
end
test "will lock the site if new owner does not have an active subscription or trial",
%{
conn: conn,
user: user
} do
Repo.update_all(from(u in Plausible.Auth.User, where: u.id == ^user.id),
set: [trial_expiry_date: Timex.today() |> Timex.shift(days: -1)]
)
inviter = insert(:user)
site = insert(:site, locked: false)
invitation =
insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :owner)
post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
assert Repo.reload!(site).locked
end
test "will end the trial of the new owner immediately", %{
conn: conn,
user: user
} do
Repo.update_all(from(u in Plausible.Auth.User, where: u.id == ^user.id),
set: [trial_expiry_date: Timex.today() |> Timex.shift(days: 7)]
)
inviter = insert(:user)
site = insert(:site, locked: false)
invitation =
insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :owner)
post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
assert Timex.before?(Repo.reload!(user).trial_expiry_date, Timex.today())
assert Repo.reload!(site).locked
end
test "if new owner does not have a trial - will set trial_expiry_date to yesterday",
%{
conn: conn,
user: user
} do
Repo.update_all(from(u in Plausible.Auth.User, where: u.id == ^user.id),
set: [trial_expiry_date: nil]
)
inviter = insert(:user)
site = insert(:site, locked: false)
invitation =
insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :owner)
post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
assert Timex.before?(Repo.reload!(user).trial_expiry_date, Timex.today())
assert Repo.reload!(site).locked
end
test "can upgrade admin to owner", %{conn: conn, user: user} do
old_owner = insert(:user)
site = insert(:site, members: [old_owner])
insert(:site_membership, site: site, user: user, role: :admin)
invitation =
insert(:invitation, site_id: site.id, inviter: old_owner, email: user.email, role: :owner)
post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
refute Repo.exists?(from(i in Plausible.Auth.Invitation, where: i.email == ^user.email))
new_owner_membership =
Repo.get_by(Plausible.Site.Membership, user_id: user.id, site_id: site.id)
assert new_owner_membership.role == :owner
end
test "works in self-hosted", %{conn: conn, user: user} do
patch_env(:is_selfhost, true)
old_owner = insert(:user)
site = insert(:site, members: [old_owner])
invitation =
insert(:invitation,
site_id: site.id,
inviter: old_owner,
email: user.email,
role: :owner
)
post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
old_owner_membership =
Repo.get_by(Plausible.Site.Membership, user_id: old_owner.id, site_id: site.id)
assert old_owner_membership.role == :admin
new_owner_membership =
Repo.get_by(Plausible.Site.Membership, user_id: user.id, site_id: site.id)
assert new_owner_membership.role == :owner
end
end
describe "POST /sites/invitations/:invitation_id/reject" do
test "deletes the invitation", %{conn: conn, user: user} do
test "rejects the invitation", %{conn: conn, user: user} do
site = insert(:site)
invitation =
@ -231,24 +91,20 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
role: :admin
)
post(conn, "/sites/invitations/#{invitation.invitation_id}/reject")
conn = post(conn, "/sites/invitations/#{invitation.invitation_id}/reject")
refute Repo.exists?(from(i in Plausible.Auth.Invitation, where: i.email == ^user.email))
end
assert redirected_to(conn, 302) == "/sites"
test "notifies the original inviter", %{conn: conn, user: user} do
inviter = insert(:user)
site = insert(:site)
refute Repo.reload(invitation)
end
invitation =
insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :admin)
test "renders error for non-existent invitation", %{conn: conn} do
conn = post(conn, "/sites/invitations/does-not-exist/reject")
post(conn, "/sites/invitations/#{invitation.invitation_id}/reject")
assert redirected_to(conn, 302) == "/sites"
assert_email_delivered_with(
to: [nil: inviter.email],
subject: "[Plausible Analytics] #{user.email} rejected your invitation to #{site.domain}"
)
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
"Invitation missing or already accepted"
end
end
@ -272,9 +128,7 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
assert redirected_to(conn, 302) == "/#{site.domain}/settings/people"
refute Repo.exists?(
from i in Plausible.Auth.Invitation, where: i.email == "jane@example.com"
)
refute Repo.reload(invitation)
end
test "fails to remove an invitation with insufficient permission", %{conn: conn, user: user} do
@ -293,9 +147,7 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
Routes.invitation_path(conn, :remove_invitation, site.domain, invitation.invitation_id)
)
assert Repo.exists?(
from i in Plausible.Auth.Invitation, where: i.email == "jane@example.com"
)
assert Repo.reload(invitation)
end
test "fails to remove an invitation from the outside", %{conn: my_conn, user: me} do
@ -324,9 +176,26 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
delete(my_conn, remove_invitation_path)
assert Repo.exists?(
from i in Plausible.Auth.Invitation, where: i.email == "jane@example.com"
)
assert Repo.reload(invitation)
end
test "renders error for non-existent invitation", %{conn: conn, user: user} do
site = insert(:site, memberships: [build(:site_membership, user: user, role: :admin)])
remove_invitation_path =
Routes.invitation_path(
conn,
:remove_invitation,
site.domain,
"does_not_exist"
)
conn = delete(conn, remove_invitation_path)
assert redirected_to(conn, 302) == "/#{site.domain}/settings/people"
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
"Invitation missing or already removed"
end
end
end

Loading…
Cancel
Save