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
Refactor Segments controller to be thinner (#4981)
Artur Pata5af43a93d534
diff --git a/lib/plausible/segment.ex b/lib/plausible/segments/segment.exsimilarity index 99%rename from lib/plausible/segment.exrename to lib/plausible/segments/segment.exindex 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.exnew file mode 100644index 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+enddiff --git a/lib/plausible_web/controllers/api/internal/segments_controller.ex b/lib/plausible_web/controllers/api/internal/segments_controller.exindex 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 Plausibleuse PlausibleWeb, :controller- use Plausible.Repouse PlausibleWeb.Plugs.ErrorHandleralias 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)endend- 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) dosegment_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)endend- 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)endend- 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 doconn,%{} = 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)endend- 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 doconn,%{} = 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)+ endend- @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 doendend- 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) == :okenddiff --git a/lib/plausible_web/plugs/feature_flag_check_plug.ex b/lib/plausible_web/plugs/feature_flag_check_plug.exindex 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 dodo: 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) doconnelsePlausibleWeb.Api.Helpers.not_found(conn, "Not found")endend+ 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.exindex aaaad69f9c..5b03d77b59 100644--- a/lib/plausible_web/router.ex+++ b/lib/plausible_web/router.ex@@ -224,11 +224,11 @@ defmodule PlausibleWeb.Router dodo: 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, :deleteendenddiff --git a/test/plausible/segment_schema_test.exs b/test/plausible/segments/segment_test.exssimilarity index 85%rename from test/plausible/segment_schema_test.exsrename to test/plausible/segments/segment_test.exsindex 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 douse ExUnit.Case- doctest Plausible.Segment, import: true+ doctest Plausible.Segments.Segment, import: truesetup 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 doendtest "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 dotest "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 doendtest "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 doendtest "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 dotest "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 doendtest "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 doendtest "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 doendtest "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.exsindex 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 doassert 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 dodefp verify_segment_in_db(segment) douncomparable_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)enddefp verify_no_segment_in_db(segment) do- assert Repo.get(Plausible.Segment, segment.id) == nil+ assert Repo.get(Plausible.Segments.Segment, segment.id) == nilendenddiff --git a/test/support/factory.ex b/test/support/factory.exindex b74ef79295..0814ac0eb5 100644--- a/test/support/factory.ex+++ b/test/support/factory.ex@@ -379,7 +379,7 @@ defmodule Plausible.Factory doenddef segment_factory do- %Plausible.Segment{+ %Plausible.Segments.Segment{segment_data: %{"filters" => [["is", "visit:entry_page", ["/blog"]]]}}end