Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

SSO: phrasing; settle on domain verification, not validation (#5508)

Adam Rutkowski70902bbc5a68
diff --git a/config/runtime.exs b/config/runtime.exs
index 4d38d500da..6322db7532 100644
--- a/config/runtime.exs
+++ b/config/runtime.exs
@@ -798,7 +798,7 @@ cloud_queues = [
lock_sites: 1,
legacy_time_on_page_cutoff: 1,
purge_cdn_cache: 1,
- sso_domain_validations: 32
+ sso_domain_ownership_verification: 32
]
queues = if(is_selfhost, do: base_queues, else: base_queues ++ cloud_queues)
diff --git a/extra/lib/plausible/auth/sso.ex b/extra/lib/plausible/auth/sso.ex
index 4f2f216da1..781caa6ea9 100644
--- a/extra/lib/plausible/auth/sso.ex
+++ b/extra/lib/plausible/auth/sso.ex
@@ -216,7 +216,7 @@ defmodule Plausible.Auth.SSO do
)
domains = Enum.flat_map(integrations, & &1.sso_domains)
- no_verified_domains? = Enum.all?(domains, &(&1.status != :validated))
+ no_verified_domains? = Enum.all?(domains, &(&1.status != :verified))
cond do
integrations == [] -> {:error, :no_integration}
diff --git a/extra/lib/plausible/auth/sso/domain.ex b/extra/lib/plausible/auth/sso/domain.ex
index bf96dee6dd..938ceb15dc 100644
--- a/extra/lib/plausible/auth/sso/domain.ex
+++ b/extra/lib/plausible/auth/sso/domain.ex
@@ -5,9 +5,9 @@ defmodule Plausible.Auth.SSO.Domain do
the setup on IdP's end.
Each pending domain should be periodically checked for
- validity by testing for presence of TXT record, meta tag
+ ownership verification by testing for presence of TXT record, meta tag
or URL. The moment whichever of them succeeds first,
- the domain is marked as validated with method and timestamp
+ the domain is marked as verified with method and timestamp
recorded.
"""
@@ -19,20 +19,20 @@ defmodule Plausible.Auth.SSO.Domain do
@type t() :: %__MODULE__{}
- @validation_methods [:dns_txt, :url, :meta_tag]
- @type validation_method() :: unquote(Enum.reduce(@validation_methods, &{:|, [], [&1, &2]}))
+ @verification_methods [:dns_txt, :url, :meta_tag]
+ @type verification_method() :: unquote(Enum.reduce(@verification_methods, &{:|, [], [&1, &2]}))
- @spec validation_methods() :: list(validation_method())
- def validation_methods(), do: @validation_methods
+ @spec verification_methods() :: list(verification_method())
+ def verification_methods(), do: @verification_methods
schema "sso_domains" do
field :identifier, Ecto.UUID
field :domain, :string
- field :validated_via, Ecto.Enum, values: @validation_methods
- field :last_validated_at, :naive_datetime
+ field :verified_via, Ecto.Enum, values: @verification_methods
+ field :last_verified_at, :naive_datetime
field :status, Ecto.Enum,
- values: [:pending, :in_progress, :validated, :invalid],
+ values: [:pending, :in_progress, :verified, :unverified],
default: :pending
belongs_to :sso_integration, Plausible.Auth.SSO.Integration
@@ -52,22 +52,22 @@ defmodule Plausible.Auth.SSO.Domain do
|> put_assoc(:sso_integration, integration)
end
- @spec valid_changeset(t(), validation_method(), NaiveDateTime.t()) ::
+ @spec verified_changeset(t(), verification_method(), NaiveDateTime.t()) ::
Ecto.Changeset.t()
- def valid_changeset(sso_domain, method, now) do
+ def verified_changeset(sso_domain, method, now) do
sso_domain
|> change()
- |> put_change(:validated_via, method)
- |> put_change(:last_validated_at, now)
- |> put_change(:status, :validated)
+ |> put_change(:verified_via, method)
+ |> put_change(:last_verified_at, now)
+ |> put_change(:status, :verified)
end
- @spec invalid_changeset(t(), NaiveDateTime.t(), atom()) :: Ecto.Changeset.t()
- def invalid_changeset(sso_domain, now, status \\ :in_progress) do
+ @spec unverified_changeset(t(), NaiveDateTime.t(), atom()) :: Ecto.Changeset.t()
+ def unverified_changeset(sso_domain, now, status \\ :in_progress) do
sso_domain
|> change()
- |> put_change(:validated_via, nil)
- |> put_change(:last_validated_at, now)
+ |> put_change(:verified_via, nil)
+ |> put_change(:last_verified_at, now)
|> put_change(:status, status)
end
diff --git a/extra/lib/plausible/auth/sso/domain/validation.ex b/extra/lib/plausible/auth/sso/domain/verification.ex
similarity index 91%
rename from extra/lib/plausible/auth/sso/domain/validation.ex
rename to extra/lib/plausible/auth/sso/domain/verification.ex
index d408d7521b..f7f48192cc 100644
--- a/extra/lib/plausible/auth/sso/domain/validation.ex
+++ b/extra/lib/plausible/auth/sso/domain/verification.ex
@@ -1,6 +1,6 @@
-defmodule Plausible.Auth.SSO.Domain.Validation do
+defmodule Plausible.Auth.SSO.Domain.Verification do
@moduledoc """
- SSO domain validation chain
+ SSO domain ownership verification chain
1. DNS TXT `{domain}` record lookup.
Successful expectation contains `plausible-sso-verification={domain-identifier}` record.
@@ -24,13 +24,13 @@ defmodule Plausible.Auth.SSO.Domain.Validation do
@prefix "plausible-sso-verification"
@spec run(String.t(), String.t(), Keyword.t()) ::
- {:ok, Domain.validation_method()} | {:error, :invalid}
+ {:ok, Domain.verification_method()} | {:error, :unverified}
def run(sso_domain, domain_identifier, opts \\ []) do
- available_methods = Domain.validation_methods()
+ available_methods = Domain.verification_methods()
methods = Keyword.get(opts, :methods, available_methods)
true = Enum.all?(methods, &(&1 in available_methods))
- Enum.reduce_while(methods, {:error, :invalid}, fn method, acc ->
+ Enum.reduce_while(methods, {:error, :unverified}, fn method, acc ->
case apply(__MODULE__, method, [sso_domain, domain_identifier, opts]) do
true -> {:halt, {:ok, method}}
false -> {:cont, acc}
@@ -114,7 +114,7 @@ defmodule Plausible.Auth.SSO.Domain.Validation do
@after_compile __MODULE__
def __after_compile__(_env, _bytecode) do
- available_methods = Domain.validation_methods()
+ available_methods = Domain.verification_methods()
exported_funs =
:functions
diff --git a/extra/lib/plausible/auth/sso/domain/validation/worker.ex b/extra/lib/plausible/auth/sso/domain/verification/worker.ex
similarity index 78%
rename from extra/lib/plausible/auth/sso/domain/validation/worker.ex
rename to extra/lib/plausible/auth/sso/domain/verification/worker.ex
index 8fbc4dc376..68a1027355 100644
--- a/extra/lib/plausible/auth/sso/domain/validation/worker.ex
+++ b/extra/lib/plausible/auth/sso/domain/verification/worker.ex
@@ -1,4 +1,4 @@
-defmodule Plausible.Auth.SSO.Domain.Validation.Worker do
+defmodule Plausible.Auth.SSO.Domain.Verification.Worker do
@moduledoc """
Background service validating SSO domains ownership
@@ -6,7 +6,7 @@ defmodule Plausible.Auth.SSO.Domain.Validation.Worker do
(former will fail the verification, latter will succeed with `dns_txt` method)
"""
use Oban.Worker,
- queue: :sso_domain_validations,
+ queue: :sso_domain_ownership_verification,
unique: true
alias Plausible.Auth.SSO
@@ -19,7 +19,7 @@ defmodule Plausible.Auth.SSO.Domain.Validation.Worker do
{:ok, result} =
Repo.transaction(fn ->
with {:ok, sso_domain} <- SSO.Domains.get(domain) do
- SSO.Domains.mark_invalid!(sso_domain, :in_progress)
+ SSO.Domains.mark_unverified!(sso_domain, :in_progress)
end
{:ok, job} =
@@ -55,9 +55,9 @@ defmodule Plausible.Auth.SSO.Domain.Validation.Worker do
case SSO.Domains.get(domain) do
{:ok, sso_domain} ->
case SSO.Domains.verify(sso_domain, service_opts) do
- %SSO.Domain{status: :validated} = validated ->
- validation_complete(sso_domain)
- {:ok, validated}
+ %SSO.Domain{status: :verified} = verified ->
+ verification_complete(sso_domain)
+ {:ok, verified}
_ ->
{:snooze, snooze_backoff(attempt)}
@@ -69,20 +69,20 @@ defmodule Plausible.Auth.SSO.Domain.Validation.Worker do
end
def perform(job) do
- validation_failure(job.args["domain"])
+ verification_failure(job.args["domain"])
{:cancel, :max_snoozes}
end
- defp validation_complete(sso_domain) do
+ defp verification_complete(sso_domain) do
send_success_notification(sso_domain)
:ok
end
- defp validation_failure(domain) do
+ defp verification_failure(domain) do
with {:ok, sso_domain} <- SSO.Domains.get(domain) do
sso_domain
- |> SSO.Domains.mark_invalid!(:invalid)
+ |> SSO.Domains.mark_unverified!(:unverified)
|> send_failure_notification()
end
@@ -94,7 +94,7 @@ defmodule Plausible.Auth.SSO.Domain.Validation.Worker do
Enum.each(owners, fn owner ->
sso_domain.domain
- |> PlausibleWeb.Email.sso_domain_validation_success(owner)
+ |> PlausibleWeb.Email.sso_domain_verification_success(owner)
|> Plausible.Mailer.send()
end)
@@ -106,7 +106,7 @@ defmodule Plausible.Auth.SSO.Domain.Validation.Worker do
Enum.each(owners, fn owner ->
sso_domain.domain
- |> PlausibleWeb.Email.sso_domain_validation_failure(owner)
+ |> PlausibleWeb.Email.sso_domain_verification_failure(owner)
|> Plausible.Mailer.send()
end)
diff --git a/extra/lib/plausible/auth/sso/domains.ex b/extra/lib/plausible/auth/sso/domains.ex
index edbc4332b1..ad47e7a05e 100644
--- a/extra/lib/plausible/auth/sso/domains.ex
+++ b/extra/lib/plausible/auth/sso/domains.ex
@@ -24,14 +24,18 @@ defmodule Plausible.Auth.SSO.Domains do
now = Keyword.get(opts, :now, NaiveDateTime.utc_now(:second))
if skip_checks? do
- mark_validated!(sso_domain, :dns_txt, now)
+ mark_verified!(sso_domain, :dns_txt, now)
else
- case SSO.Domain.Validation.run(sso_domain.domain, sso_domain.identifier, verification_opts) do
+ case SSO.Domain.Verification.run(
+ sso_domain.domain,
+ sso_domain.identifier,
+ verification_opts
+ ) do
{:ok, step} ->
- mark_validated!(sso_domain, step, now)
+ mark_verified!(sso_domain, step, now)
- {:error, :invalid} ->
- mark_invalid!(sso_domain, :in_progress, now)
+ {:error, :unverified} ->
+ mark_unverified!(sso_domain, :in_progress, now)
end
end
end
@@ -65,7 +69,7 @@ defmodule Plausible.Auth.SSO.Domains do
inner_join: i in assoc(d, :sso_integration),
inner_join: t in assoc(i, :team),
where: d.domain == ^search,
- where: d.status == :validated,
+ where: d.status == :verified,
preload: [sso_integration: {i, team: t}]
)
|> Repo.one()
@@ -131,18 +135,18 @@ defmodule Plausible.Auth.SSO.Domains do
end
end
- @spec mark_validated!(SSO.Domain.t(), SSO.Domain.validation_method(), NaiveDateTime.t()) ::
+ @spec mark_verified!(SSO.Domain.t(), SSO.Domain.verification_method(), NaiveDateTime.t()) ::
SSO.Domain.t()
- def mark_validated!(sso_domain, method, now \\ NaiveDateTime.utc_now(:second)) do
+ def mark_verified!(sso_domain, method, now \\ NaiveDateTime.utc_now(:second)) do
sso_domain
- |> SSO.Domain.valid_changeset(method, now)
+ |> SSO.Domain.verified_changeset(method, now)
|> Repo.update!()
end
- @spec mark_invalid!(SSO.Domain.t(), atom(), NaiveDateTime.t()) :: SSO.Domain.t()
- def mark_invalid!(sso_domain, status, now \\ NaiveDateTime.utc_now(:second)) do
+ @spec mark_unverified!(SSO.Domain.t(), atom(), NaiveDateTime.t()) :: SSO.Domain.t()
+ def mark_unverified!(sso_domain, status, now \\ NaiveDateTime.utc_now(:second)) do
sso_domain
- |> SSO.Domain.invalid_changeset(now, status)
+ |> SSO.Domain.unverified_changeset(now, status)
|> Repo.update!()
end
diff --git a/lib/plausible_web/email.ex b/lib/plausible_web/email.ex
index 4b13f4b4ad..28caada5ed 100644
--- a/lib/plausible_web/email.ex
+++ b/lib/plausible_web/email.ex
@@ -546,18 +546,18 @@ defmodule PlausibleWeb.Email do
end
on_ee do
- def sso_domain_validation_success(domain, user) do
+ def sso_domain_verification_success(domain, user) do
priority_email()
|> to(user.email)
|> subject("Your SSO domain #{domain} is ready!")
- |> render("sso_domain_validation_success.html", domain: domain)
+ |> render("sso_domain_verification_success.html", domain: domain)
end
- def sso_domain_validation_failure(domain, user) do
+ def sso_domain_verification_failure(domain, user) do
priority_email()
|> to(user)
- |> subject("SSO domain #{domain} validation failure")
- |> render("sso_domain_validation_failure.html", domain: domain)
+ |> subject("SSO domain #{domain} verification failure")
+ |> render("sso_domain_verification_failure.html", domain: domain)
end
end
diff --git a/lib/plausible_web/templates/email/sso_domain_validation_failure.html.heex b/lib/plausible_web/templates/email/sso_domain_verification_failure.html.heex
similarity index 100%
rename from lib/plausible_web/templates/email/sso_domain_validation_failure.html.heex
rename to lib/plausible_web/templates/email/sso_domain_verification_failure.html.heex
diff --git a/lib/plausible_web/templates/email/sso_domain_validation_success.html.heex b/lib/plausible_web/templates/email/sso_domain_verification_success.html.heex
similarity index 100%
rename from lib/plausible_web/templates/email/sso_domain_validation_success.html.heex
rename to lib/plausible_web/templates/email/sso_domain_verification_success.html.heex
diff --git a/test/plausible/auth/sso/domain/validation_test.exs b/test/plausible/auth/sso/domain/validation_test.exs
index e3d1f6449c..2e20e3c43d 100644
--- a/test/plausible/auth/sso/domain/validation_test.exs
+++ b/test/plausible/auth/sso/domain/validation_test.exs
@@ -1,4 +1,4 @@
-defmodule Plausible.Auth.SSO.Domain.ValidationTest do
+defmodule Plausible.Auth.SSO.Domain.VerificationTest do
use Plausible.DataCase, async: true
use Plausible
@@ -8,7 +8,7 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
use Plausible.Teams.Test
alias Plasusible.Test.Support.DNSServer
- alias Plausible.Auth.SSO.Domain.Validation
+ alias Plausible.Auth.SSO.Domain.Verification
alias Plug.Conn
setup do
@@ -22,11 +22,11 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
test "dns_txt" do
{:ok, port} = DNSServer.start("plausible-sso-verification=ex4mpl3")
- refute Validation.dns_txt("example.com", "failing-identifier",
+ refute Verification.dns_txt("example.com", "failing-identifier",
nameservers: [{{0, 0, 0, 0}, port}]
)
- assert Validation.dns_txt("example.com", "ex4mpl3", nameservers: [{{0, 0, 0, 0}, port}])
+ assert Verification.dns_txt("example.com", "ex4mpl3", nameservers: [{{0, 0, 0, 0}, port}])
end
test "url", %{bypass: bypass} do
@@ -34,11 +34,11 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
Conn.resp(conn, 200, "ex4mpl3")
end)
- refute Validation.url("example.com", "failing-identifier",
+ refute Verification.url("example.com", "failing-identifier",
url_override: "http://localhost:#{bypass.port}/test"
)
- assert Validation.url("example.com", "ex4mpl3",
+ assert Verification.url("example.com", "ex4mpl3",
url_override: "http://localhost:#{bypass.port}/test"
)
end
@@ -54,11 +54,11 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
""")
end)
- refute Validation.meta_tag("example.com", "failing-identifier",
+ refute Verification.meta_tag("example.com", "failing-identifier",
url_override: "http://localhost:#{bypass.port}/test"
)
- assert Validation.meta_tag("example.com", "ex4mpl3",
+ assert Verification.meta_tag("example.com", "ex4mpl3",
url_override: "http://localhost:#{bypass.port}/test"
)
end
@@ -72,7 +72,7 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
""")
end)
- refute Validation.meta_tag("example.com", "ex4mpl3",
+ refute Verification.meta_tag("example.com", "ex4mpl3",
url_override: "http://localhost:#{bypass.port}/test"
)
end
@@ -86,7 +86,7 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
""")
end)
- refute Validation.meta_tag("example.com", "ex4mpl3",
+ refute Verification.meta_tag("example.com", "ex4mpl3",
url_override: "http://localhost:#{bypass.port}/test"
)
end
@@ -103,7 +103,7 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
""")
end)
- assert Validation.meta_tag("example.com", "ex4mpl3",
+ assert Verification.meta_tag("example.com", "ex4mpl3",
url_override: "http://localhost:#{bypass.port}/test"
)
end
@@ -116,7 +116,7 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
Bypass.stub(bypass, "GET", "/", fn _conn -> raise "should never be called" end)
assert {:ok, :dns_txt} =
- Validation.run("example.com", "ex4mpl3",
+ Verification.run("example.com", "ex4mpl3",
url_override: "http://localhost:#{bypass.port}/",
nameservers: [{{0, 0, 0, 0}, dns_port}]
)
@@ -128,7 +128,7 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
end)
assert {:ok, :url} =
- Validation.run("example.com", "ex4mpl3",
+ Verification.run("example.com", "ex4mpl3",
url_override: "http://localhost:#{bypass.port}/"
)
end
@@ -144,7 +144,7 @@ defmodule Plausible.Auth.SSO.Domain.ValidationTest do
end)
assert {:ok, :meta_tag} =
- Validation.run("example.com", "ex4mpl3",
+ Verification.run("example.com", "ex4mpl3",
url_override: "http://localhost:#{bypass.port}/"
)
end
diff --git a/test/plausible/auth/sso/domains_test.exs b/test/plausible/auth/sso/domains_test.exs
index 33086a4989..c2332f307f 100644
--- a/test/plausible/auth/sso/domains_test.exs
+++ b/test/plausible/auth/sso/domains_test.exs
@@ -27,8 +27,8 @@ defmodule Plausible.Auth.SSO.DomainsTest do
assert sso_domain.domain == domain
assert is_binary(sso_domain.identifier)
- refute sso_domain.validated_via
- refute sso_domain.last_validated_at
+ refute sso_domain.verified_via
+ refute sso_domain.last_verified_at
assert sso_domain.status == :pending
end
@@ -100,18 +100,18 @@ defmodule Plausible.Auth.SSO.DomainsTest do
end
describe "verify/2" do
- test "marks domain as validated when skip_checks? option passed", %{
+ test "marks domain as verified when skip_checks? option passed", %{
integration: integration
} do
domain = generate_domain()
{:ok, sso_domain} = SSO.Domains.add(integration, domain)
- valid_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
+ verified_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
- assert valid_domain.id == sso_domain.id
- assert valid_domain.validated_via == :dns_txt
- assert valid_domain.status == :validated
- assert valid_domain.last_validated_at
+ assert verified_domain.id == sso_domain.id
+ assert verified_domain.verified_via == :dns_txt
+ assert verified_domain.status == :verified
+ assert verified_domain.last_verified_at
end
test "does mark domain as in progress, when no skip flag passed", %{
@@ -120,12 +120,12 @@ defmodule Plausible.Auth.SSO.DomainsTest do
domain = generate_domain()
{:ok, sso_domain} = SSO.Domains.add(integration, domain)
- invalid_domain = SSO.Domains.verify(sso_domain, verification_opts: [methods: []])
+ unverified_domain = SSO.Domains.verify(sso_domain, verification_opts: [methods: []])
- assert invalid_domain.id == sso_domain.id
- refute invalid_domain.validated_via
- assert invalid_domain.status == :in_progress
- assert invalid_domain.last_validated_at
+ assert unverified_domain.id == sso_domain.id
+ refute unverified_domain.verified_via
+ assert unverified_domain.status == :in_progress
+ assert unverified_domain.last_verified_at
end
end
@@ -164,7 +164,7 @@ defmodule Plausible.Auth.SSO.DomainsTest do
assert found_sso_domain.id == sso_domain.id
end
- test "returns error if matching domain is not validated", %{integration: integration} do
+ test "returns error if matching domain is not verified", %{integration: integration} do
domain = generate_domain()
{:ok, _sso_domain} = SSO.Domains.add(integration, domain)
diff --git a/test/workers/sso_domain_validation_worker_test.exs b/test/workers/sso_domain_verification_worker_test.exs
similarity index 87%
rename from test/workers/sso_domain_validation_worker_test.exs
rename to test/workers/sso_domain_verification_worker_test.exs
index bf8b26182d..70daad72e2 100644
--- a/test/workers/sso_domain_validation_worker_test.exs
+++ b/test/workers/sso_domain_verification_worker_test.exs
@@ -1,4 +1,4 @@
-defmodule Plausible.Auth.SSO.Domain.Validation.WorkerTest do
+defmodule Plausible.Auth.SSO.Domain.Verification.WorkerTest do
use Plausible.DataCase
use Plausible
@@ -7,7 +7,7 @@ defmodule Plausible.Auth.SSO.Domain.Validation.WorkerTest do
use Bamboo.Test, shared: true
- alias Plausible.Auth.SSO.Domain.Validation.Worker
+ alias Plausible.Auth.SSO.Domain.Verification.Worker
alias Plausible.Auth.SSO
@@ -46,7 +46,7 @@ defmodule Plausible.Auth.SSO.Domain.Validation.WorkerTest do
end
test "enqueue resets domain status", %{sso_domain: sso_domain} do
- %{status: :invalid} = SSO.Domains.mark_invalid!(sso_domain, :invalid)
+ %{status: :unverified} = SSO.Domains.mark_unverified!(sso_domain, :unverified)
{:ok, _} = Worker.enqueue(sso_domain.domain)
assert Plausible.Repo.reload!(sso_domain).status == :in_progress
end
@@ -68,14 +68,14 @@ defmodule Plausible.Auth.SSO.Domain.Validation.WorkerTest do
assert {:ok, %{status: :in_progress}} = SSO.Domains.get(domain)
end
- test "domain is marked as validated and emails are sent", %{
+ test "domain is marked as verified and emails are sent", %{
domain: domain,
team: team,
owner: owner
} do
owner2 = add_member(team, role: :owner)
- assert {:ok, %{status: :validated}} =
+ assert {:ok, %{status: :verified}} =
perform_job(Worker, %{"domain" => domain}, meta: %{skip_checks: true})
assert_email_delivered_with(
@@ -89,7 +89,7 @@ defmodule Plausible.Auth.SSO.Domain.Validation.WorkerTest do
)
end
- test "domain is marked as invalid when max snoozes exhausted", %{domain: domain} do
+ test "domain is marked as unverified when max snoozes exhausted", %{domain: domain} do
assert {:snooze, _} =
perform_job(Worker, %{"domain" => domain},
attempt: 14,
@@ -102,7 +102,7 @@ defmodule Plausible.Auth.SSO.Domain.Validation.WorkerTest do
meta: %{bypass_checks: true}
)
- assert_email_delivered_with(subject: "SSO domain #{domain} validation failure")
+ assert_email_delivered_with(subject: "SSO domain #{domain} verification failure")
end
end
end