Skip to content

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

Refactor Segments controller to be thinner (#4981)

Artur Pata5af43a93d534
diff --git a/lib/plausible/segment.ex b/lib/plausible/segments/segment.ex
similarity index 99%
rename from lib/plausible/segment.ex
rename to lib/plausible/segments/segment.ex
index d85ba0a6f5..26846bfb46 100644
--- a/lib/plausible/segment.ex
+++ b/lib/plausible/segments/segment.ex
@@ -1,4 +1,4 @@
-defmodule Plausible.Segment do
+defmodule Plausible.Segments.Segment do
@moduledoc """
Schema for segments. Segments are saved filter combinations.
"""
diff --git a/lib/plausible/segments/segments.ex b/lib/plausible/segments/segments.ex
new file mode 100644
index 0000000000..6284bd6345
--- /dev/null
+++ b/lib/plausible/segments/segments.ex
@@ -0,0 +1,231 @@
+defmodule Plausible.Segments do
+ @moduledoc """
+ Module for accessing Segments.
+ """
+ alias Plausible.Segments.Segment
+ alias Plausible.Repo
+ import Ecto.Query
+
+ @roles_with_personal_segments [:viewer, :editor, :admin, :owner, :super_admin]
+ @roles_with_maybe_site_segments [:editor, :admin, :owner, :super_admin]
+
+ @type error_not_enough_permissions() :: {:error, :not_enough_permissions}
+ @type error_segment_not_found() :: {:error, :segment_not_found}
+
+ @spec index(pos_integer() | nil, Plausible.Site.t(), atom()) ::
+ {:ok, [Segment.t()]} | error_not_enough_permissions()
+ def index(user_id, %Plausible.Site{} = site, site_role) do
+ fields = [:id, :name, :type, :inserted_at, :updated_at, :owner_id]
+
+ site_segments_available? =
+ site_segments_available?(site)
+
+ cond do
+ site_role in [:public] and
+ site_segments_available? ->
+ {:ok, get_public_site_segments(site.id, fields -- [:owner_id])}
+
+ site_role in @roles_with_maybe_site_segments and
+ site_segments_available? ->
+ {:ok, get_segments(user_id, site.id, fields)}
+
+ site_role in @roles_with_personal_segments ->
+ {:ok, get_segments(user_id, site.id, fields, only: :personal)}
+
+ true ->
+ {:error, :not_enough_permissions}
+ end
+ end
+
+ @spec get_one(pos_integer(), Plausible.Site.t(), atom(), pos_integer() | nil) ::
+ {:ok, Segment.t()}
+ | error_not_enough_permissions()
+ | error_segment_not_found()
+ def get_one(user_id, site, site_role, segment_id) do
+ if site_role in roles_with_personal_segments() do
+ case do_get_one(user_id, site.id, segment_id) do
+ %Segment{} = segment -> {:ok, segment}
+ nil -> {:error, :segment_not_found}
+ end
+ else
+ {:error, :not_enough_permissions}
+ end
+ end
+
+ def insert_one(
+ user_id,
+ %Plausible.Site{} = site,
+ site_role,
+ %{} = params
+ ) do
+ with :ok <- can_insert_one?(site, site_role, params),
+ %{valid?: true} = changeset <-
+ Segment.changeset(
+ %Segment{},
+ Map.merge(params, %{"site_id" => site.id, "owner_id" => user_id})
+ ),
+ :ok <-
+ Segment.validate_segment_data(site, params["segment_data"], true) do
+ {:ok, Repo.insert!(changeset)}
+ else
+ %{valid?: false, errors: errors} ->
+ {:error, {:invalid_segment, errors}}
+
+ {:error, {:invalid_filters, message}} ->
+ {:error, {:invalid_segment, segment_data: {message, []}}}
+
+ {:error, _type} = error ->
+ error
+ end
+ end
+
+ def update_one(
+ user_id,
+ %Plausible.Site{} = site,
+ site_role,
+ segment_id,
+ %{} = params
+ ) do
+ with {:ok, segment} <- get_one(user_id, site, site_role, segment_id),
+ :ok <- can_update_one?(site, site_role, params, segment.type),
+ %{valid?: true} = changeset <-
+ Segment.changeset(
+ segment,
+ Map.merge(params, %{"owner_id" => user_id})
+ ),
+ :ok <-
+ Segment.validate_segment_data_if_exists(
+ site,
+ params["segment_data"],
+ true
+ ) do
+ {:ok,
+ Repo.update!(
+ changeset,
+ returning: true
+ )}
+ else
+ %{valid?: false, errors: errors} ->
+ {:error, {:invalid_segment, errors}}
+
+ {:error, {:invalid_filters, message}} ->
+ {:error, {:invalid_segment, segment_data: {message, []}}}
+
+ {:error, _type} = error ->
+ error
+ end
+ end
+
+ def delete_one(user_id, %Plausible.Site{} = site, site_role, segment_id) do
+ with {:ok, segment} <- get_one(user_id, site, site_role, segment_id) do
+ cond do
+ segment.type == :site and site_role in roles_with_maybe_site_segments() ->
+ {:ok, do_delete_one(segment)}
+
+ segment.type == :personal and site_role in roles_with_personal_segments() ->
+ {:ok, do_delete_one(segment)}
+
+ true ->
+ {:error, :not_enough_permissions}
+ end
+ end
+ end
+
+ @spec do_get_one(pos_integer(), pos_integer(), pos_integer() | nil) ::
+ Segment.t() | nil
+ defp do_get_one(user_id, site_id, segment_id)
+
+ defp do_get_one(_user_id, _site_id, nil) do
+ nil
+ end
+
+ defp do_get_one(user_id, site_id, segment_id) do
+ query =
+ from(segment in Segment,
+ where: segment.site_id == ^site_id,
+ where: segment.id == ^segment_id,
+ where: segment.type == :site or segment.owner_id == ^user_id
+ )
+
+ Repo.one(query)
+ end
+
+ defp do_delete_one(segment) do
+ Repo.delete!(segment)
+ segment
+ end
+
+ defp can_update_one?(%Plausible.Site{} = site, site_role, params, existing_segment_type) do
+ updating_to_site_segment? = params["type"] == "site"
+
+ cond do
+ (existing_segment_type == :site or
+ updating_to_site_segment?) and site_role in roles_with_maybe_site_segments() and
+ site_segments_available?(site) ->
+ :ok
+
+ existing_segment_type == :personal and not updating_to_site_segment? and
+ site_role in roles_with_personal_segments() ->
+ :ok
+
+ true ->
+ {:error, :not_enough_permissions}
+ end
+ end
+
+ defp can_insert_one?(%Plausible.Site{} = site, site_role, params) do
+ cond do
+ params["type"] == "site" and site_role in roles_with_maybe_site_segments() and
+ site_segments_available?(site) ->
+ :ok
+
+ params["type"] == "personal" and
+ site_role in roles_with_personal_segments() ->
+ :ok
+
+ true ->
+ {:error, :not_enough_permissions}
+ end
+ end
+
+ def roles_with_personal_segments(), do: [:viewer, :editor, :admin, :owner, :super_admin]
+ def roles_with_maybe_site_segments(), do: [:editor, :admin, :owner, :super_admin]
+
+ def site_segments_available?(%Plausible.Site{} = site),
+ do: Plausible.Billing.Feature.Props.check_availability(site.team) == :ok
+
+ @spec get_public_site_segments(pos_integer(), list(atom())) :: [Segment.t()]
+ defp get_public_site_segments(site_id, fields) do
+ Repo.all(
+ from(segment in Segment,
+ select: ^fields,
+ where: segment.site_id == ^site_id,
+ where: segment.type == :site,
+ order_by: [desc: segment.updated_at, desc: segment.id]
+ )
+ )
+ end
+
+ @spec get_segments(pos_integer(), pos_integer(), list(atom()), Keyword.t()) :: [Segment.t()]
+ defp get_segments(user_id, site_id, fields, opts \\ []) do
+ query =
+ from(segment in Segment,
+ select: ^fields,
+ where: segment.site_id == ^site_id,
+ order_by: [desc: segment.updated_at, desc: segment.id]
+ )
+
+ query =
+ if Keyword.get(opts, :only) == :personal do
+ where(query, [segment], segment.type == :personal and segment.owner_id == ^user_id)
+ else
+ where(
+ query,
+ [segment],
+ segment.type == :site or (segment.type == :personal and segment.owner_id == ^user_id)
+ )
+ end
+
+ Repo.all(query)
+ end
+end
diff --git a/lib/plausible_web/controllers/api/internal/segments_controller.ex b/lib/plausible_web/controllers/api/internal/segments_controller.ex
index bcc65b972c..a1df13bff7 100644
--- a/lib/plausible_web/controllers/api/internal/segments_controller.ex
+++ b/lib/plausible_web/controllers/api/internal/segments_controller.ex
@@ -1,71 +1,37 @@
defmodule PlausibleWeb.Api.Internal.SegmentsController do
+ @moduledoc """
+ Internal API controller for segments.
+ """
use Plausible
use PlausibleWeb, :controller
- use Plausible.Repo
use PlausibleWeb.Plugs.ErrorHandler
alias PlausibleWeb.Api.Helpers, as: H
+ alias Plausible.Segments
- @fields_in_index_query [
- :id,
- :name,
- :type,
- :inserted_at,
- :updated_at,
- :owner_id
- ]
-
- def get_all_segments(
+ def index(
%Plug.Conn{
assigns: %{
site: site,
- site_role: site_role,
- current_user: current_user
+ site_role: site_role
}
} = conn,
%{} = _params
) do
- site_segments_available? =
- site_segments_available?(site)
-
- cond do
- site_role in roles_with_personal_segments() and
- site_segments_available? ->
- result =
- Repo.all(
- get_personal_and_site_segments_query(current_user.id, site.id, @fields_in_index_query)
- )
-
- json(conn, result)
-
- site_role in roles_with_personal_segments() ->
- result =
- Repo.all(
- get_personal_segments_only_query(current_user.id, site.id, @fields_in_index_query)
- )
+ user_id = normalize_current_user_id(conn)
- json(conn, result)
-
- site_role in [:public] and site_segments_available? ->
- result =
- Repo.all(
- get_site_segments_only_query(
- site.id,
- @fields_in_index_query -- [:owner_id]
- )
- )
-
- json(conn, result)
-
- true ->
+ case Segments.index(user_id, site, site_role) do
+ {:error, :not_enough_permissions} ->
H.not_enough_permissions(conn, "Not enough permissions to get segments")
+
+ {:ok, segments} ->
+ json(conn, segments)
end
end
- def get_segment(
+ def get(
%Plug.Conn{
assigns: %{
site: site,
- current_user: current_user,
site_role: site_role
}
} = conn,
@@ -73,46 +39,55 @@ defmodule PlausibleWeb.Api.Internal.SegmentsController do
) do
segment_id = normalize_segment_id_param(params["segment_id"])
- if site_role in roles_with_personal_segments() do
- result = get_one_segment(current_user.id, site.id, segment_id)
+ user_id = normalize_current_user_id(conn)
- case result do
- nil -> H.not_found(conn, "Segment not found with ID #{inspect(params["segment_id"])}")
- result when is_map(result) -> json(conn, result)
- end
- else
- H.not_enough_permissions(conn, "Not enough permissions to get segment data")
+ case Segments.get_one(
+ user_id,
+ site,
+ site_role,
+ segment_id
+ ) do
+ {:error, :not_enough_permissions} ->
+ H.not_enough_permissions(conn, "Not enough permissions to get segment data")
+
+ {:error, :segment_not_found} ->
+ segment_not_found(conn, params["segment_id"])
+
+ {:ok, segment} ->
+ json(conn, segment)
end
end
- def create_segment(
+ def create(
%Plug.Conn{
assigns: %{
site: site,
+ current_user: %{id: user_id},
site_role: site_role
}
} = conn,
%{} = params
) do
- site_segments_available? = site_segments_available?(site)
-
- cond do
- params["type"] == Atom.to_string(:personal) and
- site_role in roles_with_personal_segments() ->
- do_insert_segment(conn, params)
+ case Segments.insert_one(user_id, site, site_role, params) do
+ {:error, :not_enough_permissions} ->
+ H.not_enough_permissions(conn, "Not enough permissions to create segment")
- params["type"] == Atom.to_string(:site) and site_segments_available? and
- site_role in roles_with_maybe_site_segments() ->
- do_insert_segment(conn, params)
+ {:error, {:invalid_segment, errors}} when is_list(errors) ->
+ conn
+ |> put_status(400)
+ |> json(%{
+ errors:
+ Enum.map(errors, fn {field_key, {message, opts}} -> [field_key, message, opts] end)
+ })
- true ->
- H.not_enough_permissions(conn, "Not enough permissions to create segment")
+ {:ok, segment} ->
+ json(conn, segment)
end
end
- def create_segment(%Plug.Conn{} = conn, _params), do: H.bad_request(conn, "Invalid request")
+ def create(%Plug.Conn{} = conn, _params), do: invalid_request(conn)
- def update_segment(
+ def update(
%Plug.Conn{
assigns: %{
site: site,
@@ -123,36 +98,31 @@ defmodule PlausibleWeb.Api.Internal.SegmentsController do
conn,
%{} = params
) do
- site_segments_available? = site_segments_available?(site)
-
segment_id = normalize_segment_id_param(params["segment_id"])
- existing_segment = get_one_segment(user_id, site.id, segment_id)
-
- cond do
- is_nil(existing_segment) ->
- H.not_found(conn, "Segment not found with ID #{inspect(params["segment_id"])}")
-
- existing_segment.type == :personal and params["type"] != "site" and
- site_role in roles_with_personal_segments() ->
- do_update_segment(conn, params, existing_segment, user_id)
+ case Segments.update_one(user_id, site, site_role, segment_id, params) do
+ {:error, :not_enough_permissions} ->
+ H.not_enough_permissions(conn, "Not enough permissions to edit segment")
- existing_segment.type == :personal and params["type"] == "site" and site_segments_available? and
- site_role in roles_with_maybe_site_segments() ->
- do_update_segment(conn, params, existing_segment, user_id)
+ {:error, :segment_not_found} ->
+ segment_not_found(conn, params["segment_id"])
- existing_segment.type == :site and site_segments_available? and
- site_role in roles_with_maybe_site_segments() ->
- do_update_segment(conn, params, existing_segment, user_id)
+ {:error, {:invalid_segment, errors}} when is_list(errors) ->
+ conn
+ |> put_status(400)
+ |> json(%{
+ errors:
+ Enum.map(errors, fn {field_key, {message, opts}} -> [field_key, message, opts] end)
+ })
- true ->
- H.not_enough_permissions(conn, "Not enough permissions to edit segment")
+ {:ok, segment} ->
+ json(conn, segment)
end
end
- def update_segment(%Plug.Conn{} = conn, _params), do: H.bad_request(conn, "Invalid request")
+ def update(%Plug.Conn{} = conn, _params), do: invalid_request(conn)
- def delete_segment(
+ def delete(
%Plug.Conn{
assigns: %{
site: site,
@@ -163,64 +133,25 @@ defmodule PlausibleWeb.Api.Internal.SegmentsController do
conn,
%{} = params
) do
- site_segments_available? = site_segments_available?(site)
-
segment_id = normalize_segment_id_param(params["segment_id"])
- existing_segment = get_one_segment(user_id, site.id, segment_id)
-
- cond do
- is_nil(existing_segment) ->
- H.not_found(conn, "Segment not found with ID #{inspect(params["segment_id"])}")
-
- existing_segment.type == :personal and
- site_role in roles_with_personal_segments() ->
- do_delete_segment(conn, existing_segment)
-
- existing_segment.type == :site and
- site_segments_available? and
- site_role in roles_with_maybe_site_segments() ->
- do_delete_segment(conn, existing_segment)
-
- true ->
+ case Segments.delete_one(user_id, site, site_role, segment_id) do
+ {:error, :not_enough_permissions} ->
H.not_enough_permissions(conn, "Not enough permissions to delete segment")
- end
- end
- def delete_segment(%Plug.Conn{} = conn, _params), do: H.bad_request(conn, "Invalid request")
+ {:error, :segment_not_found} ->
+ segment_not_found(conn, params["segment_id"])
- @spec get_site_segments_only_query(pos_integer(), list(atom())) :: Ecto.Query.t()
- defp get_site_segments_only_query(site_id, fields) do
- from(segment in Plausible.Segment,
- select: ^fields,
- where: segment.site_id == ^site_id,
- where: segment.type == :site,
- order_by: [desc: segment.updated_at, desc: segment.id]
- )
+ {:ok, segment} ->
+ json(conn, segment)
+ end
end
- @spec get_personal_segments_only_query(pos_integer(), pos_integer(), list(atom())) ::
- Ecto.Query.t()
- defp get_personal_segments_only_query(user_id, site_id, fields) do
- from(segment in Plausible.Segment,
- select: ^fields,
- where: segment.site_id == ^site_id,
- where: segment.type == :personal and segment.owner_id == ^user_id,
- order_by: [desc: segment.updated_at, desc: segment.id]
- )
- end
+ def delete(%Plug.Conn{} = conn, _params), do: invalid_request(conn)
- @spec get_personal_and_site_segments_query(pos_integer(), pos_integer(), list(atom())) ::
- Ecto.Query.t()
- defp get_personal_and_site_segments_query(user_id, site_id, fields) do
- from(segment in Plausible.Segment,
- select: ^fields,
- where: segment.site_id == ^site_id,
- where:
- segment.type == :site or (segment.type == :personal and segment.owner_id == ^user_id),
- order_by: [desc: segment.updated_at, desc: segment.id]
- )
- end
+ @spec normalize_current_user_id(Plug.Conn.t()) :: nil | pos_integer()
+ defp normalize_current_user_id(conn),
+ do: if(is_nil(conn.assigns[:current_user]), do: nil, else: conn.assigns[:current_user].id)
@spec normalize_segment_id_param(any()) :: nil | pos_integer()
defp normalize_segment_id_param(input) do
@@ -230,104 +161,11 @@ defmodule PlausibleWeb.Api.Internal.SegmentsController do
end
end
- defp get_one_segment(_user_id, _site_id, nil) do
- nil
+ defp segment_not_found(%Plug.Conn{} = conn, segment_id_param) do
+ H.not_found(conn, "Segment not found with ID #{inspect(segment_id_param)}")
end
- defp get_one_segment(user_id, site_id, segment_id) do
- query =
- from(segment in Plausible.Segment,
- where: segment.site_id == ^site_id,
- where: segment.id == ^segment_id,
- where: segment.type == :site or segment.owner_id == ^user_id
- )
-
- Repo.one(query)
+ defp invalid_request(%Plug.Conn{} = conn) do
+ H.bad_request(conn, "Invalid request")
end
-
- defp do_insert_segment(
- %Plug.Conn{
- assigns: %{
- site: site,
- current_user: %{id: user_id}
- }
- } = conn,
- %{} = params
- ) do
- segment_definition = Map.merge(params, %{"site_id" => site.id, "owner_id" => user_id})
-
- with %{valid?: true} = changeset <-
- Plausible.Segment.changeset(
- %Plausible.Segment{},
- segment_definition
- ),
- :ok <- Plausible.Segment.validate_segment_data(site, params["segment_data"], true) do
- segment = Repo.insert!(changeset)
- json(conn, segment)
- else
- %{valid?: false, errors: errors} ->
- conn
- |> put_status(400)
- |> json(%{
- errors: Enum.map(errors, fn {field_key, {message, _}} -> [field_key, message] end)
- })
-
- {:error, {:invalid_filters, message}} ->
- conn |> put_status(400) |> json(%{errors: [["segment_data", message]]})
- end
- end
-
- defp do_update_segment(
- %Plug.Conn{} = conn,
- %{} = params,
- %Plausible.Segment{} = existing_segment,
- owner_override
- ) do
- partial_segment_definition = Map.merge(params, %{"owner_id" => owner_override})
-
- with %{valid?: true} = changeset <-
- Plausible.Segment.changeset(
- existing_segment,
- partial_segment_definition
- ),
- :ok <-
- Plausible.Segment.validate_segment_data_if_exists(
- conn.assigns.site,
- params["segment_data"],
- true
- ) do
- json(
- conn,
- Repo.update!(
- changeset,
- returning: true
- )
- )
- else
- %{valid?: false, errors: errors} ->
- conn
- |> put_status(400)
- |> json(%{
- errors:
- Enum.map(errors, fn {field_key, {message, opts}} -> [field_key, message, opts] end)
- })
-
- {:error, {:invalid_filters, message}} ->
- conn |> put_status(400) |> json(%{errors: [["segment_data", message, []]]})
- end
- end
-
- defp do_delete_segment(
- %Plug.Conn{} = conn,
- %Plausible.Segment{} = existing_segment
- ) do
- Repo.delete!(existing_segment)
- json(conn, existing_segment)
- end
-
- defp roles_with_personal_segments(), do: [:viewer, :editor, :admin, :owner, :super_admin]
- defp roles_with_maybe_site_segments(), do: [:editor, :admin, :owner, :super_admin]
-
- defp site_segments_available?(site),
- do: Plausible.Billing.Feature.Props.check_availability(site.team) == :ok
end
diff --git a/lib/plausible_web/plugs/feature_flag_check_plug.ex b/lib/plausible_web/plugs/feature_flag_check_plug.ex
index 75698da084..c04e23e38d 100644
--- a/lib/plausible_web/plugs/feature_flag_check_plug.ex
+++ b/lib/plausible_web/plugs/feature_flag_check_plug.ex
@@ -12,13 +12,16 @@ defmodule PlausibleWeb.Plugs.FeatureFlagCheckPlug do
do: raise(ArgumentError, "The first argument must be a non-empty list of feature flags")
def call(%Plug.Conn{} = conn, flags) do
- if validate(conn.assigns.current_user, conn.assigns.site, flags) do
+ if validate(conn.assigns[:current_user], conn.assigns.site, flags) do
conn
else
PlausibleWeb.Api.Helpers.not_found(conn, "Not found")
end
end
+ defp validate(nil = _current_user, site, flags),
+ do: Enum.all?(flags, fn flag -> FunWithFlags.enabled?(flag, for: site) end)
+
defp validate(current_user, site, flags),
do:
Enum.all?(flags, fn flag ->
diff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.ex
index aaaad69f9c..5b03d77b59 100644
--- a/lib/plausible_web/router.ex
+++ b/lib/plausible_web/router.ex
@@ -224,11 +224,11 @@ defmodule PlausibleWeb.Router do
do: plug(PlausibleWeb.Plugs.FeatureFlagCheckPlug, [:saved_segments])
pipe_through :segments_endpoints
- get "/", SegmentsController, :get_all_segments
- post "/", SegmentsController, :create_segment
- get "/:segment_id", SegmentsController, :get_segment
- patch "/:segment_id", SegmentsController, :update_segment
- delete "/:segment_id", SegmentsController, :delete_segment
+ get "/", SegmentsController, :index
+ post "/", SegmentsController, :create
+ get "/:segment_id", SegmentsController, :get
+ patch "/:segment_id", SegmentsController, :update
+ delete "/:segment_id", SegmentsController, :delete
end
end
diff --git a/test/plausible/segment_schema_test.exs b/test/plausible/segments/segment_test.exs
similarity index 85%
rename from test/plausible/segment_schema_test.exs
rename to test/plausible/segments/segment_test.exs
index 104fbf160c..355aa635d6 100644
--- a/test/plausible/segment_schema_test.exs
+++ b/test/plausible/segments/segment_test.exs
@@ -1,9 +1,9 @@
-defmodule Plausible.SegmentSchemaTest do
+defmodule Plausible.Segments.SegmentTest do
use ExUnit.Case
- doctest Plausible.Segment, import: true
+ doctest Plausible.Segments.Segment, import: true
setup do
- segment = %Plausible.Segment{
+ segment = %Plausible.Segments.Segment{
name: "any name",
type: :personal,
segment_data: %{"filters" => ["is", "visit:page", ["/blog"]]},
@@ -15,7 +15,7 @@ defmodule Plausible.SegmentSchemaTest do
end
test "changeset has required fields" do
- assert Plausible.Segment.changeset(%Plausible.Segment{}, %{}).errors == [
+ assert Plausible.Segments.Segment.changeset(%Plausible.Segments.Segment{}, %{}).errors == [
segment_data: {"property \"filters\" must be an array with at least one member", []},
name: {"can't be blank", [validation: :required]},
segment_data: {"can't be blank", [validation: :required]},
@@ -27,7 +27,7 @@ defmodule Plausible.SegmentSchemaTest do
test "changeset does not allow setting owner_id to nil (setting to nil happens with database triggers)",
%{segment: valid_segment} do
- assert Plausible.Segment.changeset(
+ assert Plausible.Segments.Segment.changeset(
valid_segment,
%{
owner_id: nil
@@ -38,7 +38,7 @@ defmodule Plausible.SegmentSchemaTest do
end
test "changeset forbids too long name", %{segment: valid_segment} do
- assert Plausible.Segment.changeset(
+ assert Plausible.Segments.Segment.changeset(
valid_segment,
%{
name: String.duplicate("a", 256)
@@ -51,7 +51,7 @@ defmodule Plausible.SegmentSchemaTest do
end
test "changeset forbids too large segment_data", %{segment: valid_segment} do
- assert Plausible.Segment.changeset(
+ assert Plausible.Segments.Segment.changeset(
valid_segment,
%{
segment_data:
@@ -66,8 +66,8 @@ defmodule Plausible.SegmentSchemaTest do
test "changeset allows setting nil owner_id to a user id (to be able to recover dangling site segments)",
%{segment: valid_segment} do
- assert Plausible.Segment.changeset(
- %Plausible.Segment{
+ assert Plausible.Segments.Segment.changeset(
+ %Plausible.Segments.Segment{
valid_segment
| owner_id: nil
},
@@ -78,7 +78,7 @@ defmodule Plausible.SegmentSchemaTest do
end
test "changeset requires segment_data to be structured as expected", %{segment: valid_segment} do
- assert Plausible.Segment.changeset(
+ assert Plausible.Segments.Segment.changeset(
valid_segment,
%{
segment_data: %{"filters" => 1, "labels" => true, "other" => []}
@@ -93,7 +93,7 @@ defmodule Plausible.SegmentSchemaTest do
end
test "changeset forbids empty filters list", %{segment: valid_segment} do
- assert Plausible.Segment.changeset(
+ assert Plausible.Segments.Segment.changeset(
valid_segment,
%{
segment_data: %{
@@ -107,7 +107,7 @@ defmodule Plausible.SegmentSchemaTest do
end
test "changeset permits well-structured segment data", %{segment: valid_segment} do
- assert Plausible.Segment.changeset(
+ assert Plausible.Segments.Segment.changeset(
valid_segment,
%{
segment_data: %{
diff --git a/test/plausible_web/controllers/api/internal_controller/segments_controller_test.exs b/test/plausible_web/controllers/api/internal_controller/segments_controller_test.exs
index 5d355c13cd..71cc6550d5 100644
--- a/test/plausible_web/controllers/api/internal_controller/segments_controller_test.exs
+++ b/test/plausible_web/controllers/api/internal_controller/segments_controller_test.exs
@@ -330,7 +330,8 @@ defmodule PlausibleWeb.Api.Internal.SegmentsControllerTest do
"errors" => [
[
"segment_data",
- "#/filters/0: Invalid filter [\"is\", \"entry_page\", [\"/blog\"]]"
+ "#/filters/0: Invalid filter [\"is\", \"entry_page\", [\"/blog\"]]",
+ []
]
]
}
@@ -366,7 +367,7 @@ defmodule PlausibleWeb.Api.Internal.SegmentsControllerTest do
assert is_binary(response["updated_at"])
assert response["inserted_at"] == response["updated_at"]
- verify_segment_in_db(%Plausible.Segment{
+ verify_segment_in_db(%Plausible.Segments.Segment{
id: response["id"],
name: response["name"],
type: String.to_existing_atom(response["type"]),
@@ -569,11 +570,11 @@ defmodule PlausibleWeb.Api.Internal.SegmentsControllerTest do
defp verify_segment_in_db(segment) do
uncomparable_keys = [:__meta__, :site]
- assert Map.drop(Repo.get(Plausible.Segment, segment.id), uncomparable_keys) ==
+ assert Map.drop(Repo.get(Plausible.Segments.Segment, segment.id), uncomparable_keys) ==
Map.drop(segment, uncomparable_keys)
end
defp verify_no_segment_in_db(segment) do
- assert Repo.get(Plausible.Segment, segment.id) == nil
+ assert Repo.get(Plausible.Segments.Segment, segment.id) == nil
end
end
diff --git a/test/support/factory.ex b/test/support/factory.ex
index b74ef79295..0814ac0eb5 100644
--- a/test/support/factory.ex
+++ b/test/support/factory.ex
@@ -379,7 +379,7 @@ defmodule Plausible.Factory do
end
def segment_factory do
- %Plausible.Segment{
+ %Plausible.Segments.Segment{
segment_data: %{"filters" => [["is", "visit:entry_page", ["/blog"]]]}
}
end