Lock traffic notifications (#3641)

* Update communication

* Remove an unreachable function (mistyped)

* [migration] Make accept_traffic_until a date

* Fix typo

* Set `accept_traffic_until` when creating a site

* Update sites `accept_traffic_until` on subscription change

* Add a note to yearly cancellation notification

* Rephrase annual e-mail for clarity

* Pass the small build test

* Add email notifications

* Fixup

* Implement `accept_traffic_until` notification worker

* Fixup - no need to test this for small build

* Update moduledoc

* Move moduletag

* s/sent_at/sent_on

* Use WHERE NOT EXISTS instead of LEFT JOIN

* Use upsert when tracking notifications sent

* Store sent marker before actually sending notification

* Prefer to keep `accept_traffic_until` on the user record

This gives us a single source of truth, addresses cases like
ownership transparently, simplifies the code and enables CRM toggles.
The only downside is that there's another join performed in the
Sites.Cache full refresh - in this case, small refreshes are
skipped - but this is fine, since the traffic will be let in
anyway.

* Expose `accepted_traffic_until` in the CRM

* Update lib/plausible/auth/user.ex

Co-authored-by: Adrian Gruntkowski <adrian.gruntkowski@gmail.com>

* Preload owner in CRM

* Use the offset parameter in trial over e-mail contents

* Format

* Harden cache test

---------

Co-authored-by: Adrian Gruntkowski <adrian.gruntkowski@gmail.com>
pull/3655/head r2023.12.28-296
hq1 3 years ago committed by GitHub
parent 66d4b3a966
commit f755b20569
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -506,7 +506,9 @@ cloud_cron = [
# Daily at 15
{"0 15 * * *", Plausible.Workers.NotifyAnnualRenewal},
# Every midnight
{"0 0 * * *", Plausible.Workers.LockSites}
{"0 0 * * *", Plausible.Workers.LockSites},
# Daily at 5
{"0 5 * * *", Plausible.Workers.AcceptTrafficUntil}
]
crontab = if(is_selfhost, do: base_cron, else: base_cron ++ cloud_cron)
@ -520,7 +522,8 @@ base_queues = [
site_setup_emails: 1,
clean_invitations: 1,
google_analytics_imports: 1,
domain_change_transition: 1
domain_change_transition: 1,
check_accept_traffic_until: 1
]
cloud_queues = [

@ -19,6 +19,9 @@ defmodule Plausible.Auth.User do
@required [:email, :name, :password]
@trial_accept_traffic_until_offset_days 14
@susbscription_accept_traffic_until_offset_days 30
schema "users" do
field :email, :string
field :password_hash
@ -30,6 +33,7 @@ defmodule Plausible.Auth.User do
field :theme, Ecto.Enum, values: [:system, :light, :dark]
field :email_verified, :boolean
field :previous_email, :string
field :accept_traffic_until, :date
# A field only used as a manual override - allow subscribing
# to any plan, even when exceeding its pageview limit
@ -107,12 +111,28 @@ defmodule Plausible.Auth.User do
:email_verified,
:theme,
:trial_expiry_date,
:allow_next_upgrade_override
:allow_next_upgrade_override,
:accept_traffic_until
])
|> validate_required([:email, :name, :email_verified])
|> maybe_bump_accept_traffic_until()
|> unique_constraint(:email)
end
defp maybe_bump_accept_traffic_until(changeset) do
expiry_change = get_change(changeset, :trial_expiry_date)
if expiry_change do
put_change(
changeset,
:accept_traffic_until,
Date.add(expiry_change, @trial_accept_traffic_until_offset_days)
)
else
changeset
end
end
def set_password(user, password) do
user
|> cast(%{password: password}, [:password])
@ -135,7 +155,12 @@ defmodule Plausible.Auth.User do
end
def start_trial(user) do
change(user, trial_expiry_date: trial_expiry())
trial_expiry = trial_expiry()
change(user,
trial_expiry_date: trial_expiry,
accept_traffic_until: Date.add(trial_expiry, @trial_accept_traffic_until_offset_days)
)
end
def end_trial(user) do
@ -183,6 +208,11 @@ defmodule Plausible.Auth.User do
Path.join(PlausibleWeb.Endpoint.url(), ["avatar/", hash])
end
def trial_accept_traffic_until_offset_days(), do: @trial_accept_traffic_until_offset_days
def subscription_accept_traffic_until_offset_days(),
do: @susbscription_accept_traffic_until_offset_days
defp validate_email_changed(changeset) do
if !get_change(changeset, :email) && !changeset.errors[:email] do
add_error(changeset, :email, "can't be the same", validation: :different_email)

