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 Plausible.CacheTest do
use Plausible.DataCase, async: true
alias Plausible.Cache
import ExUnit.CaptureLog
defmodule ExampleCache do
use Plausible.Cache
def name(), do: __MODULE__
def child_id(), do: __MODULE__
def count_all(), do: 100
def base_db_query() do
%Ecto.Query{}
end
def get_from_source("existing_key") do
:from_source
end
def get_from_source(_) do
nil
end
end
defmodule UnavailableRepo do
def all(_query) do
raise DBConnection.ConnectionError, "connection not available and request was dropped"
end
end
defmodule UnavailableCache do
use Plausible.Cache
def name(), do: __MODULE__
def child_id(), do: __MODULE__
def count_all(), do: 100
def repo(), do: UnavailableRepo
def base_db_query(), do: %Ecto.Query{}
def get_from_source(key), do: repo().all(key)
end
describe "public cache interface" do
test "cache process is started, but falls back to the database if cache is disabled", %{
test: test
} do
{:ok, _} =
Supervisor.start_link(
[{ExampleCache, [cache_name: ExampleCache.name(), child_id: test]}],
strategy: :one_for_one,
name: :"cache_supervisor_#{test}"
)
insert(:site, domain: "example.test")
refute Cache.enabled?()
assert Process.alive?(Process.whereis(ExampleCache.name()))
refute Process.whereis(ExampleCache.Warmer)
assert :from_source = ExampleCache.get("existing_key")
assert ExampleCache.size() == 0
refute ExampleCache.get("other.test")
end
test "critical cache errors are logged and nil is returned" do
log =
capture_log(fn ->
assert ExampleCache.get("key", force?: true, cache_name: NonExistingCache) == nil
end)
assert log =~ "Error retrieving key from 'NonExistingCache'"
end
test "cache is not ready when it doesn't exist", %{test: test} do
refute ExampleCache.ready?(test)
end
test "refresh_all returns an error when the database is unavailable", %{test: test} do
assert {:error, %DBConnection.ConnectionError{}} =
UnavailableCache.refresh_all(cache_name: test)
end
end
describe "merging cache items" do
test "merging adds new items", %{test: test} do
{:ok, _} = start_test_cache(test)
:ok = ExampleCache.merge_items([{"item1", :item1}], cache_name: test)
assert :item1 == ExampleCache.get("item1", cache_name: test, force?: true)
end
test "merging no new items leaves the old cache intact", %{test: test} do
{:ok, _} = start_test_cache(test)
:ok = ExampleCache.merge_items([{"item1", :item1}], cache_name: test)
:ok = ExampleCache.merge_items([], cache_name: test)
assert :item1 == ExampleCache.get("item1", cache_name: test, force?: true)
end
test "merging removes stale items", %{test: test} do
{:ok, _} = start_test_cache(test)
:ok = ExampleCache.merge_items([{"item1", :item1}], cache_name: test)
:ok = ExampleCache.merge_items([{"item2", :item2}], cache_name: test)
refute ExampleCache.get("item1", cache_name: test, force?: true)
assert ExampleCache.get("item2", cache_name: test, force?: true)
end
test "merging optionally leaves stale items intact", %{test: test} do
{:ok, _} = start_test_cache(test)
:ok = ExampleCache.merge_items([{"item1", :item1}], cache_name: test)
:ok =
ExampleCache.merge_items([{"item2", :item2}],
cache_name: test,
delete_stale_items?: false
)
assert ExampleCache.get("item1", cache_name: test, force?: true)
assert ExampleCache.get("item2", cache_name: test, force?: true)
end
test "merging updates changed items", %{test: test} do
{:ok, _} = start_test_cache(test)
:ok =
ExampleCache.merge_items([{"item1", :item1}, {"item2", :item2}],
cache_name: test
)
:ok =
ExampleCache.merge_items([{"item1", :changed}, {"item2", :item2}],
cache_name: test
)
assert :changed == ExampleCache.get("item1", cache_name: test, force?: true)
assert :item2 == ExampleCache.get("item2", cache_name: test, force?: true)
end
test "put puts into local cache, overwriting as appropriate", %{test: test} do
{:ok, _} = start_test_cache(test)
opts = [cache_name: test, force?: true]
assert ExampleCache.put("key", :item1, opts)
assert ExampleCache.get("key", opts) == :item1
assert ExampleCache.put("key", :updated, opts)
assert ExampleCache.get("key", opts) == :updated
end
test "broadcast_put puts into local cache", %{test: test} do
{:ok, _} = start_test_cache(test)
:ok = ExampleCache.broadcast_put("item1", :item1, cache_name: test)
assert eventually(fn ->
{ExampleCache.get("item1", cache_name: test, force?: true) == :item1, :ok}
end)
end
test "broadcast_delete deletes from local cache", %{test: test} do
{:ok, _} = start_test_cache(test)
:item1 = ExampleCache.put("item1", :item1, cache_name: test)
:ok = ExampleCache.broadcast_delete("item1", cache_name: test)
assert eventually(fn ->
{ExampleCache.get("item1", cache_name: test, force?: true) == nil, :ok}
end)
end
end
describe "warming the cache" do
test "cache warmer process warms up the cache", %{test: test} do
test_pid = self()
opts = [
cache_impl: ExampleCache,
force_start?: true,
warmer_fn: report_back(test_pid),
cache_name: test,
interval: 30
]
{:ok, _} =
Supervisor.start_link([{Plausible.Cache.Warmer, opts}],
strategy: :one_for_one,
name: test
)
assert Process.whereis(Plausible.Cache.Warmer)
assert_receive {:cache_warmed, %{opts: got_opts}}
assert got_opts[:cache_name] == test
end
test "cache warmer warms periodically with an interval", %{test: test} do
test_pid = self()
opts = [
cache_impl: ExampleCache,
force_start?: true,
warmer_fn: report_back(test_pid),
cache_name: test,
interval: 30
]
{:ok, _} = start_test_warmer(opts)
assert_receive {:cache_warmed, %{at: at1}}, 100
assert_receive {:cache_warmed, %{at: at2}}, 100
assert_receive {:cache_warmed, %{at: at3}}, 100
assert is_integer(at1)
assert is_integer(at2)
assert is_integer(at3)
assert at1 < at2
assert at3 > at2
end
test "cache warmer backs off retries until it succeeds, then stops", %{test: test} do
opts = [
cache_impl: ExampleCache,
force_start?: true,
warmer_fn: fail_first(self(), 3),
cache_name: test,
interval: :timer.hours(1),
retry_interval: 60,
max_retries: 4
]
capture_log(fn ->
{:ok, _} = start_test_warmer(opts)
warmed_at =
for _ <- 1..4 do
assert_receive {:cache_warmed, %{at: at}}, 1000
at
end
scheduling_tolerance = 100
for {[previous_at, at], backoff} <-
Enum.zip(Enum.chunk_every(warmed_at, 2, 1, :discard), [60, 120, 240]) do
elapsed = System.convert_time_unit(at - previous_at, :native, :millisecond)
assert elapsed >= backoff
assert elapsed <= backoff + div(backoff, 3) + scheduling_tolerance
end
refute_receive {:cache_warmed, _}, 800
end)
end
test "cache warmer stops retrying after a few failed retries", %{test: test} do
opts = [
cache_impl: ExampleCache,
force_start?: true,
warmer_fn: report_back(self(), {:error, :db_unavailable}),
cache_name: test,
interval: :timer.hours(1),
retry_interval: 10
]
errors =
capture_log([level: :error], fn ->
{:ok, _} = start_test_warmer(opts)
for _ <- 1..4, do: assert_receive({:cache_warmed, _}, 1000)
refute_receive {:cache_warmed, _}, 300
end)
assert [_] = Regex.scan(~r/failed - :db_unavailable/, errors)
end
for max_retries <- [0, 1, 4] do
test "cache warmer stops after #{max_retries} configured retries", %{test: test} do
max_retries = unquote(max_retries)
opts = [
cache_impl: ExampleCache,
force_start?: true,
warmer_fn: report_back(self(), {:error, :db_unavailable}),
cache_name: test,
interval: :timer.hours(1),
retry_interval: 10,
max_retries: max_retries
]
capture_log(fn ->
{:ok, _} = start_test_warmer(opts)
for _ <- 0..max_retries, do: assert_receive({:cache_warmed, _}, 1000)
refute_receive {:cache_warmed, _}, 300
end)
end
end
test "cache warmer ignores a pending retry after a regular cycle", %{test: test} do
opts = [
cache_impl: ExampleCache,
force_start?: true,
warmer_fn: fail_first(self(), 1),
cache_name: test,
interval: :timer.hours(1),
retry_interval: 300
]
log =
capture_log(fn ->
{:ok, warmer} = start_test_warmer(opts)
assert_receive {:cache_warmed, _}, 1000
send(warmer, :"$cycle")
assert_receive {:cache_warmed, _}, 1000
refute_receive {:cache_warmed, _}, 600
end)
assert log =~ "retrying in"
end
test "cache warmer does not retry a failing run without a retry interval", %{test: test} do
opts = [
cache_impl: ExampleCache,
force_start?: true,
warmer_fn: report_back(self(), {:error, :db_unavailable}),
cache_name: test,
interval: :timer.hours(1)
]
capture_log(fn ->
{:ok, _} = start_test_warmer(opts)
assert_receive {:cache_warmed, _}, 1000
refute_receive {:cache_warmed, _}, 200
end)
end
test "cache warmer does not retry a successful run", %{test: test} do
test_pid = self()
opts = [
cache_impl: ExampleCache,
force_start?: true,
warmer_fn: report_back(test_pid),
cache_name: test,
interval: :timer.hours(1),
retry_interval: 30
]
{:ok, _} = start_test_warmer(opts)
assert_receive {:cache_warmed, _}, 1000
refute_receive {:cache_warmed, _}, 150
end
end
defp report_back(test_pid, result \\ :ok) do
fn opts ->
send(test_pid, {:cache_warmed, %{at: System.monotonic_time(), opts: opts}})
result
end
end
defp fail_first(test_pid, times) do
runs = :counters.new(1, [])
fn opts ->
:counters.add(runs, 1, 1)
result = if :counters.get(runs, 1) <= times, do: {:error, :db_unavailable}, else: :ok
report_back(test_pid, result).(opts)
end
end
defp start_test_warmer(opts) do
child_name_opt = {:child_name, Keyword.fetch!(opts, :cache_name)}
%{start: {m, f, a}} = Cache.Warmer.child_spec([child_name_opt | opts])
apply(m, f, a)
end
defp start_test_cache(cache_name) do
%{start: {m, f, a}} = ExampleCache.child_spec(cache_name: cache_name)
apply(m, f, a)
end
end