Leon4gr45 commited on
Commit
573b432
·
verified ·
1 Parent(s): ab6c456

Delete test/plausible/site/cache_test.exs with huggingface_hub

Browse files
Files changed (1) hide show
  1. test/plausible/site/cache_test.exs +0 -375
test/plausible/site/cache_test.exs DELETED
@@ -1,375 +0,0 @@
1
- defmodule Plausible.Site.CacheTest do
2
- use Plausible.DataCase, async: true
3
-
4
- alias Plausible.{Site, Goal}
5
- alias Plausible.Site.Cache
6
-
7
- describe "public cache interface" do
8
- test "cache caches sites", %{test: test} do
9
- {:ok, _} =
10
- Supervisor.start_link([{Cache, [cache_name: test, child_id: :test_cache_caches_id]}],
11
- strategy: :one_for_one,
12
- name: :"cache_supervisor_#{test}"
13
- )
14
-
15
- %{id: first_id} = site1 = new_site(domain: "site1.example.com")
16
-
17
- owner = new_user(team: [accept_traffic_until: ~D[2021-01-01]])
18
- viewer = new_user(team: [accept_traffic_until: ~D[2022-01-01]])
19
- admin = new_user(team: [accept_traffic_until: ~D[2020-01-01]])
20
-
21
- site = new_site(owner: owner, domain: "site2.example.com")
22
- add_guest(site, user: viewer, role: :viewer)
23
- add_guest(site, user: admin, role: :editor)
24
-
25
- # excluded from cache
26
- new_site(owner: owner, domain: "consolidated.example.com", consolidated: true)
27
-
28
- :ok = Cache.refresh_all(cache_name: test)
29
-
30
- {:ok, _} = Plausible.Repo.delete(site1)
31
-
32
- assert Cache.size(test) == 2
33
-
34
- assert %Site{from_cache?: true, id: ^first_id} =
35
- Cache.get("site1.example.com", force?: true, cache_name: test)
36
-
37
- assert %Site{from_cache?: true} =
38
- Cache.get("site2.example.com", force?: true, cache_name: test)
39
-
40
- assert %Site{from_cache?: false, team: %{accept_traffic_until: ~D[2021-01-01]}} =
41
- Cache.get("site2.example.com", cache_name: test)
42
-
43
- refute Cache.get("site3.example.com", cache_name: test, force?: true)
44
- refute Cache.get("consolidated.example.com", cache_name: test, force?: true)
45
- end
46
-
47
- @tag :ee_only
48
- test "cache caches revenue goals", %{test: test} do
49
- {:ok, _} =
50
- Supervisor.start_link(
51
- [{Cache, [cache_name: test, child_id: :test_cache_caches_revenue_goals]}],
52
- strategy: :one_for_one,
53
- name: :"cache_supervisor_#{test}"
54
- )
55
-
56
- %{id: site_id} = site = new_site(domain: "site1.example.com")
57
-
58
- {:ok, _goal} =
59
- Plausible.Goals.create(site, %{"event_name" => "Purchase", "currency" => :BRL})
60
-
61
- {:ok, _goal} =
62
- Plausible.Goals.create(site, %{"event_name" => "Add to Cart", "currency" => :USD})
63
-
64
- {:ok, _goal} = Plausible.Goals.create(site, %{"event_name" => "Click", "currency" => nil})
65
-
66
- :ok = Cache.refresh_all(cache_name: test)
67
-
68
- {:ok, _} = Plausible.Repo.delete(site)
69
-
70
- assert %Site{from_cache?: true, id: ^site_id, revenue_goals: cached_goals} =
71
- Cache.get("site1.example.com", force?: true, cache_name: test)
72
-
73
- assert [
74
- %Goal{event_name: "Add to Cart", currency: :USD},
75
- %Goal{event_name: "Purchase", currency: :BRL}
76
- ] = Enum.sort_by(cached_goals, & &1.event_name)
77
- end
78
-
79
- @tag :ee_only
80
- test "cache caches revenue goals with event refresh", %{test: test} do
81
- {:ok, _} =
82
- Supervisor.start_link(
83
- [{Cache, [cache_name: test, child_id: :test_revenue_goals_event_refresh]}],
84
- strategy: :one_for_one,
85
- name: :"cache_supervisor_#{test}"
86
- )
87
-
88
- yesterday = DateTime.utc_now() |> DateTime.add(-1 * 60 * 60 * 24)
89
-
90
- # the site was added yesterday so full refresh will pick it up
91
- %{id: site_id} = site = new_site(domain: "site1.example.com", updated_at: yesterday)
92
-
93
- # the goal was added yesterday so full refresh will pick it up
94
- Plausible.Goals.create(site, %{"event_name" => "Purchase", "currency" => :BRL},
95
- now: yesterday
96
- )
97
-
98
- # this goal is added "just now"
99
- Plausible.Goals.create(site, %{"event_name" => "Add to Cart", "currency" => :USD})
100
- # and this one does not matter
101
- Plausible.Goals.create(site, %{"event_name" => "Click", "currency" => nil})
102
-
103
- # at this point, we have 3 goals associated with the cached struct
104
- :ok = Cache.refresh_all(cache_name: test)
105
-
106
- # the goal was added 70 seconds ago so partial refresh should pick it up and merge with the rest of goals
107
- Plausible.Goals.create(
108
- site,
109
- %{"event_name" => "Purchase2", "currency" => :BRL},
110
- now: DateTime.add(DateTime.utc_now(), -70)
111
- )
112
-
113
- :ok = Cache.refresh_updated_recently(cache_name: test)
114
-
115
- assert %Site{from_cache?: true, id: ^site_id, revenue_goals: cached_goals} =
116
- Cache.get("site1.example.com", force?: true, cache_name: test)
117
-
118
- assert [
119
- %Goal{event_name: "Add to Cart", currency: :USD},
120
- %Goal{event_name: "Purchase", currency: :BRL},
121
- %Goal{event_name: "Purchase2", currency: :BRL}
122
- ] = Enum.sort_by(cached_goals, & &1.event_name)
123
- end
124
-
125
- test "cache is ready when no sites exist in the db", %{test: test} do
126
- {:ok, _} = start_test_cache(test)
127
- assert Cache.ready?(test)
128
- end
129
-
130
- test "cache is not ready when sites exist in the db but cache needs refresh", %{test: test} do
131
- {:ok, _} = start_test_cache(test)
132
- insert(:site)
133
- refute Cache.ready?(test)
134
- end
135
-
136
- test "cache is ready when refreshed", %{test: test} do
137
- {:ok, _} = start_test_cache(test)
138
- new_site()
139
- :ok = Cache.refresh_all(cache_name: test)
140
- assert Cache.ready?(test)
141
- end
142
-
143
- test "cache allows lookups for sites with changed domain", %{test: test} do
144
- {:ok, _} = start_test_cache(test)
145
- new_site(domain: "new.example.com", domain_changed_from: "old.example.com")
146
- :ok = Cache.refresh_all(cache_name: test)
147
-
148
- assert Cache.get("old.example.com", force?: true, cache_name: test)
149
- assert Cache.get("new.example.com", force?: true, cache_name: test)
150
- end
151
-
152
- test "only recently updated sites can be refreshed", %{test: test} do
153
- {:ok, _} = start_test_cache(test)
154
-
155
- domain1 = "site1.example.com"
156
- domain2 = "nonexisting.example.com"
157
-
158
- cache_opts = [cache_name: test, force?: true]
159
-
160
- yesterday = DateTime.utc_now() |> DateTime.add(-1 * 60 * 60 * 24)
161
- new_site(domain: domain1, inserted_at: yesterday, updated_at: yesterday)
162
-
163
- new_site(domain: domain2)
164
-
165
- assert Cache.get(domain1, cache_opts) == nil
166
- assert Cache.get(domain2, cache_opts) == nil
167
-
168
- assert :ok = Cache.refresh_updated_recently(cache_opts)
169
-
170
- refute Cache.get(domain1, cache_opts)
171
- assert %Site{domain: ^domain2} = Cache.get(domain2, cache_opts)
172
- end
173
-
174
- test "sites with recently changed domains are refreshed", %{test: test} do
175
- {:ok, _} = start_test_cache(test)
176
- cache_opts = [cache_name: test, force?: true]
177
-
178
- domain1 = "first.example.com"
179
- domain2 = "second.example.com"
180
-
181
- site = new_site(domain: domain1)
182
- assert :ok = Cache.refresh_updated_recently(cache_opts)
183
- assert item = Cache.get(domain1, cache_opts)
184
- refute item.domain_changed_from
185
-
186
- # change domain1 to domain2
187
-
188
- {:ok, _site} = Site.Domain.change(site, domain2)
189
-
190
- # small refresh keeps both items in cache
191
-
192
- assert :ok = Cache.refresh_updated_recently(cache_opts)
193
- assert item_by_domain1 = Cache.get(domain1, cache_opts)
194
- assert item_by_domain2 = Cache.get(domain2, cache_opts)
195
-
196
- assert item_by_domain1 == item_by_domain2
197
- assert item_by_domain1.domain == domain2
198
- assert item_by_domain1.domain_changed_from == domain1
199
-
200
- # domain_changed_from gets no longer tracked
201
-
202
- {:ok, _} = Site.Domain.expire_change_transitions(-1)
203
-
204
- # full refresh removes the stale entry
205
-
206
- assert :ok = Cache.refresh_all(cache_opts)
207
-
208
- refute Cache.get(domain1, cache_opts)
209
- assert item = Cache.get(domain2, cache_opts)
210
- refute item.domain_changed_from
211
- end
212
-
213
- test "refreshing all sites sends a telemetry event",
214
- %{
215
- test: test
216
- } do
217
- domain = "site1.example.com"
218
- insert(:site, domain: domain)
219
-
220
- :ok =
221
- start_test_cache_with_telemetry_handler(test,
222
- event: Cache.telemetry_event_refresh(test, :all)
223
- )
224
-
225
- Cache.refresh_all(force?: true, cache_name: test)
226
- assert_receive {:telemetry_handled, %{}}
227
- end
228
-
229
- test "get_site_id/2", %{test: test} do
230
- {:ok, _} = start_test_cache(test)
231
-
232
- site = new_site()
233
-
234
- domain1 = site.domain
235
- domain2 = "nonexisting.example.com"
236
-
237
- :ok = Cache.refresh_all(cache_name: test)
238
-
239
- assert site.id == Cache.get_site_id(domain1, force?: true, cache_name: test)
240
- assert is_nil(Cache.get_site_id(domain2, force?: true, cache_name: test))
241
- end
242
- end
243
-
244
- describe "merging the cache" do
245
- test "merging adds new items", %{test: test} do
246
- {:ok, _} = start_test_cache(test)
247
-
248
- :ok = Cache.merge_items([{"item1", nil, :item1}], cache_name: test)
249
- assert :item1 == Cache.get("item1", cache_name: test, force?: true)
250
- end
251
-
252
- test "merging no new items leaves the old cache intact", %{test: test} do
253
- {:ok, _} = start_test_cache(test)
254
-
255
- :ok = Cache.merge_items([{"item1", nil, :item1}], cache_name: test)
256
- :ok = Cache.merge_items([], cache_name: test)
257
- assert :item1 == Cache.get("item1", cache_name: test, force?: true)
258
- end
259
-
260
- test "merging removes stale items", %{test: test} do
261
- {:ok, _} = start_test_cache(test)
262
-
263
- :ok = Cache.merge_items([{"item1", nil, :item1}], cache_name: test)
264
- :ok = Cache.merge_items([{"item2", nil, :item2}], cache_name: test)
265
-
266
- refute Cache.get("item1", cache_name: test, force?: true)
267
- assert Cache.get("item2", cache_name: test, force?: true)
268
- end
269
-
270
- test "merging optionally leaves stale items intact", %{test: test} do
271
- {:ok, _} = start_test_cache(test)
272
-
273
- :ok = Cache.merge_items([{"item1", nil, :item1}], cache_name: test)
274
-
275
- :ok =
276
- Cache.merge_items([{"item2", nil, :item2}], cache_name: test, delete_stale_items?: false)
277
-
278
- assert Cache.get("item1", cache_name: test, force?: true)
279
- assert Cache.get("item2", cache_name: test, force?: true)
280
- end
281
-
282
- test "merging updates changed items", %{test: test} do
283
- {:ok, _} = start_test_cache(test)
284
-
285
- :ok = Cache.merge_items([{"item1", nil, :item1}, {"item2", nil, :item2}], cache_name: test)
286
-
287
- :ok =
288
- Cache.merge_items([{"item1", nil, :changed}, {"item2", nil, :item2}], cache_name: test)
289
-
290
- assert :changed == Cache.get("item1", cache_name: test, force?: true)
291
- assert :item2 == Cache.get("item2", cache_name: test, force?: true)
292
- end
293
-
294
- test "merging keeps secondary keys", %{test: test} do
295
- {:ok, _} = start_test_cache(test)
296
-
297
- :ok = Cache.merge_items([{"item1", nil, :item1}], cache_name: test)
298
- :ok = Cache.merge_items([{"item2", "item1", :updated}], cache_name: test)
299
- assert :updated == Cache.get("item1", cache_name: test, force?: true)
300
- assert :updated == Cache.get("item2", cache_name: test, force?: true)
301
- end
302
-
303
- @items1 for i <- 1..200_000, do: {i, nil, :batch1}
304
- @items2 for _ <- 1..200_000, do: {Enum.random(1..400_000), nil, :batch2}
305
- @max_seconds 3
306
- test "merging large sets is expected to be under #{@max_seconds} seconds", %{test: test} do
307
- {:ok, _} = start_test_cache(test)
308
-
309
- {t1, :ok} =
310
- :timer.tc(fn ->
311
- :ok = Cache.merge_items(@items1, cache_name: test)
312
- end)
313
-
314
- {t2, :ok} =
315
- :timer.tc(fn ->
316
- :ok = Cache.merge_items(@items1, cache_name: test)
317
- end)
318
-
319
- {t3, :ok} =
320
- :timer.tc(fn ->
321
- :ok = Cache.merge_items(@items2, cache_name: test)
322
- end)
323
-
324
- assert t1 / 1_000_000 <= @max_seconds
325
- assert t2 / 1_000_000 <= @max_seconds
326
- assert t3 / 1_000_000 <= @max_seconds
327
- end
328
-
329
- test "deleted sites don't stay in cache on another refresh", %{test: test} do
330
- {:ok, _} = start_test_cache(test)
331
-
332
- domain1 = "site1.example.com"
333
- domain2 = "site2.example.com"
334
-
335
- site1 = new_site(domain: domain1)
336
- _site2 = new_site(domain: domain2)
337
-
338
- cache_opts = [cache_name: test, force?: true]
339
-
340
- :ok = Cache.refresh_all(cache_opts)
341
-
342
- assert Cache.get(domain1, cache_opts)
343
- assert Cache.get(domain2, cache_opts)
344
-
345
- Repo.delete!(site1)
346
-
347
- :ok = Cache.refresh_all(cache_opts)
348
-
349
- assert Cache.get(domain2, cache_opts)
350
-
351
- refute Cache.get(domain1, cache_opts)
352
- :ok = Cache.refresh_all(cache_opts)
353
- refute Cache.get(domain1, cache_opts)
354
- end
355
- end
356
-
357
- defp start_test_cache(cache_name) do
358
- %{start: {m, f, a}} = Cache.child_spec(cache_name: cache_name)
359
- apply(m, f, a)
360
- end
361
-
362
- defp start_test_cache_with_telemetry_handler(test, event: event) do
363
- {:ok, _} = start_test_cache(test)
364
- test_pid = self()
365
-
366
- :telemetry.attach(
367
- "#{test}-telemetry-handler",
368
- event,
369
- fn ^event, %{duration: d}, metadata, _ when is_integer(d) ->
370
- send(test_pid, {:telemetry_handled, metadata})
371
- end,
372
- %{}
373
- )
374
- end
375
- end