diff --git a/CHANGELOG.md b/CHANGELOG.md index 4ed59f16c..a9263eb8d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ All notable changes to this project will be documented in this file. ### Added +- Pages Block List in Site Settings +- Add `conversion_rate` to Stats API Timeseries and on the main graph - Add `total_conversions` and `conversion_rate` to `visitors.csv` in a goal-filtered CSV export - Ability to display total conversions (with a goal filter) on the main graph - Add `conversion_rate` to Stats API Timeseries and on the main graph diff --git a/lib/plausible/application.ex b/lib/plausible/application.ex index 3f8117f42..f197ec6a0 100644 --- a/lib/plausible/application.ex +++ b/lib/plausible/application.ex @@ -77,6 +77,21 @@ defmodule Plausible.Application do interval: :timer.seconds(35), warmer_fn: :refresh_updated_recently ]}, + {Plausible.Shield.PageRuleCache, ttl_check_interval: false, ets_options: [:bag]}, + {Plausible.Cache.Warmer, + [ + child_name: Plausible.Shield.PageRuleCache.All, + cache_impl: Plausible.Shield.PageRuleCache, + interval: :timer.minutes(3) + Enum.random(1..:timer.seconds(10)), + warmer_fn: :refresh_all + ]}, + {Plausible.Cache.Warmer, + [ + child_name: Plausible.Shield.PageRuleCache.RecentlyUpdated, + cache_impl: Plausible.Shield.PageRuleCache, + interval: :timer.seconds(35), + warmer_fn: :refresh_updated_recently + ]}, {Plausible.Auth.TOTP.Vault, key: totp_vault_key()}, PlausibleWeb.Endpoint, {Oban, Application.get_env(:plausible, Oban)}, diff --git a/lib/plausible/ingestion/event.ex b/lib/plausible/ingestion/event.ex index 8c66c01d7..6dd680f61 100644 --- a/lib/plausible/ingestion/event.ex +++ b/lib/plausible/ingestion/event.ex @@ -29,6 +29,7 @@ defmodule Plausible.Ingestion.Event do | :dc_ip | :site_ip_blocklist | :site_country_blocklist + | :site_page_blocklist @type t() :: %__MODULE__{ domain: String.t() | nil, @@ -120,6 +121,7 @@ defmodule Plausible.Ingestion.Event do [ &drop_datacenter_ip/1, &drop_shield_rule_ip/1, + &drop_shield_rule_page/1, &put_geolocation/1, &drop_shield_rule_country/1, &put_user_agent/1, @@ -182,15 +184,18 @@ defmodule Plausible.Ingestion.Event do end defp drop_shield_rule_ip(%__MODULE__{} = event) do - domain = event.domain - address = event.request.remote_ip - - case Plausible.Shield.IPRuleCache.get({domain, address}) do - %Plausible.Shield.IPRule{action: :deny} -> - drop(event, :site_ip_blocklist) + if Plausible.Shields.ip_blocked?(event.domain, event.request.remote_ip) do + drop(event, :site_ip_blocklist) + else + event + end + end - _ -> - event + defp drop_shield_rule_page(%__MODULE__{} = event) do + if Plausible.Shields.page_blocked?(event.domain, event.request.pathname) do + drop(event, :site_page_blocklist) + else + event end end @@ -263,12 +268,10 @@ defmodule Plausible.Ingestion.Event do %__MODULE__{domain: domain, clickhouse_session_attrs: %{country_code: cc}} = event ) when is_binary(domain) and is_binary(cc) do - case Plausible.Shield.CountryRuleCache.get({domain, String.upcase(cc)}) do - %Plausible.Shield.CountryRule{action: :deny} -> - drop(event, :site_country_blocklist) - - _ -> - event + if Plausible.Shields.country_blocked?(domain, cc) do + drop(event, :site_country_blocklist) + else + event end end diff --git a/lib/plausible/shield/country_rule.ex b/lib/plausible/shield/country_rule.ex index 85bc73456..067928f34 100644 --- a/lib/plausible/shield/country_rule.ex +++ b/lib/plausible/shield/country_rule.ex @@ -24,7 +24,7 @@ defmodule Plausible.Shield.CountryRule do |> cast(attrs, [:site_id, :country_code]) |> validate_required([:site_id, :country_code]) |> validate_length(:country_code, is: 2) - |> Ecto.Changeset.validate_change(:country_code, fn :country_code, cc -> + |> validate_change(:country_code, fn :country_code, cc -> if cc in Enum.map(Location.Country.all(), & &1.alpha_2) do [] else diff --git a/lib/plausible/shield/page_rule.ex b/lib/plausible/shield/page_rule.ex new file mode 100644 index 000000000..e874e185c --- /dev/null +++ b/lib/plausible/shield/page_rule.ex @@ -0,0 +1,85 @@ +defmodule CompiledRegex do + @moduledoc """ + Ensures that the regex is compiled on load + """ + use Ecto.Type + + def type, do: :string + + def cast(val) when is_binary(val), do: {:ok, val} + def cast(_), do: :error + + def load(val), do: {:ok, Regex.compile!(val)} + def dump(val), do: {:ok, val} +end + +defmodule Plausible.Shield.PageRule do + @moduledoc """ + Schema for Pages block list + """ + use Ecto.Schema + import Ecto.Changeset + + @type t() :: %__MODULE__{} + + @primary_key {:id, :binary_id, autogenerate: true} + schema "shield_rules_page" do + belongs_to :site, Plausible.Site + field :page_path, :string + field :page_path_pattern, CompiledRegex + field :action, Ecto.Enum, values: [:deny, :allow], default: :deny + field :added_by, :string + + # If `from_cache?` is set, the struct might be incomplete - see `Plausible.Site.Shield.Rules.IP.Cache` + field :from_cache?, :boolean, virtual: true, default: false + timestamps() + end + + def changeset(rule \\ %__MODULE__{}, attrs) do + rule + |> cast(attrs, [:site_id, :page_path]) + |> validate_required([:site_id, :page_path]) + |> validate_length(:page_path, max: 250) + |> validate_change(:page_path, fn :page_path, p -> + if not String.starts_with?(p, "/") do + [page_path: "must start with /"] + else + [] + end + end) + |> store_regex() + |> unique_constraint(:page_path_pattern, + name: :shield_rules_page_site_id_page_path_pattern_index, + error_key: :page_path, + message: "rule already exists" + ) + end + + defp store_regex(changeset) do + case get_field(changeset, :page_path) do + "/" <> _ = page_path -> + regex = + page_path + |> Regex.escape() + |> String.replace("\\*\\*", ".*") + |> String.replace("\\*", ".*") + + regex = "^#{regex}$" + + verify_valid_regex(changeset, regex) + + _ -> + changeset + end + end + + defp verify_valid_regex(changeset, regex) do + case Regex.compile(regex) do + {:ok, _} -> + put_change(changeset, :page_path_pattern, regex) + + {:error, _} -> + add_error(changeset, :page_path, "could not compile regular expression") + end + end +end diff --git a/lib/plausible/shield/page_rule_cache.ex b/lib/plausible/shield/page_rule_cache.ex new file mode 100644 index 000000000..e9ba3039d --- /dev/null +++ b/lib/plausible/shield/page_rule_cache.ex @@ -0,0 +1,65 @@ +defmodule Plausible.Shield.PageRuleCache do + @moduledoc """ + Allows retrieving Page Rules by domain + """ + alias Plausible.Shield.PageRule + + import Ecto.Query + use Plausible.Cache + + @cache_name :page_blocklist_by_domain + + @cached_schema_fields ~w( + id + page_path_pattern + action + )a + + @impl true + def name(), do: @cache_name + + @impl true + def child_id(), do: :cache_page_blocklist + + @impl true + def count_all() do + Plausible.Repo.aggregate(PageRule, :count) + end + + @impl true + def base_db_query() do + from rule in PageRule, + inner_join: s in assoc(rule, :site), + select: { + s.domain, + s.domain_changed_from, + %{struct(rule, ^@cached_schema_fields) | from_cache?: true} + } + end + + @impl true + def get_from_source(domain) do + query = + base_db_query() + |> where([..., site], site.domain == ^domain) + + case Plausible.Repo.one(query) do + {_, _, rule} -> %PageRule{rule | from_cache?: false} + _any -> nil + end + end + + @impl true + def unwrap_cache_keys(items) do + Enum.reduce(items, [], fn + {domain, nil, object}, acc -> + [{domain, object} | acc] + + {domain, domain_changed_from, object}, acc -> + [ + {domain, object}, + {domain_changed_from, object} | acc + ] + end) + end +end diff --git a/lib/plausible/shields.ex b/lib/plausible/shields.ex index 25ba47d84..942b1fba0 100644 --- a/lib/plausible/shields.ex +++ b/lib/plausible/shields.ex @@ -13,11 +13,63 @@ defmodule Plausible.Shields do @maximum_country_rules 30 def maximum_country_rules(), do: @maximum_country_rules + @maximum_page_rules 30 + def maximum_page_rules(), do: @maximum_page_rules + @spec list_ip_rules(Site.t() | non_neg_integer()) :: [Shield.IPRule.t()] def list_ip_rules(site_or_id) do list(Shield.IPRule, site_or_id) end + @spec ip_blocked?(Site.t() | String.t(), String.t()) :: boolean() + def ip_blocked?(%Site{domain: domain}, address) do + ip_blocked?(domain, address) + end + + def ip_blocked?(domain, address) when is_binary(domain) and is_binary(address) do + case Shield.IPRuleCache.get({domain, address}) do + %Shield.IPRule{action: :deny} -> + true + + _ -> + false + end + end + + @spec page_blocked?(Site.t() | String.t(), String.t()) :: boolean() + def page_blocked?(%Site{domain: domain}, address) do + page_blocked?(domain, address) + end + + def page_blocked?(domain, pathname) when is_binary(domain) and is_binary(pathname) do + page_rules = Shield.PageRuleCache.get(domain) + + if page_rules do + page_rules + |> List.wrap() + |> Enum.find_value(false, fn rule -> + rule.action == :deny and Regex.match?(rule.page_path_pattern, pathname) + end) + else + false + end + end + + @spec country_blocked?(Site.t() | String.t(), String.t()) :: boolean() + def country_blocked?(%Site{domain: domain}, country_code) do + country_blocked?(domain, country_code) + end + + def country_blocked?(domain, country_code) when is_binary(domain) and is_binary(country_code) do + case Shield.CountryRuleCache.get({domain, String.upcase(country_code)}) do + %Shield.CountryRule{action: :deny} -> + true + + _ -> + false + end + end + @spec add_ip_rule(Site.t() | non_neg_integer(), map(), Keyword.t()) :: {:ok, Shield.IPRule.t()} | {:error, Ecto.Changeset.t()} def add_ip_rule(site_or_id, params, opts \\ []) do @@ -59,6 +111,28 @@ defmodule Plausible.Shields do count(Shield.CountryRule, site_or_id) end + @spec list_page_rules(Site.t() | non_neg_integer()) :: [Shield.PageRule.t()] + def list_page_rules(site_or_id) do + list(Shield.PageRule, site_or_id) + end + + @spec add_page_rule(Site.t() | non_neg_integer(), map(), Keyword.t()) :: + {:ok, Shield.PageRule.t()} | {:error, Ecto.Changeset.t()} + def add_page_rule(site_or_id, params, opts \\ []) do + opts = Keyword.put(opts, :limit, {:page_path, @maximum_page_rules}) + add(Shield.PageRule, site_or_id, params, opts) + end + + @spec remove_page_rule(Site.t() | non_neg_integer(), String.t()) :: :ok + def remove_page_rule(site_or_id, rule_id) do + remove(Shield.PageRule, site_or_id, rule_id) + end + + @spec count_page_rules(Site.t() | non_neg_integer()) :: non_neg_integer() + def count_page_rules(site_or_id) do + count(Shield.PageRule, site_or_id) + end + defp list(schema, %Site{id: id}) do list(schema, id) end diff --git a/lib/plausible/shields/country_test.exs b/lib/plausible/shields/country_test.exs new file mode 100644 index 000000000..8b2218688 --- /dev/null +++ b/lib/plausible/shields/country_test.exs @@ -0,0 +1,136 @@ +defmodule Plausible.Shields.CountryTest do + use Plausible.DataCase + import Plausible.Shields + + setup do + site = insert(:site) + {:ok, %{site: site}} + end + + describe "add_country_rule/2" do + test "no input", %{site: site} do + assert {:error, changeset} = add_country_rule(site, %{}) + assert changeset.errors == [country_code: {"can't be blank", [validation: :required]}] + refute changeset.valid? + end + + test "unsupported country", %{site: site} do + assert {:error, changeset} = add_country_rule(site, %{"country_code" => "0X"}) + assert changeset.errors == [country_code: {"is invalid", []}] + refute changeset.valid? + end + + test "incorrect country format", %{site: site} do + assert {:error, changeset} = add_country_rule(site, %{"country_code" => "Germany"}) + + assert changeset.errors == + [ + {:country_code, {"is invalid", []}}, + {:country_code, + {"should be %{count} character(s)", + [count: 2, validation: :length, kind: :is, type: :string]}} + ] + + refute changeset.valid? + end + + test "double insert", %{site: site} do + assert {:ok, _} = add_country_rule(site, %{"country_code" => "EE"}) + assert {:error, changeset} = add_country_rule(site, %{"country_code" => "EE"}) + refute changeset.valid? + + assert changeset.errors == [ + country_code: + {"has already been taken", + [ + {:constraint, :unique}, + {:constraint_name, "shield_rules_country_site_id_country_code_index"} + ]} + ] + end + + test "over limit", %{site: site} do + country_codes = + Location.Country.all() + |> Enum.take(Plausible.Shields.maximum_country_rules()) + |> Enum.map(& &1.alpha_2) + + for cc <- country_codes do + assert {:ok, _} = + add_country_rule(site, %{"country_code" => cc}) + end + + assert count_country_rules(site) == maximum_country_rules() + + assert {:error, changeset} = + add_country_rule(site, %{"country_code" => "US"}) + + refute changeset.valid? + assert changeset.errors == [country_code: {"maximum reached", []}] + end + + test "with added_by", %{site: site} do + assert {:ok, rule} = + add_country_rule(site, %{"country_code" => "EE"}, + added_by: build(:user, name: "Joe", email: "joe@example.com") + ) + + assert rule.added_by == "Joe " + end + end + + describe "remove_country_rule/2" do + test "is idempontent", %{site: site} do + {:ok, rule} = add_country_rule(site, %{"country_code" => "EE"}) + assert remove_country_rule(site, rule.id) == :ok + refute Repo.get(Plausible.Shield.CountryRule, rule.id) + assert remove_country_rule(site, rule.id) == :ok + end + end + + describe "list_country_rules/1" do + test "empty", %{site: site} do + assert(list_country_rules(site) == []) + end + + @tag :slow + test "many", %{site: site} do + {:ok, r1} = add_country_rule(site, %{"country_code" => "EE"}) + :timer.sleep(1000) + {:ok, r2} = add_country_rule(site, %{"country_code" => "PL"}) + assert [^r2, ^r1] = list_country_rules(site) + end + end + + describe "count_country_rules/1" do + test "counts", %{site: site} do + assert count_country_rules(site) == 0 + {:ok, _} = add_country_rule(site, %{"country_code" => "EE"}) + assert count_country_rules(site) == 1 + {:ok, _} = add_country_rule(site, %{"country_code" => "PL"}) + assert count_country_rules(site) == 2 + end + end + + describe "Country Rules" do + test "end to end", %{site: site} do + site2 = insert(:site) + + assert count_country_rules(site.id) == 0 + assert list_country_rules(site.id) == [] + + assert {:ok, rule} = + add_country_rule(site.id, %{"country_code" => "EE"}) + + add_country_rule(site2, %{"country_code" => "PL"}) + + assert count_country_rules(site) == 1 + assert [^rule] = list_country_rules(site) + assert rule.country_code == "EE" + assert rule.action == :deny + refute rule.from_cache? + assert country_blocked?(site, "ee") + refute country_blocked?(site, "xx") + end + end +end diff --git a/lib/plausible/shields/ip_test.exs b/lib/plausible/shields/ip_test.exs new file mode 100644 index 000000000..bd597a392 --- /dev/null +++ b/lib/plausible/shields/ip_test.exs @@ -0,0 +1,147 @@ +defmodule Plausible.Shields.IPTest do + use Plausible.DataCase + import Plausible.Shields + + setup do + site = insert(:site) + {:ok, %{site: site}} + end + + describe "add_ip_rule/2" do + test "no input", %{site: site} do + assert {:error, changeset} = add_ip_rule(site, %{}) + assert changeset.errors == [inet: {"can't be blank", [validation: :required]}] + refute changeset.valid? + end + + test "unsupported netmask", %{site: site} do + assert {:error, changeset} = add_ip_rule(site, %{"inet" => "127.0.0.0/24"}) + assert changeset.errors == [inet: {"netmask unsupported", []}] + refute changeset.valid? + assert {:ok, _} = add_ip_rule(site, %{"inet" => "127.0.0.0/32"}) + end + + test "incorrect ip", %{site: site} do + assert {:error, changeset} = add_ip_rule(site, %{"inet" => "999.999.999.999"}) + + assert changeset.errors == [ + inet: {"is invalid", [{:type, EctoNetwork.INET}, {:validation, :cast}]} + ] + + refute changeset.valid? + end + + test "non-strict IPs", %{site: site} do + assert {:error, _} = add_ip_rule(site, %{"inet" => "111"}) + end + + test "double insert", %{site: site} do + assert {:ok, _} = add_ip_rule(site, %{"inet" => "0.0.0.111"}) + assert {:error, changeset} = add_ip_rule(site, %{"inet" => "0.0.0.111"}) + refute changeset.valid? + + assert changeset.errors == [ + inet: + {"has already been taken", + [ + {:constraint, :unique}, + {:constraint_name, "shield_rules_ip_site_id_inet_index"} + ]} + ] + end + + test "ipv6", %{site: site} do + assert {:ok, rule} = + add_ip_rule(site, %{"inet" => "2001:0000:130F:0000:0000:09C0:876A:130B"}) + + assert ^rule = Repo.get(Plausible.Shield.IPRule, rule.id) + end + + test "ipv4", %{site: site} do + assert {:ok, rule} = + add_ip_rule(site, %{"inet" => "1.1.1.1"}) + + assert ^rule = Repo.get(Plausible.Shield.IPRule, rule.id) + end + + test "over limit", %{site: site} do + for i <- 1..maximum_ip_rules() do + assert {:ok, _} = + add_ip_rule(site, %{"inet" => "1.1.1.#{i}"}) + end + + assert count_ip_rules(site) == maximum_ip_rules() + + assert {:error, changeset} = + add_ip_rule(site, %{"inet" => "1.1.1.31"}) + + refute changeset.valid? + assert changeset.errors == [inet: {"maximum reached", []}] + end + + test "with added_by", %{site: site} do + assert {:ok, rule} = + add_ip_rule(site, %{"inet" => "1.1.1.1"}, + added_by: build(:user, name: "Joe", email: "joe@example.com") + ) + + assert rule.added_by == "Joe " + end + end + + describe "remove_ip_rule/2" do + test "is idempontent", %{site: site} do + {:ok, rule} = add_ip_rule(site, %{"inet" => "127.0.0.1"}) + assert remove_ip_rule(site, rule.id) == :ok + refute Repo.get(Plausible.Shield.IPRule, rule.id) + assert remove_ip_rule(site, rule.id) == :ok + end + end + + describe "list_ip_rules/1" do + test "empty", %{site: site} do + assert(list_ip_rules(site) == []) + end + + @tag :slow + test "many", %{site: site} do + {:ok, r1} = add_ip_rule(site, %{"inet" => "127.0.0.1"}) + :timer.sleep(1000) + {:ok, r2} = add_ip_rule(site, %{"inet" => "127.0.0.2"}) + assert [^r2, ^r1] = list_ip_rules(site) + end + end + + describe "count_ip_rules/1" do + test "counts", %{site: site} do + assert count_ip_rules(site) == 0 + {:ok, _} = add_ip_rule(site, %{"inet" => "127.0.0.1"}) + assert count_ip_rules(site) == 1 + {:ok, _} = add_ip_rule(site, %{"inet" => "127.0.0.2"}) + assert count_ip_rules(site) == 2 + end + end + + describe "IP Rules" do + test "end to end", %{site: site} do + site2 = insert(:site) + + assert count_ip_rules(site.id) == 0 + assert list_ip_rules(site.id) == [] + + assert {:ok, rule} = + add_ip_rule(site.id, %{"inet" => "127.0.0.1", "description" => "Localhost"}) + + add_ip_rule(site2, %{"inet" => "127.0.0.1", "description" => "Localhost"}) + + assert count_ip_rules(site) == 1 + assert [^rule] = list_ip_rules(site) + assert rule.inet == %Postgrex.INET{address: {127, 0, 0, 1}, netmask: 32} + assert rule.description == "Localhost" + assert rule.action == :deny + refute rule.from_cache? + assert ip_blocked?(site, "127.0.0.1") + refute ip_blocked?(site, "127.0.0.2") + end + end +end diff --git a/lib/plausible/shields/page_test.exs b/lib/plausible/shields/page_test.exs new file mode 100644 index 000000000..6134e9903 --- /dev/null +++ b/lib/plausible/shields/page_test.exs @@ -0,0 +1,174 @@ +defmodule Plausible.Shields.PageTest do + use Plausible.DataCase + import Plausible.Shields + + setup do + site = insert(:site) + {:ok, %{site: site}} + end + + describe "add_page_rule/2" do + test "no input", %{site: site} do + assert {:error, changeset} = add_page_rule(site, %{}) + assert changeset.errors == [page_path: {"can't be blank", [validation: :required]}] + refute changeset.valid? + end + + test "no slash", %{site: site} do + assert {:error, changeset} = add_page_rule(site, %{"page_path" => "test"}) + assert changeset.errors == [page_path: {"must start with /", []}] + refute changeset.valid? + end + + test "lengthy", %{site: site} do + long = "/" <> :binary.copy("a", 251) + assert {:error, changeset} = add_page_rule(site, %{"page_path" => long}) + assert [page_path: {"should be at most %{count} character(s)", _}] = changeset.errors + refute changeset.valid? + end + + test "double insert", %{site: site} do + assert {:ok, _} = add_page_rule(site, %{"page_path" => "/test"}) + assert {:error, changeset} = add_page_rule(site, %{"page_path" => "/test"}) + refute changeset.valid? + + assert changeset.errors == [ + page_path: + {"rule already exists", + [ + {:constraint, :unique}, + {:constraint_name, "shield_rules_page_site_id_page_path_pattern_index"} + ]} + ] + end + + test "equivalent rules are counted as dupes", %{site: site} do + assert {:ok, _} = add_page_rule(site, %{"page_path" => "/test/*"}) + assert {:error, changeset} = add_page_rule(site, %{"page_path" => "/test/**"}) + + assert changeset.errors == [ + page_path: + {"rule already exists", + [ + {:constraint, :unique}, + {:constraint_name, "shield_rules_page_site_id_page_path_pattern_index"} + ]} + ] + end + + test "regex storage: wildcard", %{site: site} do + assert {:ok, rule} = add_page_rule(site, %{"page_path" => "/test/*"}) + assert rule.page_path_pattern == "^/test/.*$" + end + + test "regex storage: no wildcard", %{site: site} do + assert {:ok, rule} = add_page_rule(site, %{"page_path" => "/test"}) + assert rule.page_path_pattern == "^/test$" + end + + test "regex storage: escaping", %{site: site} do + assert {:ok, rule} = add_page_rule(site, %{"page_path" => "/test/*/**/|+[0-9]"}) + assert rule.page_path_pattern == "^/test/.*/.*/\\|\\+\\[0\\-9\\]$" + end + + test "over limit", %{site: site} do + for i <- 1..maximum_page_rules() do + assert {:ok, _} = + add_page_rule(site, %{"page_path" => "/test/#{i}"}) + end + + assert count_page_rules(site) == maximum_page_rules() + + assert {:error, changeset} = + add_page_rule(site, %{"page_path" => "/test/31"}) + + refute changeset.valid? + assert changeset.errors == [page_path: {"maximum reached", []}] + end + + test "with added_by", %{site: site} do + assert {:ok, rule} = + add_page_rule(site, %{"page_path" => "/test"}, + added_by: build(:user, name: "Joe", email: "joe@example.com") + ) + + assert rule.added_by == "Joe " + end + end + + describe "page pattern matching" do + test "no wildcard", %{site: site} do + assert {:ok, _} = add_page_rule(site, %{"page_path" => "/test"}) + assert page_blocked?(site, "/test") + refute page_blocked?(site, "/test/hello") + refute page_blocked?(site, "test") + end + + test "wildcard", %{site: site} do + assert {:ok, _} = add_page_rule(site, %{"page_path" => "/test/*"}) + refute page_blocked?(site, "/test") + assert page_blocked?(site, "/test/") + assert page_blocked?(site, "/test/hello") + refute page_blocked?(site, "test") + refute page_blocked?(site, "/testing") + end + end + + describe "remove_page_rule/2" do + test "is idempontent", %{site: site} do + {:ok, rule} = add_page_rule(site, %{"page_path" => "/test"}) + assert remove_page_rule(site, rule.id) == :ok + refute Repo.get(Plausible.Shield.PageRule, rule.id) + assert remove_page_rule(site, rule.id) == :ok + end + end + + describe "list_page_rules/1" do + test "empty", %{site: site} do + assert(list_page_rules(site) == []) + end + + @tag :slow + test "many", %{site: site} do + {:ok, r1} = add_page_rule(site, %{"page_path" => "/test"}) + :timer.sleep(1000) + {:ok, r2} = add_page_rule(site, %{"page_path" => "/test"}) + assert [^r2, ^r1] = list_page_rules(site) + end + end + + describe "count_page_rules/1" do + test "counts", %{site: site} do + assert count_page_rules(site) == 0 + {:ok, _} = add_page_rule(site, %{"page_path" => "/test1"}) + assert count_page_rules(site) == 1 + {:ok, _} = add_page_rule(site, %{"page_path" => "/test2"}) + assert count_page_rules(site) == 2 + end + end + + describe "Page Rules" do + test "end to end", %{site: site} do + site2 = insert(:site) + + assert count_page_rules(site.id) == 0 + assert list_page_rules(site.id) == [] + + assert {:ok, rule} = + add_page_rule(site.id, %{ + "page_path" => "/test" + }) + + add_page_rule(site2, %{"page_path" => "/test"}) + + assert count_page_rules(site) == 1 + assert [%{id: rule_id}] = list_page_rules(site) + assert rule.id == rule_id + assert rule.page_path == "/test" + assert rule.action == :deny + refute rule.from_cache? + assert page_blocked?(site, "/test") + refute page_blocked?(site, "/testing") + end + end +end diff --git a/lib/plausible_web/controllers/site_controller.ex b/lib/plausible_web/controllers/site_controller.ex index 436c391c7..77c9a9343 100644 --- a/lib/plausible_web/controllers/site_controller.ex +++ b/lib/plausible_web/controllers/site_controller.ex @@ -257,7 +257,7 @@ defmodule PlausibleWeb.SiteController do end def settings_shields(conn, %{"shield" => shield}) - when shield in ["ip_addresses", "countries"] do + when shield in ["ip_addresses", "countries", "pages"] do site = conn.assigns.site conn diff --git a/lib/plausible_web/live/shields/page_rules.ex b/lib/plausible_web/live/shields/page_rules.ex new file mode 100644 index 000000000..3ff38e12b --- /dev/null +++ b/lib/plausible_web/live/shields/page_rules.ex @@ -0,0 +1,304 @@ +defmodule PlausibleWeb.Live.Shields.PageRules do + @moduledoc """ + LiveView allowing page Rules management + """ + + use Phoenix.LiveComponent, global_prefixes: ~w(x-) + use Phoenix.HTML + + alias PlausibleWeb.Live.Components.Modal + alias Plausible.Shields + alias Plausible.Shield + + import PlausibleWeb.ErrorHelpers + + def update(assigns, socket) do + socket = + socket + |> assign( + page_rules_count: assigns[:page_rules_count] || socket.assigns.page_rules_count, + site: assigns[:site] || socket.assigns.site, + current_user: assigns[:current_user] || socket.assigns.current_user, + form: new_form() + ) + |> assign_new(:page_rules, fn %{site: site} -> + Shields.list_page_rules(site) + end) + |> assign_new(:redundant_rules, fn %{page_rules: page_rules} -> + detect_redundancy(page_rules) + end) + + {:ok, socket} + end + + def render(assigns) do + ~H""" +
+
+
+

