Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
defmodule PlausibleWeb.Api.StatsController.MainGraphTest do
use PlausibleWeb.ConnCase
@user_id Enum.random(1000..9999)
defp do_query(conn, site, params, opts \\ []) do
now = Keyword.get(opts, :now)
conn
|> Plug.Conn.put_private(:now, now)
|> post("/api/stats/#{site.domain}/query", params)
|> json_response(200)
end
defp do_query_fail(conn, site, params) do
conn
|> post("/api/stats/#{site.domain}/query", params)
end
describe "plot" do
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
test "displays pageviews for the last 30 minutes in realtime graph", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2024-04-02 03:20:46])
])
response =
do_query(
conn,
site,
%{
"date_range" => "realtime_30m",
"metrics" => ["pageviews"],
"dimensions" => ["time:minute"],
"include" => %{"time_labels" => true}
},
now: ~U[2024-04-02 03:27:30Z]
)
%{"results" => results, "meta" => meta} = response
assert length(meta["time_labels"]) == 30
assert List.first(meta["time_labels"]) == "2024-04-02 02:57:00"
assert List.last(meta["time_labels"]) == "2024-04-02 03:26:00"
assert [%{"dimensions" => ["2024-04-02 03:20:00"], "metrics" => [1]}] = results
end
test "displays pageviews for the last 30 minutes for a non-UTC timezone site", %{
conn: conn,
site: site
} do
Plausible.Site.changeset(site, %{timezone: "Europe/Tallinn"})
|> Plausible.Repo.update()
populate_stats(site, [
build(:pageview, timestamp: ~N[2024-04-02 03:20:46])
])
response =
do_query(
conn,
site,
%{
"date_range" => "realtime_30m",
"metrics" => ["pageviews"],
"dimensions" => ["time:minute"],
"include" => %{"time_labels" => true}
},
now: ~U[2024-04-02 03:27:30Z]
)
%{"results" => results, "meta" => meta} = response
assert length(meta["time_labels"]) == 30
assert List.first(meta["time_labels"]) == "2024-04-02 05:57:00"
assert List.last(meta["time_labels"]) == "2024-04-02 06:26:00"
assert [%{"dimensions" => ["2024-04-02 06:20:00"], "metrics" => [1]}] = results
end
test "displays pageviews for a day", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 23:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "day",
"relative_date" => "2021-01-01",
"metrics" => ["pageviews"],
"dimensions" => ["time:hour"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01 00:00:00"], "metrics" => [1]},
%{"dimensions" => ["2021-01-01 23:00:00"], "metrics" => [1]}
]
end
test "returns empty plot with no native data and recently imported from ga in realtime graph",
%{conn: conn, site: site} do
populate_stats(site, [
build(:imported_visitors, date: Date.utc_today()),
build(:imported_visitors, date: Date.utc_today())
])
response =
do_query(conn, site, %{
"date_range" => "realtime_30m",
"metrics" => ["visitors"],
"dimensions" => ["time:minute"],
"include" => %{"imports" => true, "time_labels" => true}
})
assert length(response["meta"]["time_labels"]) == 30
assert response["results"] == []
end
test "imported data is not included for hourly interval", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00]),
build(:imported_visitors, date: ~D[2021-01-01]),
build(:imported_visitors, date: ~D[2021-01-31])
])
response =
do_query(conn, site, %{
"date_range" => "day",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:hour"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01 00:00:00"], "metrics" => [1]}
]
end
test "displays hourly stats in configured timezone", %{conn: conn, user: user} do
# UTC+1
site =
new_site(
domain: "tz-test.com",
owner: user,
timezone: "CET"
)
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "day",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:hour"]
})
# Expecting pageview to show at 1am CET
assert response["results"] == [
%{"dimensions" => ["2021-01-01 01:00:00"], "metrics" => [1]}
]
end
test "displays visitors for a month", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"include" => %{"time_labels" => true},
"dimensions" => ["time:day"]
})
assert length(response["meta"]["time_labels"]) == 31
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-01-31"], "metrics" => [1]}
]
end
test "displays visitors for last 28d", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-28 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "28d",
"relative_date" => "2021-01-29",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"time_labels" => true}
})
assert length(response["meta"]["time_labels"]) == 28
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-01-28"], "metrics" => [1]}
]
end
test "displays visitors for last 91d", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-16 00:00:00]),
build(:pageview, timestamp: ~N[2021-04-16 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "91d",
"relative_date" => "2021-04-17",
"metrics" => ["visitors"],
"dimensions" => ["time:day"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-16"], "metrics" => [1]},
%{"dimensions" => ["2021-04-16"], "metrics" => [1]}
]
end
test "displays visitors for a month with imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00]),
build(:imported_visitors, date: ~D[2021-01-01]),
build(:imported_visitors, date: ~D[2021-01-31])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [2]},
%{"dimensions" => ["2021-01-31"], "metrics" => [2]}
]
end
test "displays visitors for a month with only imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:imported_visitors, date: ~D[2021-01-01]),
build(:imported_visitors, date: ~D[2021-01-31])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-01-31"], "metrics" => [1]}
]
end
test "displays visitors for a month with imported data and filter", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00], pathname: "/pageA"),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00], pathname: "/pageA"),
build(:imported_visitors, date: ~D[2021-01-01]),
build(:imported_visitors, date: ~D[2021-01-31])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:page", ["/pageA"]]],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-01-31"], "metrics" => [1]}
]
end
test "displays visitors for 6 months with imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2020-12-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-05-31 00:00:00]),
build(:imported_visitors, date: ~D[2020-12-01]),
build(:imported_visitors, date: ~D[2021-05-31])
])
response =
do_query(conn, site, %{
"date_range" => "6mo",
"relative_date" => "2021-06-30",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"imports" => true, "time_labels" => true}
})
assert response["meta"]["time_labels"] == [
"2020-12-01",
"2021-01-01",
"2021-02-01",
"2021-03-01",
"2021-04-01",
"2021-05-01"
]
assert response["results"] == [
%{"dimensions" => ["2020-12-01"], "metrics" => [2]},
%{"dimensions" => ["2021-05-01"], "metrics" => [2]}
]
assert response["meta"]["time_label_result_indices"] == [0, nil, nil, nil, nil, 1]
end
test "displays visitors for 6 months with only imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:imported_visitors, date: ~D[2020-12-01]),
build(:imported_visitors, date: ~D[2021-05-31])
])
response =
do_query(conn, site, %{
"date_range" => "6mo",
"relative_date" => "2021-06-30",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2020-12-01"], "metrics" => [1]},
%{"dimensions" => ["2021-05-01"], "metrics" => [1]}
]
end
test "displays visitors for 12 months with imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2020-12-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-11-30 00:00:00]),
build(:imported_visitors, date: ~D[2020-12-01]),
build(:imported_visitors, date: ~D[2021-11-30])
])
response =
do_query(conn, site, %{
"date_range" => "12mo",
"relative_date" => "2021-12-31",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"imports" => true, "time_labels" => true}
})
assert length(response["meta"]["time_labels"]) == 12
assert response["results"] == [
%{"dimensions" => ["2020-12-01"], "metrics" => [2]},
%{"dimensions" => ["2021-11-01"], "metrics" => [2]}
]
end
test "displays visitors for 12 months with only imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:imported_visitors, date: ~D[2020-12-01]),
build(:imported_visitors, date: ~D[2021-11-30])
])
response =
do_query(conn, site, %{
"date_range" => "12mo",
"relative_date" => "2021-12-31",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"imports" => true, "time_labels" => true}
})
assert response["meta"]["time_labels"] == [
"2020-12-01",
"2021-01-01",
"2021-02-01",
"2021-03-01",
"2021-04-01",
"2021-05-01",
"2021-06-01",
"2021-07-01",
"2021-08-01",
"2021-09-01",
"2021-10-01",
"2021-11-01"
]
assert response["results"] == [
%{"dimensions" => ["2020-12-01"], "metrics" => [1]},
%{"dimensions" => ["2021-11-01"], "metrics" => [1]}
]
assert response["meta"]["time_label_result_indices"] ==
[0] ++ List.duplicate(nil, 10) ++ [1]
end
test "displays visitors for calendar year with imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-12-31 00:00:00]),
build(:imported_visitors, date: ~D[2021-01-01]),
build(:imported_visitors, date: ~D[2021-12-31])
])
response =
do_query(conn, site, %{
"date_range" => "year",
"relative_date" => "2021-12-31",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [2]},
%{"dimensions" => ["2021-12-01"], "metrics" => [2]}
]
end
test "displays visitors for calendar year with only imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:imported_visitors, date: ~D[2021-01-01]),
build(:imported_visitors, date: ~D[2021-12-31])
])
response =
do_query(conn, site, %{
"date_range" => "year",
"relative_date" => "2021-12-31",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-12-01"], "metrics" => [1]}
]
end
test "displays visitors for all time with just native data", %{conn: conn, site: site} do
use Plausible.Repo
Repo.update_all(from(s in "sites", where: s.id == ^site.id),
set: [stats_start_date: ~D[2020-01-01]]
)
populate_stats(site, [
build(:pageview, timestamp: ~N[2020-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-12-31 00:00:00])
])
response =
do_query(
conn,
site,
%{
"date_range" => "all",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"imports" => true, "time_labels" => true}
},
now: ~U[2022-03-15 10:00:00Z]
)
assert length(response["meta"]["time_labels"]) == 27
assert List.last(response["meta"]["time_labels"]) == "2022-03-01"
assert response["results"] == [
%{"dimensions" => ["2020-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-12-01"], "metrics" => [1]}
]
end
test "returns empty metrics under response.meta", %{conn: conn, site: site} do
response =
do_query(
conn,
site,
%{
"date_range" => "28d",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"empty_metrics" => true}
}
)
assert response["meta"]["empty_metrics"] == [0]
end
end
describe "default labels" do
setup [:create_user, :log_in, :create_site]
test "shows last 30 days", %{conn: conn, site: site} do
response =
do_query(conn, site, %{
"date_range" => "30d",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"time_labels" => true}
})
labels = response["meta"]["time_labels"]
first = Date.utc_today() |> Date.shift(day: -30) |> Date.to_iso8601()
last = Date.utc_today() |> Date.shift(day: -1) |> Date.to_iso8601()
assert List.first(labels) == first
assert List.last(labels) == last
end
test "shows last 7 days", %{conn: conn, site: site} do
response =
do_query(conn, site, %{
"date_range" => "7d",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"time_labels" => true}
})
labels = response["meta"]["time_labels"]
first = Date.utc_today() |> Date.shift(day: -7) |> Date.to_iso8601()
last = Date.utc_today() |> Date.shift(day: -1) |> Date.to_iso8601()
assert List.first(labels) == first
assert List.last(labels) == last
end
end
describe "pageviews plot" do
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
test "displays pageviews for a month", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["pageviews"],
"dimensions" => ["time:day"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [2]},
%{"dimensions" => ["2021-01-31"], "metrics" => [1]}
]
end
test "displays pageviews for a month with imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00]),
build(:imported_visitors, date: ~D[2021-01-01]),
build(:imported_visitors, date: ~D[2021-01-31])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["pageviews"],
"dimensions" => ["time:day"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [2]},
%{"dimensions" => ["2021-01-31"], "metrics" => [2]}
]
end
test "displays pageviews for a month with only imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:imported_visitors, date: ~D[2021-01-01]),
build(:imported_visitors, date: ~D[2021-01-31])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["pageviews"],
"dimensions" => ["time:day"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-01-31"], "metrics" => [1]}
]
end
end
describe "views_per_visit plot" do
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
test "views_per_visit for 28 days in weekly buckets (native data only)", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, user_id: 1, timestamp: ~N[2021-01-04 00:00:00]),
build(:pageview, user_id: 1, timestamp: ~N[2021-01-04 00:05:00]),
build(:pageview, user_id: 2, timestamp: ~N[2021-01-18 00:00:00]),
build(:pageview, user_id: 2, timestamp: ~N[2021-01-18 00:05:00]),
build(:pageview, user_id: 2, timestamp: ~N[2021-01-18 00:10:00])
])
response =
do_query(conn, site, %{
"date_range" => "28d",
"relative_date" => "2021-01-29",
"metrics" => ["views_per_visit"],
"dimensions" => ["time:week"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-04"], "metrics" => [2.0]},
%{"dimensions" => ["2021-01-18"], "metrics" => [3.0]}
]
end
test "views_per_visit for a year in monthly buckets (with imported data)", %{
conn: conn,
site: site
} do
populate_stats(site, [
# January 2021 - only imported
build(:imported_visitors, date: ~D[2021-01-01], visits: 6, pageviews: 7),
# March 2021 - imported + native combined
build(:imported_visitors, date: ~D[2021-03-01], visits: 1, pageviews: 4),
build(:pageview, user_id: 1, timestamp: ~N[2021-03-15 00:00:00]),
build(:pageview, user_id: 1, timestamp: ~N[2021-03-15 00:05:00]),
# September 2021 - only native
build(:pageview, user_id: 2, timestamp: ~N[2021-09-01 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "year",
"relative_date" => "2021-01-01",
"metrics" => ["views_per_visit"],
"dimensions" => ["time:month"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1.17]},
%{"dimensions" => ["2021-03-01"], "metrics" => [3.0]},
%{"dimensions" => ["2021-09-01"], "metrics" => [1.0]}
]
end
end
describe "visitors plot" do
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
test "displays visitors per hour with short visits", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-01 00:10:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-01 00:20:00])
])
response =
do_query(conn, site, %{
"date_range" => "day",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:hour"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01 00:00:00"], "metrics" => [2]}
]
end
test "displays visitors realtime with visits spanning multiple minutes", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2023-09-10 15:15:00], user_id: 1),
build(:pageview, timestamp: ~N[2023-09-10 15:30:00], user_id: 1),
build(:pageview, timestamp: ~N[2023-09-10 15:25:00], user_id: 2),
build(:pageview, timestamp: ~N[2023-09-10 15:35:00], user_id: 2),
build(:pageview, timestamp: ~N[2023-09-10 15:45:00], user_id: 3),
build(:pageview, timestamp: ~N[2023-09-10 15:47:00], user_id: 3)
])
response =
do_query(
conn,
site,
%{
"date_range" => "realtime_30m",
"metrics" => ["visitors"],
"dimensions" => ["time:minute"]
},
now: ~U[2023-09-10 15:50:01Z]
)
assert response["results"] == [
%{"dimensions" => ["2023-09-10 15:20:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:21:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:22:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:23:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:24:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:25:00"], "metrics" => [2]},
%{"dimensions" => ["2023-09-10 15:26:00"], "metrics" => [2]},
%{"dimensions" => ["2023-09-10 15:27:00"], "metrics" => [2]},
%{"dimensions" => ["2023-09-10 15:28:00"], "metrics" => [2]},
%{"dimensions" => ["2023-09-10 15:29:00"], "metrics" => [2]},
%{"dimensions" => ["2023-09-10 15:30:00"], "metrics" => [2]},
%{"dimensions" => ["2023-09-10 15:31:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:32:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:33:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:34:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:35:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:45:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:46:00"], "metrics" => [1]},
%{"dimensions" => ["2023-09-10 15:47:00"], "metrics" => [1]}
]
end
test "displays visitors per hour with visits spanning multiple hours", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2020-12-31 23:45:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-01 00:10:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-01 00:15:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-01 00:35:00], user_id: 2),
build(:pageview, timestamp: ~N[2021-01-01 01:00:00], user_id: 2),
build(:pageview, timestamp: ~N[2021-01-01 01:25:00], user_id: 2),
build(:pageview, timestamp: ~N[2021-01-01 01:50:00], user_id: 2),
build(:pageview, timestamp: ~N[2021-01-01 02:05:00], user_id: 2),
build(:pageview, timestamp: ~N[2021-01-01 23:45:00], user_id: 3),
build(:pageview, timestamp: ~N[2021-01-02 00:05:00], user_id: 3)
])
response =
do_query(conn, site, %{
"date_range" => "day",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:hour"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01 00:00:00"], "metrics" => [2]},
%{"dimensions" => ["2021-01-01 01:00:00"], "metrics" => [1]},
%{"dimensions" => ["2021-01-01 02:00:00"], "metrics" => [1]},
%{"dimensions" => ["2021-01-01 23:00:00"], "metrics" => [1]}
]
end
test "displays visitors per day with sessions being counted only in the last time bucket they were active in",
%{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2020-12-31 23:45:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-01 00:10:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-02 23:45:00], user_id: 2),
build(:pageview, timestamp: ~N[2021-01-03 00:10:00], user_id: 2),
build(:pageview, timestamp: ~N[2021-01-03 23:45:00], user_id: 3),
build(:pageview, timestamp: ~N[2021-01-04 00:10:00], user_id: 3),
build(:pageview, timestamp: ~N[2021-01-07 23:45:00], user_id: 4),
build(:pageview, timestamp: ~N[2021-01-08 00:10:00], user_id: 4)
])
response =
do_query(conn, site, %{
"date_range" => "7d",
"relative_date" => "2021-01-08",
"metrics" => ["visitors"],
"dimensions" => ["time:day"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-01-03"], "metrics" => [1]},
%{"dimensions" => ["2021-01-04"], "metrics" => [1]},
%{"dimensions" => ["2021-01-07"], "metrics" => [1]}
]
end
test "displays visitors per week with sessions being counted only in the last time bucket they were active in",
%{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2020-12-31 23:45:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-01 00:10:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-03 23:45:00], user_id: 2),
build(:pageview, timestamp: ~N[2021-01-04 00:10:00], user_id: 2),
build(:pageview, timestamp: ~N[2021-01-31 23:45:00], user_id: 3),
build(:pageview, timestamp: ~N[2021-02-01 00:05:00], user_id: 3)
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:week"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-01-04"], "metrics" => [1]},
%{"dimensions" => ["2021-01-25"], "metrics" => [1]}
]
end
end
describe "scroll_depth plot" do
setup [:create_user, :log_in, :create_site]
test "returns 400 when scroll_depth is queried without a page filter", %{
conn: conn,
site: site
} do
response =
do_query_fail(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["scroll_depth"],
"dimensions" => ["time:day"]
})
assert %{"error" => error} = json_response(response, 400)
assert error =~ "can only be queried with event:page filters or dimensions"
end
test "returns scroll depth per day", %{conn: conn, site: site} do
t0 = ~N[2020-01-01 00:00:00]
[t1, t2, t3] = for i <- 1..3, do: NaiveDateTime.add(t0, i, :minute)
populate_stats(site, [
build(:pageview, user_id: 12, timestamp: t0),
build(:engagement, user_id: 12, timestamp: t1, scroll_depth: 20),
build(:pageview, user_id: 34, timestamp: t0),
build(:engagement, user_id: 34, timestamp: t1, scroll_depth: 17),
build(:pageview, user_id: 34, timestamp: t2),
build(:engagement, user_id: 34, timestamp: t3, scroll_depth: 60),
build(:pageview, user_id: 56, timestamp: NaiveDateTime.add(t0, 1, :day)),
build(:engagement,
user_id: 56,
timestamp: NaiveDateTime.add(t1, 1, :day),
scroll_depth: 20
)
])
response =
do_query(conn, site, %{
"date_range" => "7d",
"relative_date" => "2020-01-08",
"metrics" => ["scroll_depth"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:page", ["/"]]]
})
assert response["results"] == [
%{"dimensions" => ["2020-01-01"], "metrics" => [40]},
%{"dimensions" => ["2020-01-02"], "metrics" => [20]}
]
end
test "returns scroll depth per day with imported data", %{conn: conn, site: site} do
site_import = insert(:site_import, site: site)
populate_stats(site, site_import.id, [
# 2020-01-01 - only native data
build(:pageview, user_id: 12, timestamp: ~N[2020-01-01 00:00:00]),
build(:engagement, user_id: 12, timestamp: ~N[2020-01-01 00:01:00], scroll_depth: 20),
build(:pageview, user_id: 34, timestamp: ~N[2020-01-01 00:00:00]),
build(:engagement, user_id: 34, timestamp: ~N[2020-01-01 00:01:00], scroll_depth: 17),
build(:pageview, user_id: 34, timestamp: ~N[2020-01-01 00:02:00]),
build(:engagement, user_id: 34, timestamp: ~N[2020-01-01 00:03:00], scroll_depth: 60),
# 2020-01-02 - both imported and native data
build(:pageview, user_id: 56, timestamp: ~N[2020-01-02 00:00:00]),
build(:engagement, user_id: 56, timestamp: ~N[2020-01-02 00:01:00], scroll_depth: 20),
build(:imported_pages,
date: ~D[2020-01-02],
page: "/",
visitors: 1,
total_scroll_depth: 40,
total_scroll_depth_visits: 1
),
# 2020-01-03 - only imported data
build(:imported_pages,
date: ~D[2020-01-03],
page: "/",
visitors: 1,
total_scroll_depth: 90,
total_scroll_depth_visits: 1
),
build(:imported_pages, date: ~D[2020-01-03], page: "/", visitors: 100)
])
response =
do_query(conn, site, %{
"date_range" => "7d",
"relative_date" => "2020-01-08",
"metrics" => ["scroll_depth"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:page", ["/"]]],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2020-01-01"], "metrics" => [40]},
%{"dimensions" => ["2020-01-02"], "metrics" => [30]},
%{"dimensions" => ["2020-01-03"], "metrics" => [90]}
]
end
end
describe "conversion_rate plot" do
setup [:create_user, :log_in, :create_site]
test "returns 400 when conversion rate is queried without a goal filter", %{
conn: conn,
site: site
} do
response =
do_query_fail(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["conversion_rate"],
"dimensions" => ["time:day"]
})
assert %{"error" => error} = json_response(response, 400)
assert error =~ "can only be queried with event:goal filters or dimensions"
end
test "displays conversion_rate for a month", %{conn: conn, site: site} do
insert(:goal, site: site, event_name: "Signup")
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-31 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["group_conversion_rate"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:goal", ["Signup"]]]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [33.33]},
%{"dimensions" => ["2021-01-31"], "metrics" => [50.0]}
]
end
end
describe "events (total conversions) plot" do
setup [:create_user, :log_in, :create_site]
test "displays total conversions for a goal", %{conn: conn, site: site} do
insert(:goal, site: site, event_name: "Signup")
populate_stats(site, [
build(:event, name: "Different", timestamp: ~N[2021-01-01 00:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-01 00:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00]),
build(:event, name: "Signup", user_id: 123, timestamp: ~N[2021-01-31 00:00:00]),
build(:event, name: "Signup", user_id: 123, timestamp: ~N[2021-01-31 00:00:00]),
build(:event, name: "Signup", user_id: 123, timestamp: ~N[2021-01-31 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["events"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:goal", ["Signup"]]]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [2]},
%{"dimensions" => ["2021-01-31"], "metrics" => [3]}
]
end
test "displays total conversions per hour with previous day comparison plot", %{
conn: conn,
site: site
} do
insert(:goal, site: site, event_name: "Signup")
populate_stats(site, [
build(:event, name: "Different", timestamp: ~N[2021-01-10 05:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-10 05:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-10 05:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-10 19:00:00]),
build(:pageview, timestamp: ~N[2021-01-10 19:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-11 04:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-11 05:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-11 18:00:00])
])
%{"results" => results, "comparison_results" => comparison_results} =
do_query(conn, site, %{
"date_range" => "day",
"relative_date" => "2021-01-11",
"metrics" => ["events"],
"dimensions" => ["time:hour"],
"filters" => [["is", "event:goal", ["Signup"]]],
"include" => %{"compare" => "previous_period"}
})
assert results == [
%{"dimensions" => ["2021-01-11 04:00:00"], "metrics" => [1]},
%{"dimensions" => ["2021-01-11 05:00:00"], "metrics" => [1]},
%{"dimensions" => ["2021-01-11 18:00:00"], "metrics" => [1]}
]
assert comparison_results == [
%{"dimensions" => ["2021-01-10 05:00:00"], "metrics" => [2], "change" => [-50]},
%{"dimensions" => ["2021-01-10 19:00:00"], "metrics" => [1], "change" => nil}
]
end
test "displays conversions per month with 12mo comparison plot", %{
conn: conn,
site: site
} do
insert(:goal, site: site, event_name: "Signup")
populate_stats(site, [
build(:event, name: "Different", timestamp: ~N[2019-12-10 00:00:00]),
build(:event, name: "Signup", timestamp: ~N[2020-01-10 00:00:00]),
build(:event, name: "Signup", timestamp: ~N[2020-02-10 00:00:00]),
build(:event, name: "Signup", timestamp: ~N[2020-03-10 00:00:00]),
build(:pageview, timestamp: ~N[2021-04-10 00:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-05-11 04:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-06-11 00:00:00]),
build(:event, name: "Signup", timestamp: ~N[2021-07-11 00:00:00])
])
%{"results" => results, "comparison_results" => comparison_results} =
do_query(conn, site, %{
"date_range" => "12mo",
"relative_date" => "2021-12-11",
"metrics" => ["events"],
"dimensions" => ["time:month"],
"filters" => [["is", "event:goal", ["Signup"]]],
"include" => %{"compare" => "previous_period"}
})
assert results == [
%{"dimensions" => ["2021-05-01"], "metrics" => [1]},
%{"dimensions" => ["2021-06-01"], "metrics" => [1]},
%{"dimensions" => ["2021-07-01"], "metrics" => [1]}
]
assert comparison_results == [
%{"dimensions" => ["2020-01-01"], "metrics" => [1], "change" => nil},
%{"dimensions" => ["2020-02-01"], "metrics" => [1], "change" => nil},
%{"dimensions" => ["2020-03-01"], "metrics" => [1], "change" => nil}
]
end
end
describe "bounce_rate plot" do
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
test "displays bounce_rate for a month", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-03 00:00:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-03 00:10:00], user_id: 1),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["bounce_rate"],
"dimensions" => ["time:day"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-03"], "metrics" => [0]},
%{"dimensions" => ["2021-01-31"], "metrics" => [100]}
]
end
test "displays bounce rate for a month with imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00]),
build(:imported_visitors, visits: 1, bounces: 0, date: ~D[2021-01-01]),
build(:imported_visitors, visits: 1, bounces: 1, date: ~D[2021-01-31])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["bounce_rate"],
"dimensions" => ["time:day"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [50]},
%{"dimensions" => ["2021-01-31"], "metrics" => [100]}
]
end
test "displays bounce rate for a month with only imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:imported_visitors, visits: 1, bounces: 0, date: ~D[2021-01-01]),
build(:imported_visitors, visits: 1, bounces: 1, date: ~D[2021-01-31])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["bounce_rate"],
"dimensions" => ["time:day"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [0]},
%{"dimensions" => ["2021-01-31"], "metrics" => [100]}
]
end
end
describe "visit_duration plot" do
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
test "displays visit_duration for a month", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview,
pathname: "/page3",
user_id: @user_id,
timestamp: ~N[2021-01-31 00:10:00]
),
build(:pageview,
pathname: "/page2",
user_id: @user_id,
timestamp: ~N[2021-01-31 00:15:00]
)
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["visit_duration"],
"dimensions" => ["time:day"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-31"], "metrics" => [300]}
]
end
test "displays visit_duration for a month with imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, user_id: @user_id, timestamp: ~N[2021-01-01 00:10:00]),
build(:pageview, user_id: @user_id, timestamp: ~N[2021-01-01 00:15:00]),
build(:imported_visitors, visits: 1, visit_duration: 100, date: ~D[2021-01-01])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["visit_duration"],
"dimensions" => ["time:day"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [200]}
]
end
test "displays visit_duration for a month with only imported data", %{conn: conn, site: site} do
populate_stats(site, [
build(:imported_visitors, visits: 1, visit_duration: 100, date: ~D[2021-01-01])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["visit_duration"],
"dimensions" => ["time:day"],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [100]}
]
end
end
describe "varying intervals" do
setup [:create_user, :log_in, :create_site]
test "displays visitors for 6mo on a day scale", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2020-12-01 00:00:00]),
build(:pageview, timestamp: ~N[2020-12-15 00:00:00]),
build(:pageview, timestamp: ~N[2020-12-15 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-15 00:00:00]),
build(:pageview, timestamp: ~N[2021-05-31 01:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "6mo",
"relative_date" => "2021-06-01",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"time_labels" => true}
})
assert length(response["meta"]["time_labels"]) == 182
assert response["results"] == [
%{"dimensions" => ["2020-12-01"], "metrics" => [1]},
%{"dimensions" => ["2020-12-15"], "metrics" => [2]},
%{"dimensions" => ["2021-01-15"], "metrics" => [1]},
%{"dimensions" => ["2021-05-31"], "metrics" => [1]}
]
end
test "displays visitors for a custom period on a monthly scale", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-15 00:00:00]),
build(:pageview, timestamp: ~N[2021-02-15 00:00:00]),
build(:pageview, timestamp: ~N[2021-06-01 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => ["2021-01-01", "2021-06-30"],
"metrics" => ["visitors"],
"dimensions" => ["time:month"]
})
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [2]},
%{"dimensions" => ["2021-02-01"], "metrics" => [1]},
%{"dimensions" => ["2021-06-01"], "metrics" => [1]}
]
end
test "returns error when the interval is not valid", %{
conn: conn,
site: site
} do
response =
do_query_fail(conn, site, %{
"date_range" => "day",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:biweekly"]
})
assert %{"error" => error} = json_response(response, 400)
assert error =~ "Invalid dimensions"
end
test "time:minute dimension for a complete day, including DST transition", %{
conn: conn,
site: site
} do
# On Oct 26, 2025, in Tallinn, Estonia, the clocks shifted back
# from 04:00 -> 03:00, so there were 25 hours in that day.
Plausible.Site.changeset(site, %{timezone: "Europe/Tallinn"})
|> Plausible.Repo.update!()
populate_stats(site, [
build(:pageview, timestamp: ~N[2025-10-26 01:01:01]),
build(:pageview, timestamp: ~N[2025-10-26 01:01:02]),
build(:pageview, timestamp: ~N[2025-10-26 10:02:30])
])
response =
do_query(conn, site, %{
"date_range" => "day",
"relative_date" => "2025-10-26",
"metrics" => ["pageviews"],
"dimensions" => ["time:minute"],
"include" => %{"time_labels" => true}
})
assert length(response["meta"]["time_labels"]) == 1500
assert response["results"] == [
%{"dimensions" => ["2025-10-26 03:01:00"], "metrics" => [2]},
%{"dimensions" => ["2025-10-26 12:02:00"], "metrics" => [1]}
]
end
test "time:minute dimension for last 24h", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:01:01]),
build(:pageview, timestamp: ~N[2021-01-01 00:01:02]),
build(:pageview, timestamp: ~N[2021-01-01 00:02:30])
])
response =
do_query(
conn,
site,
%{
"date_range" => "24h",
"metrics" => ["pageviews"],
"dimensions" => ["time:minute"],
"include" => %{"time_labels" => true}
},
now: ~U[2021-01-01 12:00:00Z]
)
assert length(response["meta"]["time_labels"]) == 1440
assert response["results"] == [
%{"dimensions" => ["2021-01-01 00:01:00"], "metrics" => [2]},
%{"dimensions" => ["2021-01-01 00:02:00"], "metrics" => [1]}
]
end
test "returns error when time:minute dimension is queried for a period longer than 24h", %{
conn: conn,
site: site
} do
response =
do_query_fail(conn, site, %{
"date_range" => ["2021-01-01", "2021-01-02"],
"metrics" => ["visitors"],
"dimensions" => ["time:minute"]
})
assert %{"error" => error} = json_response(response, 400)
assert error =~ "Invalid dimensions"
assert error =~ "time:minute"
end
test "displays visitors for a month on a weekly scale", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:15:01]),
build(:pageview, timestamp: ~N[2021-01-05 00:15:02])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:week"],
"include" => %{"time_labels" => true}
})
assert length(response["meta"]["time_labels"]) == 5
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [2]},
%{"dimensions" => ["2021-01-04"], "metrics" => [1]}
]
end
test "shows imperfect week-split month on week scale with partial week indicators", %{
conn: conn,
site: site
} do
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-09-01",
"metrics" => ["visitors"],
"dimensions" => ["time:week"],
"include" => %{"time_labels" => true, "partial_time_labels" => true}
})
assert response["meta"]["time_labels"] == [
"2021-09-01",
"2021-09-06",
"2021-09-13",
"2021-09-20",
"2021-09-27"
]
assert response["meta"]["partial_time_labels"] == ["2021-09-01", "2021-09-27"]
end
test "returns stats for the first week of the month when site timezone is ahead of UTC", %{
conn: conn,
site: site
} do
site =
site
|> Plausible.Site.changeset(%{timezone: "Europe/Copenhagen"})
|> Plausible.Repo.update!()
populate_stats(site, [
build(:pageview, timestamp: ~N[2023-03-01 12:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2023-03-01",
"metrics" => ["visitors"],
"dimensions" => ["time:week"],
"include" => %{"time_labels" => true}
})
assert List.first(response["meta"]["time_labels"]) == "2023-03-01"
assert response["results"] == [
%{"metrics" => [1], "dimensions" => ["2023-03-01"]}
]
end
test "shows half-perfect week-split month on week scale with partial week indicators", %{
conn: conn,
site: site
} do
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-10-01",
"metrics" => ["visitors"],
"dimensions" => ["time:week"],
"include" => %{"time_labels" => true, "partial_time_labels" => true}
})
assert response["meta"]["time_labels"] == [
"2021-10-01",
"2021-10-04",
"2021-10-11",
"2021-10-18",
"2021-10-25"
]
assert response["meta"]["partial_time_labels"] == ["2021-10-01"]
end
test "shows perfect week-split range on week scale with full week indicators for custom period",
%{
conn: conn,
site: site
} do
response =
do_query(conn, site, %{
"date_range" => ["2020-12-21", "2021-02-07"],
"metrics" => ["visitors"],
"dimensions" => ["time:week"],
"include" => %{"time_labels" => true, "partial_time_labels" => true}
})
assert response["meta"]["time_labels"] == [
"2020-12-21",
"2020-12-28",
"2021-01-04",
"2021-01-11",
"2021-01-18",
"2021-01-25",
"2021-02-01"
]
assert response["meta"]["partial_time_labels"] == []
end
test "shows imperfect week-split for last 28d with full week indicators", %{
conn: conn,
site: site
} do
response =
do_query(conn, site, %{
"date_range" => "28d",
"relative_date" => "2021-10-30",
"metrics" => ["visitors"],
"dimensions" => ["time:week"],
"include" => %{"time_labels" => true, "partial_time_labels" => true}
})
assert response["meta"]["time_labels"] == [
"2021-10-02",
"2021-10-04",
"2021-10-11",
"2021-10-18",
"2021-10-25"
]
assert response["meta"]["partial_time_labels"] == ["2021-10-02", "2021-10-25"]
end
test "shows imperfect month-split for custom period with full month indicators", %{
conn: conn,
site: site
} do
response =
do_query(conn, site, %{
"date_range" => ["2021-09-06", "2021-12-13"],
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"time_labels" => true, "partial_time_labels" => true}
})
assert response["meta"]["time_labels"] == [
"2021-09-01",
"2021-10-01",
"2021-11-01",
"2021-12-01"
]
assert response["meta"]["partial_time_labels"] == ["2021-09-01", "2021-12-01"]
end
test "shows perfect month-split for last 91d with full month indicators", %{
conn: conn,
site: site
} do
response =
do_query(conn, site, %{
"date_range" => "91d",
"relative_date" => "2021-12-01",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"time_labels" => true, "partial_time_labels" => true}
})
assert response["meta"]["time_labels"] == ["2021-09-01", "2021-10-01", "2021-11-01"]
assert response["meta"]["partial_time_labels"] == []
end
test "partial_time_labels is an empty list for time:day when all days are complete", %{
conn: conn,
site: site
} do
response =
do_query(conn, site, %{
"date_range" => "28d",
"relative_date" => "2021-01-28",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"time_labels" => true, "partial_time_labels" => true}
})
assert length(response["meta"]["time_labels"]) == 28
assert response["meta"]["partial_time_labels"] == []
end
test "returns comparison_partial_time_labels", %{
conn: conn,
site: site
} do
response =
do_query(conn, site, %{
"date_range" => ["2026-02-08", "2026-02-25"],
"metrics" => ["visitors"],
"dimensions" => ["time:week"],
"include" => %{
"time_labels" => true,
"partial_time_labels" => true,
"compare" => ["2026-01-08", "2026-01-25"]
}
})
assert response["meta"]["comparison_time_labels"] == [
"2026-01-08",
"2026-01-12",
"2026-01-19"
]
assert response["meta"]["comparison_partial_time_labels"] == ["2026-01-08"]
end
test "returns stats for a day with a minute interval", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2023-03-01 12:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "day",
"relative_date" => "2023-03-01",
"metrics" => ["visitors"],
"dimensions" => ["time:minute"],
"include" => %{"time_labels" => true}
})
labels = response["meta"]["time_labels"]
assert length(labels) == 24 * 60
assert List.first(labels) == "2023-03-01 00:00:00"
assert Enum.at(labels, 1) == "2023-03-01 00:01:00"
assert List.last(labels) == "2023-03-01 23:59:00"
assert response["results"] == [
%{"dimensions" => ["2023-03-01 12:00:00"], "metrics" => [1]}
]
end
test "trims hourly relative date range", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-08 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-08 06:05:00]),
build(:pageview, timestamp: ~N[2021-01-08 08:59:00]),
build(:pageview, timestamp: ~N[2021-01-08 23:59:00])
])
response =
do_query(
conn,
site,
%{
"date_range" => "day",
"relative_date" => "2021-01-08",
"metrics" => ["visitors"],
"dimensions" => ["time:hour"],
"include" => %{"time_labels" => true}
},
now: ~U[2021-01-08 08:05:00Z]
)
assert response["meta"]["time_labels"] == [
"2021-01-08 00:00:00",
"2021-01-08 01:00:00",
"2021-01-08 02:00:00",
"2021-01-08 03:00:00",
"2021-01-08 04:00:00",
"2021-01-08 05:00:00",
"2021-01-08 06:00:00",
"2021-01-08 07:00:00",
"2021-01-08 08:00:00"
]
assert response["results"] == [
%{"dimensions" => ["2021-01-08 00:00:00"], "metrics" => [1]},
%{"dimensions" => ["2021-01-08 06:00:00"], "metrics" => [1]},
%{"dimensions" => ["2021-01-08 08:00:00"], "metrics" => [1]}
]
end
test "trims monthly relative date range", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-05 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-07 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00])
])
response =
do_query(
conn,
site,
%{
"date_range" => "month",
"relative_date" => "2021-01-07",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"time_labels" => true}
},
now: ~U[2021-01-07 12:00:00Z]
)
assert response["meta"]["time_labels"] == [
"2021-01-01",
"2021-01-02",
"2021-01-03",
"2021-01-04",
"2021-01-05",
"2021-01-06",
"2021-01-07"
]
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [1]},
%{"dimensions" => ["2021-01-05"], "metrics" => [1]},
%{"dimensions" => ["2021-01-07"], "metrics" => [1]}
]
end
test "trims yearly relative date range", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-05 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-30 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-31 00:00:00]),
build(:pageview, timestamp: ~N[2021-02-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-02-09 00:00:00])
])
response =
do_query(
conn,
site,
%{
"date_range" => "year",
"relative_date" => "2021-02-07",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"time_labels" => true}
},
now: ~U[2021-02-07 12:00:00Z]
)
assert response["meta"]["time_labels"] == ["2021-01-01", "2021-02-01"]
assert response["results"] == [
%{"dimensions" => ["2021-01-01"], "metrics" => [4]},
%{"dimensions" => ["2021-02-01"], "metrics" => [1]}
]
end
end
describe "comparisons" do
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
test "returns past month stats when period=30d and comparison=previous_period", %{
conn: conn,
site: site
} do
response =
do_query(conn, site, %{
"date_range" => "30d",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"compare" => "previous_period", "time_labels" => true}
})
labels = response["meta"]["time_labels"]
comparison_labels = response["meta"]["comparison_time_labels"]
first = Date.utc_today() |> Date.shift(day: -30) |> Date.to_iso8601()
last = Date.utc_today() |> Date.shift(day: -1) |> Date.to_iso8601()
assert List.first(labels) == first
assert List.last(labels) == last
first = Date.utc_today() |> Date.shift(day: -60) |> Date.to_iso8601()
last = Date.utc_today() |> Date.shift(day: -31) |> Date.to_iso8601()
assert List.first(comparison_labels) == first
assert List.last(comparison_labels) == last
end
test "returns past year stats when period=month and comparison=year_over_year", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2020-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2020-01-05 00:00:00]),
build(:pageview, timestamp: ~N[2020-01-30 00:00:00]),
build(:pageview, timestamp: ~N[2020-01-31 00:00:00]),
build(:pageview, timestamp: ~N[2019-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2019-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2019-01-05 00:00:00]),
build(:pageview, timestamp: ~N[2019-01-05 00:00:00]),
build(:pageview, timestamp: ~N[2019-01-31 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2020-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{"compare" => "year_over_year", "time_labels" => true}
})
assert response["results"] == [
%{"dimensions" => ["2020-01-01"], "metrics" => [1]},
%{"dimensions" => ["2020-01-05"], "metrics" => [1]},
%{"dimensions" => ["2020-01-30"], "metrics" => [1]},
%{"dimensions" => ["2020-01-31"], "metrics" => [1]}
]
assert response["comparison_results"] == [
%{"dimensions" => ["2019-01-01"], "metrics" => [2], "change" => [-50]},
%{"dimensions" => ["2019-01-05"], "metrics" => [2], "change" => [-50]},
%{"dimensions" => ["2019-01-31"], "metrics" => [1], "change" => [0]}
]
assert length(response["meta"]["time_labels"]) == 31
assert length(response["meta"]["comparison_time_labels"]) == 31
assert response["meta"]["time_label_result_indices"] ==
[0, nil, nil, nil, 1] ++ List.duplicate(nil, 24) ++ [2, 3]
assert response["meta"]["comparison_time_label_result_indices"] ==
[0, nil, nil, nil, 1] ++ List.duplicate(nil, 25) ++ [2]
end
test "can return custom comparison period larger than original query", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2020-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2020-01-05 00:00:00]),
build(:pageview, timestamp: ~N[2020-01-30 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2020-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:day"],
"include" => %{
"compare" => ["2022-01-01", "2022-06-01"],
"time_labels" => true
}
})
labels = response["meta"]["time_labels"]
comparison_labels = response["meta"]["comparison_time_labels"]
assert length(labels) == 31
assert length(comparison_labels) == 152
assert length(response["results"]) == 3
assert response["comparison_results"] == []
assert List.first(comparison_labels) == "2022-01-01"
assert List.last(comparison_labels) == "2022-06-01"
end
test "compares imported data and native data together", %{conn: conn, site: site} do
populate_stats(site, [
build(:imported_visitors, date: ~D[2020-01-02]),
build(:imported_visitors, date: ~D[2020-01-02]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "year",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"imports" => true, "compare" => "year_over_year"}
})
plot = Enum.map(response["results"], fn r -> List.first(r["metrics"]) end)
comparison_plot =
Enum.map(response["comparison_results"], fn r -> List.first(r["metrics"]) end)
assert 4 == Enum.sum(plot)
assert 2 == Enum.sum(comparison_plot)
end
test "does not return imported data when with_imported is set to false when comparing", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:imported_visitors, date: ~D[2020-01-02]),
build(:imported_visitors, date: ~D[2020-01-02]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
])
response =
do_query(conn, site, %{
"date_range" => "year",
"relative_date" => "2021-01-01",
"metrics" => ["visitors"],
"dimensions" => ["time:month"],
"include" => %{"imports" => false, "compare" => "year_over_year"}
})
plot = Enum.map(response["results"], fn r -> List.first(r["metrics"]) end)
comparison_plot =
Enum.map(response["comparison_results"], fn r -> List.first(r["metrics"]) end)
assert 4 == Enum.sum(plot)
assert 0 == Enum.sum(comparison_plot)
end
test "plots conversion rate previous period comparison", %{site: site, conn: conn} do
insert(:goal, site: site, event_name: "Signup")
populate_stats(site, [
build(:event, name: "Signup", timestamp: ~N[2021-01-01 00:01:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:01:00]),
build(:pageview, timestamp: ~N[2021-01-01 00:01:00]),
build(:event, name: "Signup", timestamp: ~N[2021-01-08 00:01:00]),
build(:pageview, timestamp: ~N[2021-01-08 00:01:00])
])
%{"results" => results, "comparison_results" => comparison_results} =
do_query(conn, site, %{
"date_range" => "7d",
"relative_date" => "2021-01-15",
"metrics" => ["conversion_rate"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:goal", ["Signup"]]],
"include" => %{"compare" => "previous_period"}
})
assert results == [
%{"dimensions" => ["2021-01-08"], "metrics" => [50.0]}
]
assert comparison_results == [
%{"dimensions" => ["2021-01-01"], "metrics" => [33.33], "change" => [16.7]}
]
end
test "does trim hourly relative date range when comparing", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-08 00:00:00]),
build(:pageview, timestamp: ~N[2021-01-08 06:05:00]),
build(:pageview, timestamp: ~N[2021-01-08 08:04:00])
])
response =
do_query(
conn,
site,
%{
"date_range" => "day",
"relative_date" => "2021-01-08",
"metrics" => ["visitors"],
"dimensions" => ["time:hour"],
"include" => %{"compare" => "previous_period", "time_labels" => true}
},
now: ~U[2021-01-08 08:05:00Z]
)
assert response["meta"]["time_labels"] == [
"2021-01-08 00:00:00",
"2021-01-08 01:00:00",
"2021-01-08 02:00:00",
"2021-01-08 03:00:00",
"2021-01-08 04:00:00",
"2021-01-08 05:00:00",
"2021-01-08 06:00:00",
"2021-01-08 07:00:00",
"2021-01-08 08:00:00"
]
assert response["results"] == [
%{"dimensions" => ["2021-01-08 00:00:00"], "metrics" => [1]},
%{"dimensions" => ["2021-01-08 06:00:00"], "metrics" => [1]},
%{"dimensions" => ["2021-01-08 08:00:00"], "metrics" => [1]}
]
assert response["meta"]["comparison_time_labels"] == [
"2021-01-07 00:00:00",
"2021-01-07 01:00:00",
"2021-01-07 02:00:00",
"2021-01-07 03:00:00",
"2021-01-07 04:00:00",
"2021-01-07 05:00:00",
"2021-01-07 06:00:00",
"2021-01-07 07:00:00",
"2021-01-07 08:00:00"
]
assert response["comparison_results"] == []
assert response["meta"]["time_label_result_indices"] ==
[0, nil, nil, nil, nil, nil, 1, nil, 2]
assert response["meta"]["comparison_time_label_result_indices"] == List.duplicate(nil, 9)
end
end
describe "revenue metric dropped" do
@describetag :ee_only
setup [:create_user, :log_in, :create_site]
for revenue_metric <- ["total_revenue", "average_revenue"] do
test "#{revenue_metric} without goal filter", %{
conn: conn,
site: site
} do
response =
do_query_fail(conn, site, %{
"date_range" => "day",
"metrics" => [unquote(revenue_metric)],
"dimensions" => ["time:hour"]
})
assert %{"error" => error} = json_response(response, 400)
assert error =~ "Revenue metrics were dropped"
end
test "#{revenue_metric} with filtered goals mixing currencies", %{
conn: conn,
site: site
} do
insert(:goal, site: site, event_name: "PurchaseEUR", currency: "EUR")
insert(:goal, site: site, event_name: "PurchaseUSD", currency: "USD")
response =
do_query_fail(conn, site, %{
"date_range" => "day",
"metrics" => [unquote(revenue_metric)],
"filters" => [["is", "event:goal", ["PurchaseUSD", "PurchaseEUR"]]],
"dimensions" => ["time:hour"]
})
assert %{"error" => error} = json_response(response, 400)
assert error =~ "Revenue metrics were dropped"
end
test "#{revenue_metric} with insufficient subscription", %{
conn: conn,
user: user,
site: site
} do
insert(:goal, site: site, event_name: "PurchaseEUR", currency: "EUR")
subscribe_to_growth_plan(user)
response =
do_query_fail(conn, site, %{
"date_range" => "day",
"metrics" => [unquote(revenue_metric)],
"filters" => [["is", "event:goal", ["PurchaseEUR"]]],
"dimensions" => ["time:hour"]
})
assert %{"error" => error} = json_response(response, 400)
assert error =~ "Revenue metrics were dropped"
end
end
end
describe "total_revenue plot" do
@describetag :ee_only
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
test "plots total_revenue for a month", %{conn: conn, site: site} do
insert(:goal, site: site, event_name: "Payment", currency: "USD")
populate_stats(site, [
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("13.29"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("19.90"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-05 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("10.31"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-31 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("20.0"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-31 00:00:00]
)
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["total_revenue"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:goal", ["Payment"]]]
})
assert response["results"] == [
%{
"dimensions" => ["2021-01-01"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$13.29",
"short" => "$13.3",
"value" => 13.29
}
]
},
%{
"dimensions" => ["2021-01-05"],
"metrics" => [
%{"currency" => "USD", "long" => "$19.90", "short" => "$19.9", "value" => 19.9}
]
},
%{
"dimensions" => ["2021-01-31"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$30.31",
"short" => "$30.3",
"value" => 30.31
}
]
}
]
end
test "plots total_revenue for a week compared to last week", %{conn: conn, site: site} do
insert(:goal,
site: site,
event_name: "Payment",
currency: "USD",
display_name: "PaymentUSD"
)
populate_stats(site, [
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("13.29"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("19.90"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-05 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("10.31"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-10 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("20.0"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-12 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("10.0"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-12 01:00:00]
)
])
%{"results" => results, "comparison_results" => comparison_results} =
do_query(conn, site, %{
"date_range" => "7d",
"relative_date" => "2021-01-15",
"metrics" => ["total_revenue"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:goal", ["PaymentUSD"]]],
"include" => %{"compare" => "previous_period"}
})
assert results == [
%{
"dimensions" => ["2021-01-10"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$10.31",
"short" => "$10.3",
"value" => 10.31
}
]
},
%{
"dimensions" => ["2021-01-12"],
"metrics" => [
%{"currency" => "USD", "long" => "$30.00", "short" => "$30.0", "value" => 30.0}
]
}
]
assert comparison_results == [
%{
"dimensions" => ["2021-01-01"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$13.29",
"short" => "$13.3",
"value" => 13.29
}
],
"change" => nil
},
%{
"dimensions" => ["2021-01-05"],
"metrics" => [
%{"currency" => "USD", "long" => "$19.90", "short" => "$19.9", "value" => 19.9}
],
"change" => [51]
}
]
end
test "silently ignores imported data", %{conn: conn, site: site} do
insert(:goal, site: site, event_name: "Payment", currency: "USD")
populate_stats(site, [
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("13.29"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("13.21"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-01 00:00:00]
),
build(:imported_visitors, date: ~D[2021-01-01])
])
response =
do_query(conn, site, %{
"date_range" => "all",
"metrics" => ["total_revenue"],
"dimensions" => ["time:month"],
"filters" => [["is", "event:goal", ["Payment"]]],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{
"dimensions" => ["2021-01-01"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$26.50",
"short" => "$26.5",
"value" => 26.5
}
]
}
]
end
end
describe "average_revenue plot" do
@describetag :ee_only
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
test "plots average_revenue for a month", %{conn: conn, site: site} do
insert(:goal, site: site, event_name: "Payment", currency: "USD")
populate_stats(site, [
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("13.29"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("50.50"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("19.90"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-05 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("10.31"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-31 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("20.0"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-31 00:00:00]
)
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["average_revenue"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:goal", ["Payment"]]]
})
assert response["results"] == [
%{
"dimensions" => ["2021-01-01"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$31.90",
"short" => "$31.9",
"value" => 31.895
}
]
},
%{
"dimensions" => ["2021-01-05"],
"metrics" => [
%{"currency" => "USD", "long" => "$19.90", "short" => "$19.9", "value" => 19.9}
]
},
%{
"dimensions" => ["2021-01-31"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$15.16",
"short" => "$15.2",
"value" => 15.155
}
]
}
]
end
test "plots average_revenue for a week compared to last week", %{conn: conn, site: site} do
insert(:goal,
site: site,
event_name: "Payment",
currency: "USD",
display_name: "PaymentUSD"
)
populate_stats(site, [
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("13.29"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("19.90"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-05 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("10.31"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-10 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("20.0"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-12 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("10.0"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-12 01:00:00]
)
])
%{"results" => results, "comparison_results" => comparison_results} =
do_query(conn, site, %{
"date_range" => "7d",
"relative_date" => "2021-01-15",
"metrics" => ["average_revenue"],
"dimensions" => ["time:day"],
"filters" => [["is", "event:goal", ["PaymentUSD"]]],
"include" => %{"compare" => "previous_period", "time_labels" => true}
})
assert results == [
%{
"dimensions" => ["2021-01-10"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$10.31",
"short" => "$10.3",
"value" => 10.31
}
]
},
%{
"dimensions" => ["2021-01-12"],
"metrics" => [
%{"currency" => "USD", "long" => "$15.00", "short" => "$15.0", "value" => 15.0}
]
}
]
assert comparison_results == [
%{
"dimensions" => ["2021-01-01"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$13.29",
"short" => "$13.3",
"value" => 13.29
}
],
"change" => nil
},
%{
"dimensions" => ["2021-01-05"],
"metrics" => [
%{"currency" => "USD", "long" => "$19.90", "short" => "$19.9", "value" => 19.9}
],
"change" => [-25]
}
]
end
test "silently ignores imported data", %{conn: conn, site: site} do
insert(:goal, site: site, event_name: "Payment", currency: "USD")
populate_stats(site, [
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("3.3"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Payment",
revenue_reporting_amount: Decimal.new("1.1"),
revenue_reporting_currency: "USD",
timestamp: ~N[2021-01-01 00:00:00]
),
build(:imported_visitors, date: ~D[2021-01-01])
])
response =
do_query(conn, site, %{
"date_range" => "all",
"metrics" => ["average_revenue"],
"dimensions" => ["time:month"],
"filters" => [["is", "event:goal", ["Payment"]]],
"include" => %{"imports" => true}
})
assert response["results"] == [
%{
"dimensions" => ["2021-01-01"],
"metrics" => [
%{
"currency" => "USD",
"long" => "$2.20",
"short" => "$2.2",
"value" => 2.2
}
]
}
]
end
end
describe "present_index" do
setup [:create_user, :log_in, :create_site]
test "exists for a date range that includes the current day", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview)
])
response =
do_query(conn, site, %{
"date_range" => "month",
"metrics" => ["pageviews"],
"dimensions" => ["time:day"],
"include" => %{"time_labels" => true, "present_index" => true}
})
present_index = response["meta"]["present_index"]
assert present_index >= 0
end
test "is null for a date range that does not include the current day", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview)
])
response =
do_query(conn, site, %{
"date_range" => "month",
"relative_date" => "2021-01-01",
"metrics" => ["pageviews"],
"dimensions" => ["time:day"],
"include" => %{"time_labels" => true, "present_index" => true}
})
refute response["meta"]["present_index"]
end
for period <- ["7d", "28d", "30d", "91d"] do
test "#{period} period does not include today", %{conn: conn, site: site} do
today = "2021-01-01"
yesterday = "2020-12-31"
response =
do_query(conn, site, %{
"date_range" => unquote(period),
"relative_date" => today,
"metrics" => ["pageviews"],
"dimensions" => ["time:day"],
"include" => %{"time_labels" => true, "present_index" => true}
})
labels = response["meta"]["time_labels"]
present_index = response["meta"]["present_index"]
refute present_index
assert List.last(labels) == yesterday
end
end
test "returns present_index for time:hour interval", %{conn: conn, site: site} do
response =
do_query(
conn,
site,
%{
"date_range" => "day",
"relative_date" => "2021-01-08",
"metrics" => ["pageviews"],
"dimensions" => ["time:hour"],
"include" => %{"time_labels" => true, "present_index" => true}
},
now: ~U[2021-01-08 01:30:00Z]
)
assert response["meta"]["time_labels"] == ["2021-01-08 00:00:00", "2021-01-08 01:00:00"]
assert response["meta"]["present_index"] == 1
end
test "returns present_index for time:week interval", %{conn: conn, site: site} do
response =
do_query(
conn,
site,
%{
"date_range" => ["2021-01-04", "2021-01-17"],
"metrics" => ["pageviews"],
"dimensions" => ["time:week"],
"include" => %{"time_labels" => true, "present_index" => true}
},
now: ~U[2021-01-14 12:00:00Z]
)
assert response["meta"]["time_labels"] == ["2021-01-04", "2021-01-11"]
assert response["meta"]["present_index"] == 1
end
test "returns present_index for time:month interval", %{conn: conn, site: site} do
response =
do_query(
conn,
site,
%{
"date_range" => ["2021-01-01", "2021-02-28"],
"metrics" => ["pageviews"],
"dimensions" => ["time:month"],
"include" => %{"time_labels" => true, "present_index" => true}
},
now: ~U[2021-02-15 12:00:00Z]
)
assert response["meta"]["time_labels"] == ["2021-01-01", "2021-02-01"]
assert response["meta"]["present_index"] == 1
end
end
end