@ -14,8 +14,13 @@ defmodule Plausible.Auth.UserAdmin do
name: nil,
email: nil,
previous_email: nil,
trial_expiry_date: nil,
allow_next_upgrade_override: nil
trial_expiry_date: %{
help_text: "Change will also update Accept Traffic Until date"
},
allow_next_upgrade_override: nil,
accept_traffic_until: %{
help_text: "Change will take up to 15 minutes to propagate"
}
]
end
@ -32,7 +37,11 @@ defmodule Plausible.Auth.UserAdmin do
subscription_plan: %{value: &subscription_plan/1},
subscription_status: %{value: &subscription_status/1},
usage: %{value: &usage_link/1},
grace_period: %{value: &grace_period_status/1}
grace_period: %{value: &grace_period_status/1},
accept_traffic_until: %{
name: "Accept traffic until",
value: &format_date(&1.accept_traffic_until)
}
]
end

@ -275,6 +275,7 @@ defmodule Plausible.Billing do
|> Map.put(:subscription, subscription)
user
|> Plausible.Users.update_accept_traffic_until()
|> maybe_remove_grace_period()
|> Plausible.Users.maybe_reset_next_upgrade_override()
|> tap(&Plausible.Billing.SiteLocker.update_sites_for/1)

@ -1,10 +1,10 @@
defmodule Plausible.Ingestion.Counters.TelemetryHandler do
@moduledoc """
Susbcribes to telemetry events emitted by `Plausible.Ingestion.Event`.
Subscribes to telemetry events emitted by `Plausible.Ingestion.Event`.
Every time a request derived event is either dispatched to clickhouse or dropped,
a telemetry event is emitted respectively. That event is captured here,
its metadata is extracted and sent for internal stats aggregation via
`Counters.Buffer` interface.
`Counters.Buffer` interface.
"""
alias Plausible.Ingestion.Counters
alias Plausible.Ingestion.Event

@ -21,7 +21,6 @@ defmodule Plausible.Site do
field :conversions_enabled, :boolean, default: true
field :props_enabled, :boolean, default: true
field :funnels_enabled, :boolean, default: true
field :accept_traffic_until, :naive_datetime
field :ingest_rate_limit_scale_seconds, :integer, default: 60
# default is set via changeset/2

@ -14,7 +14,11 @@ defmodule Plausible.SiteAdmin do
end
def custom_index_query(_conn, _schema, query) do
from(r in query, preload: [memberships: :user])
from(r in query,
inner_join: o in assoc(r, :owner),
inner_join: m in assoc(r, :memberships),
preload: [owner: o, memberships: {m, :user}]
)
end
def form_fields(_) do
@ -39,15 +43,26 @@ defmodule Plausible.SiteAdmin do
inserted_at: %{name: "Created at", value: &format_date(&1.inserted_at)},
timezone: nil,
public: nil,
owner: %{value: &get_owner_email/1},
owner: %{value: &get_owner/1},
other_members: %{value: &get_other_members/1},
limits: %{
value: fn site ->
case site.ingest_rate_limit_threshold do
nil -> ""
0 -> "🛑 BLOCKED"
n -> "⏱ #{n}/#{site.ingest_rate_limit_scale_seconds}s (per server)"
end
rate_limiting_status =
case site.ingest_rate_limit_threshold do
nil -> ""
0 -> "🛑 BLOCKED"
n -> "⏱ #{n}/#{site.ingest_rate_limit_scale_seconds}s (per server)"
end
owner = site.owner
owner_limits =
if owner.accept_traffic_until &&
Date.after?(Date.utc_today(), owner.accept_traffic_until) do
"💸 Rejecting traffic"
end
{:safe, Enum.join([rate_limiting_status, owner_limits], "<br/><br/>")}
end
}
]
@ -132,11 +147,16 @@ defmodule Plausible.SiteAdmin do
Timex.format!(date, "{Mshort} {D}, {YYYY}")
end
defp get_owner_email(site) do
owner = Enum.find(site.memberships, fn m -> m.role == :owner end)
defp get_owner(site) do
owner = site.owner
if owner do
owner.user.email
{:safe,
"""
<a href="/crm/auth/user/#{owner.id}">#{owner.name}</a>
<br/><br/>
#{owner.email}
"""}
end
end