+ Pages Block List +

+

+ Reject incoming traffic for specific pages +

+ + +
+
+
+ + + Add Page + +
+ = Shields.maximum_page_rules()} + class="mt-4" + title="Maximum number of pages reached" + > +

+ You've reached the maximum number of pages you can block (<%= Shields.maximum_page_rules() %>). Please remove one before adding another. +

+
+
+ + <.live_component module={Modal} id="page-rule-form-modal"> + <.form + :let={f} + for={@form} + phx-submit="save-page-rule" + phx-target={@myself} + class="max-w-md w-full mx-auto bg-white dark:bg-gray-800" + > +

Add Page to Block List

+ + <.live_component + submit_name="page_rule[page_path]" + submit_value={f[:page_path].value} + display_value={f[:page_path].value || ""} + module={PlausibleWeb.Live.Components.ComboBox} + suggest_fun={fn input, options -> suggest_page_paths(input, options, @site) end} + id={f[:page_path].id} + creatable + /> + + <%= error_tag(f, :page_path) %> + +

+ You can use a wildcard (*) to match multiple pages. For example, + /blog/* + will match /blog/post. + Once added, we will start rejecting traffic from this page within a few minutes. +

+
+ + Add Page → + +
+ + + +

+ No Page Rules configured for this Site. +

+
+ + + + + + + + + + <%= for rule <- @page_rules do %> + + + + + + + <% end %> + +
+ page + + Status + + Remove +
+
+ + <%= rule.page_path %> + +
+
+
+ + Blocked + + + Allowed + + + + + +
+
+ +
+
+
+
+ """ + end + + def handle_event("save-page-rule", %{"page_rule" => params}, socket) do + user = socket.assigns.current_user + + case Shields.add_page_rule( + socket.assigns.site.id, + params, + added_by: user + ) do + {:ok, rule} -> + page_rules = [rule | socket.assigns.page_rules] + + socket = + socket + |> Modal.close("page-rule-form-modal") + |> assign( + form: new_form(), + page_rules: page_rules, + page_rules_count: socket.assigns.page_rules_count + 1, + redundant_rules: detect_redundancy(page_rules) + ) + + # Make sure to clear the combobox input after adding a page rule, on subsequent modal reopening + send_update(PlausibleWeb.Live.Components.ComboBox, + id: "page_rule_page_code", + display_value: "" + ) + + send_flash( + :success, + "Page rule added successfully. Traffic will be rejected within a few minutes." + ) + + {:noreply, socket} + + {:error, %Ecto.Changeset{} = changeset} -> + {:noreply, assign(socket, form: to_form(changeset))} + end + end + + def handle_event("remove-page-rule", %{"rule-id" => rule_id}, socket) do + Shields.remove_page_rule(socket.assigns.site.id, rule_id) + + send_flash( + :success, + "Page rule removed successfully. Traffic will be resumed within a few minutes." + ) + + page_rules = Enum.reject(socket.assigns.page_rules, &(&1.id == rule_id)) + + {:noreply, + socket + |> assign( + page_rules_count: socket.assigns.page_rules_count - 1, + page_rules: page_rules, + redundant_rules: detect_redundancy(page_rules) + )} + end + + def send_flash(kind, message) do + send(self(), {:flash, kind, message}) + end + + defp new_form() do + %Shield.PageRule{} + |> Shield.PageRule.changeset(%{}) + |> to_form() + end + + defp format_added_at(dt, tz) do + dt + |> Plausible.Timezones.to_datetime_in_timezone(tz) + |> Timex.format!("{YYYY}-{0M}-{0D} {h24}:{m}:{s}") + end + + def suggest_page_paths(input, _options, site) do + query = Plausible.Stats.Query.from(site, %{}) + + site + |> Plausible.Stats.filter_suggestions(query, "page", input) + |> Enum.map(fn %{label: label, value: value} -> {label, value} end) + end + + defp detect_redundancy(page_rules) do + page_rules + |> Enum.reduce(%{}, fn rule, acc -> + {[^rule], remaining_rules} = + Enum.split_with( + page_rules, + fn r -> r == rule end + ) + + conflicting = + remaining_rules + |> Enum.filter(fn candidate -> + rule + |> Map.fetch!(:page_path_pattern) + |> maybe_compile() + |> Regex.match?(candidate.page_path) + end) + |> Enum.map(& &1.id) + + Enum.reduce(conflicting, acc, fn conflicting_rule_id, acc -> + Map.update(acc, conflicting_rule_id, [rule.page_path], fn existing -> + [rule.page_path | existing] + end) + end) + end) + end + + defp maybe_compile(pattern) when is_binary(pattern), do: Regex.compile!(pattern) + defp maybe_compile(%Regex{} = pattern), do: pattern +end diff --git a/lib/plausible_web/live/shields/pages.ex b/lib/plausible_web/live/shields/pages.ex new file mode 100644 index 000000000..cd42c47b3 --- /dev/null +++ b/lib/plausible_web/live/shields/pages.ex @@ -0,0 +1,53 @@ +defmodule PlausibleWeb.Live.Shields.Pages do + @moduledoc """ + LiveView for IP Addresses Shield + """ + use PlausibleWeb, :live_view + use Phoenix.HTML + + alias Plausible.Shields + alias Plausible.Sites + + def mount( + _params, + %{ + "domain" => domain, + "current_user_id" => user_id + }, + socket + ) do + socket = + socket + |> assign_new(:site, fn -> + Sites.get_for_user!(user_id, domain, [:owner, :admin, :super_admin]) + end) + |> assign_new(:page_rules_count, fn %{site: site} -> + Shields.count_page_rules(site) + end) + |> assign_new(:current_user, fn -> + Plausible.Repo.get(Plausible.Auth.User, user_id) + end) + + {:ok, socket} + end + + def render(assigns) do + ~H""" +
+ <.flash_messages flash={@flash} /> + <.live_component + module={PlausibleWeb.Live.Shields.PageRules} + current_user={@current_user} + page_rules_count={@page_rules_count} + site={@site} + id="page-rules-#{@current_user.id}" + /> +
+ """ + end + + def handle_info({:flash, kind, message}, socket) do + socket = put_live_flash(socket, kind, message) + {:noreply, socket} + end +end diff --git a/lib/plausible_web/templates/site/settings_shields.html.heex b/lib/plausible_web/templates/site/settings_shields.html.heex index 411c39fd3..489d49daf 100644 --- a/lib/plausible_web/templates/site/settings_shields.html.heex +++ b/lib/plausible_web/templates/site/settings_shields.html.heex @@ -14,4 +14,11 @@ "domain" => @site.domain } ) %> + <% "pages" -> %> + <%= live_render(@conn, PlausibleWeb.Live.Shields.Pages, + session: %{ + "site_id" => @site.id, + "domain" => @site.domain + } + ) %> <% end %> diff --git a/lib/plausible_web/views/layout_view.ex b/lib/plausible_web/views/layout_view.ex index 0b587379d..dad3cb9ae 100644 --- a/lib/plausible_web/views/layout_view.ex +++ b/lib/plausible_web/views/layout_view.ex @@ -65,10 +65,15 @@ defmodule PlausibleWeb.LayoutView do %{ key: "Shields", icon: :shield_exclamation, - value: [ - %{key: "IP Addresses", value: "shields/ip_addresses"}, - %{key: "Countries", value: "shields/countries"} - ] + value: + [ + %{key: "IP Addresses", value: "shields/ip_addresses"}, + %{key: "Countries", value: "shields/countries"}, + if FunWithFlags.enabled?(:shield_pages, for: conn.assigns[:site]) do + %{key: "Pages", value: "shields/pages"} + end + ] + |> Enum.reject(&is_nil/1) }, %{key: "Email Reports", value: "email-reports", icon: :envelope}, if conn.assigns[:current_user_role] == :owner do diff --git a/priv/repo/seeds.exs b/priv/repo/seeds.exs index e1b499f76..da7b842d9 100644 --- a/priv/repo/seeds.exs +++ b/priv/repo/seeds.exs @@ -11,6 +11,7 @@ # and so on) as they will fail if something goes wrong. FunWithFlags.enable(:imports_exports) +FunWithFlags.enable(:shield_pages) user = Plausible.Factory.insert(:user, email: "user@plausible.test", password: "plausible") diff --git a/test/plausible/ingestion/event_test.exs b/test/plausible/ingestion/event_test.exs index b6627d8bc..8714e0848 100644 --- a/test/plausible/ingestion/event_test.exs +++ b/test/plausible/ingestion/event_test.exs @@ -158,6 +158,25 @@ defmodule Plausible.Ingestion.EventTest do assert dropped.drop_reason == :site_country_blocklist end + test "event pipeline drops a request when page is on blocklist" do + site = insert(:site) + + payload = %{ + name: "pageview", + url: "http://dummy.site/blocked/page", + domain: site.domain + } + + conn = build_conn(:post, "/api/events", payload) + + {:ok, _} = Plausible.Shields.add_page_rule(site, %{"page_path" => "/blocked/**"}) + + assert {:ok, request} = Request.build(conn) + + assert {:ok, %{buffered: [], dropped: [dropped]}} = Event.build_and_buffer(request) + assert dropped.drop_reason == :site_page_blocklist + end + test "event pipeline drops events for site with accept_trafic_until in the past" do yesterday = Date.add(Date.utc_today(), -1) diff --git a/test/plausible/shield/page_rule_cache_test.exs b/test/plausible/shield/page_rule_cache_test.exs new file mode 100644 index 000000000..ba26f3cf9 --- /dev/null +++ b/test/plausible/shield/page_rule_cache_test.exs @@ -0,0 +1,107 @@ +defmodule Plausible.Shield.PageRuleCacheTest do + use Plausible.DataCase, async: true + + alias Plausible.Shield.PageRule + alias Plausible.Shield.PageRuleCache + alias Plausible.Shields + + describe "public cache interface" do + test "cache caches page rules", %{test: test} do + cache_opts = [force?: true, cache_name: test] + + {:ok, _} = + Supervisor.start_link( + [ + {PageRuleCache, + [cache_name: test, child_id: :page_rules_cache_id, ets_options: [:bag]]} + ], + strategy: :one_for_one, + name: :"cache_supervisor_#{test}" + ) + + site1 = insert(:site) + site2 = insert(:site) + + {:ok, %{id: rid1}} = Shields.add_page_rule(site1, %{"page_path" => "/test/1"}) + {:ok, %{id: rid2}} = Shields.add_page_rule(site1, %{"page_path" => "/test/2"}) + {:ok, %{id: rid3}} = Shields.add_page_rule(site2, %{"page_path" => "/test/2"}) + + :ok = PageRuleCache.refresh_all(cache_name: test) + + :ok = Shields.remove_page_rule(site1, rid1) + + assert PageRuleCache.size(test) == 3 + + # the rule order should be deterministic, but with 1s timestamp sorting precision + # race conditions may happen during tests + assert rules = PageRuleCache.get(site1.domain, cache_opts) + rule_ids = Enum.map(rules, & &1.id) + assert rid1 in rule_ids + assert rid2 in rule_ids + assert length(rules) == 2 + + assert %PageRule{from_cache?: true, id: ^rid3} = + PageRuleCache.get(site2.domain, cache_opts) + + refute PageRuleCache.get("rogue.example.com", cache_opts) + end + + test "page path patterns are already compiled when fetched from cache", %{test: test} do + site = insert(:site) + + {:ok, _} = start_test_cache(test) + cache_opts = [force?: true, cache_name: test] + + {:ok, _} = Shields.add_page_rule(site, %{"page_path" => "/hello/**/world"}) + :ok = PageRuleCache.refresh_all(cache_name: test) + assert regex = PageRuleCache.get(site.domain, cache_opts).page_path_pattern + assert regex == ~r/^\/hello\/.*\/world$/ + end + + test "cache allows lookups for page paths on sites with changed domain", %{test: test} do + {:ok, _} = start_test_cache(test) + cache_opts = [force?: true, cache_name: test] + site = insert(:site, domain: "new.example.com", domain_changed_from: "old.example.com") + + {:ok, _} = Shields.add_page_rule(site, %{"page_path" => "/#{test}"}) + :ok = PageRuleCache.refresh_all(cache_name: test) + + assert PageRuleCache.get("old.example.com", cache_opts) + assert PageRuleCache.get("new.example.com", cache_opts) + refute PageRuleCache.get("rogue.example.com", cache_opts) + end + + test "refreshes only recently added pages rules", %{test: test} do + {:ok, _} = start_test_cache(test) + + domain = "site1.example.com" + site = insert(:site, domain: domain) + + cache_opts = [cache_name: test, force?: true] + + yesterday = + NaiveDateTime.utc_now() + |> NaiveDateTime.add(-1 * 60 * 60 * 24) + |> NaiveDateTime.truncate(:second) + + {:ok, r1} = Plausible.Shields.add_page_rule(site, %{"page_path" => "/test/1"}) + Ecto.Changeset.change(r1, inserted_at: yesterday, updated_at: yesterday) |> Repo.update!() + {:ok, _} = Plausible.Shields.add_page_rule(site, %{"page_path" => "/test/2"}) + + assert PageRuleCache.get(domain, cache_opts) == nil + + assert :ok = PageRuleCache.refresh_updated_recently(cache_opts) + + assert %{page_path_pattern: ~r[^/test/2$]} = PageRuleCache.get(domain, cache_opts) + + assert :ok = PageRuleCache.refresh_all(cache_opts) + + assert [_, _] = PageRuleCache.get(domain, cache_opts) + end + end + + defp start_test_cache(cache_name) do + %{start: {m, f, a}} = PageRuleCache.child_spec(cache_name: cache_name, ets_options: [:bag]) + apply(m, f, a) + end +end diff --git a/test/plausible/shields_test.exs b/test/plausible/shields_test.exs index c39da4587..e69de29bb 100644 --- a/test/plausible/shields_test.exs +++ b/test/plausible/shields_test.exs @@ -1,270 +0,0 @@ -defmodule Plausible.ShieldsTest do - use Plausible.DataCase - import Plausible.Shields - - setup do - site = insert(:site) - {:ok, %{site: site}} - end - - describe "add_ip_rule/2" do - test "no input", %{site: site} do - assert {:error, changeset} = add_ip_rule(site, %{}) - assert changeset.errors == [inet: {"can't be blank", [validation: :required]}] - refute changeset.valid? - end - - test "unsupported netmask", %{site: site} do - assert {:error, changeset} = add_ip_rule(site, %{"inet" => "127.0.0.0/24"}) - assert changeset.errors == [inet: {"netmask unsupported", []}] - refute changeset.valid? - assert {:ok, _} = add_ip_rule(site, %{"inet" => "127.0.0.0/32"}) - end - - test "incorrect ip", %{site: site} do - assert {:error, changeset} = add_ip_rule(site, %{"inet" => "999.999.999.999"}) - - assert changeset.errors == [ - inet: {"is invalid", [{:type, EctoNetwork.INET}, {:validation, :cast}]} - ] - - refute changeset.valid? - end - - test "non-strict IPs", %{site: site} do - assert {:error, _} = add_ip_rule(site, %{"inet" => "111"}) - end - - test "double insert", %{site: site} do - assert {:ok, _} = add_ip_rule(site, %{"inet" => "0.0.0.111"}) - assert {:error, changeset} = add_ip_rule(site, %{"inet" => "0.0.0.111"}) - refute changeset.valid? - - assert changeset.errors == [ - inet: - {"has already been taken", - [ - {:constraint, :unique}, - {:constraint_name, "shield_rules_ip_site_id_inet_index"} - ]} - ] - end - - test "ipv6", %{site: site} do - assert {:ok, rule} = - add_ip_rule(site, %{"inet" => "2001:0000:130F:0000:0000:09C0:876A:130B"}) - - assert ^rule = Repo.get(Plausible.Shield.IPRule, rule.id) - end - - test "ipv4", %{site: site} do - assert {:ok, rule} = - add_ip_rule(site, %{"inet" => "1.1.1.1"}) - - assert ^rule = Repo.get(Plausible.Shield.IPRule, rule.id) - end - - test "over limit", %{site: site} do - for i <- 1..maximum_ip_rules() do - assert {:ok, _} = - add_ip_rule(site, %{"inet" => "1.1.1.#{i}"}) - end - - assert count_ip_rules(site) == maximum_ip_rules() - - assert {:error, changeset} = - add_ip_rule(site, %{"inet" => "1.1.1.31"}) - - refute changeset.valid? - assert changeset.errors == [inet: {"maximum reached", []}] - end - - test "with added_by", %{site: site} do - assert {:ok, rule} = - add_ip_rule(site, %{"inet" => "1.1.1.1"}, - added_by: build(:user, name: "Joe", email: "joe@example.com") - ) - - assert rule.added_by == "Joe " - end - end - - describe "remove_ip_rule/2" do - test "is idempontent", %{site: site} do - {:ok, rule} = add_ip_rule(site, %{"inet" => "127.0.0.1"}) - assert remove_ip_rule(site, rule.id) == :ok - refute Repo.get(Plausible.Shield.IPRule, rule.id) - assert remove_ip_rule(site, rule.id) == :ok - end - end - - describe "list_ip_rules/1" do - test "empty", %{site: site} do - assert(list_ip_rules(site) == []) - end - - @tag :slow - test "many", %{site: site} do - {:ok, r1} = add_ip_rule(site, %{"inet" => "127.0.0.1"}) - :timer.sleep(1000) - {:ok, r2} = add_ip_rule(site, %{"inet" => "127.0.0.2"}) - assert [^r2, ^r1] = list_ip_rules(site) - end - end - - describe "count_ip_rules/1" do - test "counts", %{site: site} do - assert count_ip_rules(site) == 0 - {:ok, _} = add_ip_rule(site, %{"inet" => "127.0.0.1"}) - assert count_ip_rules(site) == 1 - {:ok, _} = add_ip_rule(site, %{"inet" => "127.0.0.2"}) - assert count_ip_rules(site) == 2 - end - end - - describe "IP Rules" do - test "end to end", %{site: site} do - site2 = insert(:site) - - assert count_ip_rules(site.id) == 0 - assert list_ip_rules(site.id) == [] - - assert {:ok, rule} = - add_ip_rule(site.id, %{"inet" => "127.0.0.1", "description" => "Localhost"}) - - add_ip_rule(site2, %{"inet" => "127.0.0.1", "description" => "Localhost"}) - - assert count_ip_rules(site) == 1 - assert [^rule] = list_ip_rules(site) - assert rule.inet == %Postgrex.INET{address: {127, 0, 0, 1}, netmask: 32} - assert rule.description == "Localhost" - assert rule.action == :deny - refute rule.from_cache? - end - end - - describe "add_country_rule/2" do - test "no input", %{site: site} do - assert {:error, changeset} = add_country_rule(site, %{}) - assert changeset.errors == [country_code: {"can't be blank", [validation: :required]}] - refute changeset.valid? - end - - test "unsupported country", %{site: site} do - assert {:error, changeset} = add_country_rule(site, %{"country_code" => "0X"}) - assert changeset.errors == [country_code: {"is invalid", []}] - refute changeset.valid? - end - - test "incorrect country format", %{site: site} do - assert {:error, changeset} = add_country_rule(site, %{"country_code" => "Germany"}) - - assert changeset.errors == - [ - {:country_code, {"is invalid", []}}, - {:country_code, - {"should be %{count} character(s)", - [count: 2, validation: :length, kind: :is, type: :string]}} - ] - - refute changeset.valid? - end - - test "double insert", %{site: site} do - assert {:ok, _} = add_country_rule(site, %{"country_code" => "EE"}) - assert {:error, changeset} = add_country_rule(site, %{"country_code" => "EE"}) - refute changeset.valid? - - assert changeset.errors == [ - country_code: - {"has already been taken", - [ - {:constraint, :unique}, - {:constraint_name, "shield_rules_country_site_id_country_code_index"} - ]} - ] - end - - test "over limit", %{site: site} do - country_codes = - Location.Country.all() - |> Enum.take(Plausible.Shields.maximum_country_rules()) - |> Enum.map(& &1.alpha_2) - - for cc <- country_codes do - assert {:ok, _} = - add_country_rule(site, %{"country_code" => cc}) - end - - assert count_country_rules(site) == maximum_country_rules() - - assert {:error, changeset} = - add_country_rule(site, %{"country_code" => "US"}) - - refute changeset.valid? - assert changeset.errors == [country_code: {"maximum reached", []}] - end - - test "with added_by", %{site: site} do - assert {:ok, rule} = - add_country_rule(site, %{"country_code" => "EE"}, - added_by: build(:user, name: "Joe", email: "joe@example.com") - ) - - assert rule.added_by == "Joe " - end - end - - describe "remove_country_rule/2" do - test "is idempontent", %{site: site} do - {:ok, rule} = add_country_rule(site, %{"country_code" => "EE"}) - assert remove_country_rule(site, rule.id) == :ok - refute Repo.get(Plausible.Shield.CountryRule, rule.id) - assert remove_country_rule(site, rule.id) == :ok - end - end - - describe "list_country_rules/1" do - test "empty", %{site: site} do - assert(list_country_rules(site) == []) - end - - @tag :slow - test "many", %{site: site} do - {:ok, r1} = add_country_rule(site, %{"country_code" => "EE"}) - :timer.sleep(1000) - {:ok, r2} = add_country_rule(site, %{"country_code" => "PL"}) - assert [^r2, ^r1] = list_country_rules(site) - end - end - - describe "count_country_rules/1" do - test "counts", %{site: site} do - assert count_country_rules(site) == 0 - {:ok, _} = add_country_rule(site, %{"country_code" => "EE"}) - assert count_country_rules(site) == 1 - {:ok, _} = add_country_rule(site, %{"country_code" => "PL"}) - assert count_country_rules(site) == 2 - end - end - - describe "Country Rules" do - test "end to end", %{site: site} do - site2 = insert(:site) - - assert count_country_rules(site.id) == 0 - assert list_country_rules(site.id) == [] - - assert {:ok, rule} = - add_country_rule(site.id, %{"country_code" => "EE"}) - - add_country_rule(site2, %{"country_code" => "PL"}) - - assert count_country_rules(site) == 1 - assert [^rule] = list_country_rules(site) - assert rule.country_code == "EE" - assert rule.action == :deny - refute rule.from_cache? - end - end -end diff --git a/test/plausible_web/live/shields/ip_addresses_test.exs b/test/plausible_web/live/shields/ip_addresses_test.exs index fd11a431d..16a4f2b1a 100644 --- a/test/plausible_web/live/shields/ip_addresses_test.exs +++ b/test/plausible_web/live/shields/ip_addresses_test.exs @@ -95,7 +95,7 @@ defmodule PlausibleWeb.Live.Shields.IPAddressesTest do assert element_exists?(html, ~s/a[phx-click="prefill-own-ip-rule"]/) end - test "form modal does not contains link to add own IP if already added", %{ + test "form modal does not contain link to add own IP if already added", %{ site: site, conn: conn } do diff --git a/test/plausible_web/live/shields/pages_test.exs b/test/plausible_web/live/shields/pages_test.exs new file mode 100644 index 000000000..7f89456a8 --- /dev/null +++ b/test/plausible_web/live/shields/pages_test.exs @@ -0,0 +1,176 @@ +defmodule PlausibleWeb.Live.Shields.PagesTest do + use PlausibleWeb.ConnCase, async: true + + import Phoenix.LiveViewTest + import Plausible.Test.Support.HTML + + alias Plausible.Shields + + setup [:create_user, :create_site, :log_in] + + describe "Page Rules - static" do + test "renders page rules page with empty list", %{conn: conn, site: site} do + conn = get(conn, "/#{site.domain}/settings/shields/pages") + resp = html_response(conn, 200) + + assert resp =~ "No Page Rules configured for this Site" + assert resp =~ "Pages Block List" + end + + test "lists page rules with remove actions", %{conn: conn, site: site} do + {:ok, r1} = + Shields.add_page_rule(site, %{"page_path" => "/test/1"}) + + {:ok, r2} = + Shields.add_page_rule(site, %{"page_path" => "/test/2"}) + + conn = get(conn, "/#{site.domain}/settings/shields/pages") + resp = html_response(conn, 200) + + assert resp =~ "/test/1" + assert resp =~ "/test/2" + + assert remove_button_1 = find(resp, "#remove-page-rule-#{r1.id}") + assert remove_button_2 = find(resp, "#remove-page-rule-#{r2.id}") + + assert text_of_attr(remove_button_1, "phx-click" == "remove-page-rule") + assert text_of_attr(remove_button_1, "phx-value-rule-id" == r1.id) + assert text_of_attr(remove_button_2, "phx-click" == "remove-page-rule") + assert text_of_attr(remove_button_2, "phx-value-rule-id" == r2.id) + end + + test "add rule button is rendered", %{conn: conn, site: site} do + conn = get(conn, "/#{site.domain}/settings/shields/pages") + resp = html_response(conn, 200) + + assert element_exists?(resp, ~s/button#add-page-rule[x-data]/) + attr = text_of_attr(resp, ~s/button#add-page-rule/, "x-on:click") + + assert attr =~ "open-modal" + assert attr =~ "page-rule-form-modal" + end + + test "add rule button is not rendered when maximum reached", %{conn: conn, site: site} do + for i <- 1..Shields.maximum_page_rules() do + assert {:ok, _} = + Shields.add_page_rule(site, %{"page_path" => "/test/#{i}"}) + end + + conn = get(conn, "/#{site.domain}/settings/shields/pages") + resp = html_response(conn, 200) + + refute element_exists?(resp, ~s/button#add-page-rule[x-data]/) + assert resp =~ "Maximum number of pages reached" + assert resp =~ "You've reached the maximum number of pages you can block (30)" + end + end + + describe "Page Rules - LiveView" do + test "modal contains form", %{site: site, conn: conn} do + lv = get_liveview(conn, site) + html = render(lv) + + assert element_exists?( + html, + ~s/form[phx-submit="save-page-rule"] input[name="page_rule\[page_path\]"]/ + ) + + assert submit_button(html, ~s/form[phx-submit="save-page-rule"]/) + end + + test "submitting a valid Page saves it", %{conn: conn, site: site} do + lv = get_liveview(conn, site) + + lv + |> element("form") + |> render_submit(%{ + "page_rule[page_path]" => "/test/**" + }) + + html = render(lv) + + assert html =~ "/test/**" + + assert [%{page_path: "/test/**"}] = Shields.list_page_rules(site) + end + + test "submitting invalid Page renders error", %{conn: conn, site: site} do + lv = get_liveview(conn, site) + + lv + |> element("form") + |> render_submit(%{ + "page_rule[page_path]" => "WRONG" + }) + + html = render(lv) + assert html =~ "must start with /" + end + + test "clicking Remove deletes the rule", %{conn: conn, site: site} do + {:ok, _} = + Shields.add_page_rule(site, %{"page_path" => "/test/*/page"}) + + lv = get_liveview(conn, site) + + html = render(lv) + assert html =~ "/test/*/page" + + lv |> element(~s/button[phx-click="remove-page-rule"]/) |> render_click() + + html = render(lv) + refute html =~ "/test/*/page" + + assert Shields.count_page_rules(site) == 0 + end + + test "conclicting rules are annotated with a warning", %{conn: conn, site: site} do + lv = get_liveview(conn, site) + + lv + |> element("form") + |> render_submit(%{ + "page_rule[page_path]" => "/test/*" + }) + + html = render(lv) + refute html =~ "This rule might be redundant" + + lv + |> element("form") + |> render_submit(%{ + "page_rule[page_path]" => "/test/another" + }) + + html = render(lv) + + assert html =~ "/test/*" + assert html =~ "/test/another" + + assert html =~ + "This rule might be redundant because the following rules may match first:\n\n/test/*" + + broader_rule_id = + site + |> Shields.list_page_rules() + |> Enum.find(&(&1.page_path == "/test/*")) + |> Map.fetch!(:id) + + lv |> element(~s/button#remove-page-rule-#{broader_rule_id}/) |> render_click() + html = render(lv) + + assert html =~ "/test/another" + refute html =~ "/test/*" + + refute html =~ + "This rule might be redundant because the following rules may match first:\n\n/test/*" + end + + defp get_liveview(conn, site) do + conn = assign(conn, :live_module, PlausibleWeb.Live.Shields) + {:ok, lv, _html} = live(conn, "/#{site.domain}/settings/shields/pages") + + lv + end + end +end diff --git a/test/test_helper.exs b/test/test_helper.exs index 75e431245..78171693a 100644 --- a/test/test_helper.exs +++ b/test/test_helper.exs @@ -3,6 +3,7 @@ Mox.defmock(Plausible.HTTPClient.Mock, for: Plausible.HTTPClient.Interface) Application.ensure_all_started(:double) FunWithFlags.enable(:window_time_on_page) FunWithFlags.enable(:imports_exports) +FunWithFlags.enable(:shield_pages) Ecto.Adapters.SQL.Sandbox.mode(Plausible.Repo, :manual) if Mix.env() == :small_test do