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
Implement remaining `SSO` functions needed for setup (#5444)
Adrian Gruntkowski4a587e2a6ea3
diff --git a/extra/lib/plausible/auth/sso.ex b/extra/lib/plausible/auth/sso.exindex 1e4e88ab56..3d74021d68 100644--- a/extra/lib/plausible/auth/sso.ex+++ b/extra/lib/plausible/auth/sso.ex@@ -11,6 +11,10 @@ defmodule Plausible.Auth.SSO doalias Plausible.Repoalias Plausible.Teams+ @type policy_attr() ::+ {:sso_default_role, Teams.Policy.sso_member_role()}+ | {:sso_session_timeout_minutes, non_neg_integer()}+@spec get_integration(String.t()) :: {:ok, SSO.Integration.t()} | {:error, :not_found}def get_integration(identifier) when is_binary(identifier) doquery =@@ -69,6 +73,199 @@ defmodule Plausible.Auth.SSO doendend+ @spec deprovision_user!(Auth.User.t()) :: Auth.User.t()+ def deprovision_user!(%{type: :standard} = user), do: user++ def deprovision_user!(user) do+ user = Repo.preload(user, :sso_integration)++ :ok = Auth.UserSessions.revoke_all(user)++ user+ |> Ecto.Changeset.change()+ |> Ecto.Changeset.put_change(:type, :standard)+ |> Ecto.Changeset.put_change(:sso_identity_id, nil)+ |> Ecto.Changeset.put_assoc(:sso_integration, nil)+ |> Repo.update!()+ end++ @spec update_policy(Teams.Team.t(), [policy_attr()]) ::+ {:ok, Teams.Team.t()} | {:error, Ecto.Changeset.t()}+ def update_policy(team, attrs \\ []) do+ params = Map.new(attrs)+ policy_changeset = Teams.Policy.update_changeset(team.policy, params)++ team+ |> Ecto.Changeset.change()+ |> Ecto.Changeset.put_embed(:policy, policy_changeset)+ |> Repo.update()+ end++ @spec set_force_sso(Teams.Team.t(), Teams.Policy.force_sso_mode()) ::+ {:ok, Teams.Team.t()}+ | {:error,+ :no_integration+ | :no_domain+ | :no_verified_domain+ | :owner_mfa_disabled+ | :no_sso_user}+ def set_force_sso(team, mode) do+ with :ok <- check_force_sso(team, mode) do+ policy_changeset = Teams.Policy.force_sso_changeset(team.policy, mode)++ team+ |> Ecto.Changeset.change()+ |> Ecto.Changeset.put_embed(:policy, policy_changeset)+ |> Repo.update()+ end+ end++ @spec check_force_sso(Teams.Team.t(), Teams.Policy.force_sso_mode()) ::+ :ok+ | {:error,+ :no_integration+ | :no_domain+ | :no_verified_domain+ | :owner_mfa_disabled+ | :no_sso_user}+ def check_force_sso(_team, :none), do: :ok++ def check_force_sso(team, :all_but_owners) do+ with :ok <- check_integration_configured(team),+ :ok <- check_sso_user_present(team) do+ check_owners_mfa_enabled(team)+ end+ end++ @spec check_can_remove_integration(SSO.Integration.t()) ::+ :ok | {:error, :force_sso_enabled | :sso_users_present}+ def check_can_remove_integration(integration) do+ team = Repo.preload(integration, :team).team++ cond do+ team.policy.force_sso != :none ->+ {:error, :force_sso_enabled}++ check_sso_user_present(integration) == :ok ->+ {:error, :sso_users_present}++ true ->+ :ok+ end+ end++ @spec remove_integration(SSO.Integration.t(), Keyword.t()) ::+ :ok | {:error, :force_sso_enabled | :sso_users_present}+ def remove_integration(integration, opts \\ []) do+ force_deprovision? = Keyword.get(opts, :force_deprovision?, false)+ check = check_can_remove_integration(integration)++ case {check, force_deprovision?} do+ {:ok, _} ->+ Repo.delete!(integration)+ :ok++ {{:error, :sso_users_present}, true} ->+ users = Repo.preload(integration, :users).users++ {:ok, :ok} =+ Repo.transaction(fn ->+ Enum.each(users, &deprovision_user!/1)+ Repo.delete!(integration)+ :ok+ end)++ :ok++ {{:error, error}, _} ->+ {:error, error}+ end+ end++ defp check_integration_configured(team) do+ integrations =+ Repo.all(+ from(+ i in SSO.Integration,+ left_join: d in assoc(i, :sso_domains),+ where: i.team_id == ^team.id,+ preload: [sso_domains: d]+ )+ )++ domains = Enum.flat_map(integrations, & &1.sso_domains)+ no_verified_domains? = Enum.all?(domains, &(&1.status != :validated))++ cond do+ integrations == [] -> {:error, :no_integration}+ domains == [] -> {:error, :no_domain}+ no_verified_domains? -> {:error, :no_verified_domain}+ true -> :ok+ end+ end++ defp check_sso_user_present(%Teams.Team{} = team) do+ sso_user_count =+ Repo.aggregate(+ from(+ tm in Teams.Membership,+ inner_join: u in assoc(tm, :user),+ where: tm.team_id == ^team.id,+ where: tm.role != :guest,+ where: u.type == :sso+ ),+ :count+ )++ if sso_user_count > 0 do+ :ok+ else+ {:error, :no_sso_user}+ end+ end++ defp check_sso_user_present(%SSO.Integration{} = integration) do+ sso_user_count =+ Repo.aggregate(+ from(+ i in SSO.Integration,+ inner_join: u in assoc(i, :users),+ inner_join: tm in assoc(u, :team_memberships),+ on: tm.team_id == i.team_id,+ where: i.id == ^integration.id,+ where: tm.role != :guest,+ where: u.type == :sso+ ),+ :count+ )++ if sso_user_count > 0 do+ :ok+ else+ {:error, :no_sso_user}+ end+ end++ defp check_owners_mfa_enabled(team) do+ disabled_mfa_count =+ Repo.aggregate(+ from(+ tm in Teams.Membership,+ inner_join: u in assoc(tm, :user),+ where: tm.team_id == ^team.id,+ where: tm.role == :owner,+ where: u.totp_enabled == false or is_nil(u.totp_secret)+ ),+ :count+ )++ if disabled_mfa_count == 0 do+ :ok+ else+ {:error, :owner_mfa_disabled}+ end+ end+defp find_user(identity) docase find_user_with_fallback(identity) do{:ok, type, user, integration} ->@@ -152,6 +349,7 @@ defmodule Plausible.Auth.SSO dowith :ok <- ensure_team_member(integration.team, user),:ok <- ensure_one_membership(user, integration.team),+ :ok <- Auth.UserSessions.revoke_all(user),{:ok, user} <- Repo.update(changeset) do{:ok, :standard, integration.team, user}enddiff --git a/extra/lib/plausible/auth/sso/integration.ex b/extra/lib/plausible/auth/sso/integration.exindex e8d51b40e3..6fddbc39dc 100644--- a/extra/lib/plausible/auth/sso/integration.ex+++ b/extra/lib/plausible/auth/sso/integration.ex@@ -31,6 +31,7 @@ defmodule Plausible.Auth.SSO.Integration dobelongs_to :team, Plausible.Teams.Teamhas_many :users, Plausible.Auth.User, foreign_key: :sso_integration_id+ has_many :sso_domains, SSO.Domain, foreign_key: :sso_integration_idtimestamps()enddiff --git a/lib/plausible/auth/user.ex b/lib/plausible/auth/user.exindex 6f3cdda1b7..3d511d1ed5 100644--- a/lib/plausible/auth/user.ex+++ b/lib/plausible/auth/user.ex@@ -46,7 +46,7 @@ defmodule Plausible.Auth.User dofield :sso_identity_id, :stringfield :last_sso_login, :naive_datetime- belongs_to :sso_integration, Plausible.Auth.SSO.Integration+ belongs_to :sso_integration, Plausible.Auth.SSO.Integration, on_replace: :nilifyendhas_many :sessions, Plausible.Auth.UserSessiondiff --git a/lib/plausible/auth/user_session.ex b/lib/plausible/auth/user_session.exindex 8bf6b40f59..9e8aa5038b 100644--- a/lib/plausible/auth/user_session.ex+++ b/lib/plausible/auth/user_session.ex@@ -29,19 +29,11 @@ defmodule Plausible.Auth.UserSession do@spec timeout_duration() :: Duration.t()def timeout_duration(), do: @timeout- @spec new_session(Auth.User.t(), String.t(), NaiveDateTime.t()) :: Ecto.Changeset.t()- def new_session(user, device, now \\ NaiveDateTime.utc_now(:second)) do- %__MODULE__{}- |> cast(%{device: device}, [:device])- |> generate_token()- |> put_assoc(:user, user)- |> put_change(:timeout_at, NaiveDateTime.shift(now, @timeout))- |> touch_session(now)- end+ @spec new_session(Auth.User.t(), String.t(), Keyword.t()) :: Ecto.Changeset.t()+ def new_session(user, device, opts \\ []) do+ now = Keyword.get(opts, :now, NaiveDateTime.utc_now(:second))+ timeout_at = Keyword.get(opts, :timeout_at, NaiveDateTime.shift(now, @timeout))- @spec new_sso_session(Auth.User.t(), String.t(), NaiveDateTime.t(), NaiveDateTime.t()) ::- Ecto.Changeset.t()- def new_sso_session(user, device, timeout_at, now \\ NaiveDateTime.utc_now(:second)) do%__MODULE__{}|> cast(%{device: device}, [:device])|> generate_token()diff --git a/lib/plausible/auth/user_sessions.ex b/lib/plausible/auth/user_sessions.exindex 821f94a40e..e822742f8c 100644--- a/lib/plausible/auth/user_sessions.ex+++ b/lib/plausible/auth/user_sessions.ex@@ -3,10 +3,12 @@ defmodule Plausible.Auth.UserSessions doFunctions for interacting with user sessions."""- import Ecto.Query, only: [from: 2]+ import Ecto.Queryalias Plausible.Authalias Plausible.Repo+ @socket_id_prefix "user_sessions:"+@spec list_for_user(Auth.User.t(), NaiveDateTime.t()) :: [Auth.UserSession.t()]def list_for_user(user, now \\ NaiveDateTime.utc_now(:second)) doRepo.all(@@ -30,4 +32,118 @@ defmodule Plausible.Auth.UserSessions dotrue -> "#{diff_days} days ago"endend++ @spec get_by_token(String.t()) :: {:ok, Auth.UserSession.t()} | {:error, :not_found}+ def get_by_token(token) do+ now = NaiveDateTime.utc_now(:second)++ last_team_subscription_query = Plausible.Teams.last_subscription_join_query()++ token_query =+ from(us in Auth.UserSession,+ inner_join: u in assoc(us, :user),+ as: :user,+ left_join: tm in assoc(u, :team_memberships),+ on: tm.role != :guest,+ left_join: t in assoc(tm, :team),+ as: :team,+ left_join: o in assoc(t, :owners),+ left_lateral_join: ts in subquery(last_team_subscription_query),+ on: true,+ where: us.token == ^token and us.timeout_at > ^now,+ order_by: t.id,+ preload: [user: {u, team_memberships: {tm, team: {t, subscription: ts, owners: o}}}]+ )++ case Repo.one(token_query) do+ %Auth.UserSession{} = user_session ->+ {:ok, user_session}++ nil ->+ {:error, :not_found}+ end+ end++ @spec create!(Auth.User.t(), String.t(), Keyword.t()) :: Auth.UserSession.t()+ def create!(user, device_name, opts \\ []) do+ user+ |> Auth.UserSession.new_session(device_name, opts)+ |> Repo.insert!()+ end++ @spec remove_by_token(String.t()) :: :ok+ def remove_by_token(token) do+ Repo.delete_all(from us in Auth.UserSession, where: us.token == ^token)+ :ok+ end++ @spec touch(Auth.UserSession.t(), NaiveDateTime.t()) :: Auth.UserSession.t()+ def touch(user_session, now \\ NaiveDateTime.utc_now(:second)) do+ if NaiveDateTime.diff(now, user_session.last_used_at, :hour) >= 1 do+ Plausible.Users.bump_last_seen(user_session.user_id, now)++ user_session+ |> Repo.preload(:user)+ |> Auth.UserSession.touch_session(now)+ |> Repo.update!(allow_stale: true)+ else+ user_session+ end+ end++ @spec revoke_by_id(Auth.User.t(), pos_integer()) :: :ok+ def revoke_by_id(user, session_id) do+ {_, tokens} =+ Repo.delete_all(+ from us in Auth.UserSession,+ where: us.user_id == ^user.id and us.id == ^session_id,+ select: us.token+ )++ case tokens do+ [token] ->+ disconnect_by_token(token)++ _ ->+ :pass+ end++ :ok+ end++ @spec revoke_all(Auth.User.t(), Keyword.t()) :: :ok+ def revoke_all(user, opts \\ []) do+ except = Keyword.get(opts, :except)++ delete_query = from us in Auth.UserSession, where: us.user_id == ^user.id, select: us.token++ delete_query =+ if except do+ where(delete_query, [us], us.id != ^except.id)+ else+ delete_query+ end++ {_count, tokens} = Repo.delete_all(delete_query)++ Enum.each(tokens, &disconnect_by_token/1)+ end++ @spec disconnect_by_token(String.t()) :: :ok+ def disconnect_by_token(token_or_socket_id) do+ socket_id =+ if String.starts_with?(token_or_socket_id, @socket_id_prefix) do+ token_or_socket_id+ else+ socket_id(token_or_socket_id)+ end++ PlausibleWeb.Endpoint.broadcast(socket_id, "disconnect", %{})+ :ok+ end++ @spec socket_id(String.t()) :: String.t()+ def socket_id(token) do+ @socket_id_prefix <> Base.url_encode64(token)+ endenddiff --git a/lib/plausible/teams/policy.ex b/lib/plausible/teams/policy.exindex 19d939e748..56e5db7447 100644--- a/lib/plausible/teams/policy.ex+++ b/lib/plausible/teams/policy.ex@@ -8,9 +8,19 @@ defmodule Plausible.Teams.Policy doimport Ecto.Changeset@sso_member_roles Plausible.Teams.Membership.roles() -- [:guest]+ @force_sso_modes [:none, :all_but_owners]@update_fields [:sso_default_role, :sso_session_timeout_minutes]+ @default_timeout_minutes 6 * 60+ @max_timeout_minutes 12 * 60++ @type t() :: %__MODULE__{}++ @type sso_member_role() :: unquote(Enum.reduce(@sso_member_roles, &{:|, [], [&1, &2]}))++ @type force_sso_mode() :: unquote(Enum.reduce(@force_sso_modes, &{:|, [], [&1, &2]}))+embedded_schema do# SSO options apply to all team's integrations, should there# ever be more than one allowed at once.@@ -28,15 +38,21 @@ defmodule Plausible.Teams.Policy do# Default session timeout for SSO-enabled accounts. We might also# consider accepting session timeout from assertion, if present.- field :sso_session_timeout_minutes, :integer, default: 360+ field :sso_session_timeout_minutes, :integer, default: @default_timeout_minutesend+ @spec update_changeset(t(), map()) :: Ecto.Changeset.t()def update_changeset(policy, params) dopolicy|> cast(params, @update_fields)|> validate_required(@update_fields)+ |> validate_number(:sso_session_timeout_minutes,+ greater_than: 0,+ less_than: @max_timeout_minutes+ )end+ @spec force_sso_changeset(t(), force_sso_mode()) :: Ecto.Changeset.t()def force_sso_changeset(policy, mode) dopolicy|> cast(%{force_sso: mode}, [:force_sso])diff --git a/lib/plausible_web/controllers/settings_controller.ex b/lib/plausible_web/controllers/settings_controller.exindex c1757eaaf5..5d0c2b5852 100644--- a/lib/plausible_web/controllers/settings_controller.ex+++ b/lib/plausible_web/controllers/settings_controller.ex@@ -3,7 +3,6 @@ defmodule PlausibleWeb.SettingsController douse Plausible.Repoalias Plausible.Auth- alias PlausibleWeb.UserAuthalias Plausible.Teamsrequire Logger@@ -293,7 +292,7 @@ defmodule PlausibleWeb.SettingsController dowith :ok <- Auth.rate_limit(:password_change_user, user),{:ok, user} <- do_update_password(user, params) do- UserAuth.revoke_all_user_sessions(user, except: user_session)+ Auth.UserSessions.revoke_all(user, except: user_session)conn|> put_flash(:success, "Your password is now changed")@@ -342,7 +341,7 @@ defmodule PlausibleWeb.SettingsController dodef delete_session(conn, %{"id" => session_id}) docurrent_user = conn.assigns.current_user- :ok = UserAuth.revoke_user_session(current_user, session_id)+ :ok = Auth.UserSessions.revoke_by_id(current_user, session_id)conn|> put_flash(:success, "Session logged out successfully")diff --git a/lib/plausible_web/live/reset_password_form.ex b/lib/plausible_web/live/reset_password_form.exindex 60c835ed40..d39e6c2d0f 100644--- a/lib/plausible_web/live/reset_password_form.ex+++ b/lib/plausible_web/live/reset_password_form.ex@@ -7,7 +7,6 @@ defmodule PlausibleWeb.Live.ResetPasswordForm doalias Plausible.Authalias Plausible.Repo- alias PlausibleWeb.UserAuthdef mount(_params, %{"email" => email}, socket) dosocket =@@ -94,7 +93,7 @@ defmodule PlausibleWeb.Live.ResetPasswordForm docase result do{:ok, user} ->- UserAuth.revoke_all_user_sessions(user)+ Auth.UserSessions.revoke_all(user){:noreply, assign(socket, trigger_submit: true)}{:error, changeset} ->diff --git a/lib/plausible_web/plugs/user_session_touch.ex b/lib/plausible_web/plugs/user_session_touch.exindex 5802a0c231..5af39c4d3c 100644--- a/lib/plausible_web/plugs/user_session_touch.ex+++ b/lib/plausible_web/plugs/user_session_touch.ex@@ -5,7 +5,7 @@ defmodule PlausibleWeb.Plugs.UserSessionTouch doimport Plug.Conn- alias PlausibleWeb.UserAuth+ alias Plausible.Authdef init(opts \\ []) doopts@@ -16,7 +16,7 @@ defmodule PlausibleWeb.Plugs.UserSessionTouch doassign(conn,:current_user_session,- UserAuth.touch_user_session(user_session)+ Auth.UserSessions.touch(user_session))elseconndiff --git a/lib/plausible_web/user_auth.ex b/lib/plausible_web/user_auth.exindex bc718d87fa..1c48dd0994 100644--- a/lib/plausible_web/user_auth.ex+++ b/lib/plausible_web/user_auth.ex@@ -5,10 +5,7 @@ defmodule PlausibleWeb.UserAuth douse Plausible- import Ecto.Query-alias Plausible.Auth- alias Plausible.Repoalias PlausibleWeb.TwoFactoralias PlausibleWeb.Router.Helpers, as: Routes@@ -27,10 +24,11 @@ defmodule PlausibleWeb.UserAuth dodef log_in_user(conn, %Auth.User{} = user, redirect_path) doredirect_to = login_redirect_path(conn, redirect_path)- {token, _} = create_user_session(conn, user)+ device_name = get_device_name(conn)+ session = Auth.UserSessions.create!(user, device_name)conn- |> set_user_token(token)+ |> set_user_token(session.token)|> set_logged_in_cookie()|> Phoenix.Controller.redirect(to: redirect_to)end@@ -38,16 +36,13 @@ defmodule PlausibleWeb.UserAuth doon_ee dodef log_in_user(conn, %Auth.SSO.Identity{} = identity, redirect_path) docase Auth.SSO.provision_user(identity) do- {:ok, provisioning_from, team, user} ->- if provisioning_from == :standard do- :ok = revoke_all_user_sessions(user)- end-+ {:ok, _provisioning_from, team, user} ->redirect_to = login_redirect_path(conn, redirect_path)- {token, _} = create_sso_user_session(conn, user, identity.expires_at)+ device_name = get_device_name(conn)+ session = Auth.UserSessions.create!(user, device_name, timeout_at: identity.expires_at)conn- |> set_user_token(token)+ |> set_user_token(session.token)|> Plug.Conn.put_session("current_team_id", team.identifier)|> set_logged_in_cookie()|> Phoenix.Controller.redirect(to: redirect_to)@@ -75,28 +70,17 @@ defmodule PlausibleWeb.UserAuth dolog_in_user(conn, user, redirect_path)endend-- defp create_sso_user_session(conn, user, expires_at) do- device_name = get_device_name(conn)-- user_session =- user- |> Auth.UserSession.new_sso_session(device_name, expires_at)- |> Repo.insert!()-- {user_session.token, user_session}- endend@spec log_out_user(Plug.Conn.t()) :: Plug.Conn.t()def log_out_user(conn) docase get_user_token(conn) do- {:ok, token} -> remove_user_session(token)+ {:ok, token} -> Auth.UserSessions.remove_by_token(token){:error, _} -> :passendif live_socket_id = Plug.Conn.get_session(conn, :live_socket_id) do- PlausibleWeb.Endpoint.broadcast(live_socket_id, "disconnect", %{})+ Auth.UserSessions.disconnect_by_token(live_socket_id)endconn@@ -112,62 +96,11 @@ defmodule PlausibleWeb.UserAuth dodef get_user_session(conn_or_session) dowith {:ok, token} <- get_user_token(conn_or_session) do- get_session_by_token(token)- end- end-- @spec touch_user_session(Auth.UserSession.t(), NaiveDateTime.t()) :: Auth.UserSession.t()- def touch_user_session(user_session, now \\ NaiveDateTime.utc_now(:second)) do- if NaiveDateTime.diff(now, user_session.last_used_at, :hour) >= 1 do- Plausible.Users.bump_last_seen(user_session.user_id, now)-- user_session- |> Repo.preload(:user)- |> Auth.UserSession.touch_session(now)- |> Repo.update!(allow_stale: true)- else- user_session- end- end-- @spec revoke_user_session(Auth.User.t(), pos_integer()) :: :ok- def revoke_user_session(user, session_id) do- {_, tokens} =- Repo.delete_all(- from us in Auth.UserSession,- where: us.user_id == ^user.id and us.id == ^session_id,- select: us.token- )-- case tokens do- [token] ->- PlausibleWeb.Endpoint.broadcast(live_socket_id(token), "disconnect", %{})-- _ ->- :pass- end-- :ok- end-- @spec revoke_all_user_sessions(Auth.User.t(), Keyword.t()) :: :ok- def revoke_all_user_sessions(user, opts \\ []) do- except = Keyword.get(opts, :except)-- delete_query = from us in Auth.UserSession, where: us.user_id == ^user.id, select: us.token-- delete_query =- if except do- where(delete_query, [us], us.id != ^except.id)- else- delete_query+ case Auth.UserSessions.get_by_token(token) do+ {:ok, session} -> {:ok, session}+ {:error, :not_found} -> {:error, :session_not_found}end-- {_count, tokens} = Repo.delete_all(delete_query)-- Enum.each(tokens, fn token ->- PlausibleWeb.Endpoint.broadcast(live_socket_id(token), "disconnect", %{})- end)+ endend@doc """@@ -185,36 +118,6 @@ defmodule PlausibleWeb.UserAuth do)end- defp get_session_by_token(token) do- now = NaiveDateTime.utc_now(:second)-- last_team_subscription_query = Plausible.Teams.last_subscription_join_query()-- token_query =- from(us in Auth.UserSession,- inner_join: u in assoc(us, :user),- as: :user,- left_join: tm in assoc(u, :team_memberships),- on: tm.role != :guest,- left_join: t in assoc(tm, :team),- as: :team,- left_join: o in assoc(t, :owners),- left_lateral_join: ts in subquery(last_team_subscription_query),- on: true,- where: us.token == ^token and us.timeout_at > ^now,- order_by: t.id,- preload: [user: {u, team_memberships: {tm, team: {t, subscription: ts, owners: o}}}]- )-- case Repo.one(token_query) do- %Auth.UserSession{} = user_session ->- {:ok, user_session}-- nil ->- {:error, :session_not_found}- end- end-defp set_user_token(conn, token) doconn|> renew_session()@@ -245,11 +148,7 @@ defmodule PlausibleWeb.UserAuth dodefp put_token_in_session(conn, token) doconn|> Plug.Conn.put_session(:user_token, token)- |> Plug.Conn.put_session(:live_socket_id, live_socket_id(token))- end-- defp live_socket_id(token) do- "user_sessions:#{Base.url_encode64(token)}"+ |> Plug.Conn.put_session(:live_socket_id, Auth.UserSessions.socket_id(token))enddefp get_user_token(%Plug.Conn{} = conn) do@@ -266,22 +165,6 @@ defmodule PlausibleWeb.UserAuth do{:error, :no_valid_token}end- defp create_user_session(conn, user) do- device_name = get_device_name(conn)-- user_session =- user- |> Auth.UserSession.new_session(device_name)- |> Repo.insert!()-- {user_session.token, user_session}- end-- defp remove_user_session(token) do- Repo.delete_all(from us in Auth.UserSession, where: us.token == ^token)- :ok- end-@unknown_label "Unknown"defp get_device_name(%Plug.Conn{} = conn) dodiff --git a/test/plausible/auth/sso_test.exs b/test/plausible/auth/sso_test.exsindex db98639459..3268e212a9 100644--- a/test/plausible/auth/sso_test.exs+++ b/test/plausible/auth/sso_test.exs@@ -5,6 +5,7 @@ defmodule Plausible.Auth.SSOTest doon_ee douse Plausible.Teams.Test+ alias Plausible.Authalias Plausible.Auth.SSOdescribe "initiate_saml_integration/1" do@@ -304,6 +305,381 @@ defmodule Plausible.Auth.SSOTest doendend+ describe "deprovision_user!/1" do+ test "deprovisions SSO user" do+ team = new_site().team+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ identity = new_identity("Clarence Fortridge", "clarence@" <> domain)+ {:ok, _, _, user} = SSO.provision_user(identity)++ user = Repo.reload!(user)+ session = Auth.UserSessions.create!(user, "Unknown")++ updated_user = SSO.deprovision_user!(user)++ refute Repo.reload(session)+ assert updated_user.id == user.id+ assert updated_user.type == :standard+ refute updated_user.sso_identity_id+ refute updated_user.sso_integration_id+ end++ test "handles standard user gracefully without revoking existing sessions" do+ user = new_user()+ session = Auth.UserSessions.create!(user, "Unknown")++ assert updated_user = SSO.deprovision_user!(user)++ assert Repo.reload(session)+ assert updated_user.id == user.id+ assert updated_user.type == :standard+ refute updated_user.sso_identity_id+ refute updated_user.sso_integration_id+ end+ end++ describe "update_policy/2" do+ test "updates team policy attributes" do+ team = new_site().team++ assert team.policy.sso_default_role == :viewer+ assert team.policy.sso_session_timeout_minutes == 360++ assert {:ok, team} =+ SSO.update_policy(+ team,+ sso_default_role: "editor",+ sso_session_timeout_minutes: 600+ )++ assert team.policy.sso_default_role == :editor+ assert team.policy.sso_session_timeout_minutes == 600+ end++ test "accepts single attributes leaving others as they are" do+ team = new_site().team++ assert team.policy.sso_default_role == :viewer+ assert team.policy.sso_session_timeout_minutes == 360++ assert {:ok, team} = SSO.update_policy(team, sso_default_role: "editor")++ assert team.policy.sso_default_role == :editor+ assert team.policy.sso_session_timeout_minutes == 360+ end+ end++ describe "check_force_sso/2" do+ test "returns ok when conditions are met for setting all_but_owners" do+ # Owner with MFA enabled+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Lance Wurst", "lance@" <> domain)+ {:ok, _, _, _sso_user} = SSO.provision_user(identity)++ assert :ok = SSO.check_force_sso(team, :all_but_owners)+ end++ test "returns error when one owner does not have MFA configured" do+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Owner without MFA+ another_owner = new_user()+ add_member(team, user: another_owner, role: :owner)++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Carrie Mower", "lance@" <> domain)+ {:ok, _, _, _sso_user} = SSO.provision_user(identity)++ assert {:error, :owner_mfa_disabled} = SSO.check_force_sso(team, :all_but_owners)+ end++ test "returns error when there's no provisioned SSO user present" do+ # Owner with MFA enabled+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ assert {:error, :no_sso_user} = SSO.check_force_sso(team, :all_but_owners)+ end++ test "returns error when there's no verified SSO domain present" do+ # Owner with MFA enabled+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ # Unverified domain+ {:ok, _sso_domain} = SSO.Domains.add(integration, domain)++ assert {:error, :no_verified_domain} = SSO.check_force_sso(team, :all_but_owners)+ end++ test "returns error when there's no SSO domain present" do+ # Owner with MFA enabled+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ _integration = SSO.initiate_saml_integration(team)++ assert {:error, :no_domain} = SSO.check_force_sso(team, :all_but_owners)+ end++ test "returns error when there's no SSO integration present" do+ # Owner with MFA enabled+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ assert {:error, :no_integration} = SSO.check_force_sso(team, :all_but_owners)+ end++ test "returns ok when setting to none" do+ team = new_site().team++ assert :ok = SSO.check_force_sso(team, :none)+ end+ end++ describe "set_enforce_sso/2" do+ test "sets enforce mode to all_but_owners when conditions met" do+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Lance Wurst", "lance@" <> domain)+ {:ok, _, _, _sso_user} = SSO.provision_user(identity)++ assert {:ok, updated_team} = SSO.set_force_sso(team, :all_but_owners)++ assert updated_team.id == team.id+ assert updated_team.policy.force_sso == :all_but_owners+ end++ test "returns error when conditions not met" do+ team = new_site().team++ assert {:error, :no_integration} = SSO.set_force_sso(team, :all_but_owners)+ end++ test "sets enforce mode to none" do+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Lance Wurst", "lance@" <> domain)+ {:ok, _, _, _sso_user} = SSO.provision_user(identity)++ {:ok, team} = SSO.set_force_sso(team, :all_but_owners)++ assert {:ok, updated_team} = SSO.set_force_sso(team, :none)++ assert updated_team.id == team.id+ assert updated_team.policy.force_sso == :none+ end+ end++ describe "check_can_remove_integration/1" do+ test "returns ok if conditions to remove integration met" do+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Lance Wurst", "lance@" <> domain)+ {:ok, _, _, sso_user} = SSO.provision_user(identity)++ # SSO user deprovisioned+ _user = SSO.deprovision_user!(sso_user)++ integration = Repo.reload!(integration)+ assert :ok = SSO.check_can_remove_integration(integration)+ end++ test "returns error if force SSO enabled" do+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Lance Wurst", "lance@" <> domain)+ {:ok, _, _, sso_user} = SSO.provision_user(identity)++ # Force SSO enabled+ {:ok, _} = SSO.set_force_sso(team, :all_but_owners)++ # SSO user deprovisioned+ _user = SSO.deprovision_user!(sso_user)++ integration = Repo.reload!(integration)+ assert {:error, :force_sso_enabled} = SSO.check_can_remove_integration(integration)+ end++ test "returns error if SSO user present" do+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Lance Wurst", "lance@" <> domain)+ {:ok, _, _, _sso_user} = SSO.provision_user(identity)++ integration = Repo.reload!(integration)+ assert {:error, :sso_users_present} = SSO.check_can_remove_integration(integration)+ end+ end++ describe "remove_integration/1,2" do+ test "removes integration when conditions met" do+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Lance Wurst", "lance@" <> domain)+ {:ok, _, _, sso_user} = SSO.provision_user(identity)++ # SSO user deprovisioned+ _user = SSO.deprovision_user!(sso_user)++ integration = Repo.reload!(integration)++ assert :ok = SSO.remove_integration(integration)+ refute Repo.reload(integration)+ refute Repo.reload(sso_domain)+ end++ test "returns error when conditions not met" do+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Lance Wurst", "lance@" <> domain)+ {:ok, _, _, _sso_user} = SSO.provision_user(identity)++ integration = Repo.reload!(integration)++ assert {:error, :sso_users_present} = SSO.remove_integration(integration)+ assert Repo.reload(integration)+ assert Repo.reload(sso_domain)+ end++ test "succeeds when SSO user present and force flag set" do+ owner = new_user(totp_enabled: true, totp_secret: "secret")+ team = new_site(owner: owner).team++ # Setup integration+ integration = SSO.initiate_saml_integration(team)+ domain = "example-#{Enum.random(1..10_000)}.com"++ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ # Provisioned SSO identity+ #+ identity = new_identity("Carrie Mower", "carrie@" <> domain)+ {:ok, _, _, sso_user} = SSO.provision_user(identity)++ integration = Repo.reload!(integration)++ assert :ok = SSO.remove_integration(integration, force_deprovision?: true)+ refute Repo.reload(integration)+ refute Repo.reload(sso_domain)++ # SSO user is deprovisioned+ sso_user = Repo.reload(sso_user)++ assert sso_user.type == :standard+ refute sso_user.sso_identity_id+ refute sso_user.sso_integration_id+ end+ end+defp new_identity(name, email, id \\ Ecto.UUID.generate()) do%SSO.Identity{id: id,diff --git a/test/plausible/auth/user_sessions_test.exs b/test/plausible/auth/user_sessions_test.exsindex 673d2e795f..dae8844b48 100644--- a/test/plausible/auth/user_sessions_test.exs+++ b/test/plausible/auth/user_sessions_test.exs@@ -1,5 +1,9 @@defmodule Plausible.Auth.UserSessionsTest douse Plausible.DataCase, async: true+ use Plausible.Teams.Test+ use Plausible++ import Phoenix.ChannelTestalias Plausible.Authalias Plausible.Auth.UserSessions@@ -50,6 +54,212 @@ defmodule Plausible.Auth.UserSessionsTest doendend+ describe "touch/1,2" do+ setup do+ user = new_user()++ session =+ user+ |> Auth.UserSession.new_session("A Device")+ |> Repo.insert!()++ {:ok, user: user, session: session}+ end++ test "refreshes user session timestamps", %{user: user, session: session} do+ two_days_later =+ NaiveDateTime.utc_now(:second)+ |> NaiveDateTime.shift(day: 2)++ assert refreshed_session =+ %Auth.UserSession{} = UserSessions.touch(session, two_days_later)++ assert refreshed_session.id == session.id+ assert NaiveDateTime.compare(refreshed_session.last_used_at, two_days_later) == :eq+ assert NaiveDateTime.compare(Repo.reload(user).last_seen, two_days_later) == :eq+ assert NaiveDateTime.compare(refreshed_session.timeout_at, session.timeout_at) == :gt+ end++ test "does not refresh if timestamps were updated less than hour before", %{+ user: user,+ session: session+ } do+ last_seen = Repo.reload(user).last_seen++ fifty_minutes_later =+ NaiveDateTime.utc_now(:second)+ |> NaiveDateTime.shift(minute: 50)++ assert refreshed_session1 =+ %Auth.UserSession{} =+ UserSessions.touch(session, fifty_minutes_later)++ assert NaiveDateTime.compare(+ refreshed_session1.last_used_at,+ session.last_used_at+ ) == :eq++ assert NaiveDateTime.compare(Repo.reload(user).last_seen, last_seen) == :eq++ sixty_five_minutes_later =+ NaiveDateTime.utc_now(:second)+ |> NaiveDateTime.shift(minute: 65)++ assert refreshed_session2 =+ %Auth.UserSession{} =+ UserSessions.touch(session, sixty_five_minutes_later)++ assert NaiveDateTime.compare(+ refreshed_session2.last_used_at,+ sixty_five_minutes_later+ ) == :eq++ assert NaiveDateTime.compare(Repo.reload(user).last_seen, sixty_five_minutes_later) == :eq+ end++ test "handles concurrent refresh gracefully", %{session: session} do+ # concurrent update+ now = NaiveDateTime.utc_now(:second)+ two_days_later = NaiveDateTime.shift(now, day: 2)++ Repo.update_all(+ from(us in Auth.UserSession, where: us.token == ^session.token),+ set: [timeout_at: two_days_later, last_used_at: now]+ )++ assert refreshed_session = %Auth.UserSession{} = UserSessions.touch(session)++ assert refreshed_session.id == session.id+ assert Repo.reload(session)+ end++ test "handles deleted session case gracefully", %{session: session} do+ Repo.delete!(session)++ assert refreshed_session = %Auth.UserSession{} = UserSessions.touch(session)++ assert refreshed_session.id == session.id++ refute Repo.reload(session)+ end++ on_ee do+ test "only records last usage but does not refresh for SSO user", %{+ user: user,+ session: session+ } do+ sixty_five_minutes_later =+ NaiveDateTime.utc_now(:second)+ |> NaiveDateTime.shift(minute: 65)++ user |> Ecto.Changeset.change(type: :sso) |> Repo.update!()++ session = Repo.reload!(session)++ assert refreshed_session =+ %Auth.UserSession{} =+ UserSessions.touch(session, sixty_five_minutes_later)++ assert refreshed_session.id == session.id++ assert NaiveDateTime.compare(refreshed_session.last_used_at, sixty_five_minutes_later) ==+ :eq++ assert NaiveDateTime.compare(refreshed_session.timeout_at, session.timeout_at) == :eq+ end+ end+ end++ describe "revoke_by_id/2" do+ setup do+ user = new_user()++ session =+ user+ |> Auth.UserSession.new_session("A Device")+ |> Repo.insert!()++ {:ok, user: user, session: session}+ end++ test "deletes and disconnects user session", %{user: user, session: active_session} do+ live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)+ Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)++ another_session =+ user+ |> Auth.UserSession.new_session("Some Device")+ |> Repo.insert!()++ assert :ok = UserSessions.revoke_by_id(user, active_session.id)++ assert [remaining_session] = Repo.preload(user, :sessions).sessions+ assert_broadcast "disconnect", %{}+ assert remaining_session.id == another_session.id+ refute Repo.reload(active_session)+ assert Repo.reload(another_session)+ end++ test "does not delete session of another user", %{user: user, session: active_session} do+ other_session =+ insert(:user)+ |> Auth.UserSession.new_session("Some Device")+ |> Repo.insert!()++ assert :ok = UserSessions.revoke_by_id(user, other_session.id)++ assert Repo.reload(active_session)+ assert Repo.reload(other_session)+ end++ test "executes gracefully when session does not exist", %{user: user, session: active_session} do+ Repo.delete!(active_session)++ assert :ok = UserSessions.revoke_by_id(user, active_session.id)+ end+ end++ describe "revoke_all/1,2" do+ setup do+ user = new_user()++ session =+ user+ |> Auth.UserSession.new_session("A Device")+ |> Repo.insert!()++ {:ok, user: user, session: session}+ end++ test "deletes and disconnects all user's sessions", %{user: user, session: active_session} do+ live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)+ Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)++ another_session =+ user+ |> Auth.UserSession.new_session("Some Device")+ |> Repo.insert!()++ unrelated_session =+ insert(:user)+ |> Auth.UserSession.new_session("Some Device")+ |> Repo.insert!()++ assert :ok = UserSessions.revoke_all(user)++ assert [] = Repo.preload(user, :sessions).sessions+ assert_broadcast "disconnect", %{}+ refute Repo.reload(another_session)+ assert Repo.reload(unrelated_session)+ end++ test "executes gracefully when user has no sessions" do+ user = insert(:user)++ assert :ok = UserSessions.revoke_all(user)+ end+ end+defp last_used_humanize(user, dt) douser|> insert_session("Some Device", dt)@@ -58,7 +268,7 @@ defmodule Plausible.Auth.UserSessionsTest dodefp insert_session(user, device_name, now) douser- |> Auth.UserSession.new_session(device_name, now)+ |> Auth.UserSession.new_session(device_name, now: now)|> Repo.insert!()endenddiff --git a/test/plausible_web/controllers/settings_controller_test.exs b/test/plausible_web/controllers/settings_controller_test.exsindex 249e423f1f..da3f6b4955 100644--- a/test/plausible_web/controllers/settings_controller_test.exs+++ b/test/plausible_web/controllers/settings_controller_test.exs@@ -603,7 +603,7 @@ defmodule PlausibleWeb.SettingsControllerTest doanother_session =user- |> Auth.UserSession.new_session("Some Device", seventy_minutes_ago)+ |> Auth.UserSession.new_session("Some Device", now: seventy_minutes_ago)|> Repo.insert!()conn = get(conn, Routes.settings_path(conn, :security))diff --git a/test/plausible_web/user_auth_test.exs b/test/plausible_web/user_auth_test.exsindex 5458c799cb..295619674c 100644--- a/test/plausible_web/user_auth_test.exs+++ b/test/plausible_web/user_auth_test.exs@@ -3,10 +3,6 @@ defmodule PlausibleWeb.UserAuthTest douse Plausibleuse Plausible.Teams.Test- import Ecto.Query, only: [from: 2]- import Phoenix.ChannelTest-- alias Plausible.Authalias Plausible.Repoalias PlausibleWeb.UserAuth@@ -297,191 +293,6 @@ defmodule PlausibleWeb.UserAuthTest doendend- describe "touch_user_session/1" do- setup [:create_user, :log_in]-- test "refreshes user session timestamps", %{user: user} do- %{sessions: [user_session]} = Repo.preload(user, :sessions)-- two_days_later =- NaiveDateTime.utc_now(:second)- |> NaiveDateTime.shift(day: 2)-- assert refreshed_session =- %Auth.UserSession{} = UserAuth.touch_user_session(user_session, two_days_later)-- assert refreshed_session.id == user_session.id- assert NaiveDateTime.compare(refreshed_session.last_used_at, two_days_later) == :eq- assert NaiveDateTime.compare(Repo.reload(user).last_seen, two_days_later) == :eq- assert NaiveDateTime.compare(refreshed_session.timeout_at, user_session.timeout_at) == :gt- end-- test "does not refresh if timestamps were updated less than hour before", %{user: user} do- %{sessions: [user_session]} = Repo.preload(user, :sessions)- user_session = Repo.reload(user_session)- last_seen = Repo.reload(user).last_seen-- fifty_minutes_later =- NaiveDateTime.utc_now(:second)- |> NaiveDateTime.shift(minute: 50)-- assert refreshed_session1 =- %Auth.UserSession{} =- UserAuth.touch_user_session(user_session, fifty_minutes_later)-- assert NaiveDateTime.compare(- refreshed_session1.last_used_at,- user_session.last_used_at- ) == :eq-- assert NaiveDateTime.compare(Repo.reload(user).last_seen, last_seen) == :eq-- sixty_five_minutes_later =- NaiveDateTime.utc_now(:second)- |> NaiveDateTime.shift(minute: 65)-- assert refreshed_session2 =- %Auth.UserSession{} =- UserAuth.touch_user_session(user_session, sixty_five_minutes_later)-- assert NaiveDateTime.compare(- refreshed_session2.last_used_at,- sixty_five_minutes_later- ) == :eq-- assert NaiveDateTime.compare(Repo.reload(user).last_seen, sixty_five_minutes_later) == :eq- end-- test "handles concurrent refresh gracefully", %{user: user} do- %{sessions: [user_session]} = Repo.preload(user, :sessions)-- # concurrent update- now = NaiveDateTime.utc_now(:second)- two_days_later = NaiveDateTime.shift(now, day: 2)-- Repo.update_all(- from(us in Auth.UserSession, where: us.token == ^user_session.token),- set: [timeout_at: two_days_later, last_used_at: now]- )-- assert refreshed_session =- %Auth.UserSession{} = UserAuth.touch_user_session(user_session)-- assert refreshed_session.id == user_session.id- assert Repo.reload(user_session)- end-- test "handles deleted session case gracefully", %{user: user} do- %{sessions: [user_session]} = Repo.preload(user, :sessions)- Repo.delete!(user_session)-- assert refreshed_session =- %Auth.UserSession{} = UserAuth.touch_user_session(user_session)-- assert refreshed_session.id == user_session.id-- refute Repo.reload(user_session)- end-- on_ee do- test "only records last usage but does not refresh for SSO user", %{user: user} do- sixty_five_minutes_later =- NaiveDateTime.utc_now(:second)- |> NaiveDateTime.shift(minute: 65)-- user = user |> Ecto.Changeset.change(type: :sso) |> Repo.update!()-- %{sessions: [session]} = Repo.preload(user, :sessions)-- assert refreshed_session =- %Auth.UserSession{} =- UserAuth.touch_user_session(session, sixty_five_minutes_later)-- assert refreshed_session.id == session.id-- assert NaiveDateTime.compare(refreshed_session.last_used_at, sixty_five_minutes_later) ==- :eq-- assert NaiveDateTime.compare(refreshed_session.timeout_at, session.timeout_at) == :eq- end- end- end-- describe "revoke_user_session/2" do- setup [:create_user, :log_in]-- test "deletes and disconnects user session", %{user: user} do- assert [active_session] = Repo.preload(user, :sessions).sessions- live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)- Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)-- another_session =- user- |> Auth.UserSession.new_session("Some Device")- |> Repo.insert!()-- assert :ok = UserAuth.revoke_user_session(user, active_session.id)- assert [remaining_session] = Repo.preload(user, :sessions).sessions- assert_broadcast "disconnect", %{}- assert remaining_session.id == another_session.id- refute Repo.reload(active_session)- assert Repo.reload(another_session)- end-- test "does not delete session of another user", %{user: user} do- assert [active_session] = Repo.preload(user, :sessions).sessions-- other_session =- insert(:user)- |> Auth.UserSession.new_session("Some Device")- |> Repo.insert!()-- assert :ok = UserAuth.revoke_user_session(user, other_session.id)-- assert Repo.reload(active_session)- assert Repo.reload(other_session)- end-- test "executes gracefully when session does not exist", %{user: user} do- assert [active_session] = Repo.preload(user, :sessions).sessions- Repo.delete!(active_session)-- assert :ok = UserAuth.revoke_user_session(user, active_session.id)- end- end-- describe "revoke_all_user_sessions/1" do- setup [:create_user, :log_in]-- test "deletes and disconnects all user's sessions", %{user: user} do- assert [active_session] = Repo.preload(user, :sessions).sessions- live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)- Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)-- another_session =- user- |> Auth.UserSession.new_session("Some Device")- |> Repo.insert!()-- unrelated_session =- insert(:user)- |> Auth.UserSession.new_session("Some Device")- |> Repo.insert!()-- assert :ok = UserAuth.revoke_all_user_sessions(user)- assert [] = Repo.preload(user, :sessions).sessions- assert_broadcast "disconnect", %{}- refute Repo.reload(another_session)- assert Repo.reload(unrelated_session)- end-- test "executes gracefully when user has no sessions" do- user = insert(:user)-- assert :ok = UserAuth.revoke_all_user_sessions(user)- end- end-@user_agent "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36"@user_agent_mobile "Mozilla/5.0 (Linux; Android 6.0; U007 Pro Build/MRA58K; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/44.0.2403.119 Mobile Safari/537.36"@user_agent_tablet "Mozilla/5.0 (Linux; U; Android 4.2.2; it-it; Surfing TAB B 9.7 3G Build/JDQ39) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30"diff --git a/test/support/teams/test.ex b/test/support/teams/test.exindex d7aa04e5fb..4774458157 100644--- a/test/support/teams/test.ex+++ b/test/support/teams/test.ex@@ -2,6 +2,8 @@ defmodule Plausible.Teams.Test do@moduledoc """Convenience assertions for teams schema transition"""+ use Plausible+alias Plausible.Repoalias Plausible.Teams@@ -56,6 +58,11 @@ defmodule Plausible.Teams.Test dodef new_user(args \\ []) do{team_args, args} = Keyword.pop(args, :team, []){trial_expiry_date, args} = Keyword.pop(args, :trial_expiry_date)++ on_ee do+ args = Keyword.merge([type: :standard], args)+ end+user = insert(:user, args)trial_expiry_date =diff --git a/test/workers/clean_user_sessions_test.exs b/test/workers/clean_user_sessions_test.exsindex e6006866ea..8d677c1e65 100644--- a/test/workers/clean_user_sessions_test.exs+++ b/test/workers/clean_user_sessions_test.exs@@ -28,7 +28,7 @@ defmodule Plausible.Workers.CleanUserSessionsTest douser = insert(:user)user- |> UserSession.new_session("Unknown", now)+ |> UserSession.new_session("Unknown", now: now)|> Repo.insert!()endend