@ -56,7 +56,6 @@ defmodule Plausible.Site.Cache do
domain_changed_from
ingest_rate_limit_scale_seconds
ingest_rate_limit_threshold
accept_traffic_until
)a
@type t() :: Site.t()
@ -117,12 +116,13 @@ defmodule Plausible.Site.Cache do
defp sites_by_domain_query do
from s in Site,
left_join: rg in assoc(s, :revenue_goals),
inner_join: owner in assoc(s, :owner),
select: {
s.domain,
s.domain_changed_from,
%{struct(s, ^@cached_schema_fields) | from_cache?: true}
},
preload: [revenue_goals: rg]
preload: [revenue_goals: rg, owner: owner]
end
@spec merge(new_items :: [Site.t()], opts :: Keyword.t()) :: :ok

@ -44,9 +44,9 @@ defmodule Plausible.Site.GateKeeper do
defp policy(domain, opts) when is_binary(domain) do
with from_cache <- Cache.get(domain, Keyword.get(opts, :cache_opts, [])),
site = %Site{accept_traffic_until: accept_traffic_until} <- from_cache do
site = %Site{owner: %{accept_traffic_until: accept_traffic_until}} <- from_cache do
if not is_nil(accept_traffic_until) and
NaiveDateTime.after?(NaiveDateTime.utc_now(), accept_traffic_until) do
Date.after?(Date.utc_today(), accept_traffic_until) do
:payment_required
else
check_rate_limit(site, opts)

@ -2,6 +2,8 @@ defmodule Plausible.Users do
@moduledoc """
User context
"""
use Plausible
@accept_traffic_until_free ~D[2135-01-01]
import Ecto.Query
@ -9,6 +11,42 @@ defmodule Plausible.Users do
alias Plausible.Billing.Subscription
alias Plausible.Repo
@spec update_accept_traffic_until(Auth.User.t()) :: Auth.User.t()
def update_accept_traffic_until(user) do
user
|> Auth.User.changeset(%{accept_traffic_until: accept_traffic_until(user)})
|> Repo.update!()
end
@spec accept_traffic_until(Auth.User.t()) :: Date.t()
on_full_build do
def accept_traffic_until(user) do
user = with_subscription(user)
cond do
Plausible.Billing.on_trial?(user) ->
Timex.shift(user.trial_expiry_date,
days: Auth.User.trial_accept_traffic_until_offset_days()
)
user.subscription && user.subscription.paddle_plan_id == "free_10k" ->
@accept_traffic_until_free
user.subscription && user.subscription.next_bill_date ->
Timex.shift(user.subscription.next_bill_date,
days: Auth.User.subscription_accept_traffic_until_offset_days()
)
true ->
raise "This user is neither on trial or has a valid subscription. Manual intervention required."
end
end
else
def accept_traffic_until(_user) do
@accept_traffic_until_free
end
end
def with_subscription(%Auth.User{id: user_id} = user) do
Repo.preload(user, subscription: last_subscription_query(user_id))
end

