From e67850c11dc41f8d4580499d86a2cd825fe657f1 Mon Sep 17 00:00:00 2001 From: Adrian Gruntkowski Date: Mon, 2 Oct 2023 14:57:57 +0200 Subject: [PATCH] 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 * Make invitation removal and rejection resilient to races --------- Co-authored-by: hq1 --- lib/plausible/billing/billing.ex | 57 ++-- lib/plausible/billing/site_locker.ex | 51 ++- lib/plausible/mailer.ex | 4 +- lib/plausible/site/membership.ex | 16 +- lib/plausible/site/memberships.ex | 11 + .../site/memberships/accept_invitation.ex | 163 +++++++++ lib/plausible/site/memberships/invitations.ex | 45 +++ .../site/memberships/reject_invitation.ex | 29 ++ .../site/memberships/remove_invitation.ex | 18 + lib/plausible/sites.ex | 24 +- .../controllers/invitation_controller.ex | 158 +++------ .../controllers/site/membership_controller.ex | 10 +- .../controllers/site_controller.ex | 2 +- .../templates/site/index.html.eex | 2 +- lib/workers/lock_sites.ex | 2 +- test/plausible/billing/billing_test.exs | 31 +- test/plausible/billing/site_locker_test.exs | 122 +++++-- .../memberships/accept_invitation_test.exs | 323 ++++++++++++++++++ .../memberships/reject_invitation_test.exs | 58 ++++ .../memberships/remove_invitation_test.exs | 52 +++ test/plausible/site/sites_test.exs | 32 +- .../external_stats_controller/auth_test.exs | 4 +- .../invitation_controller_test.exs | 197 ++--------- 23 files changed, 1035 insertions(+), 376 deletions(-) create mode 100644 lib/plausible/site/memberships.ex create mode 100644 lib/plausible/site/memberships/accept_invitation.ex create mode 100644 lib/plausible/site/memberships/invitations.ex create mode 100644 lib/plausible/site/memberships/reject_invitation.ex create mode 100644 lib/plausible/site/memberships/remove_invitation.ex create mode 100644 test/plausible/site/memberships/accept_invitation_test.exs create mode 100644 test/plausible/site/memberships/reject_invitation_test.exs create mode 100644 test/plausible/site/memberships/remove_invitation_test.exs diff --git a/lib/plausible/billing/billing.ex b/lib/plausible/billing/billing.ex index 5581c088e..932f55adb 100644 --- a/lib/plausible/billing/billing.ex +++ b/lib/plausible/billing/billing.ex @@ -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 diff --git a/lib/plausible/billing/site_locker.ex b/lib/plausible/billing/site_locker.ex index 1cec2e836..cb4802287 100644 --- a/lib/plausible/billing/site_locker.ex +++ b/lib/plausible/billing/site_locker.ex @@ -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) diff --git a/lib/plausible/mailer.ex b/lib/plausible/mailer.ex index c63ab3059..f7c6acb0c 100644 --- a/lib/plausible/mailer.ex +++ b/lib/plausible/mailer.ex @@ -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 diff --git a/lib/plausible/site/membership.ex b/lib/plausible/site/membership.ex index 52e7c94e8..6e663faf5 100644 --- a/lib/plausible/site/membership.ex +++ b/lib/plausible/site/membership.ex @@ -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 diff --git a/lib/plausible/site/memberships.ex b/lib/plausible/site/memberships.ex new file mode 100644 index 000000000..71dc272d1 --- /dev/null +++ b/lib/plausible/site/memberships.ex @@ -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 diff --git a/lib/plausible/site/memberships/accept_invitation.ex b/lib/plausible/site/memberships/accept_invitation.ex new file mode 100644 index 000000000..95043cd8f --- /dev/null +++ b/lib/plausible/site/memberships/accept_invitation.ex @@ -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 diff --git a/lib/plausible/site/memberships/invitations.ex b/lib/plausible/site/memberships/invitations.ex new file mode 100644 index 000000000..f51e5beb9 --- /dev/null +++ b/lib/plausible/site/memberships/invitations.ex @@ -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 diff --git a/lib/plausible/site/memberships/reject_invitation.ex b/lib/plausible/site/memberships/reject_invitation.ex new file mode 100644 index 000000000..40b1a1e2b --- /dev/null +++ b/lib/plausible/site/memberships/reject_invitation.ex @@ -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 diff --git a/lib/plausible/site/memberships/remove_invitation.ex b/lib/plausible/site/memberships/remove_invitation.ex new file mode 100644 index 000000000..abb650fe7 --- /dev/null +++ b/lib/plausible/site/memberships/remove_invitation.ex @@ -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 diff --git a/lib/plausible/sites.ex b/lib/plausible/sites.ex index 1823df2ba..ee10cca76 100644 --- a/lib/plausible/sites.ex +++ b/lib/plausible/sites.ex @@ -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 diff --git a/lib/plausible_web/controllers/invitation_controller.ex b/lib/plausible_web/controllers/invitation_controller.ex index 26435f0ff..b8a1934a9 100644 --- a/lib/plausible_web/controllers/invitation_controller.ex +++ b/lib/plausible_web/controllers/invitation_controller.ex @@ -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 diff --git a/lib/plausible_web/controllers/site/membership_controller.ex b/lib/plausible_web/controllers/site/membership_controller.ex index b90785942..c6004cbf1 100644 --- a/lib/plausible_web/controllers/site/membership_controller.ex +++ b/lib/plausible_web/controllers/site/membership_controller.ex @@ -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 = diff --git a/lib/plausible_web/controllers/site_controller.ex b/lib/plausible_web/controllers/site_controller.ex index ac994ab0c..db6c18a03 100644 --- a/lib/plausible_web/controllers/site_controller.ex +++ b/lib/plausible_web/controllers/site_controller.ex @@ -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 diff --git a/lib/plausible_web/templates/site/index.html.eex b/lib/plausible_web/templates/site/index.html.eex index b1c4ac81b..4d50c10c6 100644 --- a/lib/plausible_web/templates/site/index.html.eex +++ b/lib/plausible_web/templates/site/index.html.eex @@ -1,6 +1,6 @@
- <%= if @needs_to_upgrade == {true, :no_active_subscription} do %> + <%= if @needs_to_upgrade == {:needs_to_upgrade, :no_active_subscription} do %>
diff --git a/lib/workers/lock_sites.ex b/lib/workers/lock_sites.ex index 69356d6cd..e1007dcb3 100644 --- a/lib/workers/lock_sites.ex +++ b/lib/workers/lock_sites.ex @@ -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 diff --git a/test/plausible/billing/billing_test.exs b/test/plausible/billing/billing_test.exs index e924c7506..d49b4997d 100644 --- a/test/plausible/billing/billing_test.exs +++ b/test/plausible/billing/billing_test.exs @@ -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 diff --git a/test/plausible/billing/site_locker_test.exs b/test/plausible/billing/site_locker_test.exs index 52b6859f8..58292fc18 100644 --- a/test/plausible/billing/site_locker_test.exs +++ b/test/plausible/billing/site_locker_test.exs @@ -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) diff --git a/test/plausible/site/memberships/accept_invitation_test.exs b/test/plausible/site/memberships/accept_invitation_test.exs new file mode 100644 index 000000000..b5c38e2ef --- /dev/null +++ b/test/plausible/site/memberships/accept_invitation_test.exs @@ -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 diff --git a/test/plausible/site/memberships/reject_invitation_test.exs b/test/plausible/site/memberships/reject_invitation_test.exs new file mode 100644 index 000000000..f6149c00d --- /dev/null +++ b/test/plausible/site/memberships/reject_invitation_test.exs @@ -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 diff --git a/test/plausible/site/memberships/remove_invitation_test.exs b/test/plausible/site/memberships/remove_invitation_test.exs new file mode 100644 index 000000000..7df3ffe21 --- /dev/null +++ b/test/plausible/site/memberships/remove_invitation_test.exs @@ -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 diff --git a/test/plausible/site/sites_test.exs b/test/plausible/site/sites_test.exs index 41d9e2ad0..34385bc99 100644 --- a/test/plausible/site/sites_test.exs +++ b/test/plausible/site/sites_test.exs @@ -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) diff --git a/test/plausible_web/controllers/api/external_stats_controller/auth_test.exs b/test/plausible_web/controllers/api/external_stats_controller/auth_test.exs index 1c6117aa7..25016f6e0 100644 --- a/test/plausible_web/controllers/api/external_stats_controller/auth_test.exs +++ b/test/plausible_web/controllers/api/external_stats_controller/auth_test.exs @@ -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) diff --git a/test/plausible_web/controllers/invitation_controller_test.exs b/test/plausible_web/controllers/invitation_controller_test.exs index 8121b4485..d68ab6733 100644 --- a/test/plausible_web/controllers/invitation_controller_test.exs +++ b/test/plausible_web/controllers/invitation_controller_test.exs @@ -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