analytics/test/workers/check_usage_test.exs
Adrian Gruntkowski 17b12ddaeb
Implement basics of Teams (#4658)
* Extend schemas with new fields and relationships for teams

* Implement listing sites and sites with invitations with teams

* Implement creating invitations with teams

* Implement accepting invites with teams

* Add `Teams.SiteTransfer` schema

* Implement creating ownership transfers

* Implement accepting site transfer between teams

* Make results shapes from `Teams.Memberships` role functions more consistent

* Remove :team relation from ApiKey schema

* Pass and provision team on subscription creation

* Pass and provision team on enterprise plan creation

* Implement creating site for a team

* Keep team in sync during legacy ownership transfer and invitations

* Resolve conflict in `Teams.get_or_create` without transaction

* Abstract `GracePeriod` manipulation behind `Plausible.Users`

* Put `User.start_trial` behind `Plausible.Users` API

* Sync team fields on user update, if team exists

* Sync cleaning invitations, updating and removing members

* Transfer invitations too

* Implement backfill script

* Allow separate pg repo for backfill script

* Rollback purposefully at the end

* Update backfill script with parallel processing

* Use `IS DISTINCT FROM` when comparing nullable fields

* Handle no teams to backfill case gracefully when reporting

* Parallelize guest memberships backfill

* Remove transaction wrapping and query timeouts

* Make team sync check more granular and fix formatting

* Wrap single team backfill in a transatction for consistent restarts

* Make invitation and site transfer backfills preserve invitation ID

* Update migration repo config for easier dev access

* Backfill teams for users with subscriptions without sites

* Log timestamps

* Put teams sync behind a compile-time flag

* Keep timestamps in sync and fix subscriptions backfill

* Fix formatting

* Make credo happy

* Don't `use Plausible.Migration` to avoid dialyzer complaining

None of the tooling from there is used anywhere and `@repo` can
be defined directly in the migration script.

* Drop SSL workarounds in the backfill script

---------

Co-authored-by: Adam Rutkowski <hq@mtod.org>
2024-10-21 07:35:23 +00:00

519 lines
16 KiB
Elixir

defmodule Plausible.Workers.CheckUsageTest do
use Plausible.DataCase, async: true
use Bamboo.Test
import Double
alias Plausible.Workers.CheckUsage
require Plausible.Billing.Subscription.Status
setup [:create_user, :create_site]
@paddle_id_10k "558018"
@date_range Date.range(Timex.today(), Timex.today())
@accepted_status_values [
Plausible.Billing.Subscription.Status.active(),
Plausible.Billing.Subscription.Status.past_due(),
Plausible.Billing.Subscription.Status.deleted()
]
test "ignores user without subscription" do
CheckUsage.perform(nil)
assert_no_emails_delivered()
end
test "operates on the current subscription",
%{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: :active
)
insert(:subscription,
user: user,
paddle_plan_id: "wont-exist-should-crash",
last_bill_date: Timex.shift(Timex.today(), days: -1),
inserted_at: DateTime.shift(DateTime.utc_now(), day: -2),
status: :deleted
)
CheckUsage.perform(nil, usage_stub)
assert_email_delivered_with(
to: [user],
subject: "[Action required] You have outgrown your Plausible subscription tier"
)
end
test "sends more than one email", %{user: user} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
user2 = insert(:user)
insert(:site, members: [user2])
for u <- [user, user2] do
insert(:subscription,
user: u,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
next_bill_date: Timex.shift(Timex.today(), days: +5),
status: :active
)
end
CheckUsage.perform(nil, usage_stub)
assert_email_delivered_with(
to: [user],
subject: "[Action required] You have outgrown your Plausible subscription tier"
)
assert_email_delivered_with(
to: [user2],
subject: "[Action required] You have outgrown your Plausible subscription tier"
)
end
test "ignores user with paused subscription", %{user: user} do
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: Plausible.Billing.Subscription.Status.paused()
)
CheckUsage.perform(nil)
assert_no_emails_delivered()
end
for status <- @accepted_status_values do
describe "#{status} subscription, regular customers" do
test "ignores user with subscription but no usage", %{user: user} do
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil)
assert_no_emails_delivered()
assert Repo.reload(user).grace_period == nil
end
test "does not send an email if account has been over the limit for one billing month", %{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 9_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert_no_emails_delivered()
assert Repo.reload(user).grace_period == nil
end
test "does not send an email if account is over the limit by less than 10%", %{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 10_999},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert_no_emails_delivered()
assert Repo.reload(user).grace_period == nil
end
test "sends an email when an account is over their limit for two consecutive billing months",
%{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert_email_delivered_with(
to: [user],
subject: "[Action required] You have outgrown your Plausible subscription tier"
)
assert Repo.reload(user).grace_period.end_date == Timex.shift(Timex.today(), days: 7)
end
test "sends an email suggesting enterprise plan when usage is greater than 10M ", %{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000_000},
last_cycle: %{date_range: @date_range, total: 11_000_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert_delivered_email_matches(%{html_body: html_body})
assert html_body =~
"Your usage exceeds our standard plans, so please reply back to this email for a tailored quote"
end
test "skips checking users who already have a grace period", %{user: user} do
%{grace_period: existing_grace_period} = Plausible.Users.start_grace_period(user)
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert_no_emails_delivered()
assert Repo.reload(user).grace_period.id == existing_grace_period.id
end
test "recommends a plan to upgrade to", %{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert_delivered_email_matches(%{
html_body: html_body
})
assert html_body =~ "We recommend you upgrade to the 100k/mo plan"
end
test "clears grace period when plan is applicable again", %{user: user} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert user |> Repo.reload() |> Plausible.Auth.GracePeriod.active?()
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 9_000}
}
end)
CheckUsage.perform(nil, usage_stub)
refute user |> Repo.reload() |> Plausible.Auth.GracePeriod.active?()
end
end
end
for status <- @accepted_status_values do
describe "#{status} subscription, enterprise customers" do
test "skips checking enterprise users who already have a grace period", %{user: user} do
%{grace_period: existing_grace_period} =
Plausible.Users.start_manual_lock_grace_period(user)
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 1_100_000},
last_cycle: %{date_range: @date_range, total: 1_100_000}
}
end)
enterprise_plan = insert(:enterprise_plan, user: user, monthly_pageview_limit: 1_000_000)
insert(:subscription,
user: user,
paddle_plan_id: enterprise_plan.paddle_plan_id,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert_no_emails_delivered()
assert Repo.reload(user).grace_period.id == existing_grace_period.id
end
test "checks billable pageview usage for enterprise customer, sends usage information to enterprise@plausible.io",
%{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 1_100_000},
last_cycle: %{date_range: @date_range, total: 1_100_000}
}
end)
enterprise_plan = insert(:enterprise_plan, user: user, monthly_pageview_limit: 1_000_000)
insert(:subscription,
user: user,
paddle_plan_id: enterprise_plan.paddle_plan_id,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert_email_delivered_with(
to: [{nil, "enterprise@plausible.io"}],
subject: "#{user.email} has outgrown their enterprise plan"
)
end
test "checks site limit for enterprise customer, sends usage information to enterprise@plausible.io",
%{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 1},
last_cycle: %{date_range: @date_range, total: 1}
}
end)
enterprise_plan = insert(:enterprise_plan, user: user, site_limit: 2)
insert(:site, members: [user])
insert(:site, members: [user])
insert(:site, members: [user])
insert(:subscription,
user: user,
paddle_plan_id: enterprise_plan.paddle_plan_id,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert_email_delivered_with(
to: [{nil, "enterprise@plausible.io"}],
subject: "#{user.email} has outgrown their enterprise plan"
)
end
test "starts grace period when plan is outgrown", %{user: user} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 1_100_000},
last_cycle: %{date_range: @date_range, total: 1_100_000}
}
end)
enterprise_plan = insert(:enterprise_plan, user: user, monthly_pageview_limit: 1_000_000)
insert(:subscription,
user: user,
paddle_plan_id: enterprise_plan.paddle_plan_id,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
CheckUsage.perform(nil, usage_stub)
assert user |> Repo.reload() |> Plausible.Auth.GracePeriod.active?()
end
end
end
describe "timing" do
test "checks usage one day after the last_bill_date", %{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1)
)
CheckUsage.perform(nil, usage_stub)
assert_email_delivered_with(
to: [user],
subject: "[Action required] You have outgrown your Plausible subscription tier"
)
end
test "does not check exactly one month after last_bill_date", %{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: ~D[2021-03-28]
)
CheckUsage.perform(nil, usage_stub, ~D[2021-03-28])
assert_no_emails_delivered()
end
test "for yearly subscriptions, checks usage multiple months + one day after the last_bill_date",
%{
user: user
} do
usage_stub =
Plausible.Billing.Quota.Usage
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
last_cycle: %{date_range: @date_range, total: 11_000}
}
end)
insert(:subscription,
user: user,
paddle_plan_id: @paddle_id_10k,
last_bill_date: ~D[2021-06-29]
)
CheckUsage.perform(nil, usage_stub, ~D[2021-08-30])
assert_email_delivered_with(
to: [user],
subject: "[Action required] You have outgrown your Plausible subscription tier"
)
end
end
end