| defmodule Plausible.Stats.Query.QueryParseAndBuildTest do |
| use Plausible.DataCase |
| import Plausible.AssertMatches |
|
|
| alias Plausible.Stats.{Query, DateTimeRange, Filters, QueryError} |
|
|
| @now DateTime.new!(~D[2021-05-05], ~T[12:30:00], "Etc/UTC") |
| @date_range_today %DateTimeRange{ |
| first: DateTime.new!(~D[2021-05-05], ~T[00:00:00], "Etc/UTC"), |
| last: @now |
| } |
| @date_range_day %DateTimeRange{ |
| first: DateTime.new!(~D[2021-05-05], ~T[00:00:00], "Etc/UTC"), |
| last: DateTime.new!(~D[2021-05-05], ~T[23:59:59], "Etc/UTC") |
| } |
| @date_range_7d %DateTimeRange{ |
| first: DateTime.new!(~D[2021-04-28], ~T[00:00:00], "Etc/UTC"), |
| last: DateTime.new!(~D[2021-05-04], ~T[23:59:59], "Etc/UTC") |
| } |
| @date_range_10d %DateTimeRange{ |
| first: DateTime.new!(~D[2021-04-25], ~T[00:00:00], "Etc/UTC"), |
| last: DateTime.new!(~D[2021-05-04], ~T[23:59:59], "Etc/UTC") |
| } |
| @date_range_30d %DateTimeRange{ |
| first: DateTime.new!(~D[2021-04-05], ~T[00:00:00], "Etc/UTC"), |
| last: DateTime.new!(~D[2021-05-04], ~T[23:59:59], "Etc/UTC") |
| } |
| @date_range_month %DateTimeRange{ |
| first: DateTime.new!(~D[2021-05-01], ~T[00:00:00], "Etc/UTC"), |
| last: DateTime.new!(~D[2021-05-31], ~T[23:59:59], "Etc/UTC") |
| } |
| @date_range_3mo %DateTimeRange{ |
| first: DateTime.new!(~D[2021-02-01], ~T[00:00:00], "Etc/UTC"), |
| last: DateTime.new!(~D[2021-04-30], ~T[23:59:59], "Etc/UTC") |
| } |
| @date_range_6mo %DateTimeRange{ |
| first: DateTime.new!(~D[2020-11-01], ~T[00:00:00], "Etc/UTC"), |
| last: DateTime.new!(~D[2021-04-30], ~T[23:59:59], "Etc/UTC") |
| } |
| @date_range_year %DateTimeRange{ |
| first: DateTime.new!(~D[2021-01-01], ~T[00:00:00], "Etc/UTC"), |
| last: DateTime.new!(~D[2021-12-31], ~T[23:59:59], "Etc/UTC") |
| } |
| @date_range_12mo %DateTimeRange{ |
| first: DateTime.new!(~D[2020-05-01], ~T[00:00:00], "Etc/UTC"), |
| last: DateTime.new!(~D[2021-04-30], ~T[23:59:59], "Etc/UTC") |
| } |
|
|
| @default_include %Plausible.Stats.QueryInclude{ |
| imports: false, |
| imports_meta: false, |
| time_labels: false, |
| total_rows: false, |
| compare: nil, |
| compare_match_day_of_week: false, |
| legacy_time_on_page_cutoff: nil, |
| trim_relative_date_range: false |
| } |
|
|
| setup [:create_user, :create_site] |
|
|
| def check_goals(query, opts) do |
| assert %Query{ |
| preloaded_goals: preloaded_goals, |
| revenue_warning: revenue_warning, |
| revenue_currencies: revenue_currencies |
| } = query |
|
|
| assert goal_names(preloaded_goals[:all]) == |
| Enum.sort(Keyword.get(opts, :preloaded_goals)[:all]) |
|
|
| assert goal_names(preloaded_goals[:matching_toplevel_filters]) == |
| Enum.sort(Keyword.get(opts, :preloaded_goals)[:matching_toplevel_filters]) |
|
|
| assert revenue_warning == Keyword.get(opts, :revenue_warning) |
| assert revenue_currencies == Keyword.get(opts, :revenue_currencies) |
| end |
|
|
| defp goal_names(goals), do: Enum.map(goals, & &1.display_name) |> Enum.sort() |
|
|
| describe "metrics" do |
| test "public API does not recognize exit_rate metric", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["exit_rate"], |
| "date_range" => "all" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error =~ "Invalid metric" |
| end |
|
|
| test "public API does not recognize total_visitors metric", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_visitors"], |
| "date_range" => "all" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error =~ "Invalid metric" |
| end |
|
|
| test "valid metrics passed", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => "all" |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "fuller list of metrics", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => [ |
| "visitors", |
| "pageviews", |
| "visits", |
| "events", |
| "bounce_rate", |
| "visit_duration" |
| ], |
| "date_range" => "all" |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [ |
| :visitors, |
| :pageviews, |
| :visits, |
| :events, |
| :bounce_rate, |
| :visit_duration |
| ], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "same metric queried multiple times", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["events", "visitors", "visitors"], |
| "date_range" => "all" |
| } |
|
|
| assert {:error, |
| %QueryError{ |
| code: :failed_schema_validation, |
| message: "#/metrics: Expected items to be unique but they were not." |
| }} = |
| Query.parse_and_build(site, params, now: @now) |
| end |
|
|
| test "no metrics passed", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => [], |
| "date_range" => "all" |
| } |
|
|
| assert {:error, |
| %QueryError{ |
| code: :failed_schema_validation, |
| message: "#/metrics: Expected a minimum of 1 items but got 0." |
| }} = |
| Query.parse_and_build(site, params, now: @now) |
| end |
| end |
|
|
| describe "filters validation" do |
| for operation <- [ |
| :is, |
| :is_not, |
| :matches, |
| :matches_not, |
| :contains, |
| :contains_not |
| ] do |
| test "#{operation} filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| [Atom.to_string(unquote(operation)), "event:name", ["foo"]] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [^unquote(operation), "event:name", ["foo"]] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "#{operation} filter with invalid clause", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| [Atom.to_string(unquote(operation)), "event:name", "foo"] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "#/filters/0: Invalid filter [\"#{unquote(operation)}\", \"event:name\", \"foo\"]" |
| end |
| end |
|
|
| for operation <- [:matches_wildcard, :matches_wildcard_not] do |
| test "#{operation} is not a valid filter operation in public API", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| [Atom.to_string(unquote(operation)), "event:name", ["foo"]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "#/filters/0: Invalid filter [\"#{unquote(operation)}\", \"event:name\", [\"foo\"]]" |
| end |
| end |
|
|
| for too_short_filter <- [ |
| [], |
| ["and"], |
| ["or"], |
| ["and", []], |
| ["or", []], |
| ["not"], |
| ["is_not"], |
| ["is_not", "event:name"], |
| ["has_done"], |
| ["has_not_done"] |
| ] do |
| test "errors on too short filter #{inspect(too_short_filter)}", %{ |
| site: site |
| } do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| unquote(too_short_filter) |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == ~s(#/filters/0: Invalid filter #{inspect(unquote(too_short_filter))}) |
| end |
| end |
|
|
| valid_filter = ["is", "event:props:foobar", ["value"]] |
|
|
| for too_long_filter <- [ |
| ["and", [valid_filter], "extra"], |
| ["or", [valid_filter], []], |
| ["not", valid_filter, 1], |
| Enum.concat(valid_filter, [true]) |
| ] do |
| test "errors on too long filter #{inspect(too_long_filter)}", %{ |
| site: site |
| } do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| unquote(too_long_filter) |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == ~s(#/filters/0: Invalid filter #{inspect(unquote(too_long_filter))}) |
| end |
| end |
|
|
| test "filtering by invalid operation", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["exists?", "event:name", ["foo"]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/filters/0: Invalid filter [\"exists?\", \"event:name\", [\"foo\"]]" |
| end |
|
|
| test "filtering by custom properties", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is", "event:props:foobar", ["value"]] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:is, "event:props:foobar", ["value"]] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| for dimension <- Filters.event_props() do |
| if dimension != "goal" do |
| test "filtering by event:#{dimension} filter", %{site: site} do |
| prefixed_dimension = "event:#{unquote(dimension)}" |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is", prefixed_dimension, ["foo"]] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:is, ^prefixed_dimension, ["foo"]] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
| end |
| end |
|
|
| for dimension <- Filters.visit_props() do |
| test "filtering by visit:#{dimension} filter", %{site: site} do |
| prefixed_dimension = "visit:#{unquote(dimension)}" |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is", prefixed_dimension, ["ab"]] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:is, ^prefixed_dimension, ["ab"]] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
| end |
|
|
| test "invalid event filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is", "event:device", ["foo"]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/filters/0: Invalid filter [\"is\", \"event:device\", [\"foo\"]]" |
| end |
|
|
| test "invalid visit filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is", "visit:name", ["foo"]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/filters/0: Invalid filter [\"is\", \"visit:name\", [\"foo\"]]" |
| end |
|
|
| test "invalid filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => "foobar" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/filters: Type mismatch. Expected Array but got String." |
| end |
|
|
| test "numeric filter is invalid", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "visit:os_version", [123]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "Invalid filter '[\"is\", \"visit:os_version\", [123]]'." |
| end |
|
|
| test "numbers are valid for visit:city", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "visit:city", [123, 456]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:is, "visit:city", [123, 456]] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "strings are valid for visit:city", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "visit:city", ["123", "456"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:is, "visit:city", ["123", "456"]] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "invalid visit:country filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "visit:country", ["USA"]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid visit:country filter, visit:country needs to be a valid 2-letter country code." |
| end |
|
|
| test "valid nested `not`, `and` and `or`", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| [ |
| "or", |
| [ |
| [ |
| "and", |
| [ |
| ["is", "visit:city_name", ["Tallinn"]], |
| ["is", "visit:country_name", ["Estonia"]] |
| ] |
| ], |
| ["not", ["is", "visit:country_name", ["Estonia"]]] |
| ] |
| ] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [ |
| :or, |
| [ |
| [ |
| :and, |
| [ |
| [:is, "visit:city_name", ["Tallinn"]], |
| [:is, "visit:country_name", ["Estonia"]] |
| ] |
| ], |
| [:not, [:is, "visit:country_name", ["Estonia"]]] |
| ] |
| ] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "valid has_done and has_not_done filters", %{site: site} do |
| insert(:goal, %{site: site, event_name: "Signup"}) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["has_done", ["is", "event:name", ["Signup"]]], |
| [ |
| "has_not_done", |
| [ |
| "or", |
| [ |
| ["is", "event:goal", ["Signup"]], |
| ["is", "event:page", ["/signup"]] |
| ] |
| ] |
| ] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:has_done, [:is, "event:name", ["Signup"]]], |
| [ |
| :has_not_done, |
| [ |
| :or, |
| [[:is, "event:goal", ["Signup"]], [:is, "event:page", ["/signup"]]] |
| ] |
| ] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "fails when using visit filters within has_done filters", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["has_done", ["is", "visit:browser", ["Chrome"]]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid filters. Behavioral filters (has_done, has_not_done) can only be used with event dimension filters." |
| end |
|
|
| test "fails when nesting behavioral filters", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["has_done", ["has_not_done", ["is", "visit:browser", ["Chrome"]]]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid filters. Behavioral filters (has_done, has_not_done) cannot be nested." |
| end |
|
|
| for operator <- ["not", "or", "has_done", "has_not_done"] do |
| test "invalid `#{operator}` clause", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [[unquote(operator), []]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/filters/0: Invalid filter [\"#{unquote(operator)}\", []]" |
| end |
| end |
|
|
| test "event:hostname filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "event:hostname", ["a.plausible.io"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:is, "event:hostname", ["a.plausible.io"]] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "event:hostname filter not at top level is invalid", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["not", ["is", "event:hostname", ["a.plausible.io"]]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid filters. Dimension `event:hostname` can only be filtered at the top level." |
| end |
|
|
| for operation <- [:is, :contains, :is_not, :contains_not] do |
| test "#{operation} allows case_sensitive modifier", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| [ |
| Atom.to_string(unquote(operation)), |
| "event:page", |
| ["/foo"], |
| %{"case_sensitive" => false} |
| ], |
| [ |
| Atom.to_string(unquote(operation)), |
| "event:name", |
| ["/foo"], |
| %{"case_sensitive" => true} |
| ] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [ |
| ^unquote(operation), |
| "event:page", |
| ["/foo"], |
| %{case_sensitive: false} |
| ], |
| [^unquote(operation), "event:name", ["/foo"], %{case_sensitive: true}] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
| end |
|
|
| for operation <- [:matches, :matches_not] do |
| test "case_sensitive modifier is not valid for #{operation}", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| [ |
| Atom.to_string(unquote(operation)), |
| "event:hostname", |
| ["a.plausible.io"], |
| %{"case_sensitive" => false} |
| ] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "#/filters/0: Invalid filter [\"#{unquote(operation)}\", \"event:hostname\", [\"a.plausible.io\"], %{\"case_sensitive\" => false}]" |
| end |
| end |
| end |
|
|
| describe "preloading goals" do |
| setup %{site: site} do |
| insert(:goal, %{site: site, event_name: "Signup"}) |
| insert(:goal, %{site: site, event_name: "Purchase"}) |
| insert(:goal, %{site: site, event_name: "Contact"}) |
|
|
| :ok |
| end |
|
|
| test "with exact match", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "event:goal", ["Signup", "Purchase"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:goal", ["Signup", "Purchase"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Contact", "Purchase", "Signup"], |
| matching_toplevel_filters: ["Purchase", "Signup"] |
| }, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "with case insensitive match", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "event:goal", ["signup", "purchase"], %{"case_sensitive" => false}]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:is, "event:goal", ["signup", "purchase"], %{case_sensitive: false}] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Contact", "Purchase", "Signup"], |
| matching_toplevel_filters: ["Purchase", "Signup"] |
| }, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "with contains match", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["contains", "event:goal", ["Sign", "pur"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [[:contains, "event:goal", ["Sign", "pur"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Contact", "Purchase", "Signup"], |
| matching_toplevel_filters: ["Signup"] |
| }, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "with case insensitive contains match", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["contains", "event:goal", ["sign", "CONT"], %{"case_sensitive" => false}]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:contains, "event:goal", ["sign", "CONT"], %{case_sensitive: false}] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Contact", "Purchase", "Signup"], |
| matching_toplevel_filters: ["Contact", "Signup"] |
| }, |
| revenue_currencies: %{} |
| ) |
| end |
| end |
|
|
| describe "include validation" do |
| test "setting include values", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => ["time"], |
| "include" => %{"imports" => true, "time_labels" => true, "total_rows" => true} |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["time"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: %{ |
| imports: true, |
| imports_meta: false, |
| time_labels: true, |
| total_rows: true, |
| compare: nil, |
| compare_match_day_of_week: false, |
| legacy_time_on_page_cutoff: nil, |
| trim_relative_date_range: false |
| }, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "setting invalid imports value", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "include" => "foobar" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/include: Type mismatch. Expected Object but got String." |
| end |
|
|
| test "setting include.time_labels without time dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "include" => %{"time_labels" => true} |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "Invalid include.time_labels: requires a time dimension." |
| end |
| end |
|
|
| describe "pagination validation" do |
| test "setting pagination values", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => ["time"], |
| "pagination" => %{"limit" => 100, "offset" => 200} |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["time"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 100, offset: 200} |
| } = query |
| end |
|
|
| test "out of range limit value", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "pagination" => %{"limit" => 100_000} |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/pagination/limit: Expected the value to be <= 10000" |
| end |
|
|
| test "out of range offset value", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "pagination" => %{"offset" => -5} |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/pagination/offset: Expected the value to be >= 0" |
| end |
| end |
|
|
| describe "event:goal filter validation" do |
| test "valid filters", %{site: site} do |
| insert(:goal, %{site: site, event_name: "Signup"}) |
| insert(:goal, %{site: site, page_path: "/thank-you"}) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is", "event:goal", ["Signup", "Visit /thank-you"]] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:is, "event:goal", ["Signup", "Visit /thank-you"]] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Signup", "Visit /thank-you"], |
| matching_toplevel_filters: ["Signup", "Visit /thank-you"] |
| }, |
| revenue_warning: nil, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "invalid event filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is", "event:goal", ["Signup"]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid filters. The goal `Signup` is not configured for this site. Find out how to configure goals here: https://plausible.io/docs/stats-api#filtering-by-goals" |
| end |
|
|
| test "invalid page filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is", "event:goal", ["Visit /thank-you"]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid filters. The goal `Visit /thank-you` is not configured for this site. Find out how to configure goals here: https://plausible.io/docs/stats-api#filtering-by-goals" |
| end |
|
|
| test "unsupported filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is_not", "event:goal", ["Signup"]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/filters/0: Invalid filter [\"is_not\", \"event:goal\", [\"Signup\"]]" |
| end |
|
|
| test "not top-level filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| [ |
| "or", |
| [ |
| ["is", "event:goal", ["Signup"]], |
| ["is", "event:name", ["pageview"]] |
| ] |
| ] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid filters. Dimension `event:goal` can only be filtered at the top level." |
| end |
|
|
| test "allowed within behavioral filters has_done", %{site: site} do |
| insert(:goal, %{site: site, event_name: "Signup"}) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| [ |
| "has_done", |
| [ |
| "or", |
| [ |
| ["is", "event:goal", ["Signup"]], |
| ["is", "event:name", ["pageview"]] |
| ] |
| ] |
| ] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [ |
| :has_done, |
| [ |
| :or, |
| [ |
| [:is, "event:goal", ["Signup"]], |
| [:is, "event:name", ["pageview"]] |
| ] |
| ] |
| ] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{all: ["Signup"], matching_toplevel_filters: ["Signup"]}, |
| revenue_warning: nil, |
| revenue_currencies: %{} |
| ) |
| end |
| end |
|
|
| describe "date range validation" do |
| for shortcut <- ["realtime", "30m"] do |
| test "public API does not recognize #{shortcut} date_range", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => unquote(shortcut) |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error =~ "Invalid date range" |
| end |
| end |
|
|
| for {shortcut, expected_date_range} <- [ |
| {"day", @date_range_today}, |
| {"7d", @date_range_7d}, |
| {"10d", @date_range_10d}, |
| {"30d", @date_range_30d}, |
| {"month", @date_range_month}, |
| {"3mo", @date_range_3mo}, |
| {"6mo", @date_range_6mo}, |
| {"12mo", @date_range_12mo}, |
| {"year", @date_range_year} |
| ] do |
| test "parses '#{shortcut}' date_range shortcut ", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => unquote(shortcut) |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^unquote(Macro.escape(expected_date_range)), |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
| end |
|
|
| test "parsing `all` with previous data", %{site: site} do |
| site = Map.put(site, :stats_start_date, ~D[2020-01-01]) |
| expected_date_range = DateTimeRange.new!(~D[2020-01-01], ~D[2021-05-05], "Etc/UTC") |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => "all" |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^expected_date_range, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "parsing `all` with no previous data", %{site: site} do |
| site = Map.put(site, :stats_start_date, nil) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => "all" |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "parsing custom date range from simple date strings", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => ["2021-05-05", "2021-05-05"] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "parsing custom date range from iso8601 timestamps", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => ["2024-01-01T00:00:00Z", "2024-01-02T23:59:59Z"] |
| } |
|
|
| expected_utc_time_range = |
| DateTimeRange.new!( |
| DateTime.new!(~D[2024-01-01], ~T[00:00:00], "Etc/UTC"), |
| DateTime.new!(~D[2024-01-02], ~T[23:59:59], "Etc/UTC") |
| ) |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^expected_utc_time_range, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "parsing custom date range from iso8601 timestamps with non-UTC timezone", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => ["2024-08-29T07:12:34-07:00", "2024-08-29T10:12:34-07:00"] |
| } |
|
|
| expected_utc_time_range = |
| DateTimeRange.new!(~U[2024-08-29 14:12:34Z], ~U[2024-08-29 17:12:34Z]) |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^expected_utc_time_range, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| for invalid_value <- ["-1d", "foo", ["21415-00", "eee"]] do |
| test "errors on invalid date range value (#{inspect(invalid_value)})", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "date_range" => unquote(invalid_value), |
| "metrics" => ["visitors"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/date_range: Invalid date range #{inspect(unquote(invalid_value))}" |
| end |
| end |
|
|
| test "999999999mo is invalid date range", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "date_range" => "999999999mo", |
| "metrics" => ["visitors"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "Invalid date_range \"999999999mo\"" |
| end |
|
|
| test "custom date range is invalid when timestamps do not include timezone info", %{ |
| site: site |
| } do |
| params = %{ |
| "site_id" => site.domain, |
| "date_range" => ["2021-02-03T00:00:00", "2021-02-03T23:59:59"], |
| "metrics" => ["visitors"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "Invalid date_range '[\"2021-02-03T00:00:00\", \"2021-02-03T23:59:59\"]'." |
| end |
|
|
| test "custom date range is invalid when timestamp timezone is invalid", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "date_range" => ["2021-02-03T00:00:00-25:00", "2021-02-03T23:59:59-25:00"], |
| "metrics" => ["visitors"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "#/date_range: Invalid date range [\"2021-02-03T00:00:00-25:00\", \"2021-02-03T23:59:59-25:00\"]" |
| end |
|
|
| test "custom date range is invalid when date and timestamp are combined", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "date_range" => ["2021-02-03T00:00:00Z", "2021-02-04"], |
| "metrics" => ["visitors"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "#/date_range: Invalid date range [\"2021-02-03T00:00:00Z\", \"2021-02-04\"]" |
| end |
|
|
| test "parses date_range.first into a datetime right after the gap in site.timezone", %{ |
| site: site |
| } do |
| site = %{site | timezone: "America/Santiago"} |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => ["2022-09-11", "2022-09-11"] |
| } |
|
|
| expected_utc_time_range = |
| DateTimeRange.new!(~U[2022-09-11 04:00:00Z], ~U[2022-09-12 02:59:59Z]) |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^expected_utc_time_range, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "parses date_range.first into the latest of ambiguous datetimes in site.timezone", %{ |
| site: site |
| } do |
| site = %{site | timezone: "America/Havana"} |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => ["2023-11-05", "2023-11-05"] |
| } |
|
|
| expected_utc_time_range = |
| DateTimeRange.new!(~U[2023-11-05 05:00:00Z], ~U[2023-11-06 04:59:59Z]) |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^expected_utc_time_range, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "parses date_range.last into the earliest of ambiguous datetimes in site.timezone", %{ |
| site: site |
| } do |
| site = %{site | timezone: "America/Asuncion"} |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => ["2024-03-23", "2024-03-23"] |
| } |
|
|
| expected_utc_time_range = |
| DateTimeRange.new!(~U[2024-03-23 03:00:00Z], ~U[2024-03-24 02:59:59Z]) |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^expected_utc_time_range, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
| end |
|
|
| describe "dimensions validation" do |
| for dimension <- Filters.event_props() do |
| test "event:#{dimension} dimension", %{site: site} do |
| prefixed_dimension = "event:#{unquote(dimension)}" |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => [prefixed_dimension] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: [^prefixed_dimension], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
| end |
|
|
| for dimension <- Filters.visit_props() do |
| test "visit:#{dimension} dimension", %{site: site} do |
| prefixed_dimension = "visit:#{unquote(dimension)}" |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => [prefixed_dimension] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: [^prefixed_dimension], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
| end |
|
|
| test "time:minute dimension fails public schema validation", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => ["time:minute"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/dimensions/0: Invalid dimension \"time:minute\"" |
| end |
|
|
| test "custom properties dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => ["event:props:foobar"] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["event:props:foobar"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "invalid custom property dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => ["event:props:"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/dimensions/0: Invalid dimension \"event:props:\"" |
| end |
|
|
| test "invalid dimension name passed", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => ["visitors"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/dimensions/0: Invalid dimension \"visitors\"" |
| end |
|
|
| test "invalid dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => "foobar" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/dimensions: Type mismatch. Expected Array but got String." |
| end |
|
|
| test "dimensions are not unique", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => ["event:name", "event:name"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/dimensions: Expected items to be unique but they were not." |
| end |
| end |
|
|
| describe "order_by validation" do |
| test "ordering by metric", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => "all", |
| "order_by" => [["events", "desc"], ["visitors", "asc"]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: [], |
| order_by: [{:events, :desc}, {:visitors, :asc}], |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "ordering by dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => ["event:name"], |
| "order_by" => [["event:name", "desc"]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["event:name"], |
| order_by: [{"event:name", :desc}], |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "ordering by invalid value", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "order_by" => [["visssss", "desc"]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "#/order_by/0/0: Invalid value in order_by \"visssss\"" |
| end |
|
|
| test "ordering by not queried metric", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "order_by" => [["events", "desc"]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid order_by entry '{:events, :desc}'. Entry is not a queried metric or dimension." |
| end |
|
|
| test "ordering by not queried dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "order_by" => [["event:name", "desc"]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid order_by entry '{\"event:name\", :desc}'. Entry is not a queried metric or dimension." |
| end |
| end |
|
|
| describe "custom props access" do |
| test "filters - no access", %{site: site, user: user} do |
| subscribe_to_enterprise_plan(user, features: [Plausible.Billing.Feature.StatsAPI]) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["not", ["is", "event:props:foobar", ["foo"]]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "The owner of this site does not have access to the custom properties feature." |
| end |
|
|
| test "dimensions - no access", %{site: site, user: user} do |
| subscribe_to_enterprise_plan(user, features: [Plausible.Billing.Feature.StatsAPI]) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "dimensions" => ["event:props:foobar"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "The owner of this site does not have access to the custom properties feature." |
| end |
| end |
|
|
| describe "conversion_rate metric" do |
| test "fails validation on its own", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["conversion_rate"], |
| "date_range" => "all" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Metric `conversion_rate` can only be queried with event:goal filters or dimensions." |
| end |
|
|
| test "succeeds with event:goal filter", %{site: site} do |
| insert(:goal, %{site: site, event_name: "Signup"}) |
| insert(:goal, %{site: site, event_name: "Purchase", currency: "USD"}) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["conversion_rate"], |
| "date_range" => "all", |
| "filters" => [["is", "event:goal", ["Signup"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:conversion_rate], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:goal", ["Signup"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Purchase", "Signup"], |
| matching_toplevel_filters: ["Signup"] |
| }, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "succeeds with event:goal dimension", %{site: site} do |
| insert(:goal, %{site: site, event_name: "Purchase", currency: "USD"}) |
| insert(:goal, %{site: site, event_name: "Signup"}) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["conversion_rate"], |
| "date_range" => "all", |
| "dimensions" => ["event:goal"] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:conversion_rate], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["event:goal"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Purchase", "Signup"], |
| matching_toplevel_filters: ["Purchase", "Signup"] |
| }, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "custom properties filter with special metric", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["conversion_rate", "group_conversion_rate"], |
| "date_range" => "all", |
| "filters" => [["is", "event:props:foo", ["bar"]]], |
| "dimensions" => ["event:goal"] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:conversion_rate, :group_conversion_rate], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:is, "event:props:foo", ["bar"]] |
| ], |
| dimensions: ["event:goal"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "not top level custom properties filter with special metric is invalid", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["conversion_rate", "group_conversion_rate"], |
| "date_range" => "all", |
| "filters" => [["not", ["is", "event:props:foo", ["bar"]]]], |
| "dimensions" => ["event:goal"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid filters. When `conversion_rate` or `group_conversion_rate` metrics are used, custom property filters can only be used on top level." |
| end |
| end |
|
|
| describe "scroll_depth metric" do |
| test "fails validation on its own", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["scroll_depth"], |
| "date_range" => "all" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Metric `scroll_depth` can only be queried with event:page filters or dimensions." |
| end |
|
|
| test "fails with only a non-top-level event:page filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["scroll_depth"], |
| "date_range" => "all", |
| "filters" => [["not", ["is", "event:page", ["/"]]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Metric `scroll_depth` can only be queried with event:page filters or dimensions." |
| end |
|
|
| test "succeeds with top-level event:page filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["scroll_depth"], |
| "date_range" => "all", |
| "filters" => [["is", "event:page", ["/"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:scroll_depth], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:page", ["/"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "succeeds with event:page dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["scroll_depth"], |
| "date_range" => "all", |
| "dimensions" => ["event:page"] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:scroll_depth], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["event:page"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
| end |
|
|
| describe "views_per_visit metric" do |
| test "succeeds with normal filters", %{site: site} do |
| insert(:goal, %{site: site, event_name: "Signup"}) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["views_per_visit"], |
| "date_range" => "all", |
| "filters" => [["is", "event:goal", ["Signup"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:views_per_visit], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:goal", ["Signup"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{all: ["Signup"], matching_toplevel_filters: ["Signup"]}, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "fails validation if event:page filter specified", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["views_per_visit"], |
| "date_range" => "all", |
| "filters" => [["is", "event:page", ["/"]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "Metric `views_per_visit` cannot be queried with a filter on `event:page`." |
| end |
|
|
| test "fails validation with non-time dimensions", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["views_per_visit"], |
| "date_range" => "all", |
| "dimensions" => ["event:name"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "Metric `views_per_visit` cannot be queried with non-time dimensions." |
| end |
| end |
|
|
| describe "time_on_page metric" do |
| test "fails validation on its own", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["time_on_page"], |
| "date_range" => "all" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Metric `time_on_page` can only be queried with event:page filters or dimensions." |
| end |
|
|
| test "succeeds with event:page dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["time_on_page"], |
| "date_range" => "all", |
| "dimensions" => ["time", "event:page"] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:time_on_page], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["time", "event:page"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "succeeds with event:page filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["time_on_page"], |
| "date_range" => "all", |
| "filters" => [["is", "event:page", ["/"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:time_on_page], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:page", ["/"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "fails when using only a behavioral filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["time_on_page"], |
| "date_range" => "all", |
| "filters" => [ |
| ["has_done", ["is", "event:page", ["/"]]] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Metric `time_on_page` can only be queried with event:page filters or dimensions." |
| end |
| end |
|
|
| describe "revenue metrics" do |
| @describetag :ee_only |
|
|
| setup %{user: user} do |
| subscribe_to_enterprise_plan(user, features: [Plausible.Billing.Feature.RevenueGoals]) |
| :ok |
| end |
|
|
| test "can request", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_revenue", "average_revenue"], |
| "date_range" => "all" |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:total_revenue, :average_revenue], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: [], |
| matching_toplevel_filters: [] |
| }, |
| revenue_warning: :no_revenue_goals_matching, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "no access" do |
| user = new_user() |
| site = new_site(owner: user) |
|
|
| subscribe_to_enterprise_plan(user, features: [Plausible.Billing.Feature.StatsAPI]) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_revenue", "average_revenue"], |
| "date_range" => "all" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "The owner of this site does not have access to the revenue metrics feature." |
| end |
|
|
| test "with event:goal filters with same currency", %{site: site} do |
| insert(:goal, |
| site: site, |
| event_name: "Purchase", |
| currency: "USD", |
| display_name: "PurchaseUSD" |
| ) |
|
|
| insert(:goal, site: site, event_name: "Subscription", currency: "USD") |
| insert(:goal, site: site, event_name: "Signup") |
| insert(:goal, site: site, event_name: "Logout") |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_revenue", "average_revenue"], |
| "date_range" => "all", |
| "filters" => [["is", "event:goal", ["PurchaseUSD", "Signup", "Subscription"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:total_revenue, :average_revenue], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:goal", ["PurchaseUSD", "Signup", "Subscription"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["PurchaseUSD", "Signup", "Subscription", "Logout"], |
| matching_toplevel_filters: ["PurchaseUSD", "Signup", "Subscription"] |
| }, |
| revenue_warning: nil, |
| revenue_currencies: %{default: :USD} |
| ) |
| end |
|
|
| test "with event:goal filters with different currencies", %{site: site} do |
| insert(:goal, site: site, event_name: "Purchase", currency: "USD") |
| insert(:goal, site: site, event_name: "Subscription", currency: "EUR") |
| insert(:goal, site: site, event_name: "Signup") |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_revenue", "average_revenue"], |
| "date_range" => "all", |
| "filters" => [["is", "event:goal", ["Purchase", "Signup", "Subscription"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:total_revenue, :average_revenue], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:goal", ["Purchase", "Signup", "Subscription"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Purchase", "Signup", "Subscription"], |
| matching_toplevel_filters: ["Purchase", "Signup", "Subscription"] |
| }, |
| revenue_warning: :no_single_revenue_currency, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "with event:goal filters with no revenue currencies", %{site: site} do |
| insert(:goal, site: site, event_name: "Purchase", currency: "USD") |
| insert(:goal, site: site, event_name: "Subscription", currency: "EUR") |
| insert(:goal, site: site, event_name: "Signup") |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_revenue", "average_revenue"], |
| "date_range" => "all", |
| "filters" => [["is", "event:goal", ["Signup"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:total_revenue, :average_revenue], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:goal", ["Signup"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Purchase", "Subscription", "Signup"], |
| matching_toplevel_filters: ["Signup"] |
| }, |
| revenue_warning: :no_revenue_goals_matching, |
| revenue_currencies: %{} |
| ) |
| end |
|
|
| test "with event:goal dimension, different currencies", %{site: site} do |
| insert(:goal, site: site, event_name: "Purchase", currency: "USD") |
| insert(:goal, site: site, event_name: "Donation", currency: "EUR") |
| insert(:goal, site: site, event_name: "Signup") |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_revenue", "average_revenue"], |
| "date_range" => "all", |
| "dimensions" => ["event:goal"] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:total_revenue, :average_revenue], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["event:goal"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Donation", "Purchase", "Signup"], |
| matching_toplevel_filters: ["Donation", "Purchase", "Signup"] |
| }, |
| revenue_warning: nil, |
| revenue_currencies: %{"Donation" => :EUR, "Purchase" => :USD} |
| ) |
| end |
|
|
| test "with event:goal dimension and filters", %{site: site} do |
| insert(:goal, site: site, event_name: "Purchase", currency: "USD") |
| insert(:goal, site: site, event_name: "Subscription", currency: "EUR") |
| insert(:goal, site: site, event_name: "Signup") |
| insert(:goal, site: site, event_name: "Logout") |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_revenue", "average_revenue"], |
| "date_range" => "all", |
| "dimensions" => ["event:goal"], |
| "filters" => [["is", "event:goal", ["Purchase", "Signup", "Subscription"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:total_revenue, :average_revenue], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:goal", ["Purchase", "Signup", "Subscription"]]], |
| dimensions: ["event:goal"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Logout", "Purchase", "Signup", "Subscription"], |
| matching_toplevel_filters: ["Purchase", "Signup", "Subscription"] |
| }, |
| revenue_warning: nil, |
| revenue_currencies: %{"Purchase" => :USD, "Subscription" => :EUR} |
| ) |
| end |
|
|
| test "with event:goal dimension and filters with no revenue goals matching", %{ |
| site: site |
| } do |
| insert(:goal, site: site, event_name: "Purchase", currency: "USD") |
| insert(:goal, site: site, event_name: "Subscription", currency: "USD") |
| insert(:goal, site: site, event_name: "Signup") |
| insert(:goal, site: site, event_name: "Logout") |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_revenue", "average_revenue"], |
| "date_range" => "all", |
| "dimensions" => ["event:goal"], |
| "filters" => [["is", "event:goal", ["Signup"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:total_revenue, :average_revenue], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:goal", ["Signup"]]], |
| dimensions: ["event:goal"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
|
|
| check_goals(query, |
| preloaded_goals: %{ |
| all: ["Logout", "Signup", "Subscription", "Purchase"], |
| matching_toplevel_filters: ["Signup"] |
| }, |
| revenue_warning: :no_revenue_goals_matching, |
| revenue_currencies: %{} |
| ) |
| end |
| end |
|
|
| @tag :ce_build_only |
| test "revenue metrics are not available on CE", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["total_revenue", "average_revenue"], |
| "date_range" => "all" |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "#/metrics/0: Invalid metric \"total_revenue\"\n#/metrics/1: Invalid metric \"average_revenue\"" |
| end |
|
|
| describe "session metrics" do |
| test "single session metric succeeds", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["bounce_rate"], |
| "date_range" => "all", |
| "dimensions" => ["visit:device"] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:bounce_rate], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["visit:device"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "fails if using session metric with event dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["bounce_rate"], |
| "date_range" => "all", |
| "dimensions" => ["event:props:foo"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Session metric(s) `bounce_rate` cannot be queried along with event dimension(s) `event:props:foo`" |
| end |
|
|
| test "fails if using event metric with session-only dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["events"], |
| "date_range" => "all", |
| "dimensions" => ["visit:exit_page"] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Event metric(s) `events` cannot be queried along with session dimension(s) `visit:exit_page`" |
| end |
|
|
| test "does not fail if using session metric with event:page dimension", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["bounce_rate"], |
| "date_range" => "all", |
| "dimensions" => ["event:page"] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:bounce_rate], |
| utc_time_range: ^@date_range_day, |
| filters: [], |
| dimensions: ["event:page"], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "does not fail if using session metric with event filter", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["bounce_rate"], |
| "date_range" => "all", |
| "filters" => [["is", "event:props:foo", ["(none)"]]] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:bounce_rate], |
| utc_time_range: ^@date_range_day, |
| filters: [[:is, "event:props:foo", ["(none)"]]], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
| end |
|
|
| describe "filtering with segments" do |
| test "parsing fails when too many segments in query", %{ |
| user: user, |
| site: site |
| } do |
| segments = |
| insert_list(11, :segment, |
| type: :site, |
| owner: user, |
| site: site, |
| name: "any" |
| ) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [ |
| ["and", segments |> Enum.map(fn segment -> ["is", "segment", [segment.id]] end)] |
| ] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "Invalid filters. You can only use up to 10 segment filters in a query." |
| end |
|
|
| test "parsing fails when segment filter is used, but segment is from another site", %{ |
| site: site |
| } do |
| other_user = new_user() |
| other_site = new_site(owner: other_user) |
|
|
| segment = |
| insert(:segment, |
| type: :site, |
| owner: other_user, |
| site: other_site, |
| name: "any" |
| ) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "segment", [segment.id]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "Invalid filters. Some segments don't exist or aren't accessible." |
| end |
|
|
| test "hiding custom properties filters in segments doesn't allow bypasssing feature check", |
| %{ |
| site: site, |
| user: user |
| } do |
| subscribe_to_enterprise_plan(user, features: [Plausible.Billing.Feature.StatsAPI]) |
|
|
| segment = |
| insert(:segment, |
| type: :site, |
| owner: user, |
| site: site, |
| name: "segment with custom props filter", |
| segment_data: %{"filters" => [["is", "event:props:foobar", ["foo"]]]} |
| ) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "segment", [segment.id]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "The owner of this site does not have access to the custom properties feature." |
| end |
|
|
| test "querying conversion rate is illegal if the complex event:goal filter is within a segment", |
| %{ |
| site: site, |
| user: user |
| } do |
| segment = |
| insert(:segment, |
| type: :site, |
| owner: user, |
| site: site, |
| name: "any", |
| segment_data: %{ |
| "filters" => [ |
| [ |
| "or", |
| [ |
| ["is", "event:goal", ["Signup"]], |
| ["contains", "event:page", ["/"]] |
| ] |
| ] |
| ] |
| } |
| ) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "conversion_rate"], |
| "date_range" => "all", |
| "filters" => [["is", "segment", [segment.id]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == |
| "Invalid filters. Dimension `event:goal` can only be filtered at the top level." |
| end |
|
|
| test "resolves segments correctly", %{site: site, user: user} do |
| emea_segment = |
| insert(:segment, |
| type: :site, |
| owner: user, |
| site: site, |
| name: "EMEA", |
| segment_data: %{ |
| "filters" => [["is", "visit:country", ["FR", "DE"]]], |
| "labels" => %{"FR" => "France", "DE" => "Germany"} |
| } |
| ) |
|
|
| apac_segment = |
| insert(:segment, |
| type: :site, |
| owner: user, |
| site: site, |
| name: "APAC", |
| segment_data: %{ |
| "filters" => [["is", "visit:country", ["AU", "NZ"]]], |
| "labels" => %{"AU" => "Australia", "NZ" => "New Zealand"} |
| } |
| ) |
|
|
| firefox_segment = |
| insert(:segment, |
| type: :site, |
| owner: user, |
| site: site, |
| name: "APAC", |
| segment_data: %{ |
| "filters" => [ |
| ["is", "visit:browser", ["Firefox"]], |
| ["is", "visit:os", ["Linux"]] |
| ] |
| } |
| ) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => "all", |
| "filters" => [ |
| [ |
| "and", |
| [ |
| ["is", "segment", [apac_segment.id, emea_segment.id]], |
| ["is", "segment", [firefox_segment.id]] |
| ] |
| ] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [ |
| :or, |
| [ |
| [:and, [[:is, "visit:country", ["AU", "NZ"]]]], |
| [:and, [[:is, "visit:country", ["FR", "DE"]]]] |
| ] |
| ], |
| [ |
| :and, |
| [ |
| [:is, "visit:browser", ["Firefox"]], |
| [:is, "visit:os", ["Linux"]] |
| ] |
| ] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "resolves segments containing otherwise internal features", %{site: site, user: user} do |
| insert(:goal, %{site: site, event_name: "Signup"}) |
|
|
| segment_from_dashboard = |
| insert(:segment, |
| name: "A segment that contains internal features", |
| type: :site, |
| owner: user, |
| site: site, |
| segment_data: %{ |
| "filters" => [["matches_wildcard", "event:page", ["/blog/**"]]] |
| } |
| ) |
|
|
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors", "events"], |
| "date_range" => "all", |
| "filters" => [ |
| ["is", "segment", [segment_from_dashboard.id]] |
| ] |
| } |
|
|
| assert {:ok, query} = Query.parse_and_build(site, params, now: @now) |
|
|
| assert_matches %Query{ |
| metrics: [:visitors, :events], |
| utc_time_range: ^@date_range_day, |
| filters: [ |
| [:matches_wildcard, "event:page", ["/blog/**"]] |
| ], |
| dimensions: [], |
| order_by: nil, |
| timezone: ^site.timezone, |
| include: ^@default_include, |
| pagination: %{limit: 10_000, offset: 0} |
| } = query |
| end |
|
|
| test "validation fails with string segment ids", %{site: site} do |
| params = %{ |
| "site_id" => site.domain, |
| "metrics" => ["visitors"], |
| "date_range" => "all", |
| "filters" => [["is", "segment", ["123"]]] |
| } |
|
|
| assert {:error, %QueryError{message: error}} = |
| Query.parse_and_build(site, params, now: @now) |
|
|
| assert error == "Invalid filter '[\"is\", \"segment\", [\"123\"]]'." |
| end |
| end |
| end |
|
|
