Leon4gr45 commited on
Commit
dc34bac
·
verified ·
1 Parent(s): 209d3db

Delete test/plausible_web/controllers/auth_controller_test.exs with huggingface_hub

Browse files
test/plausible_web/controllers/auth_controller_test.exs DELETED
@@ -1,2165 +0,0 @@
1
- defmodule PlausibleWeb.AuthControllerTest do
2
- use PlausibleWeb.ConnCase, async: true
3
- use Bamboo.Test
4
- use Plausible.Repo
5
-
6
- import Mox
7
-
8
- require Logger
9
- require Plausible.Billing.Subscription.Status
10
-
11
- alias Plausible.Auth
12
- alias Plausible.Auth.User
13
- alias Plausible.Billing.Subscription
14
-
15
- setup {PlausibleWeb.FirstLaunchPlug.Test, :skip}
16
- setup [:verify_on_exit!]
17
-
18
- describe "GET /register" do
19
- test "shows the register form", %{conn: conn} do
20
- conn = get(conn, "/register")
21
-
22
- html = html_response(conn, 200)
23
-
24
- if ee?() do
25
- assert html =~ "Start your 30-day free trial"
26
- else
27
- assert html =~ "Create your #{Plausible.product_name()} account"
28
- end
29
- end
30
- end
31
-
32
- describe "POST /login (register_action = register_form)" do
33
- test "registering sends an activation link", %{conn: conn} do
34
- Repo.insert!(
35
- User.new(%{
36
- name: "Jane Doe",
37
- email: "user@example.com",
38
- password: "very-secret-and-very-long-123",
39
- password_confirmation: "very-secret-and-very-long-123"
40
- })
41
- )
42
-
43
- post(conn, "/login",
44
- user: %{
45
- email: "user@example.com",
46
- password: "very-secret-and-very-long-123",
47
- register_action: "register_form"
48
- }
49
- )
50
-
51
- assert_delivered_email_matches(%{to: [{_, user_email}], subject: subject})
52
- assert user_email == "user@example.com"
53
- assert subject =~ "is your Plausible email verification code"
54
- end
55
-
56
- test "user is redirected to activate page after registration", %{conn: conn} do
57
- Repo.insert!(
58
- User.new(%{
59
- name: "Jane Doe",
60
- email: "user@example.com",
61
- password: "very-secret-and-very-long-123",
62
- password_confirmation: "very-secret-and-very-long-123"
63
- })
64
- )
65
-
66
- conn =
67
- post(conn, "/login",
68
- user: %{
69
- email: "user@example.com",
70
- password: "very-secret-and-very-long-123",
71
- register_action: "register_form"
72
- }
73
- )
74
-
75
- assert redirected_to(conn, 302) == "/activate?flow=register&team_identifier="
76
- end
77
-
78
- test "logs the user in", %{conn: conn} do
79
- user =
80
- Repo.insert!(
81
- User.new(%{
82
- name: "Jane Doe",
83
- email: "user@example.com",
84
- password: "very-secret-and-very-long-123",
85
- password_confirmation: "very-secret-and-very-long-123"
86
- })
87
- )
88
-
89
- conn =
90
- post(conn, "/login",
91
- user: %{
92
- email: "user@example.com",
93
- password: "very-secret-and-very-long-123",
94
- register_action: "register_form"
95
- }
96
- )
97
-
98
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
99
- assert get_session(conn, :user_token) == token
100
- end
101
- end
102
-
103
- describe "GET /register/invitations/:invitation_id" do
104
- test "shows the register form", %{conn: conn} do
105
- inviter = new_user()
106
- site = new_site(owner: inviter)
107
-
108
- invitation = invite_guest(site, "user@email.co", role: :editor, inviter: inviter)
109
-
110
- conn = get(conn, "/register/invitation/#{invitation.invitation_id}")
111
-
112
- assert html_response(conn, 200) =~ "Accept your invitation to join your team."
113
- end
114
- end
115
-
116
- describe "POST /login (register_action = register_from_invitation_form)" do
117
- setup do
118
- inviter = new_user()
119
- site = new_site(owner: inviter)
120
-
121
- invitation = invite_guest(site, "user@email.co", role: :editor, inviter: inviter)
122
-
123
- user =
124
- Repo.insert!(
125
- User.new(%{
126
- name: "Jane Doe",
127
- email: "user@example.com",
128
- password: "very-secret-and-very-long-123",
129
- password_confirmation: "very-secret-and-very-long-123"
130
- })
131
- )
132
-
133
- {:ok, %{site: site, invitation: invitation, user: user}}
134
- end
135
-
136
- test "registering sends an activation link", %{conn: conn} do
137
- post(conn, "/login",
138
- user: %{
139
- name: "Jane Doe",
140
- email: "user@example.com",
141
- password: "very-secret-and-very-long-123",
142
- password_confirmation: "very-secret-and-very-long-123",
143
- register_action: "register_from_invitation_form",
144
- team_identifier: ""
145
- }
146
- )
147
-
148
- assert_delivered_email_matches(%{to: [{_, user_email}], subject: subject})
149
- assert user_email == "user@example.com"
150
- assert subject =~ "is your Plausible email verification code"
151
- end
152
-
153
- test "user is redirected to activate page after registration", %{conn: conn} do
154
- conn =
155
- post(conn, "/login",
156
- user: %{
157
- name: "Jane Doe",
158
- email: "user@example.com",
159
- password: "very-secret-and-very-long-123",
160
- password_confirmation: "very-secret-and-very-long-123",
161
- register_action: "register_from_invitation_form",
162
- team_identifier: ""
163
- }
164
- )
165
-
166
- assert redirected_to(conn, 302) == "/activate?flow=invitation&team_identifier="
167
- end
168
-
169
- test "user with team invite is redirected to activate page after registration", %{conn: conn} do
170
- team_identifier = Ecto.UUID.generate()
171
-
172
- conn =
173
- post(conn, "/login",
174
- user: %{
175
- name: "Jane Doe",
176
- email: "user@example.com",
177
- password: "very-secret-and-very-long-123",
178
- password_confirmation: "very-secret-and-very-long-123",
179
- register_action: "register_from_invitation_form",
180
- team_identifier: team_identifier
181
- }
182
- )
183
-
184
- assert redirected_to(conn, 302) ==
185
- "/activate?flow=invitation&team_identifier=#{team_identifier}"
186
- end
187
-
188
- test "logs the user in", %{conn: conn, user: user} do
189
- conn =
190
- post(conn, "/login",
191
- user: %{
192
- name: "Jane Doe",
193
- email: "user@example.com",
194
- password: "very-secret-and-very-long-123",
195
- password_confirmation: "very-secret-and-very-long-123",
196
- register_action: "register_from_invitation_form",
197
- team_identifier: ""
198
- }
199
- )
200
-
201
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
202
- assert get_session(conn, :user_token) == token
203
- end
204
-
205
- test "logs the user in and redirects to sites index when email is already verified", %{
206
- conn: conn,
207
- user: user
208
- } do
209
- user |> Ecto.Changeset.change(email_verified: true) |> Repo.update!()
210
-
211
- conn =
212
- post(conn, "/login",
213
- user: %{
214
- name: "Jane Doe",
215
- email: "user@example.com",
216
- password: "very-secret-and-very-long-123",
217
- password_confirmation: "very-secret-and-very-long-123",
218
- register_action: "register_from_invitation_form",
219
- team_identifier: ""
220
- }
221
- )
222
-
223
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
224
- assert get_session(conn, :user_token) == token
225
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
226
- end
227
-
228
- test "logs the user in, accepts team invite and redirects to team sites index", %{
229
- conn: conn,
230
- user: user
231
- } do
232
- owner = new_user()
233
- _site = new_site(owner: owner)
234
- team = team_of(owner)
235
-
236
- invite_member(team, user, role: :viewer, inviter: owner)
237
-
238
- user |> Ecto.Changeset.change(email_verified: true) |> Repo.update!()
239
-
240
- conn =
241
- post(conn, "/login",
242
- user: %{
243
- name: "Jane Doe",
244
- email: "user@example.com",
245
- password: "very-secret-and-very-long-123",
246
- password_confirmation: "very-secret-and-very-long-123",
247
- register_action: "register_from_invitation_form",
248
- team_identifier: team.identifier
249
- }
250
- )
251
-
252
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
253
- assert get_session(conn, :user_token) == token
254
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index, __team: team.identifier)
255
-
256
- assert_team_membership(user, team, :viewer)
257
- end
258
-
259
- test "logs the user in and redirects to team sites index even when there's no matching team invite",
260
- %{
261
- conn: conn,
262
- user: user
263
- } do
264
- owner = new_user()
265
- _site = new_site(owner: owner)
266
- team = team_of(owner)
267
-
268
- add_member(team, user: user, role: :viewer)
269
-
270
- user |> Ecto.Changeset.change(email_verified: true) |> Repo.update!()
271
-
272
- conn =
273
- post(conn, "/login",
274
- user: %{
275
- name: "Jane Doe",
276
- email: "user@example.com",
277
- password: "very-secret-and-very-long-123",
278
- password_confirmation: "very-secret-and-very-long-123",
279
- register_action: "register_from_invitation_form",
280
- team_identifier: team.identifier
281
- }
282
- )
283
-
284
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
285
- assert get_session(conn, :user_token) == token
286
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index, __team: team.identifier)
287
- end
288
- end
289
-
290
- describe "GET /activate" do
291
- setup [:create_user, :log_in]
292
-
293
- test "if user does not have a code: prompts user to request activation code", %{conn: conn} do
294
- conn = get(conn, "/activate")
295
-
296
- assert html_response(conn, 200) =~ "Send activation code"
297
- end
298
-
299
- test "if user does have a code: prompts user to enter the activation code from their email",
300
- %{conn: conn} do
301
- conn =
302
- post(conn, "/activate/request-code")
303
- |> get("/activate")
304
-
305
- assert html_response(conn, 200) =~ "We've sent an email with your code to:"
306
- end
307
-
308
- test "passes team identifier in form data", %{conn: conn, user: user} do
309
- Auth.EmailVerification.issue_code(user)
310
-
311
- team_identifier = Ecto.UUID.generate()
312
-
313
- conn = get(conn, "/activate?team_identifier=#{team_identifier}")
314
-
315
- assert html = html_response(conn, 200)
316
-
317
- assert text_of_attr(html, "input[name=team_identifier]", "value") == team_identifier
318
- end
319
- end
320
-
321
- describe "POST /activate/request-code" do
322
- setup [:create_user, :log_in]
323
-
324
- test "generates an activation pin for user account", %{conn: conn, user: user} do
325
- post(conn, "/activate/request-code")
326
-
327
- assert code = Repo.get_by(Auth.EmailActivationCode, user_id: user.id)
328
-
329
- assert code.user_id == user.id
330
- refute Plausible.Auth.EmailVerification.expired?(code)
331
- end
332
-
333
- test "regenerates an activation pin even if there's one already", %{conn: conn, user: user} do
334
- five_minutes_ago =
335
- NaiveDateTime.utc_now()
336
- |> NaiveDateTime.shift(minute: -5)
337
- |> NaiveDateTime.truncate(:second)
338
-
339
- {:ok, verification} = Auth.EmailVerification.issue_code(user, five_minutes_ago)
340
-
341
- post(conn, "/activate/request-code")
342
-
343
- assert new_verification = Repo.get_by(Auth.EmailActivationCode, user_id: user.id)
344
-
345
- assert verification.id == new_verification.id
346
- assert verification.user_id == new_verification.user_id
347
- # this actually has a chance to fail 1 in 8999 runs
348
- # but at the same time it's good to have a confirmation
349
- # that it indeed generates a new code
350
- if verification.code == new_verification.code do
351
- Logger.warning(
352
- "Congratulations! You you have hit 1 in 8999 chance of the same " <>
353
- "email verification code repeating twice in a row!"
354
- )
355
- end
356
-
357
- assert NaiveDateTime.compare(verification.issued_at, new_verification.issued_at) == :lt
358
- end
359
-
360
- test "sends activation email to user", %{conn: conn, user: user} do
361
- post(conn, "/activate/request-code")
362
-
363
- assert_delivered_email_matches(%{to: [{_, user_email}], subject: subject})
364
- assert user_email == user.email
365
- assert subject =~ "is your Plausible email verification code"
366
- end
367
-
368
- test "redirects user to /activate", %{conn: conn} do
369
- conn = post(conn, "/activate/request-code")
370
-
371
- assert redirected_to(conn, 302) == "/activate"
372
- end
373
- end
374
-
375
- describe "POST /activate" do
376
- setup [:create_user, :log_in]
377
-
378
- test "with wrong pin - reloads the form with error", %{conn: conn} do
379
- conn = post(conn, "/activate", %{code: "1234"})
380
-
381
- assert html_response(conn, 200) =~
382
- htmlize_quotes("That code didn't work. Please try again.")
383
- end
384
-
385
- test "with expired pin - reloads the form with error", %{conn: conn, user: user} do
386
- one_day_ago =
387
- NaiveDateTime.utc_now()
388
- |> NaiveDateTime.shift(day: -1)
389
- |> NaiveDateTime.truncate(:second)
390
-
391
- {:ok, verification} = Auth.EmailVerification.issue_code(user, one_day_ago)
392
-
393
- conn = post(conn, "/activate", %{code: verification.code})
394
-
395
- assert html_response(conn, 200) =~ "The code has expired. Please request another one."
396
- end
397
-
398
- test "marks the user account as active", %{conn: conn, user: user} do
399
- Repo.update!(Plausible.Auth.User.changeset(user, %{email_verified: false}))
400
- post(conn, "/activate/request-code")
401
-
402
- verification = Repo.get_by!(Auth.EmailActivationCode, user_id: user.id)
403
-
404
- conn = post(conn, "/activate", %{code: verification.code})
405
- user = Repo.get_by(Plausible.Auth.User, id: user.id)
406
-
407
- assert user.email_verified
408
- assert redirected_to(conn) == "/sites/new?flow="
409
- end
410
-
411
- test "redirects to /sites if user has invitation", %{conn: conn, user: user} do
412
- owner = new_user()
413
- site = new_site(owner: owner)
414
- invite_guest(site, user, role: :viewer, inviter: owner)
415
-
416
- Repo.update!(Plausible.Auth.User.changeset(user, %{email_verified: false}))
417
-
418
- post(conn, "/activate/request-code")
419
-
420
- verification = Repo.get_by!(Auth.EmailActivationCode, user_id: user.id)
421
-
422
- conn = post(conn, "/activate", %{code: verification.code, team_identifier: ""})
423
-
424
- assert redirected_to(conn) == "/sites?flow="
425
- end
426
-
427
- test "accepts team invite and redirects to team sites, if team provided", %{
428
- conn: conn,
429
- user: user
430
- } do
431
- owner = new_user()
432
- _site = new_site(owner: owner)
433
- team = team_of(owner)
434
- invite_member(team, user, role: :viewer, inviter: owner)
435
-
436
- Repo.update!(Auth.User.changeset(user, %{email_verified: false}))
437
-
438
- {:ok, %{code: code}} = Auth.EmailVerification.issue_code(user)
439
-
440
- conn = post(conn, "/activate", %{code: code, team_identifier: team.identifier})
441
-
442
- assert redirected_to(conn) ==
443
- Routes.site_path(conn, :index, __team: team.identifier, flow: "")
444
-
445
- assert_team_membership(user, team, :viewer)
446
- end
447
-
448
- test "redirects to team sites if team provided, even if there's no invite", %{
449
- conn: conn,
450
- user: user
451
- } do
452
- owner = new_user()
453
- _site = new_site(owner: owner)
454
- team = team_of(owner)
455
- add_member(team, user: user, role: :viewer)
456
-
457
- Repo.update!(Auth.User.changeset(user, %{email_verified: false}))
458
-
459
- {:ok, %{code: code}} = Auth.EmailVerification.issue_code(user)
460
-
461
- conn = post(conn, "/activate", %{code: code, team_identifier: team.identifier})
462
-
463
- assert redirected_to(conn) ==
464
- Routes.site_path(conn, :index, __team: team.identifier, flow: "")
465
- end
466
-
467
- test "removes used up verification code", %{conn: conn, user: user} do
468
- Repo.update!(Plausible.Auth.User.changeset(user, %{email_verified: false}))
469
- post(conn, "/activate/request-code")
470
-
471
- verification = Repo.get_by!(Auth.EmailActivationCode, user_id: user.id)
472
-
473
- post(conn, "/activate", %{code: verification.code})
474
-
475
- refute Repo.get_by(Auth.EmailActivationCode, user_id: user.id)
476
- end
477
-
478
- test "limits activation attempts to 10 per 5 minutes", %{conn: conn} do
479
- conn = put_req_header(conn, "x-forwarded-for", "10.9.8.7")
480
-
481
- response =
482
- eventually(
483
- fn ->
484
- Enum.each(1..10, fn _ ->
485
- post(conn, "/activate", %{code: "1111"})
486
- end)
487
-
488
- conn = post(conn, "/activate", %{code: "1111"})
489
- body = html_response(conn, 200)
490
-
491
- {body =~ "Too many attempts", conn}
492
- end,
493
- 500
494
- )
495
-
496
- assert html_response(response, 200) =~
497
- "Too many attempts. Please wait a few minutes before trying again."
498
- end
499
- end
500
-
501
- describe "GET /login_form" do
502
- test "shows the login form", %{conn: conn} do
503
- conn = get(conn, "/login")
504
- assert html_response(conn, 200) =~ "Sign in to your account"
505
- end
506
-
507
- test "renders `return_to` query param as hidden input", %{conn: conn} do
508
- conn = get(conn, "/login?return_to=/dummy.site")
509
-
510
- input_value =
511
- conn
512
- |> html_response(200)
513
- |> text_of_attr("input[name=return_to]", "value")
514
-
515
- assert input_value == "/dummy.site"
516
- end
517
-
518
- @tag :ee_only
519
- test "redirects to sso login if preferred", %{conn: conn} do
520
- conn = PlausibleWeb.LoginPreference.set_sso(conn)
521
- conn = get(conn, "/login?return_to=foo")
522
- assert redirected_to(conn, 302) == "/sso/login?return_to=foo"
523
- end
524
-
525
- @tag :ee_only
526
- test "keeps standard login form if preference manually overridden", %{conn: conn} do
527
- conn = PlausibleWeb.LoginPreference.set_sso(conn)
528
- conn = get(conn, "/login?prefer=manual")
529
- assert html_response(conn, 200) =~ "Sign in to your account"
530
- end
531
- end
532
-
533
- describe "POST /login" do
534
- test "valid email and password - logs the user in", %{conn: conn} do
535
- user = insert(:user, password: "password")
536
-
537
- conn = post(conn, "/login", email: user.email, password: "password")
538
-
539
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
540
- assert get_session(conn, :user_token) == token
541
- assert redirected_to(conn) == "/sites"
542
- end
543
-
544
- test "valid email and password, user on multiple teams - logs the user in", %{conn: conn} do
545
- user = insert(:user, password: "password")
546
-
547
- # first team
548
- new_site(owner: user)
549
-
550
- # another team
551
- another_team = new_site().team |> Plausible.Teams.complete_setup()
552
- add_member(another_team, user: user, role: :owner)
553
-
554
- conn = post(conn, "/login", email: user.email, password: "password")
555
-
556
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
557
- assert get_session(conn, :user_token) == token
558
- assert redirected_to(conn) == "/sites"
559
- end
560
-
561
- test "valid email and password with return_to set - redirects properly", %{conn: conn} do
562
- user = insert(:user, password: "password")
563
-
564
- conn =
565
- post(conn, "/login",
566
- email: user.email,
567
- password: "password",
568
- return_to: Routes.settings_path(conn, :index)
569
- )
570
-
571
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :index)
572
- end
573
-
574
- test "valid email and password with 2FA enabled - sets 2FA session and redirects", %{
575
- conn: conn
576
- } do
577
- user = insert(:user, password: "password")
578
-
579
- # enable 2FA
580
- {:ok, user, _} = Auth.TOTP.initiate(user)
581
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
582
-
583
- conn = post(conn, "/login", email: user.email, password: "password")
584
-
585
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :verify_2fa_form)
586
-
587
- assert fetch_cookies(conn).cookies["session_2fa"].current_2fa_user_id == user.id
588
- refute get_session(conn)["user_token"]
589
- end
590
-
591
- test "valid email and password with 2FA enabled and remember 2FA cookie set - logs the user in",
592
- %{conn: conn} do
593
- user = insert(:user, password: "password")
594
-
595
- # enable 2FA
596
- {:ok, user, _} = Auth.TOTP.initiate(user)
597
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
598
-
599
- conn = set_remember_2fa_cookie(conn, user)
600
-
601
- conn = post(conn, "/login", email: user.email, password: "password")
602
-
603
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
604
-
605
- assert conn.resp_cookies["session_2fa"].max_age == 0
606
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
607
- assert get_session(conn, :user_token) == token
608
- end
609
-
610
- test "valid email and password with 2FA enabled and rogue remember 2FA cookie set - logs the user in",
611
- %{conn: conn} do
612
- user = insert(:user, password: "password")
613
-
614
- # enable 2FA
615
- {:ok, user, _} = Auth.TOTP.initiate(user)
616
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
617
-
618
- another_user = insert(:user)
619
- conn = set_remember_2fa_cookie(conn, another_user)
620
-
621
- conn = post(conn, "/login", email: user.email, password: "password")
622
-
623
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :verify_2fa_form)
624
-
625
- assert fetch_cookies(conn).cookies["session_2fa"].current_2fa_user_id == user.id
626
- refute get_session(conn, :user_token)
627
- end
628
-
629
- on_ee do
630
- test "SSO owner user - logs in", %{conn: conn} do
631
- owner = new_user(name: "Jane Shelley", email: "jane@example.com", password: "password")
632
- team = new_site(owner: owner).team
633
- team = Plausible.Teams.complete_setup(team)
634
-
635
- # Setup SSO
636
- integration = Auth.SSO.initiate_saml_integration(team)
637
-
638
- {:ok, sso_domain} = Auth.SSO.Domains.add(integration, "example.com")
639
- _sso_domain = Auth.SSO.Domains.verify(sso_domain, skip_checks?: true)
640
-
641
- identity = new_identity(owner.name, owner.email, integration)
642
- {:ok, _, _, _sso_user} = Auth.SSO.provision_user(identity)
643
-
644
- conn = post(conn, "/login", email: owner.email, password: "password")
645
-
646
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
647
-
648
- assert conn.resp_cookies["session_2fa"].max_age == 0
649
- assert %{sessions: [%{token: token}]} = owner |> Repo.reload!() |> Repo.preload(:sessions)
650
- assert get_session(conn, :user_token) == token
651
- end
652
-
653
- test "SSO user other than owner - renders login form again", %{conn: conn} do
654
- owner = new_user()
655
- team = new_site(owner: owner).team
656
- member = new_user(name: "Jane Shelley", email: "jane@example.com", password: "password")
657
- add_member(team, user: member, role: :viewer)
658
-
659
- # Setup SSO
660
- integration = Auth.SSO.initiate_saml_integration(team)
661
-
662
- {:ok, sso_domain} = Auth.SSO.Domains.add(integration, "example.com")
663
- _sso_domain = Auth.SSO.Domains.verify(sso_domain, skip_checks?: true)
664
-
665
- identity = new_identity(member.name, member.email, integration)
666
- {:ok, _, _, _sso_user} = Auth.SSO.provision_user(identity)
667
-
668
- conn = post(conn, "/login", email: member.email, password: "password")
669
-
670
- assert get_session(conn, :user_token) == nil
671
- assert html_response(conn, 200) =~ "Sign in to your account"
672
- end
673
-
674
- test "SSO user other than owner with personal team - renders login form again", %{
675
- conn: conn
676
- } do
677
- owner = new_user()
678
- team = new_site(owner: owner).team
679
- member = new_user(name: "Jane Shelley", email: "jane@example.com", password: "password")
680
- {:ok, _} = Plausible.Teams.get_or_create(member)
681
- add_member(team, user: member, role: :viewer)
682
-
683
- # Setup SSO
684
- integration = Auth.SSO.initiate_saml_integration(team)
685
-
686
- {:ok, sso_domain} = Auth.SSO.Domains.add(integration, "example.com")
687
- _sso_domain = Auth.SSO.Domains.verify(sso_domain, skip_checks?: true)
688
-
689
- identity = new_identity(member.name, member.email, integration)
690
- {:ok, _, _, _sso_user} = Auth.SSO.provision_user(identity)
691
-
692
- conn = post(conn, "/login", email: member.email, password: "password")
693
-
694
- assert get_session(conn, :user_token) == nil
695
- assert html_response(conn, 200) =~ "Sign in to your account"
696
- end
697
- end
698
-
699
- test "email does not exist - renders login form again", %{conn: conn} do
700
- conn = post(conn, "/login", email: "user@example.com", password: "password")
701
-
702
- assert get_session(conn, :user_token) == nil
703
- assert html_response(conn, 200) =~ "Sign in to your account"
704
- end
705
-
706
- test "bad password - renders login form again", %{conn: conn} do
707
- user = insert(:user, password: "password")
708
- conn = post(conn, "/login", email: user.email, password: "wrong")
709
-
710
- assert get_session(conn, :user_token) == nil
711
- assert html_response(conn, 200) =~ "Sign in to your account"
712
- end
713
-
714
- test "limits login attempts to 5 per minute" do
715
- user = insert(:user, password: "password")
716
-
717
- conn = put_req_header(build_conn(), "x-forwarded-for", "1.2.3.5")
718
-
719
- response =
720
- eventually(
721
- fn ->
722
- Enum.each(1..5, fn _ ->
723
- post(conn, "/login", email: user.email, password: "wrong")
724
- end)
725
-
726
- conn = post(conn, "/login", email: user.email, password: "wrong")
727
-
728
- {conn.status == 429, conn}
729
- end,
730
- 500
731
- )
732
-
733
- assert html_response(response, 429) =~ "Too many login attempts"
734
- end
735
-
736
- test "malicious automated logins", %{conn: conn1} do
737
- conn =
738
- post(conn1, "/login", %{
739
- "g-recaptcha-response" => "NwBMkEWbh",
740
- "user[email]" => "some@example.com",
741
- "user[name]" => "CJCtGVXVgfORdNN",
742
- "user[password]" => "[Filtered]",
743
- "user[password_confirmation]" => "[Filtered]",
744
- "user[register_action]" => "register_form"
745
- })
746
-
747
- assert response(conn, 403)
748
-
749
- conn =
750
- conn1
751
- |> put_req_header("content-type", "application/json")
752
- |> post("/login", """
753
- {
754
- "g-recaptcha-response": "NwBMkEWbh",
755
- "user[email]": "some@example.com",
756
- "user[name]": "CJCtGVXVgfORdNN",
757
- "user[password]": "[Filtered]",
758
- "user[password_confirmation]": "[Filtered]",
759
- "user[register_action]": "register_form"
760
- }
761
- """)
762
-
763
- assert response(conn, 403)
764
- end
765
- end
766
-
767
- describe "GET /password/request-reset" do
768
- test "renders the form", %{conn: conn} do
769
- conn = get(conn, "/password/request-reset")
770
- assert html_response(conn, 200) =~ "Enter your email to receive a password reset link."
771
- end
772
- end
773
-
774
- describe "POST /password/request-reset" do
775
- test "email is empty - renders form with error", %{conn: conn} do
776
- conn = post(conn, "/password/request-reset", %{email: ""})
777
-
778
- assert html_response(conn, 200) =~ "Enter your email to receive a password reset link."
779
- end
780
-
781
- test "email is present and exists - sends password reset email", %{conn: conn} do
782
- mock_captcha_success()
783
- user = insert(:user)
784
- conn = post(conn, "/password/request-reset", %{email: user.email})
785
-
786
- assert html_response(conn, 200) =~ "Check your email"
787
- assert_email_delivered_with(subject: "Plausible password reset")
788
- end
789
-
790
- test "renders captcha errors in case of captcha input verification failure", %{conn: conn} do
791
- mock_captcha_failure()
792
- user = insert(:user)
793
- conn = post(conn, "/password/request-reset", %{email: user.email})
794
-
795
- assert html_response(conn, 200) =~ "Please complete the captcha"
796
- end
797
- end
798
-
799
- on_ee do
800
- describe "POST /password/request-reset - SSO user" do
801
- setup [:create_user, :create_site, :create_team, :setup_sso, :provision_sso_user]
802
-
803
- test "initiates reset for owner SSO user email", %{conn: conn, user: user} do
804
- mock_captcha_success()
805
- conn = post(conn, "/password/request-reset", %{email: user.email})
806
-
807
- assert html_response(conn, 200)
808
-
809
- assert_email_delivered_with(
810
- subject: "Plausible password reset",
811
- to: [nil: user.email]
812
- )
813
- end
814
-
815
- test "does not initiate reset for non-owner SSO user", %{conn: conn, user: user, team: team} do
816
- add_member(team, role: :owner)
817
-
818
- assert {:ok, _} =
819
- Plausible.Teams.Memberships.UpdateRole.update(team, user.id, "editor", user)
820
-
821
- assert Plausible.Teams.Memberships.team_role(team, user) == {:ok, :editor}
822
-
823
- mock_captcha_success()
824
- conn = post(conn, "/password/request-reset", %{email: user.email})
825
-
826
- assert html_response(conn, 200)
827
-
828
- refute_email_delivered_with(
829
- subject: "Plausible password reset",
830
- to: [nil: user.email]
831
- )
832
- end
833
- end
834
- end
835
-
836
- describe "GET /password/reset" do
837
- test "with valid token - shows form", %{conn: conn} do
838
- user = insert(:user)
839
- token = Plausible.Auth.Token.sign_password_reset(user.email)
840
- conn = get(conn, "/password/reset", %{token: token})
841
-
842
- assert html_response(conn, 200) =~ "Reset your password"
843
- end
844
-
845
- test "with invalid token - shows error page", %{conn: conn} do
846
- conn = get(conn, "/password/reset", %{token: "blabla"})
847
-
848
- assert html_response(conn, 401) =~ "Password reset link invalid"
849
- end
850
-
851
- test "without token - shows error page", %{conn: conn} do
852
- conn = get(conn, "/password/reset", %{})
853
-
854
- assert html_response(conn, 401) =~ "Password reset link invalid"
855
- end
856
- end
857
-
858
- describe "POST /password/reset" do
859
- test "redirects the user to login and shows success message", %{conn: conn} do
860
- conn = post(conn, "/password/reset", %{})
861
-
862
- assert location = "/login" = redirected_to(conn, 302)
863
-
864
- # cookie state is as expected for logged out user
865
- assert conn.private[:plug_session_info] == :renew
866
- assert conn.resp_cookies["logged_in"].max_age == 0
867
- assert get_session(conn, :user_token) == nil
868
-
869
- {:ok, %{conn: conn}} = PlausibleWeb.FirstLaunchPlug.Test.skip(%{conn: recycle(conn)})
870
- conn = get(conn, location)
871
- assert html_response(conn, 200) =~ "Password updated successfully"
872
- end
873
- end
874
-
875
- describe "GET /logout" do
876
- setup [:create_user, :log_in]
877
-
878
- test "redirects the user to root", %{conn: conn} do
879
- conn = get(conn, "/logout")
880
-
881
- assert location = "/" = redirected_to(conn, 302)
882
-
883
- # cookie state is as expected for logged out user
884
- assert conn.private[:plug_session_info] == :renew
885
- assert conn.resp_cookies["logged_in"].max_age == 0
886
- assert get_session(conn, :user_token) == nil
887
-
888
- {:ok, %{conn: conn}} = PlausibleWeb.FirstLaunchPlug.Test.skip(%{conn: recycle(conn)})
889
- conn = get(conn, location)
890
- assert html_response(conn, 200) =~ "Welcome to Plausible!"
891
- end
892
-
893
- test "redirects user to `redirect` param when provided", %{conn: conn} do
894
- conn = get(conn, "/logout", %{redirect: "/docs"})
895
-
896
- assert redirected_to(conn, 302) == "/docs"
897
- end
898
- end
899
-
900
- on_ee do
901
- describe "DELETE /me - SSO user" do
902
- setup [:create_user, :create_site, :create_team, :setup_sso, :provision_sso_user, :log_in]
903
-
904
- test "refuses to delete SSO user", %{conn: conn, user: user} do
905
- conn = delete(conn, "/me")
906
-
907
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
908
-
909
- assert Repo.reload(user)
910
- end
911
- end
912
- end
913
-
914
- describe "DELETE /me" do
915
- setup [:create_user, :log_in, :create_site]
916
- use Plausible.Repo
917
-
918
- test "deletes the user", %{conn: conn, user: user, site: site} do
919
- Repo.insert_all("intro_emails", [
920
- %{
921
- user_id: user.id,
922
- timestamp: NaiveDateTime.utc_now()
923
- }
924
- ])
925
-
926
- Repo.insert_all("feedback_emails", [
927
- %{
928
- user_id: user.id,
929
- timestamp: NaiveDateTime.utc_now()
930
- }
931
- ])
932
-
933
- Repo.insert_all("create_site_emails", [
934
- %{
935
- user_id: user.id,
936
- timestamp: NaiveDateTime.utc_now()
937
- }
938
- ])
939
-
940
- Repo.insert_all("check_stats_emails", [
941
- %{
942
- user_id: user.id,
943
- timestamp: NaiveDateTime.utc_now()
944
- }
945
- ])
946
-
947
- Repo.insert_all("sent_renewal_notifications", [
948
- %{
949
- user_id: user.id,
950
- timestamp: NaiveDateTime.utc_now()
951
- }
952
- ])
953
-
954
- insert(:google_auth, site: site, user: user)
955
- subscribe_to_growth_plan(user, status: Subscription.Status.deleted())
956
- subscribe_to_enterprise_plan(user, site_limit: 1, subscription?: false)
957
-
958
- {:ok, team} = Plausible.Teams.get_or_create(user)
959
-
960
- conn = delete(conn, "/me")
961
- assert redirected_to(conn) == "/"
962
- assert Repo.reload(site) == nil
963
- assert Repo.reload(user) == nil
964
- assert Repo.all(Plausible.Billing.Subscription) == []
965
- assert Repo.all(Plausible.Billing.EnterprisePlan) == []
966
- refute Repo.get(Plausible.Teams.Team, team.id)
967
- end
968
-
969
- test "refuses to delete when a personal team has an active subscription", %{
970
- conn: conn,
971
- user: user
972
- } do
973
- subscribe_to_growth_plan(user, status: Subscription.Status.active())
974
-
975
- conn = delete(conn, "/me")
976
-
977
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :danger_zone)
978
-
979
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
980
- "You have an active subscription which must be canceled first"
981
-
982
- assert Repo.reload(user)
983
- end
984
-
985
- test "deletes sites that the user owns", %{conn: conn, user: user, site: owner_site} do
986
- viewer_site = new_site()
987
- add_guest(viewer_site, user: user, role: :viewer)
988
-
989
- delete(conn, "/me")
990
-
991
- assert Repo.get(Plausible.Site, viewer_site.id)
992
- refute Repo.get(Plausible.Site, owner_site.id)
993
- end
994
-
995
- test "refuses to delete user when an only owner of a setup team", %{
996
- conn: conn,
997
- user: user,
998
- site: site
999
- } do
1000
- Plausible.Teams.complete_setup(site.team)
1001
-
1002
- conn = delete(conn, "/me")
1003
-
1004
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :danger_zone)
1005
-
1006
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1007
- "You can't delete your account when you are the only owner on a team"
1008
-
1009
- assert Repo.reload(user)
1010
- end
1011
-
1012
- test "refuses to delete user when an only owner of multiple setup teams", %{
1013
- conn: conn,
1014
- user: user,
1015
- site: site
1016
- } do
1017
- Plausible.Teams.complete_setup(site.team)
1018
-
1019
- another_owner = new_user()
1020
- another_site = new_site(owner: another_owner)
1021
- add_member(another_site.team, user: user, role: :owner)
1022
- Repo.delete!(another_owner)
1023
-
1024
- conn = delete(conn, "/me")
1025
-
1026
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :danger_zone)
1027
-
1028
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1029
- "You can't delete your account when you are the only owner on a team"
1030
-
1031
- assert Repo.reload(user)
1032
- end
1033
-
1034
- test "context > team is autodeleted - personal segment is also deleted", %{
1035
- conn: conn,
1036
- user: user,
1037
- site: owner_site
1038
- } do
1039
- segment =
1040
- insert(:segment,
1041
- type: :personal,
1042
- owner: user,
1043
- site: owner_site,
1044
- name: "personal segment"
1045
- )
1046
-
1047
- delete(conn, "/me")
1048
-
1049
- refute Repo.reload(segment)
1050
- end
1051
-
1052
- test "context > team is autodeleted - site segment is also deleted", %{
1053
- conn: conn,
1054
- user: user,
1055
- site: owner_site
1056
- } do
1057
- segment =
1058
- insert(:segment,
1059
- type: :site,
1060
- owner: user,
1061
- site: owner_site,
1062
- name: "site segment"
1063
- )
1064
-
1065
- delete(conn, "/me")
1066
-
1067
- refute Repo.reload(segment)
1068
- end
1069
-
1070
- test "context > team is not autodeleted - personal segment is deleted", %{
1071
- conn: conn,
1072
- user: user
1073
- } do
1074
- another_owner = new_user()
1075
- another_site = new_site(owner: another_owner)
1076
- another_team = another_owner |> team_of() |> Plausible.Teams.complete_setup()
1077
- add_member(another_team, user: user, role: :admin)
1078
-
1079
- segment =
1080
- insert(:segment,
1081
- type: :personal,
1082
- owner: user,
1083
- site: another_site,
1084
- name: "personal segment"
1085
- )
1086
-
1087
- delete(conn, "/me")
1088
-
1089
- refute Repo.reload(segment)
1090
- end
1091
-
1092
- test "context > team is not autodeleted - site segment is kept with owner=null", %{
1093
- conn: conn,
1094
- user: user
1095
- } do
1096
- another_owner = new_user()
1097
- another_site = new_site(owner: another_owner)
1098
- another_team = another_owner |> team_of() |> Plausible.Teams.complete_setup()
1099
- add_member(another_team, user: user, role: :admin)
1100
-
1101
- segment =
1102
- insert(:segment,
1103
- type: :site,
1104
- owner: user,
1105
- site: another_site,
1106
- name: "site segment"
1107
- )
1108
-
1109
- delete(conn, "/me")
1110
-
1111
- assert Repo.reload(segment).owner_id == nil
1112
- end
1113
-
1114
- test "allows to delete user when not the only owner of a setup team", %{
1115
- conn: conn,
1116
- user: user
1117
- } do
1118
- another_owner = new_user()
1119
- another_site = new_site(owner: another_owner)
1120
- team = another_owner |> team_of() |> Plausible.Teams.complete_setup()
1121
- add_member(another_site.team, user: user, role: :owner)
1122
-
1123
- delete(conn, "/me")
1124
-
1125
- refute Repo.reload(user)
1126
- assert Repo.reload(team)
1127
- end
1128
-
1129
- test "deletes personal team in multiple teams case as well", %{
1130
- conn: conn,
1131
- user: user
1132
- } do
1133
- new_site(owner: user)
1134
- personal_team = team_of(user)
1135
- another_owner = new_user()
1136
- _another_site = new_site(owner: another_owner)
1137
- another_team = another_owner |> team_of() |> Plausible.Teams.complete_setup()
1138
- add_member(another_team, user: user, role: :owner)
1139
-
1140
- delete(conn, "/me")
1141
-
1142
- refute Repo.reload(user)
1143
- assert Repo.reload(another_team)
1144
- refute Repo.reload(personal_team)
1145
- end
1146
- end
1147
-
1148
- describe "GET /auth/google/callback" do
1149
- setup [:create_user, :log_in]
1150
-
1151
- test "shows access denied error and redirects back to settings when authentication fails for import",
1152
- %{
1153
- conn: conn
1154
- } do
1155
- site = new_site()
1156
-
1157
- state =
1158
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [site.id, "import"])
1159
-
1160
- callback_params = %{"error" => "access_denied", "state" => state}
1161
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1162
-
1163
- assert redirected_to(conn, 302) ==
1164
- Routes.site_path(conn, :settings_imports_exports, site.domain)
1165
-
1166
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1167
- "unable to authenticate your Google Analytics"
1168
- end
1169
-
1170
- test "shows access denied error and redirects back to settings when authentication fails for search console",
1171
- %{conn: conn} do
1172
- site = new_site()
1173
-
1174
- state =
1175
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [
1176
- site.id,
1177
- "search-console"
1178
- ])
1179
-
1180
- callback_params = %{"error" => "access_denied", "state" => state}
1181
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1182
-
1183
- assert redirected_to(conn, 302) ==
1184
- Routes.site_path(conn, :settings_integrations, site.domain)
1185
-
1186
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1187
- "unable to authenticate your Google Analytics"
1188
- end
1189
-
1190
- test "shows server error and redirects back to settings when request fails on Google's end for import",
1191
- %{
1192
- conn: conn
1193
- } do
1194
- site = new_site()
1195
-
1196
- state =
1197
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [site.id, "import"])
1198
-
1199
- callback_params = %{"error" => "server_error", "state" => state}
1200
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1201
-
1202
- assert redirected_to(conn, 302) ==
1203
- Routes.site_path(conn, :settings_imports_exports, site.domain)
1204
-
1205
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1206
- "Google's authentication service is temporarily unavailable"
1207
- end
1208
-
1209
- test "shows server error and redirects back to settings when request fails on Google's end for search console",
1210
- %{
1211
- conn: conn
1212
- } do
1213
- site = new_site()
1214
-
1215
- state =
1216
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [
1217
- site.id,
1218
- "search-console"
1219
- ])
1220
-
1221
- callback_params = %{"error" => "temporarily_unavailable", "state" => state}
1222
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1223
-
1224
- assert redirected_to(conn, 302) ==
1225
- Routes.site_path(conn, :settings_integrations, site.domain)
1226
-
1227
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1228
- "Google's authentication service is temporarily unavailable"
1229
- end
1230
-
1231
- test "shows generic error and redirects back to settings on unknown Google failure for import",
1232
- %{
1233
- conn: conn
1234
- } do
1235
- site = new_site()
1236
-
1237
- state =
1238
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [site.id, "import"])
1239
-
1240
- callback_params = %{"error" => "unknown", "state" => state}
1241
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1242
-
1243
- assert redirected_to(conn, 302) ==
1244
- Routes.site_path(conn, :settings_imports_exports, site.domain)
1245
-
1246
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1247
- "unable to authenticate your Google Analytics"
1248
- end
1249
-
1250
- test "shows generic error and redirects back to settings when request fails on Google's end for search console",
1251
- %{
1252
- conn: conn
1253
- } do
1254
- site = new_site()
1255
-
1256
- state =
1257
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [
1258
- site.id,
1259
- "search-console"
1260
- ])
1261
-
1262
- callback_params = %{"error" => "unknown", "state" => state}
1263
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1264
-
1265
- assert redirected_to(conn, 302) ==
1266
- Routes.site_path(conn, :settings_integrations, site.domain)
1267
-
1268
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1269
- "unable to authenticate your Google Analytics"
1270
- end
1271
-
1272
- test "rejects error callback with tampered state", %{conn: conn} do
1273
- site = new_site()
1274
-
1275
- state =
1276
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [site.id, "import"])
1277
-
1278
- callback_params = %{"error" => "access_denied", "state" => state <> "gibberish"}
1279
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1280
-
1281
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
1282
- end
1283
-
1284
- test "rejects error callback with signed state containing non-existent site", %{conn: conn} do
1285
- site = new_site()
1286
- Repo.delete!(site)
1287
-
1288
- state =
1289
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [site.id, "import"])
1290
-
1291
- callback_params = %{"error" => "access_denied", "state" => state}
1292
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1293
-
1294
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
1295
- end
1296
-
1297
- test "rejects success callback with tampered state", %{conn: conn} do
1298
- site = new_site()
1299
-
1300
- state =
1301
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [site.id, "import"])
1302
-
1303
- callback_params = %{"code" => "CodeForToken", "state" => state <> "gibberish"}
1304
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1305
-
1306
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
1307
- end
1308
-
1309
- test "rejects success callback with signed state containing non-existent site", %{conn: conn} do
1310
- site = new_site()
1311
- Repo.delete!(site)
1312
-
1313
- state =
1314
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [site.id, "import"])
1315
-
1316
- callback_params = %{"code" => "CodeForToken", "state" => state}
1317
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1318
-
1319
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
1320
- end
1321
-
1322
- test "success callback rejects state pointing to a site the current user does not own",
1323
- %{conn: conn} do
1324
- victim_site = new_site()
1325
-
1326
- attacker = new_user()
1327
- {:ok, conn: attacker_conn} = log_in(%{user: attacker, conn: conn})
1328
-
1329
- # craft a validly signed state pointing at the victim's site_id
1330
- state =
1331
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [
1332
- victim_site.id,
1333
- "search-console"
1334
- ])
1335
-
1336
- callback_params = %{"code" => "CodeForToken", "state" => state}
1337
-
1338
- attacker_conn =
1339
- get(attacker_conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1340
-
1341
- assert redirected_to(attacker_conn, 302) == Routes.auth_path(conn, :login_form)
1342
-
1343
- # confirm no GoogleAuth record was created for the victim's site
1344
- refute Repo.exists?(
1345
- from ga in Plausible.Site.GoogleAuth, where: ga.site_id == ^victim_site.id
1346
- )
1347
- end
1348
-
1349
- test "success callback for import redirects to property selection", %{conn: conn, user: user} do
1350
- mock_google_access_token(user.email)
1351
-
1352
- site = new_site(owner: user)
1353
-
1354
- state =
1355
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [site.id, "import"])
1356
-
1357
- callback_params = %{"code" => "CodeForToken", "state" => state}
1358
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1359
-
1360
- assert redirect_url = redirected_to(conn, 302)
1361
-
1362
- assert redirect_url =~ "/import/google-analytics/property"
1363
- assert redirect_url =~ "access_token=SomeAccessToken"
1364
- assert redirect_url =~ "refresh_token=SomeRefreshToken"
1365
- assert redirect_url =~ "expires_at="
1366
- end
1367
-
1368
- test "success callback for search console creates a google auth entry and redirects to integrations form",
1369
- %{conn: conn, user: user} do
1370
- site = new_site(owner: user)
1371
-
1372
- mock_google_access_token(user.email)
1373
-
1374
- state =
1375
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [
1376
- site.id,
1377
- "search-console"
1378
- ])
1379
-
1380
- callback_params = %{"code" => "CodeForToken", "state" => state}
1381
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1382
-
1383
- assert redirected_to(conn, 302) ==
1384
- Routes.site_path(conn, :settings_integrations, site.domain)
1385
-
1386
- assert_matches %{
1387
- access_token: "SomeAccessToken",
1388
- refresh_token: "SomeRefreshToken",
1389
- user_id: ^user.id,
1390
- email: ^user.email,
1391
- expires: %NaiveDateTime{}
1392
- } =
1393
- Repo.one(
1394
- from ga in Plausible.Site.GoogleAuth, where: ga.site_id == ^site.id
1395
- )
1396
- end
1397
-
1398
- test "success callback for search console creates a google auth entry and redirects to integrations form for editor",
1399
- %{conn: conn, user: user} do
1400
- site = new_site()
1401
- add_guest(site, user: user, role: :editor)
1402
-
1403
- mock_google_access_token(user.email)
1404
-
1405
- state =
1406
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [
1407
- site.id,
1408
- "search-console"
1409
- ])
1410
-
1411
- callback_params = %{"code" => "CodeForToken", "state" => state}
1412
- conn = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1413
-
1414
- assert redirected_to(conn, 302) ==
1415
- Routes.site_path(conn, :settings_integrations, site.domain)
1416
-
1417
- assert_matches %{
1418
- access_token: "SomeAccessToken",
1419
- refresh_token: "SomeRefreshToken",
1420
- user_id: ^user.id,
1421
- email: ^user.email,
1422
- expires: %NaiveDateTime{}
1423
- } =
1424
- Repo.one(
1425
- from ga in Plausible.Site.GoogleAuth, where: ga.site_id == ^site.id
1426
- )
1427
- end
1428
-
1429
- test "success callback for search console handles repeat callback for the same site gracefully",
1430
- %{conn: conn, user: user} do
1431
- site = new_site(owner: user)
1432
- another_email = new_user().email
1433
-
1434
- mock_google_access_token(user.email)
1435
- mock_google_access_token(another_email)
1436
-
1437
- state =
1438
- Phoenix.Token.sign(PlausibleWeb.Endpoint, "google-oauth-state", [
1439
- site.id,
1440
- "search-console"
1441
- ])
1442
-
1443
- callback_params = %{"code" => "CodeForToken", "state" => state}
1444
- conn_first = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1445
-
1446
- assert redirected_to(conn_first, 302) ==
1447
- Routes.site_path(conn, :settings_integrations, site.domain)
1448
-
1449
- assert_matches %{
1450
- access_token: "SomeAccessToken",
1451
- refresh_token: "SomeRefreshToken",
1452
- user_id: ^user.id,
1453
- email: ^user.email,
1454
- expires: %NaiveDateTime{}
1455
- } =
1456
- Repo.one(
1457
- from ga in Plausible.Site.GoogleAuth, where: ga.site_id == ^site.id
1458
- )
1459
-
1460
- conn_second = get(conn, Routes.auth_path(conn, :google_auth_callback), callback_params)
1461
-
1462
- assert redirected_to(conn_second, 302) ==
1463
- Routes.site_path(conn, :settings_integrations, site.domain)
1464
-
1465
- assert_matches %{
1466
- access_token: "SomeAccessToken",
1467
- refresh_token: "SomeRefreshToken",
1468
- user_id: ^user.id,
1469
- email: ^another_email,
1470
- expires: %NaiveDateTime{}
1471
- } =
1472
- Repo.one(
1473
- from ga in Plausible.Site.GoogleAuth, where: ga.site_id == ^site.id
1474
- )
1475
- end
1476
- end
1477
-
1478
- describe "POST /2fa/setup/initiate" do
1479
- setup [:create_user, :log_in]
1480
-
1481
- test "initiates setup rendering QR and human friendly versions of secret", %{
1482
- conn: conn,
1483
- user: user
1484
- } do
1485
- conn = post(conn, Routes.auth_path(conn, :initiate_2fa_setup))
1486
-
1487
- secret = Base.encode32(Repo.reload!(user).totp_secret)
1488
-
1489
- assert html = html_response(conn, 200)
1490
-
1491
- assert element_exists?(html, "svg")
1492
- assert html =~ secret
1493
- refute html =~ "You've been redirected here because your team enforces 2FA."
1494
- end
1495
-
1496
- test "shows additional notice when `force` parameter set", %{conn: conn} do
1497
- conn = post(conn, Routes.auth_path(conn, :initiate_2fa_setup, force: "true"))
1498
-
1499
- assert html = html_response(conn, 200)
1500
- assert html =~ "You've been redirected here because your team enforces 2FA."
1501
- end
1502
-
1503
- test "redirects back to settings if 2FA is already setup", %{conn: conn, user: user} do
1504
- {:ok, user, _} = Auth.TOTP.initiate(user)
1505
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1506
-
1507
- conn = post(conn, Routes.auth_path(conn, :initiate_2fa_setup))
1508
-
1509
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :security) <> "#update-2fa"
1510
-
1511
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1512
- "Two-Factor Authentication is already setup"
1513
- end
1514
- end
1515
-
1516
- describe "GET /2fa/setup/verify" do
1517
- setup [:create_user, :log_in]
1518
-
1519
- test "renders form when 2FA setup is initiated", %{conn: conn, user: user} do
1520
- {:ok, _, _} = Auth.TOTP.initiate(user)
1521
-
1522
- conn = get(conn, Routes.auth_path(conn, :verify_2fa_setup))
1523
-
1524
- assert html = html_response(conn, 200)
1525
-
1526
- assert text_of_attr(html, "form#verify-2fa-form", "action") ==
1527
- Routes.auth_path(conn, :verify_2fa_setup)
1528
-
1529
- assert element_exists?(html, "input[name=code]")
1530
-
1531
- assert element_exists?(
1532
- html,
1533
- ~s|a[data-method="post"][data-to="#{Routes.auth_path(conn, :initiate_2fa_setup)}"]|
1534
- )
1535
- end
1536
-
1537
- test "redirects back to settings if 2FA not initiated", %{conn: conn} do
1538
- conn = get(conn, Routes.auth_path(conn, :verify_2fa_setup))
1539
-
1540
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :security) <> "#update-2fa"
1541
- end
1542
- end
1543
-
1544
- describe "POST /2fa/setup/verify" do
1545
- setup [:create_user, :log_in]
1546
-
1547
- test "enables 2FA and renders recovery codes when valid code provided", %{
1548
- conn: conn,
1549
- user: user
1550
- } do
1551
- {:ok, user, _} = Auth.TOTP.initiate(user)
1552
- code = NimbleTOTP.verification_code(user.totp_secret)
1553
-
1554
- conn = post(conn, Routes.auth_path(conn, :verify_2fa_setup), %{code: code})
1555
-
1556
- assert html = html_response(conn, 200)
1557
-
1558
- assert list = [_ | _] = find(html, "#recovery-codes-list > *") |> LazyHTML.to_tree()
1559
- assert length(list) == 10
1560
-
1561
- assert user |> Repo.reload!() |> Auth.TOTP.enabled?()
1562
- end
1563
-
1564
- test "renders error on invalid code provided", %{conn: conn, user: user} do
1565
- {:ok, _, _} = Auth.TOTP.initiate(user)
1566
-
1567
- conn = post(conn, Routes.auth_path(conn, :verify_2fa_setup), %{code: "invalid"})
1568
-
1569
- assert html_response(conn, 200)
1570
-
1571
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1572
- "The provided code is invalid."
1573
- end
1574
-
1575
- test "redirects to settings when 2FA is not initiated", %{conn: conn} do
1576
- conn = post(conn, Routes.auth_path(conn, :verify_2fa_setup), %{code: "123123"})
1577
-
1578
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :security) <> "#update-2fa"
1579
-
1580
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1581
- "Please enable Two-Factor Authentication"
1582
- end
1583
- end
1584
-
1585
- describe "POST /2fa/disable" do
1586
- setup [:create_user, :log_in]
1587
-
1588
- test "disables 2FA when valid password provided", %{conn: conn, user: user} do
1589
- {:ok, user, _} = Auth.TOTP.initiate(user)
1590
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1591
-
1592
- conn = post(conn, Routes.auth_path(conn, :disable_2fa), %{password: "password"})
1593
-
1594
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :security) <> "#update-2fa"
1595
-
1596
- assert Phoenix.Flash.get(conn.assigns.flash, :success) =~
1597
- "Two-Factor Authentication is disabled"
1598
-
1599
- refute user |> Repo.reload!() |> Auth.TOTP.enabled?()
1600
- end
1601
-
1602
- test "renders error when invalid password provided", %{conn: conn, user: user} do
1603
- {:ok, user, _} = Auth.TOTP.initiate(user)
1604
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1605
-
1606
- conn = post(conn, Routes.auth_path(conn, :disable_2fa), %{password: "invalid"})
1607
-
1608
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :security) <> "#update-2fa"
1609
-
1610
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Incorrect password provided"
1611
- end
1612
- end
1613
-
1614
- on_ee do
1615
- describe "POST /2fa/disable - SSO user" do
1616
- setup [:create_user, :create_site, :create_team, :setup_sso, :provision_sso_user, :log_in]
1617
-
1618
- test "refuses to disable for SSO user", %{conn: conn, user: user} do
1619
- {:ok, user, _} = Auth.TOTP.initiate(user)
1620
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1621
-
1622
- conn = post(conn, Routes.auth_path(conn, :disable_2fa), %{password: "password"})
1623
-
1624
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
1625
-
1626
- assert user |> Repo.reload!() |> Auth.TOTP.enabled?()
1627
- end
1628
- end
1629
- end
1630
-
1631
- describe "POST /2fa/recovery_codes" do
1632
- setup [:create_user, :log_in]
1633
-
1634
- test "generates new recovery codes when valid password provided", %{conn: conn, user: user} do
1635
- {:ok, user, _} = Auth.TOTP.initiate(user)
1636
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1637
-
1638
- conn =
1639
- post(conn, Routes.auth_path(conn, :generate_2fa_recovery_codes), %{password: "password"})
1640
-
1641
- assert html = html_response(conn, 200)
1642
-
1643
- assert list = [_ | _] = find(html, "#recovery-codes-list > *") |> LazyHTML.to_tree()
1644
- assert length(list) == 10
1645
- end
1646
-
1647
- test "renders error when invalid password provided", %{conn: conn, user: user} do
1648
- {:ok, user, _} = Auth.TOTP.initiate(user)
1649
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1650
-
1651
- conn =
1652
- post(conn, Routes.auth_path(conn, :generate_2fa_recovery_codes), %{password: "invalid"})
1653
-
1654
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :security) <> "#update-2fa"
1655
-
1656
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Incorrect password provided"
1657
- end
1658
-
1659
- test "renders error when 2FA is not enabled", %{conn: conn} do
1660
- conn =
1661
- post(conn, Routes.auth_path(conn, :generate_2fa_recovery_codes), %{password: "password"})
1662
-
1663
- assert redirected_to(conn, 302) == Routes.settings_path(conn, :security) <> "#update-2fa"
1664
-
1665
- assert Phoenix.Flash.get(conn.assigns.flash, :error) =~
1666
- "Please enable Two-Factor Authentication"
1667
- end
1668
- end
1669
-
1670
- describe "GET /2fa/verify" do
1671
- test "renders verification form when 2FA session present", %{conn: conn} do
1672
- user = insert(:user)
1673
-
1674
- # enable 2FA
1675
- {:ok, user, _} = Auth.TOTP.initiate(user)
1676
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1677
-
1678
- conn = login_with_cookie(conn, user.email, "password")
1679
-
1680
- conn =
1681
- get(
1682
- conn,
1683
- Routes.auth_path(conn, :verify_2fa_form, return_to: Routes.settings_path(conn, :index))
1684
- )
1685
-
1686
- assert html = html_response(conn, 200)
1687
-
1688
- assert text_of_attr(html, "form", "action") ==
1689
- Routes.auth_path(conn, :verify_2fa, return_to: Routes.settings_path(conn, :index))
1690
-
1691
- assert element_exists?(html, "input[name=code]")
1692
-
1693
- assert element_exists?(html, "input[name=remember_2fa]")
1694
-
1695
- assert text_of_attr(html, "input[name=return_to]", "value") ==
1696
- Routes.settings_path(conn, :index)
1697
-
1698
- assert element_exists?(
1699
- html,
1700
- "a[href='#{Routes.auth_path(conn, :verify_2fa_recovery_code_form)}']"
1701
- )
1702
- end
1703
-
1704
- test "redirects to login when cookie not found", %{conn: conn} do
1705
- user = insert(:user)
1706
-
1707
- # enable 2FA
1708
- {:ok, user, _} = Auth.TOTP.initiate(user)
1709
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1710
-
1711
- conn = get(conn, Routes.auth_path(conn, :verify_2fa_form))
1712
-
1713
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
1714
- end
1715
-
1716
- test "redirects to login when 2FA not enabled", %{conn: conn} do
1717
- user = insert(:user)
1718
-
1719
- # enable 2FA
1720
- {:ok, user, _} = Auth.TOTP.initiate(user)
1721
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1722
-
1723
- conn = login_with_cookie(conn, user.email, "password")
1724
-
1725
- {:ok, _} = Auth.TOTP.disable(user, "password")
1726
-
1727
- conn = get(conn, Routes.auth_path(conn, :verify_2fa_form))
1728
-
1729
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
1730
- end
1731
- end
1732
-
1733
- describe "POST /2fa/verify" do
1734
- test "redirects to sites when code verification succeeds", %{conn: conn} do
1735
- user = insert(:user)
1736
-
1737
- # enable 2FA
1738
- {:ok, user, _} = Auth.TOTP.initiate(user)
1739
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
1740
-
1741
- conn = login_with_cookie(conn, user.email, "password")
1742
-
1743
- code = NimbleTOTP.verification_code(user.totp_secret)
1744
-
1745
- conn = post(conn, Routes.auth_path(conn, :verify_2fa), %{code: code})
1746
-
1747
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
1748
-
1749
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
1750
- assert get_session(conn)["user_token"] == token
1751
- # 2FA session terminated
1752
- assert conn.resp_cookies["session_2fa"].max_age == 0
1753
- # Remember cookie unset
1754
- assert conn.resp_cookies["remember_2fa"].max_age == 0
1755
- end
1756
-
1757
- test "redirects to return_to when set", %{conn: conn} do
1758
- user = insert(:user)
1759
-
1760
- # enable 2FA
1761
- {:ok, user, _} = Auth.TOTP.initiate(user)
1762
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
1763
-
1764
- conn = login_with_cookie(conn, user.email, "password")
1765
-
1766
- code = NimbleTOTP.verification_code(user.totp_secret)
1767
-
1768
- conn =
1769
- post(conn, Routes.auth_path(conn, :verify_2fa), %{code: code, return_to: "/dummy.site"})
1770
-
1771
- assert redirected_to(conn, 302) == "/dummy.site"
1772
- end
1773
-
1774
- test "sets remember cookie when device trusted", %{conn: conn} do
1775
- user = insert(:user)
1776
-
1777
- # enable 2FA
1778
- {:ok, user, _} = Auth.TOTP.initiate(user)
1779
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
1780
-
1781
- conn = login_with_cookie(conn, user.email, "password")
1782
-
1783
- code = NimbleTOTP.verification_code(user.totp_secret)
1784
-
1785
- conn = post(conn, Routes.auth_path(conn, :verify_2fa), %{code: code, remember_2fa: "true"})
1786
-
1787
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
1788
-
1789
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
1790
- assert get_session(conn)["user_token"] == token
1791
- # 2FA session terminated
1792
- assert conn.resp_cookies["session_2fa"].max_age == 0
1793
- # Remember cookie set
1794
- assert conn.resp_cookies["remember_2fa"].max_age > 0
1795
- end
1796
-
1797
- test "overwrites rogue remember cookie when device trusted", %{conn: conn} do
1798
- user = insert(:user)
1799
-
1800
- # enable 2FA
1801
- {:ok, user, _} = Auth.TOTP.initiate(user)
1802
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
1803
-
1804
- conn = login_with_cookie(conn, user.email, "password")
1805
-
1806
- another_user = insert(:user, totp_token: "different_token")
1807
- conn = set_remember_2fa_cookie(conn, another_user)
1808
-
1809
- code = NimbleTOTP.verification_code(user.totp_secret)
1810
-
1811
- conn = post(conn, Routes.auth_path(conn, :verify_2fa), %{code: code, remember_2fa: "true"})
1812
-
1813
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
1814
-
1815
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
1816
- assert get_session(conn)["user_token"] == token
1817
- # 2FA session terminated
1818
- assert conn.resp_cookies["session_2fa"].max_age == 0
1819
- # Remember cookie set
1820
- assert conn.resp_cookies["remember_2fa"].max_age > 0
1821
- assert fetch_cookies(conn).cookies["remember_2fa"] == user.totp_token
1822
- end
1823
-
1824
- test "clears rogue remember cookie when device _not_ trusted", %{conn: conn} do
1825
- user = insert(:user)
1826
-
1827
- # enable 2FA
1828
- {:ok, user, _} = Auth.TOTP.initiate(user)
1829
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
1830
-
1831
- conn = login_with_cookie(conn, user.email, "password")
1832
-
1833
- another_user = insert(:user, totp_token: "different_token")
1834
- conn = set_remember_2fa_cookie(conn, another_user)
1835
-
1836
- code = NimbleTOTP.verification_code(user.totp_secret)
1837
-
1838
- conn = post(conn, Routes.auth_path(conn, :verify_2fa), %{code: code})
1839
-
1840
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
1841
-
1842
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
1843
- assert get_session(conn, :user_token) == token
1844
- # 2FA session terminated
1845
- assert conn.resp_cookies["session_2fa"].max_age == 0
1846
- # Remember cookie cleared
1847
- assert conn.resp_cookies["remember_2fa"].max_age == 0
1848
- end
1849
-
1850
- test "returns error on invalid code", %{conn: conn} do
1851
- user = insert(:user)
1852
-
1853
- # enable 2FA
1854
- {:ok, user, _} = Auth.TOTP.initiate(user)
1855
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
1856
-
1857
- conn = login_with_cookie(conn, user.email, "password")
1858
-
1859
- conn = post(conn, Routes.auth_path(conn, :verify_2fa), %{code: "invalid"})
1860
-
1861
- assert html_response(conn, 200) =~ "The provided code is invalid"
1862
- end
1863
-
1864
- test "redirects to login when cookie not found", %{conn: conn} do
1865
- user = insert(:user)
1866
-
1867
- # enable 2FA
1868
- {:ok, user, _} = Auth.TOTP.initiate(user)
1869
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1870
-
1871
- code = NimbleTOTP.verification_code(user.totp_secret)
1872
-
1873
- conn = post(conn, Routes.auth_path(conn, :verify_2fa, %{code: code}))
1874
-
1875
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
1876
- end
1877
-
1878
- test "passes through when 2FA is disabled", %{conn: conn} do
1879
- user = insert(:user)
1880
-
1881
- # enable 2FA
1882
- {:ok, user, _} = Auth.TOTP.initiate(user)
1883
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
1884
-
1885
- conn = login_with_cookie(conn, user.email, "password")
1886
-
1887
- code = NimbleTOTP.verification_code(user.totp_secret)
1888
-
1889
- {:ok, _} = Auth.TOTP.disable(user, "password")
1890
-
1891
- conn = post(conn, Routes.auth_path(conn, :verify_2fa), %{code: code})
1892
-
1893
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
1894
-
1895
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
1896
- assert get_session(conn)["user_token"] == token
1897
- # 2FA session terminated
1898
- assert conn.resp_cookies["session_2fa"].max_age == 0
1899
- end
1900
-
1901
- test "limits verification attempts to 5 per minute", %{conn: conn} do
1902
- user = insert(:user, email: "ratio#{Ecto.UUID.generate()}@example.com")
1903
-
1904
- # enable 2FA
1905
- {:ok, user, _} = Auth.TOTP.initiate(user)
1906
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
1907
-
1908
- conn =
1909
- conn
1910
- |> login_with_cookie(user.email, "password")
1911
- |> put_req_header("x-forwarded-for", "1.1.1.1")
1912
-
1913
- response =
1914
- eventually(
1915
- fn ->
1916
- Enum.each(1..5, fn _ ->
1917
- post(conn, Routes.auth_path(conn, :verify_2fa), %{code: "invalid"})
1918
- end)
1919
-
1920
- conn = post(conn, Routes.auth_path(conn, :verify_2fa), %{code: "invalid"})
1921
-
1922
- {conn.status == 429, conn}
1923
- end,
1924
- 500
1925
- )
1926
-
1927
- assert get_session(response, :user_token) == nil
1928
- # 2FA session terminated
1929
- assert response.resp_cookies["session_2fa"].max_age == 0
1930
- assert html_response(response, 429) =~ "Too many login attempts"
1931
- end
1932
- end
1933
-
1934
- describe "GET /2fa/use_recovery_code" do
1935
- test "renders recovery verification form when 2FA session present", %{conn: conn} do
1936
- user = insert(:user)
1937
-
1938
- # enable 2FA
1939
- {:ok, user, _} = Auth.TOTP.initiate(user)
1940
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1941
-
1942
- conn = login_with_cookie(conn, user.email, "password")
1943
-
1944
- conn = get(conn, Routes.auth_path(conn, :verify_2fa_recovery_code_form))
1945
-
1946
- assert html = html_response(conn, 200)
1947
-
1948
- assert text_of_attr(html, "form", "action") ==
1949
- Routes.auth_path(conn, :verify_2fa_recovery_code)
1950
-
1951
- assert element_exists?(html, "input[name=recovery_code]")
1952
-
1953
- assert element_exists?(html, "a[href='#{Routes.auth_path(conn, :verify_2fa_form)}']")
1954
- end
1955
-
1956
- test "redirects to login when cookie not found", %{conn: conn} do
1957
- user = insert(:user)
1958
-
1959
- # enable 2FA
1960
- {:ok, user, _} = Auth.TOTP.initiate(user)
1961
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1962
-
1963
- conn = get(conn, Routes.auth_path(conn, :verify_2fa_recovery_code_form))
1964
-
1965
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
1966
- end
1967
-
1968
- test "redirects to login when 2FA not enabled", %{conn: conn} do
1969
- user = insert(:user)
1970
-
1971
- # enable 2FA
1972
- {:ok, user, _} = Auth.TOTP.initiate(user)
1973
- {:ok, _, _} = Auth.TOTP.enable(user, :skip_verify)
1974
-
1975
- conn = login_with_cookie(conn, user.email, "password")
1976
-
1977
- {:ok, _} = Auth.TOTP.disable(user, "password")
1978
-
1979
- conn = get(conn, Routes.auth_path(conn, :verify_2fa_recovery_code_form))
1980
-
1981
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
1982
- end
1983
- end
1984
-
1985
- describe "POST /2fa/use_recovery_code" do
1986
- test "redirects to sites when recovery code verification succeeds", %{conn: conn} do
1987
- user = insert(:user)
1988
-
1989
- # enable 2FA
1990
- {:ok, user, _} = Auth.TOTP.initiate(user)
1991
- {:ok, user, %{recovery_codes: [recovery_code | _]}} = Auth.TOTP.enable(user, :skip_verify)
1992
-
1993
- conn = login_with_cookie(conn, user.email, "password")
1994
-
1995
- conn =
1996
- post(conn, Routes.auth_path(conn, :verify_2fa_recovery_code), %{
1997
- recovery_code: recovery_code
1998
- })
1999
-
2000
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
2001
-
2002
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
2003
- assert get_session(conn)["user_token"] == token
2004
- # 2FA session terminated
2005
- assert conn.resp_cookies["session_2fa"].max_age == 0
2006
- end
2007
-
2008
- test "returns error on invalid recovery code", %{conn: conn} do
2009
- user = insert(:user)
2010
-
2011
- # enable 2FA
2012
- {:ok, user, _} = Auth.TOTP.initiate(user)
2013
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
2014
-
2015
- conn = login_with_cookie(conn, user.email, "password")
2016
-
2017
- conn =
2018
- post(conn, Routes.auth_path(conn, :verify_2fa_recovery_code), %{recovery_code: "invalid"})
2019
-
2020
- assert html_response(conn, 200) =~ "The provided recovery code is invalid"
2021
- end
2022
-
2023
- test "redirects to login when cookie not found", %{conn: conn} do
2024
- user = insert(:user)
2025
-
2026
- # enable 2FA
2027
- {:ok, user, _} = Auth.TOTP.initiate(user)
2028
- {:ok, _, %{recovery_codes: [recovery_code | _]}} = Auth.TOTP.enable(user, :skip_verify)
2029
-
2030
- conn =
2031
- post(
2032
- conn,
2033
- Routes.auth_path(conn, :verify_2fa_recovery_code, %{recovery_code: recovery_code})
2034
- )
2035
-
2036
- assert redirected_to(conn, 302) == Routes.auth_path(conn, :login_form)
2037
- end
2038
-
2039
- test "passes through when 2FA is disabled", %{conn: conn} do
2040
- user = insert(:user)
2041
-
2042
- # enable 2FA
2043
- {:ok, user, _} = Auth.TOTP.initiate(user)
2044
- {:ok, user, %{recovery_codes: [recovery_code | _]}} = Auth.TOTP.enable(user, :skip_verify)
2045
-
2046
- conn = login_with_cookie(conn, user.email, "password")
2047
-
2048
- {:ok, _} = Auth.TOTP.disable(user, "password")
2049
-
2050
- conn =
2051
- post(conn, Routes.auth_path(conn, :verify_2fa_recovery_code), %{
2052
- recovery_code: recovery_code
2053
- })
2054
-
2055
- assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
2056
-
2057
- assert %{sessions: [%{token: token}]} = user |> Repo.reload!() |> Repo.preload(:sessions)
2058
- assert get_session(conn)["user_token"] == token
2059
- # 2FA session terminated
2060
- assert conn.resp_cookies["session_2fa"].max_age == 0
2061
- end
2062
-
2063
- test "limits verification attempts to 5 per minute", %{conn: conn} do
2064
- user = insert(:user, email: "ratio#{Ecto.UUID.generate()}@example.com")
2065
-
2066
- # enable 2FA
2067
- {:ok, user, _} = Auth.TOTP.initiate(user)
2068
- {:ok, user, _} = Auth.TOTP.enable(user, :skip_verify)
2069
-
2070
- conn =
2071
- conn
2072
- |> login_with_cookie(user.email, "password")
2073
- |> put_req_header("x-forwarded-for", "1.2.3.4")
2074
-
2075
- response =
2076
- eventually(
2077
- fn ->
2078
- Enum.each(1..5, fn _ ->
2079
- post(conn, Routes.auth_path(conn, :verify_2fa_recovery_code), %{
2080
- recovery_code: "invalid"
2081
- })
2082
- end)
2083
-
2084
- conn =
2085
- post(conn, Routes.auth_path(conn, :verify_2fa_recovery_code), %{
2086
- recovery_code: "invalid"
2087
- })
2088
-
2089
- {conn.status == 429, conn}
2090
- end,
2091
- 500
2092
- )
2093
-
2094
- assert get_session(response, :user_token) == nil
2095
- # 2FA session terminated
2096
- assert response.resp_cookies["session_2fa"].max_age == 0
2097
- assert html_response(response, 429) =~ "Too many login attempts"
2098
- end
2099
- end
2100
-
2101
- defp login_with_cookie(conn, email, password) do
2102
- conn
2103
- |> post(Routes.auth_path(conn, :login), %{
2104
- email: email,
2105
- password: password
2106
- })
2107
- |> recycle()
2108
- |> prepare_conn()
2109
- end
2110
-
2111
- defp set_remember_2fa_cookie(conn, user) do
2112
- conn
2113
- |> PlausibleWeb.TwoFactor.Session.maybe_set_remember_2fa(user, "true")
2114
- |> recycle()
2115
- |> prepare_conn()
2116
- end
2117
-
2118
- defp mock_captcha_success() do
2119
- mock_captcha(true)
2120
- end
2121
-
2122
- defp mock_captcha_failure() do
2123
- mock_captcha(false)
2124
- end
2125
-
2126
- defp mock_captcha(success) do
2127
- expect(
2128
- Plausible.HTTPClient.Mock,
2129
- :post,
2130
- fn _, _, _ ->
2131
- {:ok,
2132
- %Finch.Response{
2133
- status: 200,
2134
- headers: [{"content-type", "application/json"}],
2135
- body: %{"success" => success}
2136
- }}
2137
- end
2138
- )
2139
- end
2140
-
2141
- defp mock_google_access_token(email) do
2142
- body =
2143
- %{"email" => email}
2144
- |> Jason.encode!()
2145
- |> Base.encode64(padding: false)
2146
-
2147
- expect(
2148
- Plausible.HTTPClient.Mock,
2149
- :post,
2150
- fn _, _, _ ->
2151
- {:ok,
2152
- %Finch.Response{
2153
- status: 200,
2154
- headers: [{"content-type", "application/json"}],
2155
- body: %{
2156
- "expires_in" => 3600,
2157
- "access_token" => "SomeAccessToken",
2158
- "refresh_token" => "SomeRefreshToken",
2159
- "id_token" => ".#{body}."
2160
- }
2161
- }}
2162
- end
2163
- )
2164
- end
2165
- end