@ -150,8 +150,4 @@ defmodule PlausibleWeb.BillingController do
{:error, :no_subscription}
end
end
def preview_susbcription(_, _) do
{:error, :no_user_id}
end
end

@ -113,7 +113,10 @@ defmodule PlausibleWeb.Email do
|> to(user)
|> tag("trial-over-email")
|> subject("Your Plausible trial has ended")
|> render("trial_over_email.html", user: user)
|> render("trial_over_email.html",
user: user,
extra_offset: Plausible.Auth.User.trial_accept_traffic_until_offset_days()
)
end
def stats_report(email, assigns) do
@ -190,7 +193,12 @@ defmodule PlausibleWeb.Email do
end
def yearly_expiration_notification(user) do
date = Timex.format!(user.subscription.next_bill_date, "{Mfull} {D}, {YYYY}")
next_bill_date = Timex.format!(user.subscription.next_bill_date, "{Mfull} {D}, {YYYY}")
accept_traffic_until =
user
|> Plausible.Users.accept_traffic_until()
|> Timex.format!("{Mfull} {D}, {YYYY}")
priority_email()
|> to(user)
@ -198,7 +206,8 @@ defmodule PlausibleWeb.Email do
|> subject("Your Plausible subscription is about to expire")
|> render("yearly_expiration_notification.html", %{
user: user,
date: date
next_bill_date: next_bill_date,
accept_traffic_until: accept_traffic_until
})
end
@ -344,6 +353,22 @@ defmodule PlausibleWeb.Email do
})
end
def approaching_accept_traffic_until(user) do
base_email()
|> to(user.email)
|> tag("drop-traffic-warning-first")
|> subject("We'll stop counting your stats")
|> render("approaching_accept_traffic_until.html", time: "next week")
end
def approaching_accept_traffic_until_tomorrow(user) do
base_email()
|> to(user.email)
|> tag("drop-traffic-warning-final")
|> subject("A reminder that we'll stop counting your stats tomorrow")
|> render("approaching_accept_traffic_until.html", time: "tomorrow")
end
@doc """
Unlike the default 'base' emails, priority emails cannot be unsubscribed from. This is achieved
by sending them through a dedicated 'priority' message stream in Postmark.

@ -0,0 +1,8 @@
You used to have an active account with Plausible Analytics, a simple, lightweight, open source and privacy-first Google Analytics alternative.
We've noticed that you're still sending us stats so we're writing to inform you that we'll stop accepting stats from your sites <%= @time %>. We're an independent, bootstrapped service and we don't sell your data, so this will reduce our server costs and help keep us sustainable.
If you'd like to continue counting your site stats in a privacy-friendly way, please
<a href={plausible_url()}>login to your Plausible account</a> and start a subscription.
Do you have any questions or need help with anything? Just reply to this email and we'll gladly help.

@ -3,4 +3,4 @@ Your free Plausible trial has now expired. Upgrade your account to continue rece
<%= link("Upgrade now", to: PlausibleWeb.Router.Helpers.billing_url(PlausibleWeb.Endpoint, :choose_plan)) %>
<br /><br />
We will keep recording stats for another month to give you time to upgrade.
We will keep recording stats for <%= @extra_offset %> days to give you time to upgrade.

@ -1,7 +1,9 @@
Time flies! This is a reminder that your annual subscription for Plausible Analytics will expire on <%= @date %>.
Time flies! This is a reminder that your annual subscription for Plausible Analytics will expire on <%= @next_bill_date %>.
<br /><br />
You need to <%= link("renew your subscription", to: PlausibleWeb.Router.Helpers.billing_url(PlausibleWeb.Endpoint, :choose_plan)) %> if you want to continue using Plausible to count your website stats in a privacy-friendly way.
<br /><br />
If you don't want to continue your subscription, there's no action required. You will lose access to the stats on <%= @date %>.
If you don't want to continue your subscription, there's no action required. You will lose access to your dashboard on <%= @next_bill_date %>.
<br /><br />
Have a question, feedback or need some guidance? Just reply to this email to get in touch!
Note that we'll stop accepting stats on <%= @accept_traffic_until %>. We're an independent, bootstrapped service and we don't sell your data, so this will reduce our server costs and help keep us sustainable. If you'd like to continue counting your site stats in a privacy-friendly way, please login to your Plausible account and renew your subscription.

@ -43,7 +43,7 @@
your account. If you do not upgrade your account <%= grace_period_end(
@conn.assigns[:current_user]
) %>, we will
lock your stats and they won't be accessible. <%= link("Upgrade now →",
lock your dashboard and it won't be accessible. <%= link("Upgrade now →",
to: "/settings",
class: "text-sm font-medium text-yellow-800"
) %>

@ -0,0 +1,95 @@
defmodule Plausible.Workers.AcceptTrafficUntil do
@moduledoc """
A worker meant to be run once a day that sends out e-mail notifications to site
owners assuming:
- their sites still receive traffic (i.e. have stats for yesterday)
- `site.accept_traffic_until` is approaching either tomorrow or exactly in 7 days
Users having no sites or sites that receive no traffic, won't be notified.
We make a tiny effort here to make sure we send the same notification at most once a day.
"""
use Oban.Worker, queue: :check_accept_traffic_until
import Ecto.Query
alias Plausible.Auth.User
alias Plausible.Site
alias Plausible.Repo
alias Plausible.ClickhouseRepo
@impl Oban.Worker
def perform(_job, today \\ Date.utc_today()) do
tomorrow = today |> Date.add(+1)
next_week = today |> Date.add(+7)
# send at most one notification per user, per day
sent_today_query =
from s in "sent_accept_traffic_until_notifications",
where: s.user_id == parent_as(:user).id and s.sent_on == ^today,
select: true
notifications =
Repo.all(
from u in User,
as: :user,
join: sm in Site.Membership,
on: sm.user_id == u.id,
where: sm.role == :owner,
where: u.accept_traffic_until == ^tomorrow or u.accept_traffic_until == ^next_week,
where: not exists(sent_today_query),
select: %{
id: u.id,
email: u.email,
deadline: u.accept_traffic_until,
site_ids: fragment("array_agg(?.site_id)", sm)
},
group_by: u.id
)
for notification <- notifications do
case {has_stats?(notification.site_ids, today), notification.deadline} do
{true, ^tomorrow} ->
notification
|> store_sent(today)
|> PlausibleWeb.Email.approaching_accept_traffic_until_tomorrow()
|> Plausible.Mailer.send()
{true, ^next_week} ->
notification
|> store_sent(today)
|> PlausibleWeb.Email.approaching_accept_traffic_until()
|> Plausible.Mailer.send()
_ ->
nil
end
end
{:ok, Enum.count(notifications)}
end
defp has_stats?(site_ids, today) do
yesterday = Date.add(today, -1)
ClickhouseRepo.exists?(
from e in "events_v2",
where: fragment("toDate(?) >= ?", e.timestamp, ^yesterday),
where: e.site_id in ^site_ids
)
end
defp store_sent(notification, today) do
Repo.insert_all(
"sent_accept_traffic_until_notifications",
[
%{
user_id: notification.id,
sent_on: today
}
],
on_conflict: :nothing,
conflict_target: [:user_id, :sent_on]
)
notification
end
end

@ -0,0 +1,56 @@
defmodule Plausible.UsersTest do
use Plausible.DataCase, async: true
alias Plausible.Users
alias Plausible.Auth.User
alias Plausible.Repo
describe "update_accept_traffic_until" do
@describetag :full_build_only
test "update" do
user = insert(:user) |> User.start_trial() |> Repo.update!()
# 30 for trial + 14
assert Date.diff(user.accept_traffic_until, Date.utc_today()) ==
30 + User.trial_accept_traffic_until_offset_days()
future = Date.add(Date.utc_today(), 30)
insert(:subscription, user: user, next_bill_date: future)
assert updated_user = Users.update_accept_traffic_until(user)
assert Date.diff(updated_user.accept_traffic_until, future) ==
User.subscription_accept_traffic_until_offset_days()
end
test "retrieve: trial + 14 days" do
user = insert(:user)
assert Users.accept_traffic_until(user) ==
Date.utc_today() |> Date.add(30 + User.trial_accept_traffic_until_offset_days())
end
test "retrieve: last_bill_date + 30 days" do
future = Date.add(Date.utc_today(), 30)
user = insert(:user, subscription: build(:subscription, next_bill_date: future))
assert Users.accept_traffic_until(user) ==
future |> Date.add(User.subscription_accept_traffic_until_offset_days())
end
test "retrieve: free plan" do
user = insert(:user, subscription: build(:subscription, paddle_plan_id: "free_10k"))
assert Users.accept_traffic_until(user) == ~D[2135-01-01]
end
test "retrieve: invalid user (there's one in the prod DB as of today, due to some testing)" do
user = insert(:user, trial_expiry_date: nil)
assert_raise RuntimeError,
~r/Manual intervention required/,
fn ->
assert Users.accept_traffic_until(user) == ~D[2135-01-01]
end
end
end
end

@ -189,6 +189,19 @@ defmodule Plausible.BillingTest do
refute Repo.reload!(site).locked
end
@tag :full_build_only
test "updates accept_traffic_until" do
user = insert(:user)
%{@subscription_created_params | "passthrough" => user.id}
|> Billing.subscription_created()
next_bill = Date.from_iso8601!(@subscription_created_params["next_bill_date"])
assert Repo.reload!(user).accept_traffic_until ==
Date.add(next_bill, 30)
end
test "sets user.allow_next_upgrade_override field to false" do
user = insert(:user, allow_next_upgrade_override: true)
@ -250,6 +263,24 @@ defmodule Plausible.BillingTest do
refute Repo.reload!(site).locked
end
@tag :full_build_only
test "updates accept_traffic_until" do
user = insert(:user)
subscription = insert(:subscription, user: user)
@subscription_updated_params
|> Map.merge(%{
"subscription_id" => subscription.paddle_subscription_id,
"passthrough" => user.id
})
|> Billing.subscription_updated()
next_bill = Date.from_iso8601!(@subscription_updated_params["next_bill_date"])
assert Repo.reload!(user).accept_traffic_until ==
Date.add(next_bill, 30)
end
test "sets user.allow_next_upgrade_override field to false" do
user = insert(:user, allow_next_upgrade_override: true)
subscription = insert(:subscription, user: user)

@ -118,8 +118,13 @@ defmodule Plausible.Ingestion.EventTest do
end
test "event pipeline drops events for site with accept_trafic_until in the past" do
yesterday = NaiveDateTime.add(NaiveDateTime.utc_now(), -1, :day)
site = insert(:site, ingest_rate_limit_threshold: 1, accept_traffic_until: yesterday)
yesterday = Date.add(Date.utc_today(), -1)
site =
insert(:site,
ingest_rate_limit_threshold: 1,
members: [build(:user, accept_traffic_until: yesterday)]
)
payload = %{
name: "pageview",

@ -36,7 +36,23 @@ defmodule Plausible.Site.CacheTest do
%{id: first_id} = site1 = insert(:site, domain: "site1.example.com")
_ =
insert(:site, domain: "site2.example.com", accept_traffic_until: ~N[2021-01-01 00:00:00])
insert(:site,
domain: "site2.example.com",
memberships: [
build(:site_membership,
user: build(:user, accept_traffic_until: ~D[2022-01-01]),
role: :viewer
),
build(:site_membership,
user: build(:user, accept_traffic_until: ~D[2021-01-01]),
role: :owner
),
build(:site_membership,
user: build(:user, accept_traffic_until: ~D[2020-01-01]),
role: :admin
)
]
)
:ok = Cache.refresh_all(cache_name: test)
@ -50,7 +66,7 @@ defmodule Plausible.Site.CacheTest do
assert %Site{from_cache?: true} =
Cache.get("site2.example.com", force?: true, cache_name: test)
assert %Site{from_cache?: false, accept_traffic_until: ~N[2021-01-01 00:00:00]} =
assert %Site{from_cache?: false, owner: %{accept_traffic_until: ~D[2021-01-01]}} =
Cache.get("site2.example.com", cache_name: test)
refute Cache.get("site3.example.com", cache_name: test, force?: true)

@ -16,9 +16,13 @@ defmodule Plausible.Site.GateKeeperTest do
test "sites with accepted_traffic_until < now are denied", %{test: test, opts: opts} do
domain = "expired.example.com"
yesterday = NaiveDateTime.utc_now() |> NaiveDateTime.add(-1, :day)
yesterday = Date.utc_today() |> Date.add(-1)
%{id: _} = add_site_and_refresh_cache(test, domain: domain, accept_traffic_until: yesterday)
%{id: _} =
add_site_and_refresh_cache(test,
domain: domain,
members: [build(:user, accept_traffic_until: yesterday)]
)
assert {:deny, :payment_required} = GateKeeper.check(domain, opts)
end

@ -3,6 +3,17 @@ defmodule Plausible.SitesTest do
alias Plausible.Sites
describe "create a site" do
test "creates a site" do
user = insert(:user)
params = %{"domain" => "example.com", "timezone" => "Europe/London"}
assert {:ok, %{site: %{domain: "example.com", timezone: "Europe/London"}}} =
Sites.create(user, params)
end
end
describe "is_member?" do
test "is true if user is a member of the site" do
user = insert(:user)

@ -245,6 +245,34 @@ defmodule PlausibleWeb.EmailTest do
end
end
describe "approaching accept_traffic_until" do
test "renders first warning" do
user = build(:user)
%{html_body: body, subject: subject} =
PlausibleWeb.Email.approaching_accept_traffic_until(user)
assert subject == "We'll stop counting your stats"
assert body =~ plausible_link()
assert body =~
"We've noticed that you're still sending us stats so we're writing to inform you that we'll stop accepting stats from your sites next week."
end
test "renders final warning" do
user = build(:user)
%{html_body: body, subject: subject} =
PlausibleWeb.Email.approaching_accept_traffic_until_tomorrow(user)
assert subject == "A reminder that we'll stop counting your stats tomorrow"
assert body =~ plausible_link()
assert body =~
"We've noticed that you're still sending us stats so we're writing to inform you that we'll stop accepting stats from your sites tomorrow."
end
end
def plausible_link() do
plausible_url = PlausibleWeb.EmailView.plausible_url()
"<a href=\"#{plausible_url}\">#{plausible_url}</a>"

@ -213,6 +213,10 @@ defmodule Plausible.TestUtils do
NaiveDateTime.truncate(naive, :second)
end
def to_naive_truncate(%Date{} = date) do
NaiveDateTime.new!(date, ~T[00:00:00])
end
def eventually(expectation, wait_time_ms \\ 50, retries \\ 10) do
Enum.reduce_while(1..retries, nil, fn attempt, _acc ->
case expectation.() do

@ -0,0 +1,126 @@
defmodule Plausible.Workers.AcceptTrafficUntilTest do
use Plausible.DataCase, async: true
use Bamboo.Test
alias Plausible.Workers.AcceptTrafficUntil
@moduletag :full_build_only
test "does not send any notifications when sites have no stats" do
today = Date.utc_today()
next_week = today |> Date.add(+7)
tomorrow = today |> Date.add(+1)
user1 = insert(:user, accept_traffic_until: next_week)
user2 = insert(:user, accept_traffic_until: tomorrow)
_site1 = insert(:site, members: [user1])
_site2 = insert(:site, members: [user2])
{:ok, 2} = AcceptTrafficUntil.perform(nil)
refute_notifications(user1.email)
refute_notifications(user2.email)
end
test "tomorrow: sends one e-mail" do
tomorrow = Date.utc_today() |> Date.add(+1)
user = insert(:user, accept_traffic_until: tomorrow)
:site |> insert(members: [user]) |> populate_stats([build(:pageview)])
{:ok, 1} = AcceptTrafficUntil.perform(nil)
assert_final_notification(user.email)
end
test "next week: sends one e-mail" do
next_week = Date.utc_today() |> Date.add(+7)
user = insert(:user, accept_traffic_until: next_week)
:site |> insert(members: [user]) |> populate_stats([build(:pageview)])
{:ok, 1} = AcceptTrafficUntil.perform(nil)
assert_weekly_notification(user.email)
end
test "sends combined warnings in one shot" do
today = Date.utc_today()
next_week = today |> Date.add(+7)
tomorrow = today |> Date.add(+1)
in_8_days = today |> Date.add(+8)
user1 = insert(:user, accept_traffic_until: next_week)
user2 = insert(:user, accept_traffic_until: tomorrow)
user3 = insert(:user, accept_traffic_until: in_8_days, email: "nope@example.com")
user4 = insert(:user, accept_traffic_until: today, email: "nope2@example.com")
:site |> insert(members: [user1]) |> populate_stats([build(:pageview)])
:site |> insert(members: [user2]) |> populate_stats([build(:pageview)])
:site |> insert(members: [user3]) |> populate_stats([build(:pageview)])
:site |> insert(members: [user4]) |> populate_stats([build(:pageview)])
{:ok, 2} = AcceptTrafficUntil.perform(nil)
assert_weekly_notification(user1.email)
assert_final_notification(user2.email)
refute_notifications("nope@example.com")
refute_notifications("nope2@example.com")
end
test "sends multiple notifications per recipient as the time passes" do
today = Date.utc_today()
email = "cycle@example.com"
user = insert(:user, email: email) |> Plausible.Auth.User.start_trial() |> Repo.update!()
site = insert(:site, members: [user])
populate_stats(site, [
build(:pageview, timestamp: today),
build(:pageview, timestamp: Date.add(user.trial_expiry_date, 7)),
build(:pageview, timestamp: Date.add(user.trial_expiry_date, 8)),
build(:pageview, timestamp: Date.add(user.trial_expiry_date, 13))
])
# today's worker is no-op
{:ok, 0} = AcceptTrafficUntil.perform(nil, today)
refute_notifications(email)
# trial_expiry + 7 days worker => we'll stop counting next week
{:ok, 1} = AcceptTrafficUntil.perform(nil, Date.add(user.trial_expiry_date, 7))
assert_weekly_notification(email)
# another call on the same day == no-op, e-mail already sent
{:ok, 0} = AcceptTrafficUntil.perform(nil, Date.add(user.trial_expiry_date, 7))
refute_notifications(email)
# another call on another day == no-op, no notification type applies
{:ok, 0} = AcceptTrafficUntil.perform(nil, Date.add(user.trial_expiry_date, 8))
refute_notifications(email)
# day before accept_stats_until (trial_expiry_date + 14 - 1)
{:ok, 1} = AcceptTrafficUntil.perform(nil, Date.add(user.trial_expiry_date, 13))
assert_final_notification(email)
# another one on the day before accept_stats_until (trial_expiry_date + 14 - 1) == no-op
{:ok, 0} = AcceptTrafficUntil.perform(nil, Date.add(user.trial_expiry_date, 13))
refute_notifications(email)
end
defp assert_weekly_notification(email) when is_binary(email) do
assert_email_delivered_with(
to: [nil: email],
subject: PlausibleWeb.Email.approaching_accept_traffic_until(%{email: email}).subject
)
end
defp assert_final_notification(email) when is_binary(email) do
assert_email_delivered_with(
to: [nil: email],
subject:
PlausibleWeb.Email.approaching_accept_traffic_until_tomorrow(%{email: email}).subject
)
end
defp refute_notifications(email) when is_binary(email) do
refute_email_delivered_with(to: [nil: email])
end
end
Loading…
Cancel
Save