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
defmodule Plausible.TeamsTest do
use Plausible.DataCase, async: true
use Bamboo.Test
alias Plausible.Billing.Subscription
alias Plausible.Teams
alias Plausible.Repo
require Plausible.Billing.Subscription.Status
describe "name/1" do
test "returns default name when there's no team" do
assert Teams.name(nil) == "My personal sites"
end
test "returns default name when team setup is not completed yet" do
user = new_user(team: [setup_complete: false, name: "Foo"])
team = team_of(user)
assert Teams.name(team) == "My personal sites"
end
test "returns team name for a setup team" do
user = new_user(team: [setup_complete: true, name: "Foo"])
team = team_of(user)
assert Teams.name(team) == "Foo"
end
end
describe "get_or_create/1" do
test "creates 'My personal sites' if user is a member of no teams" do
today = Date.utc_today()
user = new_user()
user_id = user.id
assert {:ok, team} = Teams.get_or_create(user)
assert team.name == "My personal sites"
assert Date.compare(team.trial_expiry_date, today) == :gt
assert [
%{user_id: ^user_id, role: :owner, is_autocreated: true}
] = Repo.preload(team, :team_memberships).team_memberships
end
@tag :ee_only
test "sets hourly API request limit to 600 in EE" do
user = new_user()
assert {:ok, team} = Teams.get_or_create(user)
assert team.hourly_api_request_limit == 600
end
@tag :ce_build_only
test "sets hourly API request limit to 1000000 in CE" do
user = new_user()
assert {:ok, team} = Teams.get_or_create(user)
assert team.hourly_api_request_limit == 1_000_000
end
test "returns existing team if user already owns one" do
user = new_user(trial_expiry_date: ~D[2020-04-01])
user_id = user.id
existing_team = team_of(user)
assert {:ok, team} = Teams.get_or_create(user)
assert team.id == existing_team.id
assert Date.compare(team.trial_expiry_date, ~D[2020-04-01])
assert team.name == "My personal sites"
assert [
%{user_id: ^user_id, role: :owner, is_autocreated: true}
] = Repo.preload(team, :team_memberships).team_memberships
end
test "returns existing owned team even if explicitly assigned as owner" do
user = new_user()
user_id = user.id
site = new_site()
existing_team = site.team
add_member(existing_team, user: user, role: :owner)
assert {:ok, team} = Teams.get_or_create(user)
assert team.id == existing_team.id
assert [
%{role: :owner},
%{user_id: ^user_id, role: :owner, is_autocreated: false}
] =
team
|> Repo.preload(:team_memberships)
|> Map.fetch!(:team_memberships)
|> Enum.sort_by(& &1.id)
end
test "creates 'My personal sites' if user is a guest on another team" do
user = new_user()
user_id = user.id
site = new_site()
existing_team = site.team
add_guest(site, user: user, role: :editor)
assert {:ok, team} = Teams.get_or_create(user)
assert team.id != existing_team.id
assert team.name == "My personal sites"
assert [%{user_id: ^user_id, role: :owner, is_autocreated: true}] =
team
|> Repo.preload(:team_memberships)
|> Map.fetch!(:team_memberships)
end
test "creates 'My personal sites' if user is a non-owner member on existing teams" do
user = new_user()
user_id = user.id
site1 = new_site()
team1 = site1.team
site2 = new_site()
team2 = site2.team
add_member(team1, user: user, role: :viewer)
add_member(team2, user: user, role: :editor)
assert {:ok, team} = Teams.get_or_create(user)
assert team.id != team1.id
assert team.id != team2.id
assert [%{user_id: ^user_id, role: :owner, is_autocreated: true}] =
team
|> Repo.preload(:team_memberships)
|> Map.fetch!(:team_memberships)
end
test "creates 'My personal sites' if user only owns a setup team" do
user = new_user()
_site = new_site(owner: user)
setup_team = user |> team_of() |> Teams.complete_setup()
assert {:ok, team} = Teams.get_or_create(user)
assert team.id != setup_team.id
assert team.name == "My personal sites"
refute team.setup_complete
assert [team_membership] = Repo.preload(team, :team_memberships).team_memberships
assert team_membership.user_id == user.id
assert team_membership.role == :owner
assert team_membership.is_autocreated == true
end
test "returns existing owned team if user is also a non-owner member on existing teams" do
user = new_user()
_site = new_site(owner: user)
user_id = user.id
owned_team = team_of(user)
site1 = new_site()
team1 = site1.team
site2 = new_site()
team2 = site2.team
add_member(team1, user: user, role: :viewer)
add_member(team2, user: user, role: :editor)
assert {:ok, team} = Teams.get_or_create(user)
assert team.id == owned_team.id
assert [%{user_id: ^user_id, role: :owner, is_autocreated: true}] =
team
|> Repo.preload(:team_memberships)
|> Map.fetch!(:team_memberships)
end
test "returns error if user is an owner of more than one team already" do
user = new_user()
site1 = new_site()
team1 = site1.team
site2 = new_site()
team2 = site2.team
add_member(team1, user: user, role: :owner)
add_member(team2, user: user, role: :owner)
assert {:error, :multiple_teams} = Teams.get_or_create(user)
end
end
on_ee do
describe "get_or_create/1 - SSO user" do
setup [:create_user, :create_team, :setup_sso, :provision_sso_user]
test "does not allow creating personal team to SSO user", %{user: user} do
assert {:error, :permission_denied} = Teams.get_or_create(user)
end
end
describe "force_create_my_team/1 - SSO user" do
setup [:create_user, :create_team, :setup_sso, :provision_sso_user]
test "crashes when trying to create a team for SSO user", %{user: user} do
assert_raise RuntimeError, ~r/SSO user tried to force create a personal team/, fn ->
Teams.force_create_my_team(user)
end
end
end
end
describe "get_by_owner/1" do
test "returns error if user does not own any team" do
user = new_user()
assert {:error, :no_team} = Teams.get_by_owner(user)
end
test "returns error if user does not exist anymore" do
user = new_user()
_site = new_site(owner: user)
Repo.delete!(user)
assert {:error, :no_team} = Teams.get_by_owner(user)
end
test "returns existing 'My personal sites' if user already owns one" do
user = new_user(trial_expiry_date: ~D[2020-04-01])
user_id = user.id
existing_team = team_of(user)
assert {:ok, team} = Teams.get_by_owner(user)
assert team.id == existing_team.id
assert Date.compare(team.trial_expiry_date, ~D[2020-04-01])
assert team.name == "My personal sites"
assert [
%{user_id: ^user_id, role: :owner, is_autocreated: true}
] = Repo.preload(team, :team_memberships).team_memberships
end
test "returns existing owned team if explicitly assigned as owner" do
user = new_user()
user_id = user.id
site = new_site()
existing_team = site.team
add_member(existing_team, user: user, role: :owner)
assert {:ok, team} = Teams.get_by_owner(user)
assert team.id == existing_team.id
assert [
%{role: :owner},
%{user_id: ^user_id, role: :owner, is_autocreated: false}
] =
team
|> Repo.preload(:team_memberships)
|> Map.fetch!(:team_memberships)
|> Enum.sort_by(& &1.id)
end
test "returns existing owned team if user is also a non-owner member on existing teams" do
user = new_user()
_site = new_site(owner: user)
user_id = user.id
owned_team = team_of(user)
site1 = new_site()
team1 = site1.team
site2 = new_site()
team2 = site2.team
add_member(team1, user: user, role: :viewer)
add_member(team2, user: user, role: :editor)
assert {:ok, team} = Teams.get_by_owner(user)
assert team.id == owned_team.id
assert [%{user_id: ^user_id, role: :owner, is_autocreated: true}] =
team
|> Repo.preload(:team_memberships)
|> Map.fetch!(:team_memberships)
end
test "returns error if user is an owner of more than one team" do
user = new_user()
site1 = new_site()
team1 = site1.team
site2 = new_site()
team2 = site2.team
add_member(team1, user: user, role: :owner)
add_member(team2, user: user, role: :owner)
assert {:error, :multiple_teams} = Teams.get_by_owner(user)
end
end
describe "trial_days_left" do
test "is 30 days for new signup" do
user = new_user(trial_expiry_date: Teams.Team.trial_expiry())
on_ee do
assert Teams.trial_days_left(team_of(user)) == 30
else
assert Teams.trial_days_left(team_of(user)) > 1000
end
end
test "is based on trial_expiry_date" do
user = new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: 1))
assert Teams.trial_days_left(team_of(user)) == 1
end
end
describe "on_trial?" do
@describetag :ee_only
test "is true with >= 0 trial days left" do
user = new_user(trial_expiry_date: Date.utc_today())
assert Teams.on_trial?(team_of(user))
end
test "is false with < 0 trial days left" do
user = new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: -1))
refute Teams.on_trial?(team_of(user))
end
test "is false if user has subscription" do
user = new_user(trial_expiry_date: Date.utc_today())
subscribe_to_growth_plan(user)
refute Teams.on_trial?(team_of(user))
end
end
describe "update_accept_traffic_until" do
@describetag :ee_only
test "update" do
user = new_user()
{:ok, team} = Teams.get_or_create(user)
team = Teams.start_trial(team)
# 30 for trial + 14
assert Date.diff(team.accept_traffic_until, Date.utc_today()) ==
30 + Teams.Team.trial_accept_traffic_until_offset_days()
future = Date.add(Date.utc_today(), 30)
subscribe_to_growth_plan(user, next_bill_date: future)
assert updated_team = Teams.update_accept_traffic_until(team)
assert Date.diff(updated_team.accept_traffic_until, future) ==
Teams.Team.subscription_accept_traffic_until_offset_days()
end
test "retrieve: trial + 14 days" do
user = new_user()
{:ok, team} = Teams.get_or_create(user)
team = Teams.start_trial(team)
assert Teams.accept_traffic_until(Repo.reload!(team)) ==
Date.utc_today()
|> Date.add(30 + Teams.Team.trial_accept_traffic_until_offset_days())
end
test "retrieve: last_bill_date + 30 days" do
future = Date.add(Date.utc_today(), 30)
user = new_user() |> subscribe_to_growth_plan(next_bill_date: future)
assert Teams.accept_traffic_until(team_of(user)) ==
future |> Date.add(Teams.Team.subscription_accept_traffic_until_offset_days())
end
test "retrieve: free plan" do
user = new_user() |> subscribe_to_plan("free_10k")
assert Teams.accept_traffic_until(team_of(user)) == ~D[2135-01-01]
end
end
describe "complete_setup/1" do
test "writes setup markers" do
owner = new_user()
_site = new_site(owner: owner)
team = team_of(owner)
refute team.setup_complete
refute team.setup_at
Teams.complete_setup(team)
team = Repo.reload!(team)
assert team.setup_complete
assert team.setup_at
end
test "is a no-op for a team that's already set up" do
owner = new_user()
_site = new_site(owner: owner)
team =
owner
|> team_of()
|> Teams.Team.setup_changeset(
NaiveDateTime.utc_now(:second)
|> NaiveDateTime.shift(month: -1)
)
|> Repo.update!()
assert setup_at = team.setup_at
Teams.complete_setup(team)
team = Repo.reload!(team)
assert team.setup_at == setup_at
end
end
describe "setup/4" do
@subject_prefix if ee?(), do: "[Plausible Analytics] ", else: "[Plausible CE] "
test "renames the team, completes setup and invites members" do
owner = new_user()
_site = new_site(owner: owner)
team = team_of(owner)
assert {:ok, team} =
Teams.setup(
team,
"New Team Name",
[%{email: "[email protected]", role: :editor}],
owner
)
assert team.name == "New Team Name"
assert team.setup_complete
assert [invitation] = Teams.Invitations.pending_team_invitations_for(team)
assert invitation.email == "[email protected]"
assert invitation.role == :editor
assert_email_delivered_with(
to: [nil: "[email protected]"],
subject: @subject_prefix <> "You've been invited to \"New Team Name\" team"
)
end
test "rolls back the rename and setup completion when an invitation fails" do
owner = new_user()
_site = new_site(owner: owner)
team = team_of(owner)
assert {:error, :already_a_member} =
Teams.setup(
team,
"New Team Name",
[
%{email: "[email protected]", role: :editor},
%{email: owner.email, role: :viewer}
],
owner
)
team = Repo.reload!(team)
assert team.name == Teams.default_name()
refute team.setup_complete
assert [] = Teams.Invitations.pending_team_invitations_for(team)
assert_no_emails_delivered()
end
test "returns the name changeset error without inviting anyone" do
owner = new_user()
_site = new_site(owner: owner)
team = team_of(owner)
assert {:error, %Ecto.Changeset{data: %Teams.Team{}} = changeset} =
Teams.setup(team, "", [%{email: "[email protected]", role: :editor}], owner)
assert {"can't be blank", _} = changeset.errors[:name]
team = Repo.reload!(team)
refute team.setup_complete
assert [] = Teams.Invitations.pending_team_invitations_for(team)
assert_no_emails_delivered()
end
end
describe "create/3" do
@subject_prefix if ee?(), do: "[Plausible Analytics] ", else: "[Plausible CE] "
test "creates a set up team owned by the user and invites members" do
today = Date.utc_today()
user = new_user()
assert {:ok, team} =
Teams.create(user, "New Team", [%{email: "[email protected]", role: :editor}])
assert team.name == "New Team"
assert team.setup_complete
assert team.setup_at
assert team.identifier
assert Date.compare(team.trial_expiry_date, today) == :gt
assert [team_membership] = Repo.preload(team, :team_memberships).team_memberships
assert team_membership.user_id == user.id
assert team_membership.role == :owner
assert team_membership.is_autocreated == false
assert [invitation] = Teams.Invitations.pending_team_invitations_for(team)
assert invitation.email == "[email protected]"
assert invitation.role == :editor
assert_email_delivered_with(
to: [nil: "[email protected]"],
subject: @subject_prefix <> "You've been invited to \"New Team\" team"
)
end
test "creates a team without any invitations" do
user = new_user()
assert {:ok, team} = Teams.create(user, "New Team", [])
assert team.setup_complete
assert [] = Teams.Invitations.pending_team_invitations_for(team)
assert_no_emails_delivered()
end
test "leaves the user's existing personal team untouched" do
user = new_user()
_site = new_site(owner: user)
personal_team = team_of(user)
assert {:ok, team} = Teams.create(user, "New Team", [])
assert team.id != personal_team.id
personal_team = Repo.reload!(personal_team)
assert personal_team.name == Teams.default_name()
refute personal_team.setup_complete
assert [team_membership] = Repo.preload(personal_team, :team_memberships).team_memberships
assert team_membership.user_id == user.id
assert team_membership.role == :owner
assert team_membership.is_autocreated == true
assert {:ok, %{id: personal_team_id}} = Teams.get_or_create(user)
assert personal_team_id == personal_team.id
end
test "rolls back team creation when an invitation fails" do
user = new_user()
assert {:error, :already_a_member} =
Teams.create(user, "New Team", [
%{email: "[email protected]", role: :editor},
%{email: user.email, role: :viewer}
])
assert {:error, :no_team} = Teams.get_by_owner(user)
assert_no_emails_delivered()
end
test "returns a name changeset error without creating a team" do
user = new_user()
assert {:error, %Ecto.Changeset{data: %Teams.Team{}} = changeset} =
Teams.create(user, Teams.default_name(), [
%{email: "[email protected]", role: :editor}
])
assert [name: {"is reserved", _}] = changeset.errors
assert {:error, :no_team} = Teams.get_by_owner(user)
assert_no_emails_delivered()
end
end
on_ee do
describe "create/3 - SSO user" do
setup [:create_user, :create_team, :setup_sso, :provision_sso_user]
test "does not allow creating a team to SSO user", %{user: user} do
assert {:error, :permission_denied} = Teams.create(user, "New Team", [])
end
end
end
describe "delete/1" do
test "deletes a team" do
user = new_user()
subscribe_to_growth_plan(user, status: Subscription.Status.deleted())
subscribe_to_enterprise_plan(user, site_limit: 1, subscription?: false)
team = team_of(user)
team = Teams.complete_setup(team)
another_user = new_user()
another_site = new_site(owner: another_user)
another_team = team_of(another_user)
add_member(another_team, user: user, role: :owner)
site1 = new_site(team: team)
site2 = new_site(team: team)
viewer_member = new_user()
add_member(team, user: viewer_member, role: :viewer)
owner_member = new_user()
add_member(team, user: owner_member, role: :owner)
guest_member = new_user()
add_guest(site1, user: guest_member, role: :editor)
team_invitee = new_user()
invite_member(team, team_invitee, inviter: user, role: :admin)
guest_invitee = new_user()
invite_guest(site2, guest_invitee, inviter: user, role: :viewer)
assert {:ok, :deleted} = Teams.delete(team)
refute Repo.reload(team)
assert Repo.reload(another_user)
assert Repo.reload(another_team)
assert Repo.reload(another_site)
refute Repo.reload(site1)
refute Repo.reload(site2)
assert Repo.reload(viewer_member)
refute_team_member(viewer_member, team)
assert Repo.reload(owner_member)
refute_team_member(owner_member, team)
assert Repo.reload(guest_member)
refute_team_member(guest_member, team)
assert Repo.reload(team_invitee)
refute_team_invitation(team, team_invitee.email)
assert Repo.reload(guest_invitee)
refute_team_invitation(team, guest_invitee.email)
end
test "does not delete a team with active subscription" do
user = new_user()
subscribe_to_growth_plan(user, status: Subscription.Status.active())
team = team_of(user)
assert {:error, :active_subscription} = Teams.delete(team)
assert Repo.reload(team)
end
end
describe "owned_sites/1" do
setup [:create_user, :create_team]
test "returns sites owned by a team", %{user: user, team: team} do
%{id: site_id} = new_site(owner: user)
new_site(owner: user, consolidated: true)
assert [%{id: ^site_id}] = Teams.owned_sites(team)
end
test "limit limits number of sites returned", %{user: user, team: team} do
%{id: site_id1} = new_site(owner: user, domain: "b")
%{id: site_id2} = new_site(owner: user, domain: "c")
%{id: _site_id3} = new_site(owner: user, domain: "d")
new_site(owner: user, consolidated: true, domain: "a")
assert [%{id: ^site_id1}, %{id: ^site_id2}] = Teams.owned_sites(team, 2)
end
test "returns empty list for no team" do
assert [] = Teams.owned_sites(nil)
end
end
describe "owned_sites_ids/1" do
setup [:create_user, :create_team]
test "returns site IDs owned by a team", %{user: user, team: team} do
%{id: site_id2} = new_site(owner: user)
%{id: site_id1} = new_site(owner: user)
new_site(owner: user, consolidated: true)
assert [^site_id1, ^site_id2] = Teams.owned_sites_ids(team)
end
test "returns empty list for no team" do
assert [] = Teams.owned_sites_ids(nil)
end
end
describe "owned_sites_count/1" do
setup [:create_user, :create_team]
test "returns site count owned by a team", %{user: user, team: team} do
new_site(owner: user)
new_site(owner: user)
new_site(owner: user, consolidated: true)
assert Teams.owned_sites_count(team) == 2
end
test "returns empty list for no team" do
assert Teams.owned_sites_count(nil) == 0
end
end
end