Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
Lock traffic notifications (#3641)
hq1f755b2056992
diff --git a/config/runtime.exs b/config/runtime.exsindex 7339e64ec3..02d06211e4 100644--- a/config/runtime.exs+++ b/config/runtime.exs@@ -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 = [diff --git a/lib/plausible/auth/user.ex b/lib/plausible/auth/user.exindex b0ecc5b1ac..7dc117ff45 100644--- a/lib/plausible/auth/user.ex+++ b/lib/plausible/auth/user.ex@@ -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" dofield :email, :stringfield :password_hash@@ -30,6 +33,7 @@ defmodule Plausible.Auth.User dofield :theme, Ecto.Enum, values: [:system, :light, :dark]field :email_verified, :booleanfield :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) douser|> cast(%{password: password}, [:password])@@ -135,7 +155,12 @@ defmodule Plausible.Auth.User doenddef 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)+ )enddef end_trial(user) do@@ -183,6 +208,11 @@ defmodule Plausible.Auth.User doPath.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) doif !get_change(changeset, :email) && !changeset.errors[:email] doadd_error(changeset, :email, "can't be the same", validation: :different_email)diff --git a/lib/plausible/auth/user_admin.ex b/lib/plausible/auth/user_admin.exindex 2cd6c3c944..690e34c1a4 100644--- a/lib/plausible/auth/user_admin.ex+++ b/lib/plausible/auth/user_admin.ex@@ -14,8 +14,13 @@ defmodule Plausible.Auth.UserAdmin doname: 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 dosubscription_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)+ }]enddiff --git a/lib/plausible/billing/billing.ex b/lib/plausible/billing/billing.exindex fcc5d2785c..5a958f51c9 100644--- a/lib/plausible/billing/billing.ex+++ b/lib/plausible/billing/billing.ex@@ -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)diff --git a/lib/plausible/ingestion/counters/telemetry_handler.ex b/lib/plausible/ingestion/counters/telemetry_handler.exindex a4b264ee97..1abfa83ca3 100644--- a/lib/plausible/ingestion/counters/telemetry_handler.ex+++ b/lib/plausible/ingestion/counters/telemetry_handler.ex@@ -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.Countersalias Plausible.Ingestion.Eventdiff --git a/lib/plausible/site.ex b/lib/plausible/site.exindex 8a1a5e3607..c571619abe 100644--- a/lib/plausible/site.ex+++ b/lib/plausible/site.ex@@ -21,7 +21,6 @@ defmodule Plausible.Site dofield :conversions_enabled, :boolean, default: truefield :props_enabled, :boolean, default: truefield :funnels_enabled, :boolean, default: true- field :accept_traffic_until, :naive_datetimefield :ingest_rate_limit_scale_seconds, :integer, default: 60# default is set via changeset/2diff --git a/lib/plausible/site/admin.ex b/lib/plausible/site/admin.exindex c4b75113f2..7bf3e0c031 100644--- a/lib/plausible/site/admin.ex+++ b/lib/plausible/site/admin.ex@@ -14,7 +14,11 @@ defmodule Plausible.SiteAdmin doenddef 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}]+ )enddef form_fields(_) do@@ -39,15 +43,26 @@ defmodule Plausible.SiteAdmin doinserted_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 doTimex.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.ownerif owner do- owner.user.email+ {:safe,+ """+ <a href="/crm/auth/user/#{owner.id}">#{owner.name}</a>+ <br/><br/>+ #{owner.email}+ """}endenddiff --git a/lib/plausible/site/cache.ex b/lib/plausible/site/cache.exindex 55df2bf4e4..21c7417cfe 100644--- a/lib/plausible/site/cache.ex+++ b/lib/plausible/site/cache.ex@@ -56,7 +56,6 @@ defmodule Plausible.Site.Cache dodomain_changed_fromingest_rate_limit_scale_secondsingest_rate_limit_threshold- accept_traffic_until)a@type t() :: Site.t()@@ -117,12 +116,13 @@ defmodule Plausible.Site.Cache dodefp sites_by_domain_query dofrom 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()) :: :okdiff --git a/lib/plausible/site/gate_keeper.ex b/lib/plausible/site/gate_keeper.exindex ca3df06d8b..e552f16374 100644--- a/lib/plausible/site/gate_keeper.ex+++ b/lib/plausible/site/gate_keeper.ex@@ -44,9 +44,9 @@ defmodule Plausible.Site.GateKeeper dodefp policy(domain, opts) when is_binary(domain) dowith 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 doif 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_requiredelsecheck_rate_limit(site, opts)diff --git a/lib/plausible/users.ex b/lib/plausible/users.exindex 3d07cfff07..3cd22453bb 100644--- a/lib/plausible/users.ex+++ b/lib/plausible/users.ex@@ -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 doalias Plausible.Billing.Subscriptionalias 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) doRepo.preload(user, subscription: last_subscription_query(user_id))enddiff --git a/lib/plausible_web/controllers/billing_controller.ex b/lib/plausible_web/controllers/billing_controller.exindex b8abf6db00..6069e2958b 100644--- a/lib/plausible_web/controllers/billing_controller.ex+++ b/lib/plausible_web/controllers/billing_controller.ex@@ -150,8 +150,4 @@ defmodule PlausibleWeb.BillingController do{:error, :no_subscription}endend-- def preview_susbcription(_, _) do- {:error, :no_user_id}- endenddiff --git a/lib/plausible_web/email.ex b/lib/plausible_web/email.exindex 7385839f83..fd1c7300a5 100644--- a/lib/plausible_web/email.ex+++ b/lib/plausible_web/email.ex@@ -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()+ )enddef stats_report(email, assigns) do@@ -190,7 +193,12 @@ defmodule PlausibleWeb.Email doenddef 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 achievedby sending them through a dedicated 'priority' message stream in Postmark.diff --git a/lib/plausible_web/templates/email/approaching_accept_traffic_until.html.heex b/lib/plausible_web/templates/email/approaching_accept_traffic_until.html.heexnew file mode 100644index 0000000000..f5e12414ad--- /dev/null+++ b/lib/plausible_web/templates/email/approaching_accept_traffic_until.html.heex@@ -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.diff --git a/lib/plausible_web/templates/email/trial_over_email.html.eex b/lib/plausible_web/templates/email/trial_over_email.html.eexindex 55a422fcea..d5d9a174bb 100644--- a/lib/plausible_web/templates/email/trial_over_email.html.eex+++ b/lib/plausible_web/templates/email/trial_over_email.html.eex@@ -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.diff --git a/lib/plausible_web/templates/email/yearly_expiration_notification.html.eex b/lib/plausible_web/templates/email/yearly_expiration_notification.html.eexindex 1f3a96b7f6..fe2bbe3442 100644--- a/lib/plausible_web/templates/email/yearly_expiration_notification.html.eex+++ b/lib/plausible_web/templates/email/yearly_expiration_notification.html.eex@@ -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.diff --git a/lib/plausible_web/templates/layout/_notice.html.heex b/lib/plausible_web/templates/layout/_notice.html.heexindex 66afb1b411..190acacdf5 100644--- a/lib/plausible_web/templates/layout/_notice.html.heex+++ b/lib/plausible_web/templates/layout/_notice.html.heex@@ -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") %>diff --git a/lib/workers/accept_traffic_until_notification.ex b/lib/workers/accept_traffic_until_notification.exnew file mode 100644index 0000000000..6ac7cbba30--- /dev/null+++ b/lib/workers/accept_traffic_until_notification.ex@@ -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+enddiff --git a/test/plausible/auth/users_test.exs b/test/plausible/auth/users_test.exsnew file mode 100644index 0000000000..ce8c860016--- /dev/null+++ b/test/plausible/auth/users_test.exs@@ -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+enddiff --git a/test/plausible/billing/billing_test.exs b/test/plausible/billing/billing_test.exsindex da7330e40f..d4295572cf 100644--- a/test/plausible/billing/billing_test.exs+++ b/test/plausible/billing/billing_test.exs@@ -189,6 +189,19 @@ defmodule Plausible.BillingTest dorefute Repo.reload!(site).lockedend+ @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" douser = insert(:user, allow_next_upgrade_override: true)@@ -250,6 +263,24 @@ defmodule Plausible.BillingTest dorefute Repo.reload!(site).lockedend+ @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" douser = insert(:user, allow_next_upgrade_override: true)subscription = insert(:subscription, user: user)diff --git a/test/plausible/ingestion/event_test.exs b/test/plausible/ingestion/event_test.exsindex 3db601961c..8388a4f6b9 100644--- a/test/plausible/ingestion/event_test.exs+++ b/test/plausible/ingestion/event_test.exs@@ -118,8 +118,13 @@ defmodule Plausible.Ingestion.EventTest doendtest "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",diff --git a/test/plausible/site/cache_test.exs b/test/plausible/site/cache_test.exsindex d081a003f2..e0b50c8f1f 100644--- a/test/plausible/site/cache_test.exs+++ b/test/plausible/site/cache_test.exs@@ -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 doassert %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)diff --git a/test/plausible/site/gate_keeper_test.exs b/test/plausible/site/gate_keeper_test.exsindex 88d314bd14..13b590968e 100644--- a/test/plausible/site/gate_keeper_test.exs+++ b/test/plausible/site/gate_keeper_test.exs@@ -16,9 +16,13 @@ defmodule Plausible.Site.GateKeeperTest dotest "sites with accepted_traffic_until < now are denied", %{test: test, opts: opts} dodomain = "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)enddiff --git a/test/plausible/site/sites_test.exs b/test/plausible/site/sites_test.exsindex 7406d2e857..bc70c16963 100644--- a/test/plausible/site/sites_test.exs+++ b/test/plausible/site/sites_test.exs@@ -3,6 +3,17 @@ defmodule Plausible.SitesTest doalias 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?" dotest "is true if user is a member of the site" douser = insert(:user)diff --git a/test/plausible_web/email_test.exs b/test/plausible_web/email_test.exsindex 8cee8b0bc4..fc52753c48 100644--- a/test/plausible_web/email_test.exs+++ b/test/plausible_web/email_test.exs@@ -245,6 +245,34 @@ defmodule PlausibleWeb.EmailTest doendend+ 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() doplausible_url = PlausibleWeb.EmailView.plausible_url()"<a href=\"#{plausible_url}\">#{plausible_url}</a>"diff --git a/test/support/test_utils.ex b/test/support/test_utils.exindex 843abefcb1..01ae5a2cff 100644--- a/test/support/test_utils.ex+++ b/test/support/test_utils.ex@@ -213,6 +213,10 @@ defmodule Plausible.TestUtils doNaiveDateTime.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) doEnum.reduce_while(1..retries, nil, fn attempt, _acc ->case expectation.() dodiff --git a/test/workers/accept_traffic_until_test.exs b/test/workers/accept_traffic_until_test.exsnew file mode 100644index 0000000000..b66b059080--- /dev/null+++ b/test/workers/accept_traffic_until_test.exs@@ -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: "[email protected]")+ user4 = insert(:user, accept_traffic_until: today, email: "[email protected]")++ :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("[email protected]")+ refute_notifications("[email protected]")+ end++ test "sends multiple notifications per recipient as the time passes" do+ today = Date.utc_today()+ email = "[email protected]"+ 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