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 plug for checking SSO team access (#5522)
Adrian Gruntkowski307d6b004b50
diff --git a/extra/lib/plausible/auth/sso.ex b/extra/lib/plausible/auth/sso.exindex 90c3fc6576..e5c2d2b52d 100644--- a/extra/lib/plausible/auth/sso.ex+++ b/extra/lib/plausible/auth/sso.ex@@ -217,6 +217,25 @@ defmodule Plausible.Auth.SSO doendend+ @spec check_ready_to_provision(Auth.User.t(), Teams.Team.t()) ::+ :ok | {:error, :not_a_member | :multiple_memberships | :active_personal_team}+ def check_ready_to_provision(%{type: :sso} = _user, _team), do: :ok++ def check_ready_to_provision(user, team) do+ result =+ with :ok <- ensure_team_member(team, user),+ :ok <- ensure_one_membership(user, team) do+ ensure_empty_personal_team(user, team)+ end++ case result do+ :ok -> :ok+ {:error, :integration_not_found} -> {:error, :not_a_member}+ {:error, :multiple_memberships, _, _} -> {:error, :multiple_memberships}+ {:error, :active_personal_team, _, _} -> {:error, :active_personal_team}+ end+ end+defp check_integration_configured(team) dointegrations =Repo.all(diff --git a/extra/lib/plausible_web/controllers/sso_controller.ex b/extra/lib/plausible_web/controllers/sso_controller.exindex 5196c15d29..eb08cd9f52 100644--- a/extra/lib/plausible_web/controllers/sso_controller.ex+++ b/extra/lib/plausible_web/controllers/sso_controller.ex@@ -45,6 +45,24 @@ defmodule PlausibleWeb.SSOController doendend+ def provision_notice(conn, _params) do+ render(conn, "provision_notice.html")+ end++ def provision_issue(conn, params) do+ issue =+ case params["issue"] do+ "not_a_member" -> :not_a_member+ "multiple_memberships" -> :multiple_memberships+ "multiple_memberships_noforce" -> :multiple_memberships_noforce+ "active_personal_team" -> :active_personal_team+ "active_personal_team_noforce" -> :active_personal_team_noforce+ _ -> :unknown+ end++ render(conn, "provision_issue.html", issue: issue)+ end+def saml_signin(conn, params) dosaml_adapter().signin(conn, params)enddiff --git a/extra/lib/plausible_web/live/sso_management.ex b/extra/lib/plausible_web/live/sso_management.exindex b47d1c6248..79cb679b2e 100644--- a/extra/lib/plausible_web/live/sso_management.ex+++ b/extra/lib/plausible_web/live/sso_management.ex@@ -662,23 +662,26 @@ defmodule PlausibleWeb.Live.SSOManagement dotoggle_mode = if team.policy.force_sso == :none, do: :all_but_owners, else: :none{can_toggle_force_sso?, toggle_disabled_reason} =- case SSO.check_force_sso(team, toggle_mode) do- :ok ->+ case {SSO.check_force_sso(team, toggle_mode), socket.assigns.current_user.type} do+ {:ok, :sso} ->{true, nil}- {:error, :no_integration} ->+ {:ok, :standard} ->+ {false, "you must be logged in via SSO"}++ {{:error, :no_integration}, _} ->{false, "you must first setup Single Sign-on"}- {:error, :no_domain} ->+ {{:error, :no_domain}, _} ->{false, "you must add a domain"}- {:error, :no_verified_domain} ->+ {{:error, :no_verified_domain}, _} ->{false, "you must verify a domain"}- {:error, :owner_mfa_disabled} ->+ {{:error, :owner_mfa_disabled}, _} ->{false, "all Owners must have MFA enabled"}- {:error, :no_sso_user} ->+ {{:error, :no_sso_user}, _} ->{false, "at least one SSO user must log in successfully"}enddiff --git a/extra/lib/plausible_web/templates/sso/provision_issue.html.heex b/extra/lib/plausible_web/templates/sso/provision_issue.html.heexnew file mode 100644index 0000000000..57abf7d408--- /dev/null+++ b/extra/lib/plausible_web/templates/sso/provision_issue.html.heex@@ -0,0 +1,51 @@+<.focus_box>+ <:title>+ Single Sign-On enforcement+ </:title>+ <:subtitle>+ The owner of <span :if={is_nil(@conn.assigns[:current_team])}>the team</span>+ <span :if={@conn.assigns[:current_team]}>"{@conn.assigns[:current_team].name}"</span>+ has turned off regular email and password logins.+ To keep things secure and simple, you can only sign in using your organization's+ Single Sign-On (SSO) system.+ </:subtitle>++ <p :if={@issue == :multiple_memberships} class="text-sm">+ To access this team, you must first leave all other teams.+ </p>++ <p :if={@issue == :multiple_memberships_noforce} class="text-sm">+ To log in as an SSO user, you must first leave all other teams.+ </p>++ <div :if={@issue == :active_personal_team} class="text-sm flex flex-col space-y-2">+ <p>+ To access this team, you must either remove or transfer all sites you own under "My Personal Sites".+ </p>++ <p>+ You also have to cancel subscription for "My Personal Sites" if there is an active one.+ </p>+ </div>++ <div :if={@issue == :active_personal_team_noforce} class="text-sm flex flex-col space-y-2">+ <p>+ To log in as an SSO user, you must either remove or transfer all sites you own under "My Personal Sites".+ </p>++ <p>+ You also have to cancel subscription on "My Personal Sites" if there is an active one.+ </p>+ </div>++ <p :if={@issue == :not_a_member} class="text-sm">+ To access this team, you must join as a team member first.+ </p>++ <p :if={[email protected][:current_user]} class="text-sm mt-4">+ <.styled_link href={Routes.auth_path(@conn, :login_form, prefer: "manual")}>+ Log in+ </.styled_link>+ with your email and password to resolve the issue.+ </p>+</.focus_box>diff --git a/extra/lib/plausible_web/templates/sso/provision_notice.html.heex b/extra/lib/plausible_web/templates/sso/provision_notice.html.heexnew file mode 100644index 0000000000..5b3a7a68e1--- /dev/null+++ b/extra/lib/plausible_web/templates/sso/provision_notice.html.heex@@ -0,0 +1,18 @@+<.focus_box>+ <:title>+ Single Sign-On enforcement+ </:title>+ <:subtitle>+ The owner of <span :if={is_nil(@conn.assigns[:current_team])}>the team</span>+ <span :if={@conn.assigns[:current_team]}>"{@conn.assigns[:current_team].name}"</span>+ has turned off regular email and password logins.+ To keep things secure and simple, you can only sign in using your organization's+ Single Sign-On (SSO) system.+ </:subtitle>++ <p class="text-sm">+ To access this team, you must first+ <.styled_link href="/logout">log out</.styled_link>+ and log in as SSO user.+ </p>+</.focus_box>diff --git a/lib/plausible_web/live/team_management.ex b/lib/plausible_web/live/team_management.exindex 231c833cab..0fc7c44b5a 100644--- a/lib/plausible_web/live/team_management.ex+++ b/lib/plausible_web/live/team_management.ex@@ -334,7 +334,12 @@ defmodule PlausibleWeb.Live.TeamManagement dodefp entry_label(%Layout.Entry{role: :guest, type: :membership}, _), do: nildefp entry_label(%Layout.Entry{type: :invitation_pending}, _), do: "Invitation Pending"defp entry_label(%Layout.Entry{type: :invitation_sent}, _), do: "Invitation Sent"++ defp entry_label(%Layout.Entry{meta: %{user: %{id: id, type: :sso}}}, %{id: id}),+ do: "You (SSO)"+defp entry_label(%Layout.Entry{meta: %{user: %{id: id}}}, %{id: id}), do: "You"+ defp entry_label(%Layout.Entry{meta: %{user: %{type: :sso}}}, _), do: "SSO Member"defp entry_label(_, _), do: "Team Member"def at_limit?(layout, limit) dodiff --git a/lib/plausible_web/plugs/sso_team_access.ex b/lib/plausible_web/plugs/sso_team_access.exnew file mode 100644index 0000000000..1d917f39fd--- /dev/null+++ b/lib/plausible_web/plugs/sso_team_access.ex@@ -0,0 +1,53 @@+defmodule Plausible.Plugs.SSOTeamAccess do+ @moduledoc """+ Plug ensuring user is permitted to access the team+ if it has SSO setup with Force SSO policy.+ """++ use Plausible++ def init(_) do+ []+ end++ on_ee do+ import Phoenix.Controller, only: [redirect: 2]+ import Plug.Conn++ alias PlausibleWeb.Router.Helpers, as: Routes++ def call(conn, _opts) do+ current_user = conn.assigns[:current_user]+ current_team = conn.assigns[:current_team]++ eligible_for_check? =+ not is_nil(current_user) and+ not is_nil(current_team) and+ current_team.policy.force_sso == :all_but_owners and+ Plausible.Users.type(current_user) == :standard++ if eligible_for_check? do+ check_user(conn, current_user, current_team)+ else+ conn+ end+ end++ defp check_user(conn, user, team) do+ conn =+ case Plausible.Auth.SSO.check_ready_to_provision(user, team) do+ :ok ->+ redirect(conn, to: Routes.sso_path(conn, :provision_notice))++ {:error, issue} ->+ redirect(conn, to: Routes.sso_path(conn, :provision_issue, issue: issue))+ end++ halt(conn)+ end+ else+ def call(conn, _opts) do+ conn+ end+ end+enddiff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.exindex 3d4f04cd0a..cf01875cf5 100644--- a/lib/plausible_web/router.ex+++ b/lib/plausible_web/router.ex@@ -12,9 +12,23 @@ defmodule PlausibleWeb.Router doplug PlausibleWeb.Plugs.NoRobotson_ee(do: nil, else: plug(PlausibleWeb.FirstLaunchPlug, redirect_to: "/register"))plug PlausibleWeb.AuthPlug+ on_ee(do: plug(Plausible.Plugs.SSOTeamAccess))plug PlausibleWeb.Plugs.UserSessionTouchend+ on_ee do+ pipeline :browser_sso_notice do+ plug :accepts, ["html"]+ plug :fetch_session+ plug :fetch_live_flash+ plug :put_secure_browser_headers+ plug PlausibleWeb.Plugs.NoRobots+ on_ee(do: nil, else: plug(PlausibleWeb.FirstLaunchPlug, redirect_to: "/register"))+ plug PlausibleWeb.AuthPlug+ plug PlausibleWeb.Plugs.UserSessionTouch+ end+ end+pipeline :shared_link doplug :accepts, ["html"]plug :put_secure_browser_headers@@ -465,13 +479,26 @@ defmodule PlausibleWeb.Router dodelete "/team/delete", SettingsController, :delete_teamend+ on_ee do+ scope "/", PlausibleWeb do+ pipe_through [:browser_sso_notice, :csrf]++ get "/sso/notice", SSOController, :provision_notice+ get "/sso/issue", SSOController, :provision_issue+ get "/logout", AuthController, :logout+ get "/team/select", AuthController, :select_team+ end+ end+scope "/", PlausibleWeb dopipe_through [:browser, :csrf]- get "/logout", AuthController, :logout- delete "/me", AuthController, :delete_me+ on_ce do+ get "/logout", AuthController, :logout+ get "/team/select", AuthController, :select_team+ end- get "/team/select", AuthController, :select_team+ delete "/me", AuthController, :delete_meget "/auth/google/callback", AuthController, :google_auth_callbackdiff --git a/lib/plausible_web/user_auth.ex b/lib/plausible_web/user_auth.exindex 0f680e385c..04536d3b8f 100644--- a/lib/plausible_web/user_auth.ex+++ b/lib/plausible_web/user_auth.ex@@ -66,11 +66,15 @@ defmodule PlausibleWeb.UserAuth doto: Routes.sso_path(conn, :login_form, return_to: redirect_path))- {:error, reason, team, user}+ {:error, reason, _team, _user}when reason in [:multiple_memberships, :active_personal_team] ->- redirect_path = Routes.site_path(conn, :index, __team: team.identifier)+ issue = to_string(reason) <> "_noforce"- log_in_user(conn, user, redirect_path)+ conn+ |> log_out_user()+ |> Phoenix.Controller.redirect(+ to: Routes.sso_path(conn, :provision_issue, issue: issue)+ )endendenddiff --git a/test/plausible/auth/sso_test.exs b/test/plausible/auth/sso_test.exsindex d6357a008a..0253aeca9a 100644--- a/test/plausible/auth/sso_test.exs+++ b/test/plausible/auth/sso_test.exs@@ -8,6 +8,7 @@ defmodule Plausible.Auth.SSOTest doalias Plausible.Authalias Plausible.Auth.SSO+ alias Plausible.Teamsdescribe "initiate_saml_integration/1" dotest "initiates new saml integration" do@@ -887,5 +888,84 @@ defmodule Plausible.Auth.SSOTest dorefute_enqueued(worker: SSO.Domain.Verification.Worker, args: %{domain: domain})endend++ describe "check_ready_to_provision/2" do+ setup do+ owner = new_user()+ {:ok, owner, _} = Auth.TOTP.initiate(owner)+ {:ok, owner, _} = Auth.TOTP.enable(owner, :skip_verify)+ team = new_site(owner: owner).team |> Teams.complete_setup()++ 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)++ {:ok,+ team: team,+ owner: owner,+ integration: integration,+ sso_domain: sso_domain,+ domain: domain}+ end++ test "returns ok for user who is already of type SSO", %{domain: domain, team: team} do+ identity = new_identity("Lance Wurst", "lance@" <> domain)+ {:ok, _, _, sso_user} = SSO.provision_user(identity)++ assert :ok = SSO.check_ready_to_provision(sso_user, team)+ end++ test "returns ok for standard user who meets criteria", %{team: team} do+ member = add_member(team, role: :viewer)++ assert :ok = SSO.check_ready_to_provision(member, team)++ # non-active personal team+ {:ok, _personal_team} = Teams.get_or_create(member)++ # guest membership in another team's site+ another_team_site = new_site()+ add_guest(another_team_site, user: member, role: :editor)+ end++ test "returns error for non-member or guest-only user", %{team: team} do+ user = new_user()++ assert {:error, :not_a_member} = SSO.check_ready_to_provision(user, team)++ site = new_site(team: team)+ guest = add_guest(site, role: :editor)++ assert {:error, :not_a_member} = SSO.check_ready_to_provision(guest, team)+ end++ test "returns error for user with more than one membership", %{team: team} do+ user = new_user()+ add_member(team, user: user, role: :viewer)+ another_team = new_site().team |> Teams.complete_setup()+ add_member(another_team, user: user, role: :editor)++ assert {:error, :multiple_memberships} = SSO.check_ready_to_provision(user, team)+ end++ test "returns error for personal team with sites", %{team: team} do+ user = new_user()+ add_member(team, user: user, role: :viewer)++ {:ok, personal_team} = Teams.get_or_create(user)+ new_site(team: personal_team)++ assert {:error, :active_personal_team} = SSO.check_ready_to_provision(user, team)+ end++ test "returns error for personal team active subscription", %{team: team} do+ user = new_user() |> subscribe_to_growth_plan()+ add_member(team, user: user, role: :viewer)++ assert {:error, :active_personal_team} = SSO.check_ready_to_provision(user, team)+ end+ endendenddiff --git a/test/plausible_web/controllers/sso_controller_test.exs b/test/plausible_web/controllers/sso_controller_test.exsindex 147ad2fce8..568db7a0af 100644--- a/test/plausible_web/controllers/sso_controller_test.exs+++ b/test/plausible_web/controllers/sso_controller_test.exs@@ -218,5 +218,81 @@ defmodule PlausibleWeb.SSOControllerTest doassert html =~ "Configure and manage Single Sign-On for your team"endend++ describe "provision_notice/2" do+ test "renders the notice", %{conn: conn} do+ conn = get(conn, Routes.sso_path(conn, :provision_notice))++ assert html = html_response(conn, 200)++ assert html =~ "Single Sign-On enforcement"+ assert html =~ "To access this team, you must first"+ assert html =~ "log out"+ assert html =~ "and log in as SSO user"+ end+ end++ describe "provision_issue/2" do+ test "renders issue for not_a_member", %{conn: conn} do+ conn = get(conn, Routes.sso_path(conn, :provision_issue, issue: "not_a_member"))++ assert html = html_response(conn, 200)++ assert html =~ "Single Sign-On enforcement"+ assert html =~ "To access this team, you must join as a team member first"+ end++ test "renders issue for multiple_memberships", %{conn: conn} do+ conn = get(conn, Routes.sso_path(conn, :provision_issue, issue: "multiple_memberships"))++ assert html = html_response(conn, 200)++ assert html =~ "Single Sign-On enforcement"+ assert html =~ "To access this team, you must first leave all other teams"+ end++ test "renders issue for multiple_memberships_noforce", %{conn: conn} do+ conn =+ get(+ conn,+ Routes.sso_path(conn, :provision_issue, issue: "multiple_memberships_noforce")+ )++ assert html = html_response(conn, 200)++ assert html =~ "Single Sign-On enforcement"+ assert html =~ "To log in as an SSO user, you must first leave all other teams"++ assert html =~ "Log in"+ assert html =~ "with your email and password"+ end++ test "renders issue for active_personal_team", %{conn: conn} do+ conn = get(conn, Routes.sso_path(conn, :provision_issue, issue: "active_personal_team"))++ assert html = html_response(conn, 200)++ assert html =~ "Single Sign-On enforcement"+ assert html =~ "To access this team, you must either remove or transfer all sites"+ end++ test "renders issue for active_personal_team_noforce", %{conn: conn} do+ conn =+ get(+ conn,+ Routes.sso_path(conn, :provision_issue, issue: "active_personal_team_noforce")+ )++ assert html = html_response(conn, 200)++ assert html =~ "Single Sign-On enforcement"++ assert html =~+ "To log in as an SSO user, you must either remove or transfer all sites"++ assert html =~ "Log in"+ assert html =~ "with your email and password"+ end+ endendenddiff --git a/test/plausible_web/live/sso_management_test.exs b/test/plausible_web/live/sso_management_test.exsindex 05ca8a2bcc..16375b982a 100644--- a/test/plausible_web/live/sso_management_test.exs+++ b/test/plausible_web/live/sso_management_test.exs@@ -236,7 +236,11 @@ defmodule PlausibleWeb.Live.SSOMangementTest doassert text_of_attr(html, ~s|#sso-policy_sso_session_timeout_minutes|, "value") == "710"end- test "force SSO toggle", %{conn: conn, team: team, user: user} do+ test "force SSO toggle disabled when operator is standard user", %{+ conn: conn,+ team: team,+ user: user+ } dosetup_integration(team, "org.example.com"){_lv, html} = get_lv(conn)@@ -248,6 +252,31 @@ defmodule PlausibleWeb.Live.SSOMangementTest doidentity = new_identity("Lance Wurst", "[email protected]"){:ok, _, _, _sso_user} = SSO.provision_user(identity)+ {_lv, html} = get_lv(conn)++ assert element_exists?(html, "button#enable-force-sso-toggle[disabled]")+ assert html =~ "you must be logged in via SSO"+ end++ test "force SSO toggle works when operator is SSO user", %{+ conn: conn,+ team: team,+ user: user+ } do+ setup_integration(team, "example.com")+ {_lv, html} = get_lv(conn)++ assert element_exists?(html, "button#enable-force-sso-toggle[disabled]")++ {:ok, user, _} = Auth.TOTP.initiate(user)+ {:ok, _user, _} = Auth.TOTP.enable(user, :skip_verify)++ identity = new_identity(user.name, user.email)+ {:ok, _, _, user} = SSO.provision_user(identity)++ {:ok, conn: conn} = log_in(%{conn: conn, user: user})+ conn = set_current_team(conn, team)+{lv, html} = get_lv(conn)refute element_exists?(html, "button#enable-force-sso-toggle[disabled]")diff --git a/test/plausible_web/live/team_management_test.exs b/test/plausible_web/live/team_management_test.exsindex 0396ad9c77..9fe8132594 100644--- a/test/plausible_web/live/team_management_test.exs+++ b/test/plausible_web/live/team_management_test.exs@@ -76,6 +76,13 @@ defmodule PlausibleWeb.Live.TeamMangementTest donew_identity(member.name, member.email)|> Plausible.Auth.SSO.provision_user()+ {:ok, _, _, user} =+ new_identity(user.name, user.email)+ |> Plausible.Auth.SSO.provision_user()++ {:ok, conn: conn} = log_in(%{conn: conn, user: user})+ conn = set_current_team(conn, team)+lv = get_liveview(conn)html = render(lv)@@ -85,7 +92,10 @@ defmodule PlausibleWeb.Live.TeamMangementTest do"#{member_el()}:nth-of-type(1) button") == "Owner"+ assert text_of_element(html, "#{member_el()}:nth-of-type(1)") =~ "You (SSO)"+assert text_of_element(html, "#{member_el()}:nth-of-type(2) button") == "Viewer"+ assert text_of_element(html, "#{member_el()}:nth-of-type(2)") =~ "SSO Member"change_role(lv, 2, "owner")html = render(lv)diff --git a/test/plausible_web/plugs/sso_team_access_test.exs b/test/plausible_web/plugs/sso_team_access_test.exsnew file mode 100644index 0000000000..cce4f9d6d4--- /dev/null+++ b/test/plausible_web/plugs/sso_team_access_test.exs@@ -0,0 +1,144 @@+defmodule Plausible.Plugs.SSOTeamAccessTest do+ use PlausibleWeb.ConnCase, async: true+ use Plausible++ on_ee do+ use Plausible.Teams.Test++ alias Plausible.Auth+ alias Plausible.Plugs.SSOTeamAccess+ alias PlausibleWeb.AuthPlug++ describe "no user" do+ test "passes through when there's no user" do+ conn = SSOTeamAccess.call(build_conn(), [])+ refute conn.halted+ end+ end++ describe "no team" do+ setup [:create_user, :log_in]++ test "passes through when there's no team", %{conn: conn} do+ conn =+ conn+ |> Plug.Conn.fetch_query_params()+ |> AuthPlug.call([])+ |> SSOTeamAccess.call([])++ refute conn.halted+ end+ end++ describe "non-SSO team" do+ setup [:create_user, :create_team, :log_in, :setup_team]++ test "passes through for non-SSO team", %{conn: conn} do+ conn =+ conn+ |> Plug.Conn.fetch_query_params()+ |> AuthPlug.call([])+ |> SSOTeamAccess.call([])++ refute conn.halted+ end+ end++ describe "SSO team with provisioned user" do+ setup [+ :create_user,+ :create_site,+ :create_team,+ :setup_sso,+ :provision_sso_user,+ :log_in,+ :setup_team+ ]++ test "passes for SSO team without force SSO", %{conn: conn} do+ conn =+ conn+ |> Plug.Conn.fetch_query_params()+ |> AuthPlug.call([])+ |> SSOTeamAccess.call([])++ refute conn.halted+ end++ test "passes for SSO team with force SSO", %{conn: conn, team: team, user: user} do+ {:ok, user, _} = Auth.TOTP.initiate(user)+ {:ok, _user, _} = Auth.TOTP.enable(user, :skip_verify)+ {:ok, _team} = Auth.SSO.set_force_sso(team, :all_but_owners)++ conn =+ conn+ |> Plug.Conn.fetch_query_params()+ |> AuthPlug.call([])+ |> SSOTeamAccess.call([])++ refute conn.halted+ end+ end++ describe "SSO team with non-provisioned user" do+ setup [:create_user, :create_site, :create_team, :setup_sso, :log_in, :setup_team]++ test "passes for SSO team without force SSO", %{conn: conn} do+ conn =+ conn+ |> Plug.Conn.fetch_query_params()+ |> AuthPlug.call([])+ |> SSOTeamAccess.call([])++ refute conn.halted+ end++ test "redirects to notice for SSO team with force SSO", %{+ conn: conn,+ team: team,+ user: user+ } do+ {:ok, user, _} = Auth.TOTP.initiate(user)+ {:ok, _user, _} = Auth.TOTP.enable(user, :skip_verify)+ identity = new_identity("Woozy Wooster", "[email protected]")+ Auth.SSO.provision_user(identity)+ {:ok, _team} = Auth.SSO.set_force_sso(team, :all_but_owners)++ conn =+ conn+ |> Plug.Conn.fetch_query_params()+ |> AuthPlug.call([])+ |> SSOTeamAccess.call([])++ assert conn.halted+ assert redirected_to(conn, 302) == Routes.sso_path(conn, :provision_notice)+ end++ test "redirects to issue notice for SSO team with force SSO and user in invalid state", %{+ conn: conn,+ team: team,+ user: user+ } do+ another_team = new_site().team |> Plausible.Teams.complete_setup()+ add_member(another_team, user: user, role: :viewer)++ {:ok, user, _} = Auth.TOTP.initiate(user)+ {:ok, _user, _} = Auth.TOTP.enable(user, :skip_verify)+ identity = new_identity("Woozy Wooster", "[email protected]")+ Auth.SSO.provision_user(identity)+ {:ok, _team} = Auth.SSO.set_force_sso(team, :all_but_owners)++ conn =+ conn+ |> Plug.Conn.fetch_query_params()+ |> AuthPlug.call([])+ |> SSOTeamAccess.call([])++ assert conn.halted++ assert redirected_to(conn, 302) ==+ Routes.sso_path(conn, :provision_issue, issue: "multiple_memberships")+ end+ end+ end+enddiff --git a/test/plausible_web/user_auth_test.exs b/test/plausible_web/user_auth_test.exsindex 421ae22f29..fbf5dd4673 100644--- a/test/plausible_web/user_auth_test.exs+++ b/test/plausible_web/user_auth_test.exs@@ -186,7 +186,7 @@ defmodule PlausibleWeb.UserAuthTest dorefute get_session(conn, :user_token)end- test "passes through for user matching SSO identity on multiple teams, redirecting to team",+ test "tries to log out for user matching SSO identity on multiple teams, redirecting to issue notice",%{conn: conn,user: user@@ -209,11 +209,13 @@ defmodule PlausibleWeb.UserAuthTest do|> init_session()|> UserAuth.log_in_user(identity)- assert redirected_to(conn, 302) == Routes.site_path(conn, :index, __team: team.identifier)- assert get_session(conn, :user_token)+ assert redirected_to(conn, 302) ==+ Routes.sso_path(conn, :provision_issue, issue: "multiple_memberships_noforce")++ refute get_session(conn, :user_token)end- test "passes through for user matching SSO identity with active personal team, redirecting to team",+ test "tries to log out for user matching SSO identity with active personal team, redirecting to issue notice",%{conn: conn,user: user@@ -236,8 +238,10 @@ defmodule PlausibleWeb.UserAuthTest do|> init_session()|> UserAuth.log_in_user(identity)- assert redirected_to(conn, 302) == Routes.site_path(conn, :index, __team: team.identifier)- assert get_session(conn, :user_token)+ assert redirected_to(conn, 302) ==+ Routes.sso_path(conn, :provision_issue, issue: "active_personal_team_noforce")++ refute get_session(conn, :user_token)endendend