projects / akkoma / blob
? search:


66d4b1ef36bf03666cf32f4ad9610738aa479be8
[akkoma] / test / web / admin_api / controllers / admin_api_controller_test.exs
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
6 use Pleroma.Web.ConnCase
7 use Oban.Testing, repo: Pleroma.Repo
8
9 import ExUnit.CaptureLog
10 import Mock
11 import Pleroma.Factory
12 import Swoosh.TestAssertions
13
14 alias Pleroma.Activity
15 alias Pleroma.Config
16 alias Pleroma.HTML
17 alias Pleroma.MFA
18 alias Pleroma.ModerationLog
19 alias Pleroma.Repo
20 alias Pleroma.Tests.ObanHelpers
21 alias Pleroma.User
22 alias Pleroma.Web
23 alias Pleroma.Web.ActivityPub.Relay
24 alias Pleroma.Web.CommonAPI
25 alias Pleroma.Web.MediaProxy
26
27 setup_all do
28 Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
29
30 :ok
31 end
32
33 setup do
34 admin = insert(:user, is_admin: true)
35 token = insert(:oauth_admin_token, user: admin)
36
37 conn =
38 build_conn()
39 |> assign(:user, admin)
40 |> assign(:token, token)
41
42 {:ok, %{admin: admin, token: token, conn: conn}}
43 end
44
45 test "with valid `admin_token` query parameter, skips OAuth scopes check" do
46 clear_config([:admin_token], "password123")
47
48 user = insert(:user)
49
50 conn = get(build_conn(), "/api/pleroma/admin/users/#{user.nickname}?admin_token=password123")
51
52 assert json_response(conn, 200)
53 end
54
55 describe "with [:auth, :enforce_oauth_admin_scope_usage]," do
56 setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], true)
57
58 test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
59 %{admin: admin} do
60 user = insert(:user)
61 url = "/api/pleroma/admin/users/#{user.nickname}"
62
63 good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
64 good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
65 good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])
66
67 bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
68 bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
69 bad_token3 = nil
70
71 for good_token <- [good_token1, good_token2, good_token3] do
72 conn =
73 build_conn()
74 |> assign(:user, admin)
75 |> assign(:token, good_token)
76 |> get(url)
77
78 assert json_response(conn, 200)
79 end
80
81 for good_token <- [good_token1, good_token2, good_token3] do
82 conn =
83 build_conn()
84 |> assign(:user, nil)
85 |> assign(:token, good_token)
86 |> get(url)
87
88 assert json_response(conn, :forbidden)
89 end
90
91 for bad_token <- [bad_token1, bad_token2, bad_token3] do
92 conn =
93 build_conn()
94 |> assign(:user, admin)
95 |> assign(:token, bad_token)
96 |> get(url)
97
98 assert json_response(conn, :forbidden)
99 end
100 end
101 end
102
103 describe "unless [:auth, :enforce_oauth_admin_scope_usage]," do
104 setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)
105
106 test "GET /api/pleroma/admin/users/:nickname requires " <>
107 "read:accounts or admin:read:accounts or broader scope",
108 %{admin: admin} do
109 user = insert(:user)
110 url = "/api/pleroma/admin/users/#{user.nickname}"
111
112 good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
113 good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
114 good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])
115 good_token4 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
116 good_token5 = insert(:oauth_token, user: admin, scopes: ["read"])
117
118 good_tokens = [good_token1, good_token2, good_token3, good_token4, good_token5]
119
120 bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts:partial"])
121 bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
122 bad_token3 = nil
123
124 for good_token <- good_tokens do
125 conn =
126 build_conn()
127 |> assign(:user, admin)
128 |> assign(:token, good_token)
129 |> get(url)
130
131 assert json_response(conn, 200)
132 end
133
134 for good_token <- good_tokens do
135 conn =
136 build_conn()
137 |> assign(:user, nil)
138 |> assign(:token, good_token)
139 |> get(url)
140
141 assert json_response(conn, :forbidden)
142 end
143
144 for bad_token <- [bad_token1, bad_token2, bad_token3] do
145 conn =
146 build_conn()
147 |> assign(:user, admin)
148 |> assign(:token, bad_token)
149 |> get(url)
150
151 assert json_response(conn, :forbidden)
152 end
153 end
154 end
155
156 describe "DELETE /api/pleroma/admin/users" do
157 test "single user", %{admin: admin, conn: conn} do
158 user = insert(:user)
159 clear_config([:instance, :federating], true)
160
161 refute user.deactivated
162
163 with_mock Pleroma.Web.Federator,
164 publish: fn _ -> nil end do
165 conn =
166 conn
167 |> put_req_header("accept", "application/json")
168 |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
169
170 ObanHelpers.perform_all()
171
172 assert User.get_by_nickname(user.nickname).deactivated
173
174 log_entry = Repo.one(ModerationLog)
175
176 assert ModerationLog.get_log_entry_message(log_entry) ==
177 "@#{admin.nickname} deleted users: @#{user.nickname}"
178
179 assert json_response(conn, 200) == [user.nickname]
180
181 user = Repo.get(User, user.id)
182 assert user.deactivated
183
184 assert called(Pleroma.Web.Federator.publish(:_))
185 end
186 end
187
188 test "multiple users", %{admin: admin, conn: conn} do
189 user_one = insert(:user)
190 user_two = insert(:user)
191
192 conn =
193 conn
194 |> put_req_header("accept", "application/json")
195 |> delete("/api/pleroma/admin/users", %{
196 nicknames: [user_one.nickname, user_two.nickname]
197 })
198
199 log_entry = Repo.one(ModerationLog)
200
201 assert ModerationLog.get_log_entry_message(log_entry) ==
202 "@#{admin.nickname} deleted users: @#{user_one.nickname}, @#{user_two.nickname}"
203
204 response = json_response(conn, 200)
205 assert response -- [user_one.nickname, user_two.nickname] == []
206 end
207 end
208
209 describe "/api/pleroma/admin/users" do
210 test "Create", %{conn: conn} do
211 conn =
212 conn
213 |> put_req_header("accept", "application/json")
214 |> post("/api/pleroma/admin/users", %{
215 "users" => [
216 %{
217 "nickname" => "lain",
218 "email" => "lain@example.org",
219 "password" => "test"
220 },
221 %{
222 "nickname" => "lain2",
223 "email" => "lain2@example.org",
224 "password" => "test"
225 }
226 ]
227 })
228
229 response = json_response(conn, 200) |> Enum.map(&Map.get(&1, "type"))
230 assert response == ["success", "success"]
231
232 log_entry = Repo.one(ModerationLog)
233
234 assert ["lain", "lain2"] -- Enum.map(log_entry.data["subjects"], & &1["nickname"]) == []
235 end
236
237 test "Cannot create user with existing email", %{conn: conn} do
238 user = insert(:user)
239
240 conn =
241 conn
242 |> put_req_header("accept", "application/json")
243 |> post("/api/pleroma/admin/users", %{
244 "users" => [
245 %{
246 "nickname" => "lain",
247 "email" => user.email,
248 "password" => "test"
249 }
250 ]
251 })
252
253 assert json_response(conn, 409) == [
254 %{
255 "code" => 409,
256 "data" => %{
257 "email" => user.email,
258 "nickname" => "lain"
259 },
260 "error" => "email has already been taken",
261 "type" => "error"
262 }
263 ]
264 end
265
266 test "Cannot create user with existing nickname", %{conn: conn} do
267 user = insert(:user)
268
269 conn =
270 conn
271 |> put_req_header("accept", "application/json")
272 |> post("/api/pleroma/admin/users", %{
273 "users" => [
274 %{
275 "nickname" => user.nickname,
276 "email" => "someuser@plerama.social",
277 "password" => "test"
278 }
279 ]
280 })
281
282 assert json_response(conn, 409) == [
283 %{
284 "code" => 409,
285 "data" => %{
286 "email" => "someuser@plerama.social",
287 "nickname" => user.nickname
288 },
289 "error" => "nickname has already been taken",
290 "type" => "error"
291 }
292 ]
293 end
294
295 test "Multiple user creation works in transaction", %{conn: conn} do
296 user = insert(:user)
297
298 conn =
299 conn
300 |> put_req_header("accept", "application/json")
301 |> post("/api/pleroma/admin/users", %{
302 "users" => [
303 %{
304 "nickname" => "newuser",
305 "email" => "newuser@pleroma.social",
306 "password" => "test"
307 },
308 %{
309 "nickname" => "lain",
310 "email" => user.email,
311 "password" => "test"
312 }
313 ]
314 })
315
316 assert json_response(conn, 409) == [
317 %{
318 "code" => 409,
319 "data" => %{
320 "email" => user.email,
321 "nickname" => "lain"
322 },
323 "error" => "email has already been taken",
324 "type" => "error"
325 },
326 %{
327 "code" => 409,
328 "data" => %{
329 "email" => "newuser@pleroma.social",
330 "nickname" => "newuser"
331 },
332 "error" => "",
333 "type" => "error"
334 }
335 ]
336
337 assert User.get_by_nickname("newuser") === nil
338 end
339 end
340
341 describe "/api/pleroma/admin/users/:nickname" do
342 test "Show", %{conn: conn} do
343 user = insert(:user)
344
345 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")
346
347 expected = %{
348 "deactivated" => false,
349 "id" => to_string(user.id),
350 "local" => true,
351 "nickname" => user.nickname,
352 "roles" => %{"admin" => false, "moderator" => false},
353 "tags" => [],
354 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
355 "display_name" => HTML.strip_tags(user.name || user.nickname),
356 "confirmation_pending" => false,
357 "approval_pending" => false,
358 "url" => user.ap_id,
359 "registration_reason" => nil
360 }
361
362 assert expected == json_response(conn, 200)
363 end
364
365 test "when the user doesn't exist", %{conn: conn} do
366 user = build(:user)
367
368 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")
369
370 assert %{"error" => "Not found"} == json_response(conn, 404)
371 end
372 end
373
374 describe "/api/pleroma/admin/users/follow" do
375 test "allows to force-follow another user", %{admin: admin, conn: conn} do
376 user = insert(:user)
377 follower = insert(:user)
378
379 conn
380 |> put_req_header("accept", "application/json")
381 |> post("/api/pleroma/admin/users/follow", %{
382 "follower" => follower.nickname,
383 "followed" => user.nickname
384 })
385
386 user = User.get_cached_by_id(user.id)
387 follower = User.get_cached_by_id(follower.id)
388
389 assert User.following?(follower, user)
390
391 log_entry = Repo.one(ModerationLog)
392
393 assert ModerationLog.get_log_entry_message(log_entry) ==
394 "@#{admin.nickname} made @#{follower.nickname} follow @#{user.nickname}"
395 end
396 end
397
398 describe "/api/pleroma/admin/users/unfollow" do
399 test "allows to force-unfollow another user", %{admin: admin, conn: conn} do
400 user = insert(:user)
401 follower = insert(:user)
402
403 User.follow(follower, user)
404
405 conn
406 |> put_req_header("accept", "application/json")
407 |> post("/api/pleroma/admin/users/unfollow", %{
408 "follower" => follower.nickname,
409 "followed" => user.nickname
410 })
411
412 user = User.get_cached_by_id(user.id)
413 follower = User.get_cached_by_id(follower.id)
414
415 refute User.following?(follower, user)
416
417 log_entry = Repo.one(ModerationLog)
418
419 assert ModerationLog.get_log_entry_message(log_entry) ==
420 "@#{admin.nickname} made @#{follower.nickname} unfollow @#{user.nickname}"
421 end
422 end
423
424 describe "PUT /api/pleroma/admin/users/tag" do
425 setup %{conn: conn} do
426 user1 = insert(:user, %{tags: ["x"]})
427 user2 = insert(:user, %{tags: ["y"]})
428 user3 = insert(:user, %{tags: ["unchanged"]})
429
430 conn =
431 conn
432 |> put_req_header("accept", "application/json")
433 |> put(
434 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
435 "#{user2.nickname}&tags[]=foo&tags[]=bar"
436 )
437
438 %{conn: conn, user1: user1, user2: user2, user3: user3}
439 end
440
441 test "it appends specified tags to users with specified nicknames", %{
442 conn: conn,
443 admin: admin,
444 user1: user1,
445 user2: user2
446 } do
447 assert empty_json_response(conn)
448 assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
449 assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
450
451 log_entry = Repo.one(ModerationLog)
452
453 users =
454 [user1.nickname, user2.nickname]
455 |> Enum.map(&"@#{&1}")
456 |> Enum.join(", ")
457
458 tags = ["foo", "bar"] |> Enum.join(", ")
459
460 assert ModerationLog.get_log_entry_message(log_entry) ==
461 "@#{admin.nickname} added tags: #{tags} to users: #{users}"
462 end
463
464 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
465 assert empty_json_response(conn)
466 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
467 end
468 end
469
470 describe "DELETE /api/pleroma/admin/users/tag" do
471 setup %{conn: conn} do
472 user1 = insert(:user, %{tags: ["x"]})
473 user2 = insert(:user, %{tags: ["y", "z"]})
474 user3 = insert(:user, %{tags: ["unchanged"]})
475
476 conn =
477 conn
478 |> put_req_header("accept", "application/json")
479 |> delete(
480 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
481 "#{user2.nickname}&tags[]=x&tags[]=z"
482 )
483
484 %{conn: conn, user1: user1, user2: user2, user3: user3}
485 end
486
487 test "it removes specified tags from users with specified nicknames", %{
488 conn: conn,
489 admin: admin,
490 user1: user1,
491 user2: user2
492 } do
493 assert empty_json_response(conn)
494 assert User.get_cached_by_id(user1.id).tags == []
495 assert User.get_cached_by_id(user2.id).tags == ["y"]
496
497 log_entry = Repo.one(ModerationLog)
498
499 users =
500 [user1.nickname, user2.nickname]
501 |> Enum.map(&"@#{&1}")
502 |> Enum.join(", ")
503
504 tags = ["x", "z"] |> Enum.join(", ")
505
506 assert ModerationLog.get_log_entry_message(log_entry) ==
507 "@#{admin.nickname} removed tags: #{tags} from users: #{users}"
508 end
509
510 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
511 assert empty_json_response(conn)
512 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
513 end
514 end
515
516 describe "/api/pleroma/admin/users/:nickname/permission_group" do
517 test "GET is giving user_info", %{admin: admin, conn: conn} do
518 conn =
519 conn
520 |> put_req_header("accept", "application/json")
521 |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
522
523 assert json_response(conn, 200) == %{
524 "is_admin" => true,
525 "is_moderator" => false
526 }
527 end
528
529 test "/:right POST, can add to a permission group", %{admin: admin, conn: conn} do
530 user = insert(:user)
531
532 conn =
533 conn
534 |> put_req_header("accept", "application/json")
535 |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
536
537 assert json_response(conn, 200) == %{
538 "is_admin" => true
539 }
540
541 log_entry = Repo.one(ModerationLog)
542
543 assert ModerationLog.get_log_entry_message(log_entry) ==
544 "@#{admin.nickname} made @#{user.nickname} admin"
545 end
546
547 test "/:right POST, can add to a permission group (multiple)", %{admin: admin, conn: conn} do
548 user_one = insert(:user)
549 user_two = insert(:user)
550
551 conn =
552 conn
553 |> put_req_header("accept", "application/json")
554 |> post("/api/pleroma/admin/users/permission_group/admin", %{
555 nicknames: [user_one.nickname, user_two.nickname]
556 })
557
558 assert json_response(conn, 200) == %{"is_admin" => true}
559
560 log_entry = Repo.one(ModerationLog)
561
562 assert ModerationLog.get_log_entry_message(log_entry) ==
563 "@#{admin.nickname} made @#{user_one.nickname}, @#{user_two.nickname} admin"
564 end
565
566 test "/:right DELETE, can remove from a permission group", %{admin: admin, conn: conn} do
567 user = insert(:user, is_admin: true)
568
569 conn =
570 conn
571 |> put_req_header("accept", "application/json")
572 |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
573
574 assert json_response(conn, 200) == %{"is_admin" => false}
575
576 log_entry = Repo.one(ModerationLog)
577
578 assert ModerationLog.get_log_entry_message(log_entry) ==
579 "@#{admin.nickname} revoked admin role from @#{user.nickname}"
580 end
581
582 test "/:right DELETE, can remove from a permission group (multiple)", %{
583 admin: admin,
584 conn: conn
585 } do
586 user_one = insert(:user, is_admin: true)
587 user_two = insert(:user, is_admin: true)
588
589 conn =
590 conn
591 |> put_req_header("accept", "application/json")
592 |> delete("/api/pleroma/admin/users/permission_group/admin", %{
593 nicknames: [user_one.nickname, user_two.nickname]
594 })
595
596 assert json_response(conn, 200) == %{"is_admin" => false}
597
598 log_entry = Repo.one(ModerationLog)
599
600 assert ModerationLog.get_log_entry_message(log_entry) ==
601 "@#{admin.nickname} revoked admin role from @#{user_one.nickname}, @#{
602 user_two.nickname
603 }"
604 end
605 end
606
607 test "/api/pleroma/admin/users/:nickname/password_reset", %{conn: conn} do
608 user = insert(:user)
609
610 conn =
611 conn
612 |> put_req_header("accept", "application/json")
613 |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
614
615 resp = json_response(conn, 200)
616
617 assert Regex.match?(~r/(http:\/\/|https:\/\/)/, resp["link"])
618 end
619
620 describe "GET /api/pleroma/admin/users" do
621 test "renders users array for the first page", %{conn: conn, admin: admin} do
622 user = insert(:user, local: false, tags: ["foo", "bar"])
623 user2 = insert(:user, approval_pending: true, registration_reason: "I'm a chill dude")
624
625 conn = get(conn, "/api/pleroma/admin/users?page=1")
626
627 users =
628 [
629 %{
630 "deactivated" => admin.deactivated,
631 "id" => admin.id,
632 "nickname" => admin.nickname,
633 "roles" => %{"admin" => true, "moderator" => false},
634 "local" => true,
635 "tags" => [],
636 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
637 "display_name" => HTML.strip_tags(admin.name || admin.nickname),
638 "confirmation_pending" => false,
639 "approval_pending" => false,
640 "url" => admin.ap_id,
641 "registration_reason" => nil
642 },
643 %{
644 "deactivated" => user.deactivated,
645 "id" => user.id,
646 "nickname" => user.nickname,
647 "roles" => %{"admin" => false, "moderator" => false},
648 "local" => false,
649 "tags" => ["foo", "bar"],
650 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
651 "display_name" => HTML.strip_tags(user.name || user.nickname),
652 "confirmation_pending" => false,
653 "approval_pending" => false,
654 "url" => user.ap_id,
655 "registration_reason" => nil
656 },
657 %{
658 "deactivated" => user2.deactivated,
659 "id" => user2.id,
660 "nickname" => user2.nickname,
661 "roles" => %{"admin" => false, "moderator" => false},
662 "local" => true,
663 "tags" => [],
664 "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
665 "display_name" => HTML.strip_tags(user2.name || user2.nickname),
666 "confirmation_pending" => false,
667 "approval_pending" => true,
668 "url" => user2.ap_id,
669 "registration_reason" => "I'm a chill dude"
670 }
671 ]
672 |> Enum.sort_by(& &1["nickname"])
673
674 assert json_response(conn, 200) == %{
675 "count" => 3,
676 "page_size" => 50,
677 "users" => users
678 }
679 end
680
681 test "pagination works correctly with service users", %{conn: conn} do
682 service1 = User.get_or_create_service_actor_by_ap_id(Web.base_url() <> "/meido", "meido")
683
684 insert_list(25, :user)
685
686 assert %{"count" => 26, "page_size" => 10, "users" => users1} =
687 conn
688 |> get("/api/pleroma/admin/users?page=1&filters=", %{page_size: "10"})
689 |> json_response(200)
690
691 assert Enum.count(users1) == 10
692 assert service1 not in users1
693
694 assert %{"count" => 26, "page_size" => 10, "users" => users2} =
695 conn
696 |> get("/api/pleroma/admin/users?page=2&filters=", %{page_size: "10"})
697 |> json_response(200)
698
699 assert Enum.count(users2) == 10
700 assert service1 not in users2
701
702 assert %{"count" => 26, "page_size" => 10, "users" => users3} =
703 conn
704 |> get("/api/pleroma/admin/users?page=3&filters=", %{page_size: "10"})
705 |> json_response(200)
706
707 assert Enum.count(users3) == 6
708 assert service1 not in users3
709 end
710
711 test "renders empty array for the second page", %{conn: conn} do
712 insert(:user)
713
714 conn = get(conn, "/api/pleroma/admin/users?page=2")
715
716 assert json_response(conn, 200) == %{
717 "count" => 2,
718 "page_size" => 50,
719 "users" => []
720 }
721 end
722
723 test "regular search", %{conn: conn} do
724 user = insert(:user, nickname: "bob")
725
726 conn = get(conn, "/api/pleroma/admin/users?query=bo")
727
728 assert json_response(conn, 200) == %{
729 "count" => 1,
730 "page_size" => 50,
731 "users" => [
732 %{
733 "deactivated" => user.deactivated,
734 "id" => user.id,
735 "nickname" => user.nickname,
736 "roles" => %{"admin" => false, "moderator" => false},
737 "local" => true,
738 "tags" => [],
739 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
740 "display_name" => HTML.strip_tags(user.name || user.nickname),
741 "confirmation_pending" => false,
742 "approval_pending" => false,
743 "url" => user.ap_id,
744 "registration_reason" => nil
745 }
746 ]
747 }
748 end
749
750 test "search by domain", %{conn: conn} do
751 user = insert(:user, nickname: "nickname@domain.com")
752 insert(:user)
753
754 conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
755
756 assert json_response(conn, 200) == %{
757 "count" => 1,
758 "page_size" => 50,
759 "users" => [
760 %{
761 "deactivated" => user.deactivated,
762 "id" => user.id,
763 "nickname" => user.nickname,
764 "roles" => %{"admin" => false, "moderator" => false},
765 "local" => true,
766 "tags" => [],
767 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
768 "display_name" => HTML.strip_tags(user.name || user.nickname),
769 "confirmation_pending" => false,
770 "approval_pending" => false,
771 "url" => user.ap_id,
772 "registration_reason" => nil
773 }
774 ]
775 }
776 end
777
778 test "search by full nickname", %{conn: conn} do
779 user = insert(:user, nickname: "nickname@domain.com")
780 insert(:user)
781
782 conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
783
784 assert json_response(conn, 200) == %{
785 "count" => 1,
786 "page_size" => 50,
787 "users" => [
788 %{
789 "deactivated" => user.deactivated,
790 "id" => user.id,
791 "nickname" => user.nickname,
792 "roles" => %{"admin" => false, "moderator" => false},
793 "local" => true,
794 "tags" => [],
795 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
796 "display_name" => HTML.strip_tags(user.name || user.nickname),
797 "confirmation_pending" => false,
798 "approval_pending" => false,
799 "url" => user.ap_id,
800 "registration_reason" => nil
801 }
802 ]
803 }
804 end
805
806 test "search by display name", %{conn: conn} do
807 user = insert(:user, name: "Display name")
808 insert(:user)
809
810 conn = get(conn, "/api/pleroma/admin/users?name=display")
811
812 assert json_response(conn, 200) == %{
813 "count" => 1,
814 "page_size" => 50,
815 "users" => [
816 %{
817 "deactivated" => user.deactivated,
818 "id" => user.id,
819 "nickname" => user.nickname,
820 "roles" => %{"admin" => false, "moderator" => false},
821 "local" => true,
822 "tags" => [],
823 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
824 "display_name" => HTML.strip_tags(user.name || user.nickname),
825 "confirmation_pending" => false,
826 "approval_pending" => false,
827 "url" => user.ap_id,
828 "registration_reason" => nil
829 }
830 ]
831 }
832 end
833
834 test "search by email", %{conn: conn} do
835 user = insert(:user, email: "email@example.com")
836 insert(:user)
837
838 conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
839
840 assert json_response(conn, 200) == %{
841 "count" => 1,
842 "page_size" => 50,
843 "users" => [
844 %{
845 "deactivated" => user.deactivated,
846 "id" => user.id,
847 "nickname" => user.nickname,
848 "roles" => %{"admin" => false, "moderator" => false},
849 "local" => true,
850 "tags" => [],
851 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
852 "display_name" => HTML.strip_tags(user.name || user.nickname),
853 "confirmation_pending" => false,
854 "approval_pending" => false,
855 "url" => user.ap_id,
856 "registration_reason" => nil
857 }
858 ]
859 }
860 end
861
862 test "regular search with page size", %{conn: conn} do
863 user = insert(:user, nickname: "aalice")
864 user2 = insert(:user, nickname: "alice")
865
866 conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
867
868 assert json_response(conn1, 200) == %{
869 "count" => 2,
870 "page_size" => 1,
871 "users" => [
872 %{
873 "deactivated" => user.deactivated,
874 "id" => user.id,
875 "nickname" => user.nickname,
876 "roles" => %{"admin" => false, "moderator" => false},
877 "local" => true,
878 "tags" => [],
879 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
880 "display_name" => HTML.strip_tags(user.name || user.nickname),
881 "confirmation_pending" => false,
882 "approval_pending" => false,
883 "url" => user.ap_id,
884 "registration_reason" => nil
885 }
886 ]
887 }
888
889 conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
890
891 assert json_response(conn2, 200) == %{
892 "count" => 2,
893 "page_size" => 1,
894 "users" => [
895 %{
896 "deactivated" => user2.deactivated,
897 "id" => user2.id,
898 "nickname" => user2.nickname,
899 "roles" => %{"admin" => false, "moderator" => false},
900 "local" => true,
901 "tags" => [],
902 "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
903 "display_name" => HTML.strip_tags(user2.name || user2.nickname),
904 "confirmation_pending" => false,
905 "approval_pending" => false,
906 "url" => user2.ap_id,
907 "registration_reason" => nil
908 }
909 ]
910 }
911 end
912
913 test "only local users" do
914 admin = insert(:user, is_admin: true, nickname: "john")
915 token = insert(:oauth_admin_token, user: admin)
916 user = insert(:user, nickname: "bob")
917
918 insert(:user, nickname: "bobb", local: false)
919
920 conn =
921 build_conn()
922 |> assign(:user, admin)
923 |> assign(:token, token)
924 |> get("/api/pleroma/admin/users?query=bo&filters=local")
925
926 assert json_response(conn, 200) == %{
927 "count" => 1,
928 "page_size" => 50,
929 "users" => [
930 %{
931 "deactivated" => user.deactivated,
932 "id" => user.id,
933 "nickname" => user.nickname,
934 "roles" => %{"admin" => false, "moderator" => false},
935 "local" => true,
936 "tags" => [],
937 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
938 "display_name" => HTML.strip_tags(user.name || user.nickname),
939 "confirmation_pending" => false,
940 "approval_pending" => false,
941 "url" => user.ap_id,
942 "registration_reason" => nil
943 }
944 ]
945 }
946 end
947
948 test "only local users with no query", %{conn: conn, admin: old_admin} do
949 admin = insert(:user, is_admin: true, nickname: "john")
950 user = insert(:user, nickname: "bob")
951
952 insert(:user, nickname: "bobb", local: false)
953
954 conn = get(conn, "/api/pleroma/admin/users?filters=local")
955
956 users =
957 [
958 %{
959 "deactivated" => user.deactivated,
960 "id" => user.id,
961 "nickname" => user.nickname,
962 "roles" => %{"admin" => false, "moderator" => false},
963 "local" => true,
964 "tags" => [],
965 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
966 "display_name" => HTML.strip_tags(user.name || user.nickname),
967 "confirmation_pending" => false,
968 "approval_pending" => false,
969 "url" => user.ap_id,
970 "registration_reason" => nil
971 },
972 %{
973 "deactivated" => admin.deactivated,
974 "id" => admin.id,
975 "nickname" => admin.nickname,
976 "roles" => %{"admin" => true, "moderator" => false},
977 "local" => true,
978 "tags" => [],
979 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
980 "display_name" => HTML.strip_tags(admin.name || admin.nickname),
981 "confirmation_pending" => false,
982 "approval_pending" => false,
983 "url" => admin.ap_id,
984 "registration_reason" => nil
985 },
986 %{
987 "deactivated" => false,
988 "id" => old_admin.id,
989 "local" => true,
990 "nickname" => old_admin.nickname,
991 "roles" => %{"admin" => true, "moderator" => false},
992 "tags" => [],
993 "avatar" => User.avatar_url(old_admin) |> MediaProxy.url(),
994 "display_name" => HTML.strip_tags(old_admin.name || old_admin.nickname),
995 "confirmation_pending" => false,
996 "approval_pending" => false,
997 "url" => old_admin.ap_id,
998 "registration_reason" => nil
999 }
1000 ]
1001 |> Enum.sort_by(& &1["nickname"])
1002
1003 assert json_response(conn, 200) == %{
1004 "count" => 3,
1005 "page_size" => 50,
1006 "users" => users
1007 }
1008 end
1009
1010 test "only unapproved users", %{conn: conn} do
1011 user =
1012 insert(:user,
1013 nickname: "sadboy",
1014 approval_pending: true,
1015 registration_reason: "Plz let me in!"
1016 )
1017
1018 insert(:user, nickname: "happyboy", approval_pending: false)
1019
1020 conn = get(conn, "/api/pleroma/admin/users?filters=need_approval")
1021
1022 users =
1023 [
1024 %{
1025 "deactivated" => user.deactivated,
1026 "id" => user.id,
1027 "nickname" => user.nickname,
1028 "roles" => %{"admin" => false, "moderator" => false},
1029 "local" => true,
1030 "tags" => [],
1031 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
1032 "display_name" => HTML.strip_tags(user.name || user.nickname),
1033 "confirmation_pending" => false,
1034 "approval_pending" => true,
1035 "url" => user.ap_id,
1036 "registration_reason" => "Plz let me in!"
1037 }
1038 ]
1039 |> Enum.sort_by(& &1["nickname"])
1040
1041 assert json_response(conn, 200) == %{
1042 "count" => 1,
1043 "page_size" => 50,
1044 "users" => users
1045 }
1046 end
1047
1048 test "load only admins", %{conn: conn, admin: admin} do
1049 second_admin = insert(:user, is_admin: true)
1050 insert(:user)
1051 insert(:user)
1052
1053 conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
1054
1055 users =
1056 [
1057 %{
1058 "deactivated" => false,
1059 "id" => admin.id,
1060 "nickname" => admin.nickname,
1061 "roles" => %{"admin" => true, "moderator" => false},
1062 "local" => admin.local,
1063 "tags" => [],
1064 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
1065 "display_name" => HTML.strip_tags(admin.name || admin.nickname),
1066 "confirmation_pending" => false,
1067 "approval_pending" => false,
1068 "url" => admin.ap_id,
1069 "registration_reason" => nil
1070 },
1071 %{
1072 "deactivated" => false,
1073 "id" => second_admin.id,
1074 "nickname" => second_admin.nickname,
1075 "roles" => %{"admin" => true, "moderator" => false},
1076 "local" => second_admin.local,
1077 "tags" => [],
1078 "avatar" => User.avatar_url(second_admin) |> MediaProxy.url(),
1079 "display_name" => HTML.strip_tags(second_admin.name || second_admin.nickname),
1080 "confirmation_pending" => false,
1081 "approval_pending" => false,
1082 "url" => second_admin.ap_id,
1083 "registration_reason" => nil
1084 }
1085 ]
1086 |> Enum.sort_by(& &1["nickname"])
1087
1088 assert json_response(conn, 200) == %{
1089 "count" => 2,
1090 "page_size" => 50,
1091 "users" => users
1092 }
1093 end
1094
1095 test "load only moderators", %{conn: conn} do
1096 moderator = insert(:user, is_moderator: true)
1097 insert(:user)
1098 insert(:user)
1099
1100 conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
1101
1102 assert json_response(conn, 200) == %{
1103 "count" => 1,
1104 "page_size" => 50,
1105 "users" => [
1106 %{
1107 "deactivated" => false,
1108 "id" => moderator.id,
1109 "nickname" => moderator.nickname,
1110 "roles" => %{"admin" => false, "moderator" => true},
1111 "local" => moderator.local,
1112 "tags" => [],
1113 "avatar" => User.avatar_url(moderator) |> MediaProxy.url(),
1114 "display_name" => HTML.strip_tags(moderator.name || moderator.nickname),
1115 "confirmation_pending" => false,
1116 "approval_pending" => false,
1117 "url" => moderator.ap_id,
1118 "registration_reason" => nil
1119 }
1120 ]
1121 }
1122 end
1123
1124 test "load users with tags list", %{conn: conn} do
1125 user1 = insert(:user, tags: ["first"])
1126 user2 = insert(:user, tags: ["second"])
1127 insert(:user)
1128 insert(:user)
1129
1130 conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
1131
1132 users =
1133 [
1134 %{
1135 "deactivated" => false,
1136 "id" => user1.id,
1137 "nickname" => user1.nickname,
1138 "roles" => %{"admin" => false, "moderator" => false},
1139 "local" => user1.local,
1140 "tags" => ["first"],
1141 "avatar" => User.avatar_url(user1) |> MediaProxy.url(),
1142 "display_name" => HTML.strip_tags(user1.name || user1.nickname),
1143 "confirmation_pending" => false,
1144 "approval_pending" => false,
1145 "url" => user1.ap_id,
1146 "registration_reason" => nil
1147 },
1148 %{
1149 "deactivated" => false,
1150 "id" => user2.id,
1151 "nickname" => user2.nickname,
1152 "roles" => %{"admin" => false, "moderator" => false},
1153 "local" => user2.local,
1154 "tags" => ["second"],
1155 "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
1156 "display_name" => HTML.strip_tags(user2.name || user2.nickname),
1157 "confirmation_pending" => false,
1158 "approval_pending" => false,
1159 "url" => user2.ap_id,
1160 "registration_reason" => nil
1161 }
1162 ]
1163 |> Enum.sort_by(& &1["nickname"])
1164
1165 assert json_response(conn, 200) == %{
1166 "count" => 2,
1167 "page_size" => 50,
1168 "users" => users
1169 }
1170 end
1171
1172 test "`active` filters out users pending approval", %{token: token} do
1173 insert(:user, approval_pending: true)
1174 %{id: user_id} = insert(:user, approval_pending: false)
1175 %{id: admin_id} = token.user
1176
1177 conn =
1178 build_conn()
1179 |> assign(:user, token.user)
1180 |> assign(:token, token)
1181 |> get("/api/pleroma/admin/users?filters=active")
1182
1183 assert %{
1184 "count" => 2,
1185 "page_size" => 50,
1186 "users" => [
1187 %{"id" => ^admin_id},
1188 %{"id" => ^user_id}
1189 ]
1190 } = json_response(conn, 200)
1191 end
1192
1193 test "it works with multiple filters" do
1194 admin = insert(:user, nickname: "john", is_admin: true)
1195 token = insert(:oauth_admin_token, user: admin)
1196 user = insert(:user, nickname: "bob", local: false, deactivated: true)
1197
1198 insert(:user, nickname: "ken", local: true, deactivated: true)
1199 insert(:user, nickname: "bobb", local: false, deactivated: false)
1200
1201 conn =
1202 build_conn()
1203 |> assign(:user, admin)
1204 |> assign(:token, token)
1205 |> get("/api/pleroma/admin/users?filters=deactivated,external")
1206
1207 assert json_response(conn, 200) == %{
1208 "count" => 1,
1209 "page_size" => 50,
1210 "users" => [
1211 %{
1212 "deactivated" => user.deactivated,
1213 "id" => user.id,
1214 "nickname" => user.nickname,
1215 "roles" => %{"admin" => false, "moderator" => false},
1216 "local" => user.local,
1217 "tags" => [],
1218 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
1219 "display_name" => HTML.strip_tags(user.name || user.nickname),
1220 "confirmation_pending" => false,
1221 "approval_pending" => false,
1222 "url" => user.ap_id,
1223 "registration_reason" => nil
1224 }
1225 ]
1226 }
1227 end
1228
1229 test "it omits relay user", %{admin: admin, conn: conn} do
1230 assert %User{} = Relay.get_actor()
1231
1232 conn = get(conn, "/api/pleroma/admin/users")
1233
1234 assert json_response(conn, 200) == %{
1235 "count" => 1,
1236 "page_size" => 50,
1237 "users" => [
1238 %{
1239 "deactivated" => admin.deactivated,
1240 "id" => admin.id,
1241 "nickname" => admin.nickname,
1242 "roles" => %{"admin" => true, "moderator" => false},
1243 "local" => true,
1244 "tags" => [],
1245 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
1246 "display_name" => HTML.strip_tags(admin.name || admin.nickname),
1247 "confirmation_pending" => false,
1248 "approval_pending" => false,
1249 "url" => admin.ap_id,
1250 "registration_reason" => nil
1251 }
1252 ]
1253 }
1254 end
1255 end
1256
1257 test "PATCH /api/pleroma/admin/users/activate", %{admin: admin, conn: conn} do
1258 user_one = insert(:user, deactivated: true)
1259 user_two = insert(:user, deactivated: true)
1260
1261 conn =
1262 patch(
1263 conn,
1264 "/api/pleroma/admin/users/activate",
1265 %{nicknames: [user_one.nickname, user_two.nickname]}
1266 )
1267
1268 response = json_response(conn, 200)
1269 assert Enum.map(response["users"], & &1["deactivated"]) == [false, false]
1270
1271 log_entry = Repo.one(ModerationLog)
1272
1273 assert ModerationLog.get_log_entry_message(log_entry) ==
1274 "@#{admin.nickname} activated users: @#{user_one.nickname}, @#{user_two.nickname}"
1275 end
1276
1277 test "PATCH /api/pleroma/admin/users/deactivate", %{admin: admin, conn: conn} do
1278 user_one = insert(:user, deactivated: false)
1279 user_two = insert(:user, deactivated: false)
1280
1281 conn =
1282 patch(
1283 conn,
1284 "/api/pleroma/admin/users/deactivate",
1285 %{nicknames: [user_one.nickname, user_two.nickname]}
1286 )
1287
1288 response = json_response(conn, 200)
1289 assert Enum.map(response["users"], & &1["deactivated"]) == [true, true]
1290
1291 log_entry = Repo.one(ModerationLog)
1292
1293 assert ModerationLog.get_log_entry_message(log_entry) ==
1294 "@#{admin.nickname} deactivated users: @#{user_one.nickname}, @#{user_two.nickname}"
1295 end
1296
1297 test "PATCH /api/pleroma/admin/users/approve", %{admin: admin, conn: conn} do
1298 user_one = insert(:user, approval_pending: true)
1299 user_two = insert(:user, approval_pending: true)
1300
1301 conn =
1302 patch(
1303 conn,
1304 "/api/pleroma/admin/users/approve",
1305 %{nicknames: [user_one.nickname, user_two.nickname]}
1306 )
1307
1308 response = json_response(conn, 200)
1309 assert Enum.map(response["users"], & &1["approval_pending"]) == [false, false]
1310
1311 log_entry = Repo.one(ModerationLog)
1312
1313 assert ModerationLog.get_log_entry_message(log_entry) ==
1314 "@#{admin.nickname} approved users: @#{user_one.nickname}, @#{user_two.nickname}"
1315 end
1316
1317 test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation", %{admin: admin, conn: conn} do
1318 user = insert(:user)
1319
1320 conn = patch(conn, "/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
1321
1322 assert json_response(conn, 200) ==
1323 %{
1324 "deactivated" => !user.deactivated,
1325 "id" => user.id,
1326 "nickname" => user.nickname,
1327 "roles" => %{"admin" => false, "moderator" => false},
1328 "local" => true,
1329 "tags" => [],
1330 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
1331 "display_name" => HTML.strip_tags(user.name || user.nickname),
1332 "confirmation_pending" => false,
1333 "approval_pending" => false,
1334 "url" => user.ap_id,
1335 "registration_reason" => nil
1336 }
1337
1338 log_entry = Repo.one(ModerationLog)
1339
1340 assert ModerationLog.get_log_entry_message(log_entry) ==
1341 "@#{admin.nickname} deactivated users: @#{user.nickname}"
1342 end
1343
1344 describe "PUT disable_mfa" do
1345 test "returns 200 and disable 2fa", %{conn: conn} do
1346 user =
1347 insert(:user,
1348 multi_factor_authentication_settings: %MFA.Settings{
1349 enabled: true,
1350 totp: %MFA.Settings.TOTP{secret: "otp_secret", confirmed: true}
1351 }
1352 )
1353
1354 response =
1355 conn
1356 |> put("/api/pleroma/admin/users/disable_mfa", %{nickname: user.nickname})
1357 |> json_response(200)
1358
1359 assert response == user.nickname
1360 mfa_settings = refresh_record(user).multi_factor_authentication_settings
1361
1362 refute mfa_settings.enabled
1363 refute mfa_settings.totp.confirmed
1364 end
1365
1366 test "returns 404 if user not found", %{conn: conn} do
1367 response =
1368 conn
1369 |> put("/api/pleroma/admin/users/disable_mfa", %{nickname: "nickname"})
1370 |> json_response(404)
1371
1372 assert response == %{"error" => "Not found"}
1373 end
1374 end
1375
1376 describe "GET /api/pleroma/admin/restart" do
1377 setup do: clear_config(:configurable_from_database, true)
1378
1379 test "pleroma restarts", %{conn: conn} do
1380 capture_log(fn ->
1381 assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) == %{}
1382 end) =~ "pleroma restarted"
1383
1384 refute Restarter.Pleroma.need_reboot?()
1385 end
1386 end
1387
1388 test "need_reboot flag", %{conn: conn} do
1389 assert conn
1390 |> get("/api/pleroma/admin/need_reboot")
1391 |> json_response(200) == %{"need_reboot" => false}
1392
1393 Restarter.Pleroma.need_reboot()
1394
1395 assert conn
1396 |> get("/api/pleroma/admin/need_reboot")
1397 |> json_response(200) == %{"need_reboot" => true}
1398
1399 on_exit(fn -> Restarter.Pleroma.refresh() end)
1400 end
1401
1402 describe "GET /api/pleroma/admin/users/:nickname/statuses" do
1403 setup do
1404 user = insert(:user)
1405
1406 date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
1407 date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
1408 date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
1409
1410 insert(:note_activity, user: user, published: date1)
1411 insert(:note_activity, user: user, published: date2)
1412 insert(:note_activity, user: user, published: date3)
1413
1414 %{user: user}
1415 end
1416
1417 test "renders user's statuses", %{conn: conn, user: user} do
1418 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
1419
1420 assert json_response(conn, 200) |> length() == 3
1421 end
1422
1423 test "renders user's statuses with a limit", %{conn: conn, user: user} do
1424 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")
1425
1426 assert json_response(conn, 200) |> length() == 2
1427 end
1428
1429 test "doesn't return private statuses by default", %{conn: conn, user: user} do
1430 {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
1431
1432 {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
1433
1434 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
1435
1436 assert json_response(conn, 200) |> length() == 4
1437 end
1438
1439 test "returns private statuses with godmode on", %{conn: conn, user: user} do
1440 {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
1441
1442 {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
1443
1444 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
1445
1446 assert json_response(conn, 200) |> length() == 5
1447 end
1448
1449 test "excludes reblogs by default", %{conn: conn, user: user} do
1450 other_user = insert(:user)
1451 {:ok, activity} = CommonAPI.post(user, %{status: "."})
1452 {:ok, %Activity{}} = CommonAPI.repeat(activity.id, other_user)
1453
1454 conn_res = get(conn, "/api/pleroma/admin/users/#{other_user.nickname}/statuses")
1455 assert json_response(conn_res, 200) |> length() == 0
1456
1457 conn_res =
1458 get(conn, "/api/pleroma/admin/users/#{other_user.nickname}/statuses?with_reblogs=true")
1459
1460 assert json_response(conn_res, 200) |> length() == 1
1461 end
1462 end
1463
1464 describe "GET /api/pleroma/admin/moderation_log" do
1465 setup do
1466 moderator = insert(:user, is_moderator: true)
1467
1468 %{moderator: moderator}
1469 end
1470
1471 test "returns the log", %{conn: conn, admin: admin} do
1472 Repo.insert(%ModerationLog{
1473 data: %{
1474 actor: %{
1475 "id" => admin.id,
1476 "nickname" => admin.nickname,
1477 "type" => "user"
1478 },
1479 action: "relay_follow",
1480 target: "https://example.org/relay"
1481 },
1482 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
1483 })
1484
1485 Repo.insert(%ModerationLog{
1486 data: %{
1487 actor: %{
1488 "id" => admin.id,
1489 "nickname" => admin.nickname,
1490 "type" => "user"
1491 },
1492 action: "relay_unfollow",
1493 target: "https://example.org/relay"
1494 },
1495 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
1496 })
1497
1498 conn = get(conn, "/api/pleroma/admin/moderation_log")
1499
1500 response = json_response(conn, 200)
1501 [first_entry, second_entry] = response["items"]
1502
1503 assert response["total"] == 2
1504 assert first_entry["data"]["action"] == "relay_unfollow"
1505
1506 assert first_entry["message"] ==
1507 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
1508
1509 assert second_entry["data"]["action"] == "relay_follow"
1510
1511 assert second_entry["message"] ==
1512 "@#{admin.nickname} followed relay: https://example.org/relay"
1513 end
1514
1515 test "returns the log with pagination", %{conn: conn, admin: admin} do
1516 Repo.insert(%ModerationLog{
1517 data: %{
1518 actor: %{
1519 "id" => admin.id,
1520 "nickname" => admin.nickname,
1521 "type" => "user"
1522 },
1523 action: "relay_follow",
1524 target: "https://example.org/relay"
1525 },
1526 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
1527 })
1528
1529 Repo.insert(%ModerationLog{
1530 data: %{
1531 actor: %{
1532 "id" => admin.id,
1533 "nickname" => admin.nickname,
1534 "type" => "user"
1535 },
1536 action: "relay_unfollow",
1537 target: "https://example.org/relay"
1538 },
1539 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
1540 })
1541
1542 conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
1543
1544 response1 = json_response(conn1, 200)
1545 [first_entry] = response1["items"]
1546
1547 assert response1["total"] == 2
1548 assert response1["items"] |> length() == 1
1549 assert first_entry["data"]["action"] == "relay_unfollow"
1550
1551 assert first_entry["message"] ==
1552 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
1553
1554 conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
1555
1556 response2 = json_response(conn2, 200)
1557 [second_entry] = response2["items"]
1558
1559 assert response2["total"] == 2
1560 assert response2["items"] |> length() == 1
1561 assert second_entry["data"]["action"] == "relay_follow"
1562
1563 assert second_entry["message"] ==
1564 "@#{admin.nickname} followed relay: https://example.org/relay"
1565 end
1566
1567 test "filters log by date", %{conn: conn, admin: admin} do
1568 first_date = "2017-08-15T15:47:06Z"
1569 second_date = "2017-08-20T15:47:06Z"
1570
1571 Repo.insert(%ModerationLog{
1572 data: %{
1573 actor: %{
1574 "id" => admin.id,
1575 "nickname" => admin.nickname,
1576 "type" => "user"
1577 },
1578 action: "relay_follow",
1579 target: "https://example.org/relay"
1580 },
1581 inserted_at: NaiveDateTime.from_iso8601!(first_date)
1582 })
1583
1584 Repo.insert(%ModerationLog{
1585 data: %{
1586 actor: %{
1587 "id" => admin.id,
1588 "nickname" => admin.nickname,
1589 "type" => "user"
1590 },
1591 action: "relay_unfollow",
1592 target: "https://example.org/relay"
1593 },
1594 inserted_at: NaiveDateTime.from_iso8601!(second_date)
1595 })
1596
1597 conn1 =
1598 get(
1599 conn,
1600 "/api/pleroma/admin/moderation_log?start_date=#{second_date}"
1601 )
1602
1603 response1 = json_response(conn1, 200)
1604 [first_entry] = response1["items"]
1605
1606 assert response1["total"] == 1
1607 assert first_entry["data"]["action"] == "relay_unfollow"
1608
1609 assert first_entry["message"] ==
1610 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
1611 end
1612
1613 test "returns log filtered by user", %{conn: conn, admin: admin, moderator: moderator} do
1614 Repo.insert(%ModerationLog{
1615 data: %{
1616 actor: %{
1617 "id" => admin.id,
1618 "nickname" => admin.nickname,
1619 "type" => "user"
1620 },
1621 action: "relay_follow",
1622 target: "https://example.org/relay"
1623 }
1624 })
1625
1626 Repo.insert(%ModerationLog{
1627 data: %{
1628 actor: %{
1629 "id" => moderator.id,
1630 "nickname" => moderator.nickname,
1631 "type" => "user"
1632 },
1633 action: "relay_unfollow",
1634 target: "https://example.org/relay"
1635 }
1636 })
1637
1638 conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")
1639
1640 response1 = json_response(conn1, 200)
1641 [first_entry] = response1["items"]
1642
1643 assert response1["total"] == 1
1644 assert get_in(first_entry, ["data", "actor", "id"]) == moderator.id
1645 end
1646
1647 test "returns log filtered by search", %{conn: conn, moderator: moderator} do
1648 ModerationLog.insert_log(%{
1649 actor: moderator,
1650 action: "relay_follow",
1651 target: "https://example.org/relay"
1652 })
1653
1654 ModerationLog.insert_log(%{
1655 actor: moderator,
1656 action: "relay_unfollow",
1657 target: "https://example.org/relay"
1658 })
1659
1660 conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")
1661
1662 response1 = json_response(conn1, 200)
1663 [first_entry] = response1["items"]
1664
1665 assert response1["total"] == 1
1666
1667 assert get_in(first_entry, ["data", "message"]) ==
1668 "@#{moderator.nickname} unfollowed relay: https://example.org/relay"
1669 end
1670 end
1671
1672 test "gets a remote users when [:instance, :limit_to_local_content] is set to :unauthenticated",
1673 %{conn: conn} do
1674 clear_config(Pleroma.Config.get([:instance, :limit_to_local_content]), :unauthenticated)
1675 user = insert(:user, %{local: false, nickname: "u@peer1.com"})
1676 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
1677
1678 assert json_response(conn, 200)
1679 end
1680
1681 describe "GET /users/:nickname/credentials" do
1682 test "gets the user credentials", %{conn: conn} do
1683 user = insert(:user)
1684 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
1685
1686 response = assert json_response(conn, 200)
1687 assert response["email"] == user.email
1688 end
1689
1690 test "returns 403 if requested by a non-admin" do
1691 user = insert(:user)
1692
1693 conn =
1694 build_conn()
1695 |> assign(:user, user)
1696 |> get("/api/pleroma/admin/users/#{user.nickname}/credentials")
1697
1698 assert json_response(conn, :forbidden)
1699 end
1700 end
1701
1702 describe "PATCH /users/:nickname/credentials" do
1703 setup do
1704 user = insert(:user)
1705 [user: user]
1706 end
1707
1708 test "changes password and email", %{conn: conn, admin: admin, user: user} do
1709 assert user.password_reset_pending == false
1710
1711 conn =
1712 patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
1713 "password" => "new_password",
1714 "email" => "new_email@example.com",
1715 "name" => "new_name"
1716 })
1717
1718 assert json_response(conn, 200) == %{"status" => "success"}
1719
1720 ObanHelpers.perform_all()
1721
1722 updated_user = User.get_by_id(user.id)
1723
1724 assert updated_user.email == "new_email@example.com"
1725 assert updated_user.name == "new_name"
1726 assert updated_user.password_hash != user.password_hash
1727 assert updated_user.password_reset_pending == true
1728
1729 [log_entry2, log_entry1] = ModerationLog |> Repo.all() |> Enum.sort()
1730
1731 assert ModerationLog.get_log_entry_message(log_entry1) ==
1732 "@#{admin.nickname} updated users: @#{user.nickname}"
1733
1734 assert ModerationLog.get_log_entry_message(log_entry2) ==
1735 "@#{admin.nickname} forced password reset for users: @#{user.nickname}"
1736 end
1737
1738 test "returns 403 if requested by a non-admin", %{user: user} do
1739 conn =
1740 build_conn()
1741 |> assign(:user, user)
1742 |> patch("/api/pleroma/admin/users/#{user.nickname}/credentials", %{
1743 "password" => "new_password",
1744 "email" => "new_email@example.com",
1745 "name" => "new_name"
1746 })
1747
1748 assert json_response(conn, :forbidden)
1749 end
1750
1751 test "changes actor type from permitted list", %{conn: conn, user: user} do
1752 assert user.actor_type == "Person"
1753
1754 assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
1755 "actor_type" => "Service"
1756 })
1757 |> json_response(200) == %{"status" => "success"}
1758
1759 updated_user = User.get_by_id(user.id)
1760
1761 assert updated_user.actor_type == "Service"
1762
1763 assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
1764 "actor_type" => "Application"
1765 })
1766 |> json_response(400) == %{"errors" => %{"actor_type" => "is invalid"}}
1767 end
1768
1769 test "update non existing user", %{conn: conn} do
1770 assert patch(conn, "/api/pleroma/admin/users/non-existing/credentials", %{
1771 "password" => "new_password"
1772 })
1773 |> json_response(404) == %{"error" => "Not found"}
1774 end
1775 end
1776
1777 describe "PATCH /users/:nickname/force_password_reset" do
1778 test "sets password_reset_pending to true", %{conn: conn} do
1779 user = insert(:user)
1780 assert user.password_reset_pending == false
1781
1782 conn =
1783 patch(conn, "/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})
1784
1785 assert empty_json_response(conn) == ""
1786
1787 ObanHelpers.perform_all()
1788
1789 assert User.get_by_id(user.id).password_reset_pending == true
1790 end
1791 end
1792
1793 describe "instances" do
1794 test "GET /instances/:instance/statuses", %{conn: conn} do
1795 user = insert(:user, local: false, nickname: "archaeme@archae.me")
1796 user2 = insert(:user, local: false, nickname: "test@test.com")
1797 insert_pair(:note_activity, user: user)
1798 activity = insert(:note_activity, user: user2)
1799
1800 ret_conn = get(conn, "/api/pleroma/admin/instances/archae.me/statuses")
1801
1802 response = json_response(ret_conn, 200)
1803
1804 assert length(response) == 2
1805
1806 ret_conn = get(conn, "/api/pleroma/admin/instances/test.com/statuses")
1807
1808 response = json_response(ret_conn, 200)
1809
1810 assert length(response) == 1
1811
1812 ret_conn = get(conn, "/api/pleroma/admin/instances/nonexistent.com/statuses")
1813
1814 response = json_response(ret_conn, 200)
1815
1816 assert Enum.empty?(response)
1817
1818 CommonAPI.repeat(activity.id, user)
1819
1820 ret_conn = get(conn, "/api/pleroma/admin/instances/archae.me/statuses")
1821 response = json_response(ret_conn, 200)
1822 assert length(response) == 2
1823
1824 ret_conn = get(conn, "/api/pleroma/admin/instances/archae.me/statuses?with_reblogs=true")
1825 response = json_response(ret_conn, 200)
1826 assert length(response) == 3
1827 end
1828 end
1829
1830 describe "PATCH /confirm_email" do
1831 test "it confirms emails of two users", %{conn: conn, admin: admin} do
1832 [first_user, second_user] = insert_pair(:user, confirmation_pending: true)
1833
1834 assert first_user.confirmation_pending == true
1835 assert second_user.confirmation_pending == true
1836
1837 ret_conn =
1838 patch(conn, "/api/pleroma/admin/users/confirm_email", %{
1839 nicknames: [
1840 first_user.nickname,
1841 second_user.nickname
1842 ]
1843 })
1844
1845 assert ret_conn.status == 200
1846
1847 assert first_user.confirmation_pending == true
1848 assert second_user.confirmation_pending == true
1849
1850 log_entry = Repo.one(ModerationLog)
1851
1852 assert ModerationLog.get_log_entry_message(log_entry) ==
1853 "@#{admin.nickname} confirmed email for users: @#{first_user.nickname}, @#{
1854 second_user.nickname
1855 }"
1856 end
1857 end
1858
1859 describe "PATCH /resend_confirmation_email" do
1860 test "it resend emails for two users", %{conn: conn, admin: admin} do
1861 [first_user, second_user] = insert_pair(:user, confirmation_pending: true)
1862
1863 ret_conn =
1864 patch(conn, "/api/pleroma/admin/users/resend_confirmation_email", %{
1865 nicknames: [
1866 first_user.nickname,
1867 second_user.nickname
1868 ]
1869 })
1870
1871 assert ret_conn.status == 200
1872
1873 log_entry = Repo.one(ModerationLog)
1874
1875 assert ModerationLog.get_log_entry_message(log_entry) ==
1876 "@#{admin.nickname} re-sent confirmation email for users: @#{first_user.nickname}, @#{
1877 second_user.nickname
1878 }"
1879
1880 ObanHelpers.perform_all()
1881 assert_email_sent(Pleroma.Emails.UserEmail.account_confirmation_email(first_user))
1882 end
1883 end
1884
1885 describe "/api/pleroma/admin/stats" do
1886 test "status visibility count", %{conn: conn} do
1887 admin = insert(:user, is_admin: true)
1888 user = insert(:user)
1889 CommonAPI.post(user, %{visibility: "public", status: "hey"})
1890 CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
1891 CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
1892
1893 response =
1894 conn
1895 |> assign(:user, admin)
1896 |> get("/api/pleroma/admin/stats")
1897 |> json_response(200)
1898
1899 assert %{"direct" => 0, "private" => 0, "public" => 1, "unlisted" => 2} =
1900 response["status_visibility"]
1901 end
1902
1903 test "by instance", %{conn: conn} do
1904 admin = insert(:user, is_admin: true)
1905 user1 = insert(:user)
1906 instance2 = "instance2.tld"
1907 user2 = insert(:user, %{ap_id: "https://#{instance2}/@actor"})
1908
1909 CommonAPI.post(user1, %{visibility: "public", status: "hey"})
1910 CommonAPI.post(user2, %{visibility: "unlisted", status: "hey"})
1911 CommonAPI.post(user2, %{visibility: "private", status: "hey"})
1912
1913 response =
1914 conn
1915 |> assign(:user, admin)
1916 |> get("/api/pleroma/admin/stats", instance: instance2)
1917 |> json_response(200)
1918
1919 assert %{"direct" => 0, "private" => 1, "public" => 0, "unlisted" => 1} =
1920 response["status_visibility"]
1921 end
1922 end
1923 end
1924
1925 # Needed for testing
1926 defmodule Pleroma.Web.Endpoint.NotReal do
1927 end
1928
1929 defmodule Pleroma.Captcha.NotReal do
1930 end
Fork of https://akkoma.dev/AkkomaGang/akkoma.git