Leon4gr45 commited on
Commit
b1dcfc2
·
verified ·
1 Parent(s): 2d356dd

Delete test/plausible_web/controllers/api/external_stats_controller/aggregate_test.exs with huggingface_hub

Browse files
test/plausible_web/controllers/api/external_stats_controller/aggregate_test.exs DELETED
@@ -1,2036 +0,0 @@
1
- defmodule PlausibleWeb.Api.ExternalStatsController.AggregateTest do
2
- use PlausibleWeb.ConnCase
3
- alias Plausible.Billing.Feature
4
-
5
- setup [:create_user, :create_site, :create_api_key, :use_api_key]
6
- @user_id Enum.random(1000..9999)
7
-
8
- describe "feature access" do
9
- test "cannot filter by a custom prop without access to the props feature", %{
10
- conn: conn,
11
- user: user,
12
- site: site
13
- } do
14
- subscribe_to_enterprise_plan(user, features: [Feature.StatsAPI])
15
-
16
- conn =
17
- get(conn, "/api/v1/stats/aggregate", %{
18
- "site_id" => site.domain,
19
- "filters" => "event:props:author==Uku"
20
- })
21
-
22
- assert json_response(conn, 402)["error"] ==
23
- "The owner of this site does not have access to the custom properties feature"
24
- end
25
-
26
- test "can filter by an internal prop key without access to the props feature", %{
27
- conn: conn,
28
- user: user,
29
- site: site
30
- } do
31
- subscribe_to_enterprise_plan(user, features: [Feature.StatsAPI])
32
-
33
- conn =
34
- get(conn, "/api/v1/stats/aggregate", %{
35
- "site_id" => site.domain,
36
- "filters" => "event:props:url==https://site.com"
37
- })
38
-
39
- assert json_response(conn, 200)["results"]
40
- end
41
- end
42
-
43
- describe "param validation" do
44
- test "validates that date can be parsed", %{conn: conn, site: site} do
45
- conn =
46
- get(conn, "/api/v1/stats/aggregate", %{
47
- "site_id" => site.domain,
48
- "period" => "month",
49
- "date" => "2021-dkjbAS",
50
- "metrics" => "pageviews"
51
- })
52
-
53
- assert json_response(conn, 400) == %{
54
- "error" =>
55
- "Error parsing `date` parameter: invalid_format. Please specify a valid date in ISO-8601 format."
56
- }
57
- end
58
-
59
- test "ignores a given property parameter", %{conn: conn, site: site} do
60
- conn =
61
- get(conn, "/api/v1/stats/aggregate", %{
62
- "site_id" => site.domain,
63
- "property" => "event:props:author",
64
- "metrics" => "visit_duration"
65
- })
66
-
67
- assert json_response(conn, 200)
68
- end
69
-
70
- test "validates that period can be parsed", %{conn: conn, site: site} do
71
- conn =
72
- get(conn, "/api/v1/stats/aggregate", %{
73
- "site_id" => site.domain,
74
- "period" => "aosuhsacp",
75
- "metrics" => "pageviews"
76
- })
77
-
78
- assert json_response(conn, 400) == %{
79
- "error" =>
80
- "Error parsing `period` parameter: invalid period `aosuhsacp`. Please find accepted values in our docs: https://plausible.io/docs/stats-api#time-periods"
81
- }
82
- end
83
-
84
- test "custom period is not valid without a date", %{conn: conn, site: site} do
85
- conn =
86
- get(conn, "/api/v1/stats/aggregate", %{
87
- "site_id" => site.domain,
88
- "period" => "custom",
89
- "metrics" => "pageviews"
90
- })
91
-
92
- assert json_response(conn, 400) == %{
93
- "error" =>
94
- "The `date` parameter is required when using a custom period. See https://plausible.io/docs/stats-api#time-periods"
95
- }
96
- end
97
-
98
- test "validates date format in custom period", %{conn: conn, site: site} do
99
- conn =
100
- get(conn, "/api/v1/stats/aggregate", %{
101
- "site_id" => site.domain,
102
- "period" => "custom",
103
- "date" => "2020-131-2piaskj,s,a90uac",
104
- "metrics" => "pageviews"
105
- })
106
-
107
- assert json_response(conn, 400) == %{
108
- "error" =>
109
- "Invalid format for `date` parameter. When using a custom period, please include two ISO-8601 formatted dates joined by a comma. See https://plausible.io/docs/stats-api#time-periods"
110
- }
111
- end
112
-
113
- test "validates that metrics are all recognized", %{conn: conn, site: site} do
114
- conn =
115
- get(conn, "/api/v1/stats/aggregate", %{
116
- "site_id" => site.domain,
117
- "period" => "30d",
118
- "metrics" => "pageviews,led_zeppelin"
119
- })
120
-
121
- assert json_response(conn, 400) == %{
122
- "error" =>
123
- "The metric `led_zeppelin` is not recognized. Find valid metrics from the documentation: https://plausible.io/docs/stats-api#metrics"
124
- }
125
- end
126
-
127
- test "scroll depth metric is not recognized in the legacy API v1", %{conn: conn, site: site} do
128
- conn =
129
- get(conn, "/api/v1/stats/aggregate", %{
130
- "site_id" => site.domain,
131
- "period" => "30d",
132
- "metrics" => "scroll_depth"
133
- })
134
-
135
- assert json_response(conn, 400) == %{
136
- "error" =>
137
- "The metric `scroll_depth` is not recognized. Find valid metrics from the documentation: https://plausible.io/docs/stats-api#metrics"
138
- }
139
- end
140
-
141
- for property <- ["event:name", "event:goal", "event:props:custom_prop"] do
142
- test "validates that session metrics cannot be used with #{property} filter", %{
143
- conn: conn,
144
- site: site
145
- } do
146
- prop = unquote(property)
147
-
148
- if prop == "event:goal", do: insert(:goal, %{site: site, event_name: "some_value"})
149
-
150
- conn =
151
- get(conn, "/api/v1/stats/aggregate", %{
152
- "site_id" => site.domain,
153
- "period" => "30d",
154
- "metrics" => "pageviews,visit_duration",
155
- "filters" => "#{prop}==some_value"
156
- })
157
-
158
- assert json_response(conn, 400) == %{
159
- "error" =>
160
- "Session metric `visit_duration` cannot be queried when using a filter on `#{prop}`."
161
- }
162
- end
163
- end
164
-
165
- test "validates that conversion_rate cannot be queried without a goal filter", %{
166
- conn: conn,
167
- site: site
168
- } do
169
- conn =
170
- get(conn, "/api/v1/stats/aggregate", %{
171
- "site_id" => site.domain,
172
- "metrics" => "conversion_rate"
173
- })
174
-
175
- assert %{"error" => msg} = json_response(conn, 400)
176
-
177
- assert msg =~
178
- "Metric `conversion_rate` can only be queried in a goal breakdown or with a goal filter"
179
- end
180
-
181
- test "validates that views_per_visit cannot be used with event:page filter", %{
182
- conn: conn,
183
- site: site
184
- } do
185
- conn =
186
- get(conn, "/api/v1/stats/aggregate", %{
187
- "site_id" => site.domain,
188
- "filters" => "event:page==/something",
189
- "metrics" => "views_per_visit"
190
- })
191
-
192
- assert json_response(conn, 400) == %{
193
- "error" =>
194
- "Metric `views_per_visit` cannot be queried with a filter on `event:page`."
195
- }
196
- end
197
-
198
- test "validates that views_per_visit cannot be used with an event only filter", %{
199
- conn: conn,
200
- site: site
201
- } do
202
- conn =
203
- get(conn, "/api/v1/stats/aggregate", %{
204
- "site_id" => site.domain,
205
- "filters" => "event:name==Something",
206
- "metrics" => "views_per_visit"
207
- })
208
-
209
- assert json_response(conn, 400) == %{
210
- "error" =>
211
- "Session metric `views_per_visit` cannot be queried when using a filter on `event:name`."
212
- }
213
- end
214
-
215
- test "validates a metric isn't asked multiple times", %{
216
- conn: conn,
217
- site: site
218
- } do
219
- conn =
220
- get(conn, "/api/v1/stats/aggregate", %{
221
- "site_id" => site.domain,
222
- "metrics" => "visitors,visitors"
223
- })
224
-
225
- assert json_response(conn, 400) == %{
226
- "error" => "Metrics cannot be queried multiple times."
227
- }
228
- end
229
-
230
- test "validates that time_on_page cannot be queried without a page filter", %{
231
- conn: conn,
232
- site: site
233
- } do
234
- conn =
235
- get(conn, "/api/v1/stats/aggregate", %{
236
- "site_id" => site.domain,
237
- "metrics" => "time_on_page"
238
- })
239
-
240
- assert json_response(conn, 400) == %{
241
- "error" =>
242
- "Metric `time_on_page` can only be queried in a page breakdown or with a page filter."
243
- }
244
- end
245
-
246
- test "validates that time_on_page cannot be queried with a goal filter", %{
247
- conn: conn,
248
- site: site
249
- } do
250
- insert(:goal, %{site: site, event_name: "Signup"})
251
-
252
- conn =
253
- get(conn, "/api/v1/stats/aggregate", %{
254
- "site_id" => site.domain,
255
- "metrics" => "time_on_page",
256
- "filters" => "event:page==/A;event:goal==Signup"
257
- })
258
-
259
- assert json_response(conn, 400) == %{
260
- "error" => "Metric `time_on_page` cannot be queried when filtering by `event:goal`"
261
- }
262
- end
263
-
264
- test "validates that time_on_page cannot be queried with an event:name filter", %{
265
- conn: conn,
266
- site: site
267
- } do
268
- conn =
269
- get(conn, "/api/v1/stats/aggregate", %{
270
- "site_id" => site.domain,
271
- "metrics" => "time_on_page",
272
- "filters" => "event:page==/A;event:name==Signup"
273
- })
274
-
275
- assert json_response(conn, 400) == %{
276
- "error" => "Metric `time_on_page` cannot be queried when filtering by `event:name`"
277
- }
278
- end
279
- end
280
-
281
- test "aggregates a single metric", %{conn: conn, site: site} do
282
- populate_stats(site, [
283
- build(:pageview, user_id: @user_id, timestamp: ~N[2021-01-01 00:00:00]),
284
- build(:pageview, user_id: @user_id, timestamp: ~N[2021-01-01 00:25:00]),
285
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
286
- ])
287
-
288
- conn =
289
- get(conn, "/api/v1/stats/aggregate", %{
290
- "site_id" => site.domain,
291
- "period" => "day",
292
- "date" => "2021-01-01",
293
- "metrics" => "pageviews"
294
- })
295
-
296
- assert json_response(conn, 200)["results"] == %{
297
- "pageviews" => %{"value" => 3}
298
- }
299
- end
300
-
301
- test "rounds views_per_visit to two decimal places", %{
302
- conn: conn,
303
- site: site
304
- } do
305
- populate_stats(site, [
306
- build(:pageview, user_id: @user_id, timestamp: ~N[2021-01-01 00:00:00]),
307
- build(:pageview, user_id: @user_id, timestamp: ~N[2021-01-01 00:25:00]),
308
- build(:pageview, user_id: 456, timestamp: ~N[2021-01-01 00:00:00]),
309
- build(:pageview, user_id: 456, timestamp: ~N[2021-01-01 00:25:00]),
310
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
311
- ])
312
-
313
- conn =
314
- get(conn, "/api/v1/stats/aggregate", %{
315
- "site_id" => site.domain,
316
- "period" => "day",
317
- "date" => "2021-01-01",
318
- "metrics" => "views_per_visit"
319
- })
320
-
321
- assert json_response(conn, 200)["results"] == %{
322
- "views_per_visit" => %{"value" => 1.67}
323
- }
324
- end
325
-
326
- test "aggregates all metrics in a single query", %{
327
- conn: conn,
328
- site: site
329
- } do
330
- populate_stats(site, [
331
- build(:pageview, user_id: @user_id, timestamp: ~N[2021-01-01 00:00:00]),
332
- build(:pageview, user_id: @user_id, timestamp: ~N[2021-01-01 00:25:00]),
333
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
334
- ])
335
-
336
- conn =
337
- get(conn, "/api/v1/stats/aggregate", %{
338
- "site_id" => site.domain,
339
- "period" => "day",
340
- "date" => "2021-01-01",
341
- "metrics" => "pageviews,visits,views_per_visit,visitors,bounce_rate,visit_duration"
342
- })
343
-
344
- assert json_response(conn, 200)["results"] == %{
345
- "pageviews" => %{"value" => 3},
346
- "visitors" => %{"value" => 2},
347
- "visits" => %{"value" => 2},
348
- "views_per_visit" => %{"value" => 1.5},
349
- "bounce_rate" => %{"value" => 50},
350
- "visit_duration" => %{"value" => 750}
351
- }
352
- end
353
-
354
- describe "comparisons" do
355
- test "compare period=day with previous period", %{conn: conn, site: site} do
356
- populate_stats(site, [
357
- build(:pageview, timestamp: ~N[2020-12-31 00:00:00]),
358
- build(:pageview,
359
- user_id: @user_id,
360
- timestamp: ~N[2021-01-01 00:00:00]
361
- ),
362
- build(:pageview,
363
- user_id: @user_id,
364
- timestamp: ~N[2021-01-01 00:25:00]
365
- ),
366
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
367
- ])
368
-
369
- conn =
370
- get(conn, "/api/v1/stats/aggregate", %{
371
- "site_id" => site.domain,
372
- "period" => "day",
373
- "date" => "2021-01-01",
374
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
375
- "compare" => "previous_period"
376
- })
377
-
378
- assert json_response(conn, 200)["results"] == %{
379
- "pageviews" => %{"value" => 3, "change" => 200, "comparison_value" => 1},
380
- "visitors" => %{"value" => 2, "change" => 100, "comparison_value" => 1},
381
- "bounce_rate" => %{"value" => 50, "change" => -50, "comparison_value" => 100},
382
- "visit_duration" => %{"value" => 750, "change" => 100, "comparison_value" => 0}
383
- }
384
- end
385
-
386
- test "compare period=6mo with previous period", %{conn: conn, site: site} do
387
- populate_stats(site, [
388
- build(:pageview, timestamp: ~N[2020-12-31 00:00:00]),
389
- build(:pageview,
390
- user_id: @user_id,
391
- timestamp: ~N[2021-01-01 00:00:00]
392
- ),
393
- build(:pageview,
394
- user_id: @user_id,
395
- timestamp: ~N[2021-02-01 00:25:00]
396
- ),
397
- build(:pageview, timestamp: ~N[2021-03-01 00:00:00])
398
- ])
399
-
400
- conn =
401
- get(conn, "/api/v1/stats/aggregate", %{
402
- "site_id" => site.domain,
403
- "period" => "6mo",
404
- "date" => "2021-04-11",
405
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
406
- "compare" => "previous_period"
407
- })
408
-
409
- assert json_response(conn, 200)["results"] == %{
410
- "pageviews" => %{"value" => 4, "change" => 100, "comparison_value" => 0},
411
- "visitors" => %{"value" => 3, "change" => 100, "comparison_value" => 0},
412
- "bounce_rate" => %{"value" => 100, "change" => nil, "comparison_value" => 0},
413
- "visit_duration" => %{"value" => 0, "change" => 0, "comparison_value" => 0}
414
- }
415
- end
416
-
417
- test "can compare conversion_rate with previous period", %{conn: conn, site: site} do
418
- today = ~N[2023-05-05 12:00:00]
419
- yesterday = NaiveDateTime.shift(today, day: -1)
420
-
421
- populate_stats(site, [
422
- build(:event, name: "Signup", timestamp: yesterday),
423
- build(:pageview, timestamp: yesterday),
424
- build(:pageview, timestamp: yesterday),
425
- build(:event, name: "Signup", timestamp: today),
426
- build(:pageview, timestamp: today)
427
- ])
428
-
429
- insert(:goal, %{site: site, event_name: "Signup", display_name: "Signup Display Name"})
430
-
431
- conn =
432
- get(conn, "/api/v1/stats/aggregate", %{
433
- "site_id" => site.domain,
434
- "period" => "day",
435
- "date" => "2023-05-05",
436
- "metrics" => "conversion_rate",
437
- "filters" => "event:goal==Signup Display Name",
438
- "compare" => "previous_period"
439
- })
440
-
441
- assert json_response(conn, 200)["results"] == %{
442
- "conversion_rate" => %{
443
- "value" => 50.0,
444
- "change" => 16.7,
445
- "comparison_value" => 33.33
446
- }
447
- }
448
- end
449
-
450
- test "can compare time_on_page with previous period", %{conn: conn, site: site} do
451
- populate_stats(site, [
452
- build(:pageview, pathname: "/A", user_id: 111, timestamp: ~N[2021-01-01 00:00:00]),
453
- build(:engagement,
454
- pathname: "/A",
455
- user_id: 111,
456
- timestamp: ~N[2021-01-01 00:01:00],
457
- engagement_time: 60_000
458
- ),
459
- build(:pageview, pathname: "/B", user_id: 111, timestamp: ~N[2021-01-01 00:01:00]),
460
- build(:pageview, pathname: "/A", user_id: 999, timestamp: ~N[2021-01-02 00:00:00]),
461
- build(:engagement,
462
- pathname: "/A",
463
- user_id: 999,
464
- timestamp: ~N[2021-01-02 00:01:30],
465
- engagement_time: 90_000
466
- ),
467
- build(:pageview, pathname: "/B", user_id: 999, timestamp: ~N[2021-01-02 00:01:30])
468
- ])
469
-
470
- insert(:goal, %{site: site, event_name: "Signup"})
471
-
472
- conn =
473
- get(conn, "/api/v1/stats/aggregate", %{
474
- "site_id" => site.domain,
475
- "period" => "day",
476
- "date" => "2021-01-02",
477
- "metrics" => "time_on_page",
478
- "filters" => "event:page==/A",
479
- "compare" => "previous_period"
480
- })
481
-
482
- assert json_response(conn, 200)["results"] == %{
483
- "time_on_page" => %{"value" => 90, "change" => 50.0, "comparison_value" => 60}
484
- }
485
- end
486
-
487
- test "time_on_page change is nil if previous period returns a number but current period is nil",
488
- %{conn: conn, site: site} do
489
- populate_stats(site, [
490
- build(:pageview, pathname: "/A", user_id: 123, timestamp: ~N[2021-01-01 00:00:00]),
491
- build(:engagement,
492
- pathname: "/A",
493
- user_id: 123,
494
- timestamp: ~N[2021-01-01 00:01:00],
495
- engagement_time: 60_000
496
- ),
497
- build(:pageview, pathname: "/B", user_id: 123, timestamp: ~N[2021-01-01 00:01:00]),
498
- build(:pageview, pathname: "/A", timestamp: ~N[2021-01-02 00:00:00])
499
- ])
500
-
501
- insert(:goal, %{site: site, event_name: "Signup"})
502
-
503
- conn =
504
- get(conn, "/api/v1/stats/aggregate", %{
505
- "site_id" => site.domain,
506
- "period" => "day",
507
- "date" => "2021-01-02",
508
- "metrics" => "time_on_page",
509
- "filters" => "event:page==/A",
510
- "compare" => "previous_period"
511
- })
512
-
513
- assert json_response(conn, 200)["results"] == %{
514
- "time_on_page" => %{"value" => nil, "change" => nil, "comparison_value" => 60}
515
- }
516
- end
517
- end
518
-
519
- describe "with imported data" do
520
- setup :create_site_import
521
-
522
- test "does not count imported stats unless specified", %{
523
- conn: conn,
524
- site: site,
525
- site_import: site_import
526
- } do
527
- populate_stats(site, site_import.id, [
528
- build(:imported_visitors, date: ~D[2023-01-01]),
529
- build(:pageview, timestamp: ~N[2023-01-01 00:00:00])
530
- ])
531
-
532
- query_params = %{
533
- "site_id" => site.domain,
534
- "period" => "day",
535
- "date" => "2023-01-01",
536
- "metrics" => "pageviews"
537
- }
538
-
539
- conn1 = get(conn, "/api/v1/stats/aggregate", query_params)
540
-
541
- assert json_response(conn1, 200)["results"] == %{
542
- "pageviews" => %{"value" => 1}
543
- }
544
-
545
- conn2 = get(conn, "/api/v1/stats/aggregate", Map.put(query_params, "with_imported", "true"))
546
-
547
- assert json_response(conn2, 200)["results"] == %{
548
- "pageviews" => %{"value" => 2}
549
- }
550
-
551
- refute json_response(conn2, 200)["warning"]
552
- end
553
-
554
- test "counts imported stats when comparing with previous period", %{
555
- conn: conn,
556
- site: site,
557
- site_import: site_import
558
- } do
559
- populate_stats(site, site_import.id, [
560
- build(:imported_visitors,
561
- visits: 2,
562
- bounces: 1,
563
- visit_duration: 200,
564
- pageviews: 10,
565
- date: ~D[2023-01-01]
566
- ),
567
- build(:imported_visitors,
568
- visits: 4,
569
- bounces: 1,
570
- visit_duration: 100,
571
- pageviews: 8,
572
- date: ~D[2023-01-02]
573
- ),
574
- build(:pageview, timestamp: ~N[2023-01-02 00:10:00])
575
- ])
576
-
577
- conn =
578
- get(conn, "/api/v1/stats/aggregate", %{
579
- "site_id" => site.domain,
580
- "period" => "custom",
581
- "date" => "2023-01-02,2023-01-02",
582
- "metrics" => "visitors,visits,pageviews,views_per_visit,bounce_rate,visit_duration",
583
- "compare" => "previous_period",
584
- "with_imported" => "true"
585
- })
586
-
587
- assert json_response(conn, 200)["results"] == %{
588
- "visitors" => %{"value" => 2, "change" => 100, "comparison_value" => 1},
589
- "visits" => %{"value" => 5, "change" => 150, "comparison_value" => 2},
590
- "pageviews" => %{"value" => 9, "change" => -10, "comparison_value" => 10},
591
- "bounce_rate" => %{"value" => 40, "change" => -10, "comparison_value" => 50},
592
- "views_per_visit" => %{"value" => 1.8, "change" => -64, "comparison_value" => 5.0},
593
- "visit_duration" => %{"value" => 20, "change" => -80, "comparison_value" => 100}
594
- }
595
- end
596
-
597
- test "includes imported data in comparison when filter applied", %{
598
- conn: conn,
599
- site: site,
600
- site_import: site_import
601
- } do
602
- populate_stats(site, site_import.id, [
603
- build(:imported_visitors, date: ~D[2023-01-01]),
604
- build(:imported_sources, source: "Google", date: ~D[2023-01-01], visitors: 3),
605
- build(:pageview,
606
- referrer_source: "Google",
607
- timestamp: ~N[2023-01-02 00:10:00]
608
- )
609
- ])
610
-
611
- conn =
612
- get(conn, "/api/v1/stats/aggregate", %{
613
- "site_id" => site.domain,
614
- "period" => "day",
615
- "date" => "2023-01-02",
616
- "metrics" => "visitors",
617
- "filters" => "visit:source==Google",
618
- "compare" => "previous_period",
619
- "with_imported" => "true"
620
- })
621
-
622
- assert json_response(conn, 200)["results"] == %{
623
- "visitors" => %{"value" => 1, "change" => -67, "comparison_value" => 3}
624
- }
625
- end
626
-
627
- test "adds a warning when query params are not supported for imported data", %{
628
- conn: conn,
629
- site: site,
630
- site_import: site_import
631
- } do
632
- populate_stats(site, site_import.id, [
633
- build(:event,
634
- name: "Signup",
635
- "meta.key": ["package"],
636
- "meta.value": ["large"]
637
- ),
638
- build(:imported_visitors, visitors: 9)
639
- ])
640
-
641
- conn =
642
- get(conn, "/api/v1/stats/aggregate", %{
643
- "site_id" => site.domain,
644
- "period" => "day",
645
- "metrics" => "visitors",
646
- "filters" => "event:props:package==large",
647
- "compare" => "previous_period",
648
- "with_imported" => "true"
649
- })
650
-
651
- assert json_response(conn, 200)["results"] == %{
652
- "visitors" => %{"change" => 100, "value" => 1, "comparison_value" => 0}
653
- }
654
-
655
- assert json_response(conn, 200)["warning"] =~
656
- "Imported stats are not included in the results because query parameters are not supported."
657
- end
658
-
659
- test "does not add a warning when there are no site imports", %{
660
- conn: conn,
661
- site: site,
662
- site_import: site_import
663
- } do
664
- Plausible.Repo.delete!(site_import)
665
-
666
- populate_stats(site, [
667
- build(:event,
668
- name: "Signup",
669
- "meta.key": ["package"],
670
- "meta.value": ["large"]
671
- )
672
- ])
673
-
674
- conn =
675
- get(conn, "/api/v1/stats/aggregate", %{
676
- "site_id" => site.domain,
677
- "period" => "day",
678
- "metrics" => "visitors",
679
- "filters" => "event:props:package==large",
680
- "compare" => "previous_period",
681
- "with_imported" => "true"
682
- })
683
-
684
- refute json_response(conn, 200)["warning"]
685
- end
686
-
687
- test "does not add a warning when import is out of queried date range", %{
688
- conn: conn,
689
- site: site,
690
- site_import: site_import
691
- } do
692
- site_import
693
- |> Ecto.Changeset.change(end_date: Date.add(Date.utc_today(), -3))
694
- |> Plausible.Repo.update!()
695
-
696
- populate_stats(site, site_import.id, [
697
- build(:event,
698
- name: "Signup",
699
- "meta.key": ["package"],
700
- "meta.value": ["large"]
701
- ),
702
- build(:imported_visitors, visitors: 9)
703
- ])
704
-
705
- conn =
706
- get(conn, "/api/v1/stats/aggregate", %{
707
- "site_id" => site.domain,
708
- "period" => "day",
709
- "metrics" => "visitors",
710
- "filters" => "event:props:package==large",
711
- "compare" => "previous_period",
712
- "with_imported" => "true"
713
- })
714
-
715
- refute json_response(conn, 200)["warning"]
716
- end
717
-
718
- test "excludes imported data from conversion rate computation when query filters by non-imported props",
719
- %{conn: conn, site: site, site_import: site_import} do
720
- insert(:goal, site: site, event_name: "Purchase")
721
-
722
- populate_stats(site, site_import.id, [
723
- build(:event,
724
- name: "Purchase",
725
- "meta.key": ["package"],
726
- "meta.value": ["large"]
727
- ),
728
- build(:imported_visitors, visitors: 9)
729
- ])
730
-
731
- conn =
732
- get(conn, "/api/v1/stats/aggregate", %{
733
- "site_id" => site.domain,
734
- "period" => "day",
735
- "metrics" => "visitors,conversion_rate",
736
- "filters" => "event:goal==Purchase;event:props:package==large",
737
- "with_imported" => "true"
738
- })
739
-
740
- assert json_response(conn, 200)["results"] == %{
741
- "visitors" => %{"value" => 1},
742
- "conversion_rate" => %{"value" => 100.0}
743
- }
744
- end
745
-
746
- test "returns stats with page + pageview goal filter",
747
- %{conn: conn, site: site, site_import: site_import} do
748
- insert(:goal, site: site, page_path: "/blog/**", display_name: "Blog Visit")
749
-
750
- populate_stats(site, site_import.id, [
751
- build(:imported_pages, page: "/blog/1", visitors: 1, pageviews: 1),
752
- build(:imported_pages, page: "/blog/2", visitors: 2, pageviews: 2),
753
- build(:imported_pages, visitors: 3)
754
- ])
755
-
756
- conn =
757
- get(conn, "/api/v1/stats/aggregate", %{
758
- "site_id" => site.domain,
759
- "period" => "day",
760
- "metrics" => "visitors,events,conversion_rate",
761
- "filters" => "event:page==/blog/2;event:goal==Blog Visit",
762
- "with_imported" => "true"
763
- })
764
-
765
- assert json_response(conn, 200)["results"] == %{
766
- "visitors" => %{"value" => 2},
767
- "events" => %{"value" => 2},
768
- "conversion_rate" => %{"value" => 100.0}
769
- }
770
- end
771
- end
772
-
773
- describe "filters" do
774
- test "event:goal filter returns 400 when goal not configured", %{conn: conn, site: site} do
775
- conn =
776
- get(conn, "/api/v1/stats/aggregate", %{
777
- "site_id" => site.domain,
778
- "filters" => "event:goal==Register|Visit /register"
779
- })
780
-
781
- assert %{"error" => msg} = json_response(conn, 400)
782
- assert msg =~ "The goal `Register` is not configured for this site. Find out how"
783
- end
784
-
785
- test "validates that filters are valid", %{conn: conn, site: site} do
786
- conn =
787
- get(conn, "/api/v1/stats/aggregate", %{
788
- "site_id" => site.domain,
789
- "property" => "event:page",
790
- "filters" => "badproperty==bar"
791
- })
792
-
793
- assert json_response(conn, 400) == %{
794
- "error" =>
795
- "Invalid filter property 'badproperty'. Please provide a valid filter property: https://plausible.io/docs/stats-api#properties"
796
- }
797
- end
798
-
799
- test "can filter by source", %{conn: conn, site: site} do
800
- populate_stats(site, [
801
- build(:pageview,
802
- referrer_source: "Google",
803
- user_id: @user_id,
804
- timestamp: ~N[2021-01-01 00:00:00]
805
- ),
806
- build(:pageview,
807
- user_id: @user_id,
808
- timestamp: ~N[2021-01-01 00:25:00]
809
- ),
810
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
811
- ])
812
-
813
- conn =
814
- get(conn, "/api/v1/stats/aggregate", %{
815
- "site_id" => site.domain,
816
- "period" => "day",
817
- "date" => "2021-01-01",
818
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
819
- "filters" => "visit:source==Google"
820
- })
821
-
822
- assert json_response(conn, 200)["results"] == %{
823
- "pageviews" => %{"value" => 2},
824
- "visitors" => %{"value" => 1},
825
- "bounce_rate" => %{"value" => 0},
826
- "visit_duration" => %{"value" => 1500}
827
- }
828
- end
829
-
830
- test "can filter by no source/referrer", %{conn: conn, site: site} do
831
- populate_stats(site, [
832
- build(:pageview,
833
- user_id: @user_id,
834
- timestamp: ~N[2021-01-01 00:00:00]
835
- ),
836
- build(:pageview,
837
- user_id: @user_id,
838
- timestamp: ~N[2021-01-01 00:25:00]
839
- ),
840
- build(:pageview,
841
- referrer_source: "Google",
842
- timestamp: ~N[2021-01-01 00:00:00]
843
- )
844
- ])
845
-
846
- conn =
847
- get(conn, "/api/v1/stats/aggregate", %{
848
- "site_id" => site.domain,
849
- "period" => "day",
850
- "date" => "2021-01-01",
851
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
852
- "filters" => "visit:source==Direct / None"
853
- })
854
-
855
- assert json_response(conn, 200)["results"] == %{
856
- "pageviews" => %{"value" => 2},
857
- "visitors" => %{"value" => 1},
858
- "bounce_rate" => %{"value" => 0},
859
- "visit_duration" => %{"value" => 1500}
860
- }
861
- end
862
-
863
- test "can filter by referrer", %{conn: conn, site: site} do
864
- populate_stats(site, [
865
- build(:pageview,
866
- referrer: "https://facebook.com",
867
- user_id: @user_id,
868
- timestamp: ~N[2021-01-01 00:00:00]
869
- ),
870
- build(:pageview,
871
- user_id: @user_id,
872
- timestamp: ~N[2021-01-01 00:25:00]
873
- ),
874
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
875
- ])
876
-
877
- conn =
878
- get(conn, "/api/v1/stats/aggregate", %{
879
- "site_id" => site.domain,
880
- "period" => "day",
881
- "date" => "2021-01-01",
882
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
883
- "filters" => "visit:referrer==https://facebook.com"
884
- })
885
-
886
- assert json_response(conn, 200)["results"] == %{
887
- "pageviews" => %{"value" => 2},
888
- "visitors" => %{"value" => 1},
889
- "bounce_rate" => %{"value" => 0},
890
- "visit_duration" => %{"value" => 1500}
891
- }
892
- end
893
-
894
- test "wildcard referrer filter with special regex characters", %{conn: conn, site: site} do
895
- populate_stats(site, [
896
- build(:pageview, referrer: "https://a.com"),
897
- build(:pageview, referrer: "https://a.com"),
898
- build(:pageview, referrer: "https://ab.com")
899
- ])
900
-
901
- conn =
902
- get(conn, "/api/v1/stats/aggregate?period=day", %{
903
- "site_id" => site.domain,
904
- "metrics" => "visitors",
905
- "filters" => "visit:referrer==**a.com**"
906
- })
907
-
908
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 2}}
909
- end
910
-
911
- test "can filter by utm_medium", %{conn: conn, site: site} do
912
- populate_stats(site, [
913
- build(:pageview,
914
- utm_medium: "social",
915
- user_id: @user_id,
916
- timestamp: ~N[2021-01-01 00:00:00]
917
- ),
918
- build(:pageview,
919
- user_id: @user_id,
920
- timestamp: ~N[2021-01-01 00:25:00]
921
- ),
922
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
923
- ])
924
-
925
- conn =
926
- get(conn, "/api/v1/stats/aggregate", %{
927
- "site_id" => site.domain,
928
- "period" => "day",
929
- "date" => "2021-01-01",
930
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
931
- "filters" => "visit:utm_medium==social"
932
- })
933
-
934
- assert json_response(conn, 200)["results"] == %{
935
- "pageviews" => %{"value" => 2},
936
- "visitors" => %{"value" => 1},
937
- "bounce_rate" => %{"value" => 0},
938
- "visit_duration" => %{"value" => 1500}
939
- }
940
- end
941
-
942
- test "can filter by utm_source", %{conn: conn, site: site} do
943
- populate_stats(site, [
944
- build(:pageview,
945
- utm_source: "Twitter",
946
- user_id: @user_id,
947
- timestamp: ~N[2021-01-01 00:00:00]
948
- ),
949
- build(:pageview,
950
- user_id: @user_id,
951
- timestamp: ~N[2021-01-01 00:25:00]
952
- ),
953
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
954
- ])
955
-
956
- conn =
957
- get(conn, "/api/v1/stats/aggregate", %{
958
- "site_id" => site.domain,
959
- "period" => "day",
960
- "date" => "2021-01-01",
961
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
962
- "filters" => "visit:utm_source==Twitter"
963
- })
964
-
965
- assert json_response(conn, 200)["results"] == %{
966
- "pageviews" => %{"value" => 2},
967
- "visitors" => %{"value" => 1},
968
- "bounce_rate" => %{"value" => 0},
969
- "visit_duration" => %{"value" => 1500}
970
- }
971
- end
972
-
973
- test "can filter by utm_campaign", %{conn: conn, site: site} do
974
- populate_stats(site, [
975
- build(:pageview,
976
- utm_campaign: "profile",
977
- user_id: @user_id,
978
- timestamp: ~N[2021-01-01 00:00:00]
979
- ),
980
- build(:pageview,
981
- user_id: @user_id,
982
- timestamp: ~N[2021-01-01 00:25:00]
983
- ),
984
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
985
- ])
986
-
987
- conn =
988
- get(conn, "/api/v1/stats/aggregate", %{
989
- "site_id" => site.domain,
990
- "period" => "day",
991
- "date" => "2021-01-01",
992
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
993
- "filters" => "visit:utm_campaign==profile"
994
- })
995
-
996
- assert json_response(conn, 200)["results"] == %{
997
- "pageviews" => %{"value" => 2},
998
- "visitors" => %{"value" => 1},
999
- "bounce_rate" => %{"value" => 0},
1000
- "visit_duration" => %{"value" => 1500}
1001
- }
1002
- end
1003
-
1004
- test "can filter by device type", %{conn: conn, site: site} do
1005
- populate_stats(site, [
1006
- build(:pageview,
1007
- screen_size: "Desktop",
1008
- user_id: @user_id,
1009
- timestamp: ~N[2021-01-01 00:00:00]
1010
- ),
1011
- build(:pageview,
1012
- user_id: @user_id,
1013
- timestamp: ~N[2021-01-01 00:25:00]
1014
- ),
1015
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
1016
- ])
1017
-
1018
- conn =
1019
- get(conn, "/api/v1/stats/aggregate", %{
1020
- "site_id" => site.domain,
1021
- "period" => "day",
1022
- "date" => "2021-01-01",
1023
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
1024
- "filters" => "visit:device==Desktop"
1025
- })
1026
-
1027
- assert json_response(conn, 200)["results"] == %{
1028
- "pageviews" => %{"value" => 2},
1029
- "visitors" => %{"value" => 1},
1030
- "bounce_rate" => %{"value" => 0},
1031
- "visit_duration" => %{"value" => 1500}
1032
- }
1033
- end
1034
-
1035
- test "can filter by browser", %{conn: conn, site: site} do
1036
- populate_stats(site, [
1037
- build(:pageview,
1038
- browser: "Chrome",
1039
- user_id: @user_id,
1040
- timestamp: ~N[2021-01-01 00:00:00]
1041
- ),
1042
- build(:pageview,
1043
- user_id: @user_id,
1044
- timestamp: ~N[2021-01-01 00:25:00]
1045
- ),
1046
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
1047
- ])
1048
-
1049
- conn =
1050
- get(conn, "/api/v1/stats/aggregate", %{
1051
- "site_id" => site.domain,
1052
- "period" => "day",
1053
- "date" => "2021-01-01",
1054
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
1055
- "filters" => "visit:browser==Chrome"
1056
- })
1057
-
1058
- assert json_response(conn, 200)["results"] == %{
1059
- "pageviews" => %{"value" => 2},
1060
- "visitors" => %{"value" => 1},
1061
- "bounce_rate" => %{"value" => 0},
1062
- "visit_duration" => %{"value" => 1500}
1063
- }
1064
- end
1065
-
1066
- test "can filter by browser version", %{conn: conn, site: site} do
1067
- populate_stats(site, [
1068
- build(:pageview,
1069
- browser: "Chrome",
1070
- browser_version: "56",
1071
- user_id: @user_id,
1072
- timestamp: ~N[2021-01-01 00:00:00]
1073
- ),
1074
- build(:pageview,
1075
- user_id: @user_id,
1076
- timestamp: ~N[2021-01-01 00:25:00]
1077
- ),
1078
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
1079
- ])
1080
-
1081
- conn =
1082
- get(conn, "/api/v1/stats/aggregate", %{
1083
- "site_id" => site.domain,
1084
- "period" => "day",
1085
- "date" => "2021-01-01",
1086
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
1087
- "filters" => "visit:browser_version==56"
1088
- })
1089
-
1090
- assert json_response(conn, 200)["results"] == %{
1091
- "pageviews" => %{"value" => 2},
1092
- "visitors" => %{"value" => 1},
1093
- "bounce_rate" => %{"value" => 0},
1094
- "visit_duration" => %{"value" => 1500}
1095
- }
1096
- end
1097
-
1098
- test "can filter by operating system", %{conn: conn, site: site} do
1099
- populate_stats(site, [
1100
- build(:pageview,
1101
- operating_system: "Mac",
1102
- user_id: @user_id,
1103
- timestamp: ~N[2021-01-01 00:00:00]
1104
- ),
1105
- build(:pageview,
1106
- user_id: @user_id,
1107
- timestamp: ~N[2021-01-01 00:25:00]
1108
- ),
1109
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
1110
- ])
1111
-
1112
- conn =
1113
- get(conn, "/api/v1/stats/aggregate", %{
1114
- "site_id" => site.domain,
1115
- "period" => "day",
1116
- "date" => "2021-01-01",
1117
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
1118
- "filters" => "visit:os==Mac"
1119
- })
1120
-
1121
- assert json_response(conn, 200)["results"] == %{
1122
- "pageviews" => %{"value" => 2},
1123
- "visitors" => %{"value" => 1},
1124
- "bounce_rate" => %{"value" => 0},
1125
- "visit_duration" => %{"value" => 1500}
1126
- }
1127
- end
1128
-
1129
- test "can filter by operating system version", %{conn: conn, site: site} do
1130
- populate_stats(site, [
1131
- build(:pageview,
1132
- operating_system_version: "10.5",
1133
- user_id: @user_id,
1134
- timestamp: ~N[2021-01-01 00:00:00]
1135
- ),
1136
- build(:pageview,
1137
- user_id: @user_id,
1138
- timestamp: ~N[2021-01-01 00:25:00]
1139
- ),
1140
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
1141
- ])
1142
-
1143
- conn =
1144
- get(conn, "/api/v1/stats/aggregate", %{
1145
- "site_id" => site.domain,
1146
- "period" => "day",
1147
- "date" => "2021-01-01",
1148
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
1149
- "filters" => "visit:os_version==10.5"
1150
- })
1151
-
1152
- assert json_response(conn, 200)["results"] == %{
1153
- "pageviews" => %{"value" => 2},
1154
- "visitors" => %{"value" => 1},
1155
- "bounce_rate" => %{"value" => 0},
1156
- "visit_duration" => %{"value" => 1500}
1157
- }
1158
- end
1159
-
1160
- test "can filter by country", %{conn: conn, site: site} do
1161
- populate_stats(site, [
1162
- build(:pageview,
1163
- country_code: "EE",
1164
- user_id: @user_id,
1165
- timestamp: ~N[2021-01-01 00:00:00]
1166
- ),
1167
- build(:pageview,
1168
- user_id: @user_id,
1169
- timestamp: ~N[2021-01-01 00:25:00]
1170
- ),
1171
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
1172
- ])
1173
-
1174
- conn =
1175
- get(conn, "/api/v1/stats/aggregate", %{
1176
- "site_id" => site.domain,
1177
- "period" => "day",
1178
- "date" => "2021-01-01",
1179
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
1180
- "filters" => "visit:country==EE"
1181
- })
1182
-
1183
- assert json_response(conn, 200)["results"] == %{
1184
- "pageviews" => %{"value" => 2},
1185
- "visitors" => %{"value" => 1},
1186
- "bounce_rate" => %{"value" => 0},
1187
- "visit_duration" => %{"value" => 1500}
1188
- }
1189
- end
1190
-
1191
- test "can filter by page", %{
1192
- conn: conn,
1193
- site: site
1194
- } do
1195
- populate_stats(site, [
1196
- build(:pageview,
1197
- user_id: @user_id,
1198
- timestamp: ~N[2021-01-01 00:00:00]
1199
- ),
1200
- build(:pageview,
1201
- user_id: @user_id,
1202
- pathname: "/blogpost",
1203
- timestamp: ~N[2021-01-01 00:25:00]
1204
- ),
1205
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
1206
- build(:pageview,
1207
- pathname: "/blogpost",
1208
- timestamp: ~N[2021-01-01 00:00:00]
1209
- )
1210
- ])
1211
-
1212
- conn =
1213
- get(conn, "/api/v1/stats/aggregate", %{
1214
- "site_id" => site.domain,
1215
- "period" => "day",
1216
- "date" => "2021-01-01",
1217
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
1218
- "filters" => "event:page==/blogpost"
1219
- })
1220
-
1221
- assert json_response(conn, 200)["results"] == %{
1222
- "pageviews" => %{"value" => 2},
1223
- "visitors" => %{"value" => 2},
1224
- "bounce_rate" => %{"value" => 100},
1225
- "visit_duration" => %{"value" => 750}
1226
- }
1227
- end
1228
-
1229
- test "can filter by hostname", %{conn: conn, site: site} do
1230
- populate_stats(site, [
1231
- build(:pageview,
1232
- hostname: "one.example.com",
1233
- timestamp: ~N[2021-01-01 00:00:00]
1234
- ),
1235
- build(:pageview,
1236
- hostname: "example.com",
1237
- timestamp: ~N[2021-01-01 00:25:00]
1238
- ),
1239
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
1240
- ])
1241
-
1242
- conn =
1243
- get(conn, "/api/v1/stats/aggregate", %{
1244
- "site_id" => site.domain,
1245
- "period" => "day",
1246
- "date" => "2021-01-01",
1247
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
1248
- "filters" => "event:hostname==*.example.com|example.com"
1249
- })
1250
-
1251
- assert json_response(conn, 200)["results"] == %{
1252
- "pageviews" => %{"value" => 2},
1253
- "visitors" => %{"value" => 2},
1254
- "bounce_rate" => %{"value" => 100},
1255
- "visit_duration" => %{"value" => 0}
1256
- }
1257
- end
1258
-
1259
- test "filtering by event:name", %{conn: conn, site: site} do
1260
- populate_stats(site, [
1261
- build(:event,
1262
- name: "Signup",
1263
- timestamp: ~N[2021-01-01 00:00:00]
1264
- ),
1265
- build(:event,
1266
- name: "Signup",
1267
- user_id: @user_id,
1268
- timestamp: ~N[2021-01-01 00:25:00]
1269
- ),
1270
- build(:event,
1271
- name: "Signup",
1272
- user_id: @user_id,
1273
- timestamp: ~N[2021-01-01 00:25:00]
1274
- ),
1275
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00])
1276
- ])
1277
-
1278
- conn =
1279
- get(conn, "/api/v1/stats/aggregate", %{
1280
- "site_id" => site.domain,
1281
- "period" => "day",
1282
- "date" => "2021-01-01",
1283
- "metrics" => "visitors,pageviews",
1284
- "filters" => "event:name==Signup"
1285
- })
1286
-
1287
- assert json_response(conn, 200)["results"] == %{
1288
- "pageviews" => %{"value" => 0},
1289
- "visitors" => %{"value" => 2}
1290
- }
1291
- end
1292
-
1293
- test "filtering by a custom event goal", %{conn: conn, site: site} do
1294
- populate_stats(site, [
1295
- build(:event,
1296
- name: "Signup",
1297
- timestamp: ~N[2021-01-01 00:00:00]
1298
- ),
1299
- build(:event,
1300
- name: "Signup",
1301
- user_id: @user_id,
1302
- timestamp: ~N[2021-01-01 00:25:00]
1303
- ),
1304
- build(:event,
1305
- name: "Signup",
1306
- user_id: @user_id,
1307
- timestamp: ~N[2021-01-01 00:25:00]
1308
- ),
1309
- build(:event,
1310
- name: "NotConfigured",
1311
- timestamp: ~N[2021-01-01 00:25:00]
1312
- )
1313
- ])
1314
-
1315
- insert(:goal, %{site: site, event_name: "Signup"})
1316
-
1317
- conn =
1318
- get(conn, "/api/v1/stats/aggregate", %{
1319
- "site_id" => site.domain,
1320
- "period" => "day",
1321
- "date" => "2021-01-01",
1322
- "metrics" => "visitors,events",
1323
- "filters" => "event:goal==Signup"
1324
- })
1325
-
1326
- assert json_response(conn, 200)["results"] == %{
1327
- "visitors" => %{"value" => 2},
1328
- "events" => %{"value" => 3}
1329
- }
1330
- end
1331
-
1332
- test "filtering by a revenue goal", %{conn: conn, site: site} do
1333
- populate_stats(site, [
1334
- build(:event,
1335
- name: "Purchase",
1336
- timestamp: ~N[2021-01-01 00:00:00]
1337
- ),
1338
- build(:event,
1339
- name: "Purchase",
1340
- user_id: @user_id,
1341
- timestamp: ~N[2021-01-01 00:25:00]
1342
- ),
1343
- build(:event,
1344
- name: "Purchase",
1345
- user_id: @user_id,
1346
- timestamp: ~N[2021-01-01 00:25:00]
1347
- )
1348
- ])
1349
-
1350
- insert(:goal, site: site, currency: :USD, event_name: "Purchase")
1351
-
1352
- conn =
1353
- get(conn, "/api/v1/stats/aggregate", %{
1354
- "site_id" => site.domain,
1355
- "period" => "day",
1356
- "date" => "2021-01-01",
1357
- "metrics" => "visitors,events",
1358
- "filters" => "event:goal==Purchase"
1359
- })
1360
-
1361
- assert json_response(conn, 200)["results"] == %{
1362
- "visitors" => %{"value" => 2},
1363
- "events" => %{"value" => 3}
1364
- }
1365
- end
1366
-
1367
- test "filtering by a simple pageview goal", %{conn: conn, site: site} do
1368
- populate_stats(site, [
1369
- build(:pageview,
1370
- pathname: "/register",
1371
- timestamp: ~N[2021-01-01 00:00:00]
1372
- ),
1373
- build(:pageview,
1374
- pathname: "/register",
1375
- user_id: @user_id,
1376
- timestamp: ~N[2021-01-01 00:25:00]
1377
- ),
1378
- build(:pageview,
1379
- pathname: "/register",
1380
- user_id: @user_id,
1381
- timestamp: ~N[2021-01-01 00:25:00]
1382
- ),
1383
- build(:pageview,
1384
- pathname: "/",
1385
- timestamp: ~N[2021-01-01 00:25:00]
1386
- )
1387
- ])
1388
-
1389
- insert(:goal, %{site: site, page_path: "/register"})
1390
-
1391
- conn =
1392
- get(conn, "/api/v1/stats/aggregate", %{
1393
- "site_id" => site.domain,
1394
- "period" => "day",
1395
- "date" => "2021-01-01",
1396
- "metrics" => "visitors,pageviews",
1397
- "filters" => "event:goal==Visit /register"
1398
- })
1399
-
1400
- assert json_response(conn, 200)["results"] == %{
1401
- "visitors" => %{"value" => 2},
1402
- "pageviews" => %{"value" => 3}
1403
- }
1404
- end
1405
-
1406
- test "filtering by a wildcard pageview goal", %{conn: conn, site: site} do
1407
- populate_stats(site, [
1408
- build(:pageview, pathname: "/blog/post-1"),
1409
- build(:pageview, pathname: "/blog/post-2", user_id: @user_id),
1410
- build(:pageview, pathname: "/blog", user_id: @user_id),
1411
- build(:pageview, pathname: "/")
1412
- ])
1413
-
1414
- insert(:goal, %{site: site, page_path: "/blog**"})
1415
-
1416
- conn =
1417
- get(conn, "/api/v1/stats/aggregate", %{
1418
- "site_id" => site.domain,
1419
- "period" => "day",
1420
- "metrics" => "visitors,pageviews",
1421
- "filters" => "event:goal==Visit /blog**"
1422
- })
1423
-
1424
- assert json_response(conn, 200)["results"] == %{
1425
- "visitors" => %{"value" => 2},
1426
- "pageviews" => %{"value" => 3}
1427
- }
1428
- end
1429
-
1430
- test "filtering by multiple custom event goals", %{conn: conn, site: site} do
1431
- populate_stats(site, [
1432
- build(:event, name: "Signup"),
1433
- build(:event, name: "Purchase", user_id: @user_id),
1434
- build(:event, name: "Purchase", user_id: @user_id),
1435
- build(:pageview)
1436
- ])
1437
-
1438
- insert(:goal, %{site: site, event_name: "Signup"})
1439
- insert(:goal, %{site: site, event_name: "Purchase"})
1440
-
1441
- conn =
1442
- get(conn, "/api/v1/stats/aggregate", %{
1443
- "site_id" => site.domain,
1444
- "period" => "day",
1445
- "metrics" => "visitors,events",
1446
- "filters" => "event:goal==Signup|Purchase"
1447
- })
1448
-
1449
- assert json_response(conn, 200)["results"] == %{
1450
- "visitors" => %{"value" => 2},
1451
- "events" => %{"value" => 3}
1452
- }
1453
- end
1454
-
1455
- test "filtering by multiple mixed goals", %{conn: conn, site: site} do
1456
- populate_stats(site, [
1457
- build(:pageview, pathname: "/account/register"),
1458
- build(:pageview, pathname: "/register", user_id: @user_id),
1459
- build(:event, name: "Signup", user_id: @user_id),
1460
- build(:pageview)
1461
- ])
1462
-
1463
- insert(:goal, %{site: site, event_name: "Signup"})
1464
- insert(:goal, %{site: site, page_path: "/**register"})
1465
-
1466
- conn =
1467
- get(conn, "/api/v1/stats/aggregate", %{
1468
- "site_id" => site.domain,
1469
- "period" => "day",
1470
- "metrics" => "visitors,events,pageviews",
1471
- "filters" => "event:goal==Signup|Visit /**register"
1472
- })
1473
-
1474
- assert json_response(conn, 200)["results"] == %{
1475
- "visitors" => %{"value" => 2},
1476
- "events" => %{"value" => 3},
1477
- "pageviews" => %{"value" => 2}
1478
- }
1479
- end
1480
-
1481
- test "combining filters", %{conn: conn, site: site} do
1482
- populate_stats(site, [
1483
- build(:pageview,
1484
- pathname: "/blogpost",
1485
- country_code: "EE",
1486
- user_id: @user_id,
1487
- timestamp: ~N[2021-01-01 00:00:00]
1488
- ),
1489
- build(:pageview,
1490
- user_id: @user_id,
1491
- timestamp: ~N[2021-01-01 00:25:00]
1492
- ),
1493
- build(:pageview, timestamp: ~N[2021-01-01 00:00:00]),
1494
- build(:pageview,
1495
- pathname: "/blogpost",
1496
- timestamp: ~N[2021-01-01 00:00:00]
1497
- )
1498
- ])
1499
-
1500
- conn =
1501
- get(conn, "/api/v1/stats/aggregate", %{
1502
- "site_id" => site.domain,
1503
- "period" => "day",
1504
- "date" => "2021-01-01",
1505
- "metrics" => "pageviews,visitors,bounce_rate,visit_duration",
1506
- "filters" => "event:page==/blogpost;visit:country==EE"
1507
- })
1508
-
1509
- assert json_response(conn, 200)["results"] == %{
1510
- "pageviews" => %{"value" => 1},
1511
- "visitors" => %{"value" => 1},
1512
- "bounce_rate" => %{"value" => 0},
1513
- "visit_duration" => %{"value" => 1500}
1514
- }
1515
- end
1516
-
1517
- test "wildcard page filter", %{conn: conn, site: site} do
1518
- populate_stats(site, [
1519
- build(:pageview, pathname: "/en/page1"),
1520
- build(:pageview, pathname: "/en/page2"),
1521
- build(:pageview, pathname: "/pl/page1")
1522
- ])
1523
-
1524
- conn =
1525
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1526
- "site_id" => site.domain,
1527
- "metrics" => "visitors",
1528
- "filters" => "event:page==/en/**"
1529
- })
1530
-
1531
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 2}}
1532
- end
1533
-
1534
- test "negated wildcard page filter", %{conn: conn, site: site} do
1535
- populate_stats(site, [
1536
- build(:pageview, pathname: "/en/page1"),
1537
- build(:pageview, pathname: "/en/page2"),
1538
- build(:pageview, pathname: "/pl/page1")
1539
- ])
1540
-
1541
- conn =
1542
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1543
- "site_id" => site.domain,
1544
- "metrics" => "visitors",
1545
- "filters" => "event:page!=/en/**"
1546
- })
1547
-
1548
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 1}}
1549
- end
1550
-
1551
- test "wildcard and member filter combined", %{conn: conn, site: site} do
1552
- populate_stats(site, [
1553
- build(:pageview, pathname: "/en/page1"),
1554
- build(:pageview, pathname: "/en/page2"),
1555
- build(:pageview, pathname: "/pl/page1"),
1556
- build(:pageview, pathname: "/ee/page1")
1557
- ])
1558
-
1559
- conn =
1560
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1561
- "site_id" => site.domain,
1562
- "metrics" => "visitors",
1563
- "filters" => "event:page==/en/**|/pl/**"
1564
- })
1565
-
1566
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 3}}
1567
- end
1568
-
1569
- test "can escape pipe character in member + wildcard filter", %{conn: conn, site: site} do
1570
- populate_stats(site, [
1571
- build(:pageview, pathname: "/blog/post|1"),
1572
- build(:pageview, pathname: "/otherpost|1"),
1573
- build(:pageview, pathname: "/blog/post|2"),
1574
- build(:pageview, pathname: "/something-else")
1575
- ])
1576
-
1577
- conn =
1578
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1579
- "site_id" => site.domain,
1580
- "metrics" => "visitors",
1581
- "filters" => "event:page==**post\\|1|/something-else"
1582
- })
1583
-
1584
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 3}}
1585
- end
1586
-
1587
- test "handles filtering by visit country", %{
1588
- conn: conn,
1589
- site: site
1590
- } do
1591
- populate_stats(site, [
1592
- build(:pageview, country_code: "EE"),
1593
- build(:pageview, country_code: "EE"),
1594
- build(:pageview, country_code: "EE")
1595
- ])
1596
-
1597
- conn =
1598
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1599
- "site_id" => site.domain,
1600
- "metrics" => "pageviews",
1601
- "filters" => "visit:country==EE"
1602
- })
1603
-
1604
- assert json_response(conn, 200)["results"] == %{"pageviews" => %{"value" => 3}}
1605
- end
1606
- end
1607
-
1608
- describe "metrics" do
1609
- test "time_on_page with a page filter", %{conn: conn, site: site} do
1610
- populate_stats(site, [
1611
- build(:pageview,
1612
- pathname: "/A",
1613
- user_id: 123,
1614
- timestamp: ~N[2021-01-01 00:00:00]
1615
- ),
1616
- build(:engagement,
1617
- pathname: "/A",
1618
- user_id: 123,
1619
- timestamp: ~N[2021-01-01 00:01:00],
1620
- engagement_time: 60_000
1621
- ),
1622
- build(:pageview,
1623
- pathname: "/another",
1624
- user_id: 123,
1625
- timestamp: ~N[2021-01-01 00:01:00]
1626
- ),
1627
- build(:pageview,
1628
- pathname: "/A",
1629
- user_id: 321,
1630
- timestamp: ~N[2021-01-01 00:00:00]
1631
- ),
1632
- build(:engagement,
1633
- pathname: "/A",
1634
- user_id: 321,
1635
- timestamp: ~N[2021-01-01 00:01:20],
1636
- engagement_time: 80_000
1637
- ),
1638
- build(:pageview,
1639
- pathname: "/another",
1640
- user_id: 321,
1641
- timestamp: ~N[2021-01-01 00:01:20]
1642
- ),
1643
- build(:pageview, pathname: "/A", timestamp: ~N[2021-01-01 00:00:00])
1644
- ])
1645
-
1646
- conn =
1647
- get(conn, "/api/v1/stats/aggregate", %{
1648
- "site_id" => site.domain,
1649
- "period" => "day",
1650
- "date" => "2021-01-01",
1651
- "metrics" => "time_on_page",
1652
- "filters" => "event:page==/A"
1653
- })
1654
-
1655
- assert json_response(conn, 200)["results"] == %{"time_on_page" => %{"value" => 70}}
1656
- end
1657
-
1658
- test "time_on_page is returned as `nil` if it cannot be calculated", %{conn: conn, site: site} do
1659
- populate_stats(site, [
1660
- build(:pageview, pathname: "/A")
1661
- ])
1662
-
1663
- conn =
1664
- get(conn, "/api/v1/stats/aggregate", %{
1665
- "site_id" => site.domain,
1666
- "metrics" => "time_on_page",
1667
- "filters" => "event:page==/A"
1668
- })
1669
-
1670
- assert json_response(conn, 200)["results"] == %{"time_on_page" => %{"value" => nil}}
1671
- end
1672
-
1673
- test "conversion_rate when goal filter is applied", %{conn: conn, site: site} do
1674
- populate_stats(site, [
1675
- build(:event, name: "Signup"),
1676
- build(:pageview)
1677
- ])
1678
-
1679
- insert(:goal, %{site: site, event_name: "Signup"})
1680
-
1681
- conn =
1682
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1683
- "site_id" => site.domain,
1684
- "metrics" => "conversion_rate",
1685
- "filters" => "event:goal==Signup"
1686
- })
1687
-
1688
- assert json_response(conn, 200)["results"] == %{"conversion_rate" => %{"value" => 50}}
1689
- end
1690
-
1691
- test "conversion_rate when goal + custom prop filter applied", %{
1692
- conn: conn,
1693
- site: site
1694
- } do
1695
- populate_stats(site, [
1696
- build(:event, name: "Signup"),
1697
- build(:event, name: "Signup", "meta.key": ["author"], "meta.value": ["Uku"]),
1698
- build(:event, name: "Signup", "meta.key": ["author"], "meta.value": ["Marko"]),
1699
- build(:pageview)
1700
- ])
1701
-
1702
- insert(:goal, %{site: site, event_name: "Signup"})
1703
-
1704
- conn =
1705
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1706
- "site_id" => site.domain,
1707
- "metrics" => "conversion_rate,visitors,events",
1708
- "filters" => "event:goal==Signup;event:props:author==Uku"
1709
- })
1710
-
1711
- assert %{
1712
- "conversion_rate" => %{"value" => 25.0},
1713
- "visitors" => %{"value" => 1},
1714
- "events" => %{"value" => 1}
1715
- } = json_response(conn, 200)["results"]
1716
- end
1717
-
1718
- test "conversion_rate when goal + visit property filter applied", %{
1719
- conn: conn,
1720
- site: site
1721
- } do
1722
- populate_stats(site, [
1723
- build(:event, name: "Signup"),
1724
- build(:event, name: "Signup", browser: "Chrome"),
1725
- build(:event, name: "Signup", browser: "Firefox", user_id: 123),
1726
- build(:event, name: "Signup", browser: "Firefox", user_id: 123),
1727
- build(:pageview, browser: "Firefox"),
1728
- build(:pageview)
1729
- ])
1730
-
1731
- insert(:goal, %{site: site, event_name: "Signup"})
1732
-
1733
- conn =
1734
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1735
- "site_id" => site.domain,
1736
- "metrics" => "conversion_rate,visitors,events",
1737
- "filters" => "visit:browser==Firefox;event:goal==Signup"
1738
- })
1739
-
1740
- assert %{
1741
- "conversion_rate" => %{"value" => 50.0},
1742
- "visitors" => %{"value" => 1},
1743
- "events" => %{"value" => 2}
1744
- } =
1745
- json_response(conn, 200)["results"]
1746
- end
1747
-
1748
- test "conversion_rate when goal + page filter applied", %{
1749
- conn: conn,
1750
- site: site
1751
- } do
1752
- populate_stats(site, [
1753
- build(:event, name: "Signup"),
1754
- build(:event, name: "Signup", pathname: "/not-this"),
1755
- build(:event, name: "Signup", pathname: "/this", user_id: 123),
1756
- build(:event, name: "Signup", pathname: "/this", user_id: 123),
1757
- build(:pageview, pathname: "/this"),
1758
- build(:pageview)
1759
- ])
1760
-
1761
- insert(:goal, %{site: site, event_name: "Signup"})
1762
-
1763
- conn =
1764
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1765
- "site_id" => site.domain,
1766
- "metrics" => "conversion_rate,visitors,events",
1767
- "filters" => "event:page==/this;event:goal==Signup"
1768
- })
1769
-
1770
- assert %{
1771
- "conversion_rate" => %{"value" => 50.0},
1772
- "visitors" => %{"value" => 1},
1773
- "events" => %{"value" => 2}
1774
- } =
1775
- json_response(conn, 200)["results"]
1776
- end
1777
-
1778
- test "conversion_rate for the filtered goal is 0 when no stats exist", %{
1779
- conn: conn,
1780
- site: site
1781
- } do
1782
- insert(:goal, %{site: site, event_name: "Signup"})
1783
-
1784
- conn =
1785
- get(conn, "/api/v1/stats/aggregate", %{
1786
- "site_id" => site.domain,
1787
- "metrics" => "conversion_rate",
1788
- "filters" => "event:goal==Signup"
1789
- })
1790
-
1791
- assert json_response(conn, 200)["results"] == %{"conversion_rate" => %{"value" => 0}}
1792
- end
1793
- end
1794
-
1795
- describe "with json filters" do
1796
- test "filtering by exact string", %{conn: conn, site: site} do
1797
- populate_stats(site, [
1798
- build(:pageview, pathname: "/en*"),
1799
- build(:pageview, pathname: "/en*/page1"),
1800
- build(:pageview, pathname: "/en*/page2"),
1801
- build(:pageview, pathname: "/ena/page2"),
1802
- build(:pageview, pathname: "/pll/page1")
1803
- ])
1804
-
1805
- conn =
1806
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1807
- "site_id" => site.domain,
1808
- "metrics" => "visitors",
1809
- "filters" => [
1810
- ["is", "event:page", ["/en*"]]
1811
- ]
1812
- })
1813
-
1814
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 1}}
1815
- end
1816
-
1817
- test "filtering by goal", %{conn: conn, site: site} do
1818
- populate_stats(site, [
1819
- build(:pageview, pathname: "/blog/post-1"),
1820
- build(:pageview, pathname: "/blog/post-2", user_id: @user_id),
1821
- build(:pageview, pathname: "/blog", user_id: @user_id),
1822
- build(:pageview, pathname: "/")
1823
- ])
1824
-
1825
- insert(:goal, %{site: site, page_path: "/blog"})
1826
-
1827
- conn =
1828
- get(conn, "/api/v1/stats/aggregate", %{
1829
- "site_id" => site.domain,
1830
- "period" => "day",
1831
- "metrics" => "visitors,pageviews",
1832
- "filters" => [["is", "event:goal", ["Visit /blog"]]]
1833
- })
1834
-
1835
- assert json_response(conn, 200)["results"] == %{
1836
- "visitors" => %{"value" => 1},
1837
- "pageviews" => %{"value" => 1}
1838
- }
1839
- end
1840
-
1841
- test "filtering by wildcard goal", %{conn: conn, site: site} do
1842
- populate_stats(site, [
1843
- build(:pageview, pathname: "/blog/post-1"),
1844
- build(:pageview, pathname: "/blog/post-2", user_id: @user_id),
1845
- build(:pageview, pathname: "/blog", user_id: @user_id),
1846
- build(:pageview, pathname: "/")
1847
- ])
1848
-
1849
- insert(:goal, %{site: site, page_path: "/blog**"})
1850
-
1851
- conn =
1852
- get(conn, "/api/v1/stats/aggregate", %{
1853
- "site_id" => site.domain,
1854
- "period" => "day",
1855
- "metrics" => "visitors,pageviews",
1856
- "filters" => [["is", "event:goal", ["Visit /blog**"]]]
1857
- })
1858
-
1859
- assert json_response(conn, 200)["results"] == %{
1860
- "visitors" => %{"value" => 2},
1861
- "pageviews" => %{"value" => 3}
1862
- }
1863
- end
1864
-
1865
- test "contains", %{conn: conn, site: site} do
1866
- populate_stats(site, [
1867
- build(:pageview, pathname: "/en*"),
1868
- build(:pageview, pathname: "/en*/page1"),
1869
- build(:pageview, pathname: "/en*/page2"),
1870
- build(:pageview, pathname: "/ena/page2"),
1871
- build(:pageview, pathname: "/pll/page1")
1872
- ])
1873
-
1874
- conn =
1875
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1876
- "site_id" => site.domain,
1877
- "metrics" => "visitors",
1878
- "filters" => [
1879
- ["contains", "event:page", ["/en*"]]
1880
- ]
1881
- })
1882
-
1883
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 3}}
1884
- end
1885
-
1886
- test "does not contain", %{conn: conn, site: site} do
1887
- populate_stats(site, [
1888
- build(:pageview, pathname: "/en*"),
1889
- build(:pageview, pathname: "/en*/page1"),
1890
- build(:pageview, pathname: "/en*/page2"),
1891
- build(:pageview, pathname: "/ena/page2"),
1892
- build(:pageview, pathname: "/pll/page1")
1893
- ])
1894
-
1895
- conn =
1896
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1897
- "site_id" => site.domain,
1898
- "metrics" => "visitors",
1899
- "filters" => [
1900
- ["contains_not", "event:page", ["/en*"]]
1901
- ]
1902
- })
1903
-
1904
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 2}}
1905
- end
1906
-
1907
- test "matches custom event property", %{conn: conn, site: site} do
1908
- populate_stats(site, [
1909
- build(:pageview,
1910
- "meta.key": ["tier"],
1911
- "meta.value": ["large-1"]
1912
- ),
1913
- build(:pageview,
1914
- "meta.key": ["tier"],
1915
- "meta.value": ["small-1"]
1916
- ),
1917
- build(:pageview,
1918
- "meta.key": ["tier"],
1919
- "meta.value": ["small-1"]
1920
- ),
1921
- build(:pageview,
1922
- "meta.key": ["tier"],
1923
- "meta.value": ["small-2"]
1924
- )
1925
- ])
1926
-
1927
- conn =
1928
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1929
- "site_id" => site.domain,
1930
- "metrics" => "visitors",
1931
- "filters" => [
1932
- ["matches_wildcard", "event:props:tier", ["small*"]]
1933
- ]
1934
- })
1935
-
1936
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 3}}
1937
- end
1938
-
1939
- test "not matches_wildcard custom event property", %{conn: conn, site: site} do
1940
- populate_stats(site, [
1941
- build(:pageview,
1942
- "meta.key": ["tier"],
1943
- "meta.value": ["large-1"]
1944
- ),
1945
- build(:pageview,
1946
- "meta.key": ["tier"],
1947
- "meta.value": ["small-1"]
1948
- ),
1949
- build(:pageview,
1950
- "meta.key": ["tier"],
1951
- "meta.value": ["small-1"]
1952
- ),
1953
- build(:pageview,
1954
- "meta.key": ["tier"],
1955
- "meta.value": ["small-2"]
1956
- ),
1957
- build(:pageview)
1958
- ])
1959
-
1960
- conn =
1961
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1962
- "site_id" => site.domain,
1963
- "metrics" => "visitors",
1964
- "filters" => [
1965
- ["matches_wildcard_not", "event:props:tier", ["small*"]]
1966
- ]
1967
- })
1968
-
1969
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 1}}
1970
- end
1971
-
1972
- test "contains custom event property", %{conn: conn, site: site} do
1973
- populate_stats(site, [
1974
- build(:pageview,
1975
- "meta.key": ["tier"],
1976
- "meta.value": ["large-1"]
1977
- ),
1978
- build(:pageview,
1979
- "meta.key": ["tier"],
1980
- "meta.value": ["small-1"]
1981
- ),
1982
- build(:pageview,
1983
- "meta.key": ["tier"],
1984
- "meta.value": ["small-1"]
1985
- ),
1986
- build(:pageview,
1987
- "meta.key": ["tier"],
1988
- "meta.value": ["small-2"]
1989
- )
1990
- ])
1991
-
1992
- conn =
1993
- get(conn, "/api/v1/stats/aggregate?period=day", %{
1994
- "site_id" => site.domain,
1995
- "metrics" => "visitors",
1996
- "filters" => [
1997
- ["contains", "event:props:tier", ["small"]]
1998
- ]
1999
- })
2000
-
2001
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 3}}
2002
- end
2003
-
2004
- test "contains_not custom event property", %{conn: conn, site: site} do
2005
- populate_stats(site, [
2006
- build(:pageview,
2007
- "meta.key": ["tier"],
2008
- "meta.value": ["large-1"]
2009
- ),
2010
- build(:pageview,
2011
- "meta.key": ["tier"],
2012
- "meta.value": ["small-1"]
2013
- ),
2014
- build(:pageview,
2015
- "meta.key": ["tier"],
2016
- "meta.value": ["small-1"]
2017
- ),
2018
- build(:pageview,
2019
- "meta.key": ["tier"],
2020
- "meta.value": ["small-2"]
2021
- )
2022
- ])
2023
-
2024
- conn =
2025
- get(conn, "/api/v1/stats/aggregate?period=day", %{
2026
- "site_id" => site.domain,
2027
- "metrics" => "visitors",
2028
- "filters" => [
2029
- ["contains_not", "event:props:tier", ["small"]]
2030
- ]
2031
- })
2032
-
2033
- assert json_response(conn, 200)["results"] == %{"visitors" => %{"value" => 1}}
2034
- end
2035
- end
2036
- end