1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
6 use Pleroma.Web.ConnCase
10 alias Pleroma.ModerationLog
13 alias Pleroma.UserInviteToken
14 alias Pleroma.Web.CommonAPI
15 alias Pleroma.Web.MediaProxy
16 import Pleroma.Factory
18 describe "/api/pleroma/admin/users" do
20 admin = insert(:user, info: %{is_admin: true})
25 |> assign(:user, admin)
26 |> put_req_header("accept", "application/json")
27 |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
29 log_entry = Repo.one(ModerationLog)
31 assert log_entry.data["subject"]["nickname"] == user.nickname
32 assert log_entry.data["action"] == "delete"
34 assert ModerationLog.get_log_entry_message(log_entry) ==
35 "@#{admin.nickname} deleted user @#{user.nickname}"
37 assert json_response(conn, 200) == user.nickname
41 admin = insert(:user, info: %{is_admin: true})
45 |> assign(:user, admin)
46 |> put_req_header("accept", "application/json")
47 |> post("/api/pleroma/admin/users", %{
51 "email" => "lain@example.org",
55 "nickname" => "lain2",
56 "email" => "lain2@example.org",
62 response = json_response(conn, 200) |> Enum.map(&Map.get(&1, "type"))
63 assert response == ["success", "success"]
65 log_entry = Repo.one(ModerationLog)
67 assert ModerationLog.get_log_entry_message(log_entry) ==
68 "@#{admin.nickname} created users: @lain2, @lain"
71 test "Cannot create user with exisiting email" do
72 admin = insert(:user, info: %{is_admin: true})
77 |> assign(:user, admin)
78 |> put_req_header("accept", "application/json")
79 |> post("/api/pleroma/admin/users", %{
83 "email" => user.email,
89 assert json_response(conn, 409) == [
93 "email" => user.email,
96 "error" => "email has already been taken",
102 test "Cannot create user with exisiting nickname" do
103 admin = insert(:user, info: %{is_admin: true})
108 |> assign(:user, admin)
109 |> put_req_header("accept", "application/json")
110 |> post("/api/pleroma/admin/users", %{
113 "nickname" => user.nickname,
114 "email" => "someuser@plerama.social",
120 assert json_response(conn, 409) == [
124 "email" => "someuser@plerama.social",
125 "nickname" => user.nickname
127 "error" => "nickname has already been taken",
133 test "Multiple user creation works in transaction" do
134 admin = insert(:user, info: %{is_admin: true})
139 |> assign(:user, admin)
140 |> put_req_header("accept", "application/json")
141 |> post("/api/pleroma/admin/users", %{
144 "nickname" => "newuser",
145 "email" => "newuser@pleroma.social",
149 "nickname" => "lain",
150 "email" => user.email,
156 assert json_response(conn, 409) == [
160 "email" => user.email,
163 "error" => "email has already been taken",
169 "email" => "newuser@pleroma.social",
170 "nickname" => "newuser"
177 assert User.get_by_nickname("newuser") === nil
181 describe "/api/pleroma/admin/users/:nickname" do
182 test "Show", %{conn: conn} do
183 admin = insert(:user, info: %{is_admin: true})
188 |> assign(:user, admin)
189 |> get("/api/pleroma/admin/users/#{user.nickname}")
192 "deactivated" => false,
193 "id" => to_string(user.id),
195 "nickname" => user.nickname,
196 "roles" => %{"admin" => false, "moderator" => false},
198 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
199 "display_name" => HTML.strip_tags(user.name || user.nickname)
202 assert expected == json_response(conn, 200)
205 test "when the user doesn't exist", %{conn: conn} do
206 admin = insert(:user, info: %{is_admin: true})
211 |> assign(:user, admin)
212 |> get("/api/pleroma/admin/users/#{user.nickname}")
214 assert "Not found" == json_response(conn, 404)
218 describe "/api/pleroma/admin/users/follow" do
219 test "allows to force-follow another user" do
220 admin = insert(:user, info: %{is_admin: true})
222 follower = insert(:user)
225 |> assign(:user, admin)
226 |> put_req_header("accept", "application/json")
227 |> post("/api/pleroma/admin/users/follow", %{
228 "follower" => follower.nickname,
229 "followed" => user.nickname
232 user = User.get_cached_by_id(user.id)
233 follower = User.get_cached_by_id(follower.id)
235 assert User.following?(follower, user)
237 log_entry = Repo.one(ModerationLog)
239 assert ModerationLog.get_log_entry_message(log_entry) ==
240 "@#{admin.nickname} made @#{follower.nickname} follow @#{user.nickname}"
244 describe "/api/pleroma/admin/users/unfollow" do
245 test "allows to force-unfollow another user" do
246 admin = insert(:user, info: %{is_admin: true})
248 follower = insert(:user)
250 User.follow(follower, user)
253 |> assign(:user, admin)
254 |> put_req_header("accept", "application/json")
255 |> post("/api/pleroma/admin/users/unfollow", %{
256 "follower" => follower.nickname,
257 "followed" => user.nickname
260 user = User.get_cached_by_id(user.id)
261 follower = User.get_cached_by_id(follower.id)
263 refute User.following?(follower, user)
265 log_entry = Repo.one(ModerationLog)
267 assert ModerationLog.get_log_entry_message(log_entry) ==
268 "@#{admin.nickname} made @#{follower.nickname} unfollow @#{user.nickname}"
272 describe "PUT /api/pleroma/admin/users/tag" do
274 admin = insert(:user, info: %{is_admin: true})
275 user1 = insert(:user, %{tags: ["x"]})
276 user2 = insert(:user, %{tags: ["y"]})
277 user3 = insert(:user, %{tags: ["unchanged"]})
281 |> assign(:user, admin)
282 |> put_req_header("accept", "application/json")
284 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
286 }&tags[]=foo&tags[]=bar"
289 %{conn: conn, admin: admin, user1: user1, user2: user2, user3: user3}
292 test "it appends specified tags to users with specified nicknames", %{
298 assert json_response(conn, :no_content)
299 assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
300 assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
302 log_entry = Repo.one(ModerationLog)
305 [user1.nickname, user2.nickname]
306 |> Enum.map(&"@#{&1}")
309 tags = ["foo", "bar"] |> Enum.join(", ")
311 assert ModerationLog.get_log_entry_message(log_entry) ==
312 "@#{admin.nickname} added tags: #{tags} to users: #{users}"
315 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
316 assert json_response(conn, :no_content)
317 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
321 describe "DELETE /api/pleroma/admin/users/tag" do
323 admin = insert(:user, info: %{is_admin: true})
324 user1 = insert(:user, %{tags: ["x"]})
325 user2 = insert(:user, %{tags: ["y", "z"]})
326 user3 = insert(:user, %{tags: ["unchanged"]})
330 |> assign(:user, admin)
331 |> put_req_header("accept", "application/json")
333 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
338 %{conn: conn, admin: admin, user1: user1, user2: user2, user3: user3}
341 test "it removes specified tags from users with specified nicknames", %{
347 assert json_response(conn, :no_content)
348 assert User.get_cached_by_id(user1.id).tags == []
349 assert User.get_cached_by_id(user2.id).tags == ["y"]
351 log_entry = Repo.one(ModerationLog)
354 [user1.nickname, user2.nickname]
355 |> Enum.map(&"@#{&1}")
358 tags = ["x", "z"] |> Enum.join(", ")
360 assert ModerationLog.get_log_entry_message(log_entry) ==
361 "@#{admin.nickname} removed tags: #{tags} from users: #{users}"
364 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
365 assert json_response(conn, :no_content)
366 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
370 describe "/api/pleroma/admin/users/:nickname/permission_group" do
371 test "GET is giving user_info" do
372 admin = insert(:user, info: %{is_admin: true})
376 |> assign(:user, admin)
377 |> put_req_header("accept", "application/json")
378 |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
380 assert json_response(conn, 200) == %{
382 "is_moderator" => false
386 test "/:right POST, can add to a permission group" do
387 admin = insert(:user, info: %{is_admin: true})
392 |> assign(:user, admin)
393 |> put_req_header("accept", "application/json")
394 |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
396 assert json_response(conn, 200) == %{
400 log_entry = Repo.one(ModerationLog)
402 assert ModerationLog.get_log_entry_message(log_entry) ==
403 "@#{admin.nickname} made @#{user.nickname} admin"
406 test "/:right DELETE, can remove from a permission group" do
407 admin = insert(:user, info: %{is_admin: true})
408 user = insert(:user, info: %{is_admin: true})
412 |> assign(:user, admin)
413 |> put_req_header("accept", "application/json")
414 |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
416 assert json_response(conn, 200) == %{
420 log_entry = Repo.one(ModerationLog)
422 assert ModerationLog.get_log_entry_message(log_entry) ==
423 "@#{admin.nickname} revoked admin role from @#{user.nickname}"
427 describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
428 setup %{conn: conn} do
429 admin = insert(:user, info: %{is_admin: true})
433 |> assign(:user, admin)
434 |> put_req_header("accept", "application/json")
436 %{conn: conn, admin: admin}
439 test "deactivates the user", %{conn: conn, admin: admin} do
444 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
446 user = User.get_cached_by_id(user.id)
447 assert user.info.deactivated == true
448 assert json_response(conn, :no_content)
450 log_entry = Repo.one(ModerationLog)
452 assert ModerationLog.get_log_entry_message(log_entry) ==
453 "@#{admin.nickname} deactivated user @#{user.nickname}"
456 test "activates the user", %{conn: conn, admin: admin} do
457 user = insert(:user, info: %{deactivated: true})
461 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})
463 user = User.get_cached_by_id(user.id)
464 assert user.info.deactivated == false
465 assert json_response(conn, :no_content)
467 log_entry = Repo.one(ModerationLog)
469 assert ModerationLog.get_log_entry_message(log_entry) ==
470 "@#{admin.nickname} activated user @#{user.nickname}"
473 test "returns 403 when requested by a non-admin", %{conn: conn} do
478 |> assign(:user, user)
479 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
481 assert json_response(conn, :forbidden)
485 describe "POST /api/pleroma/admin/email_invite, with valid config" do
487 [user: insert(:user, info: %{is_admin: true})]
490 clear_config([:instance, :registrations_open]) do
491 Pleroma.Config.put([:instance, :registrations_open], false)
494 clear_config([:instance, :invites_enabled]) do
495 Pleroma.Config.put([:instance, :invites_enabled], true)
498 test "sends invitation and returns 204", %{conn: conn, user: user} do
499 recipient_email = "foo@bar.com"
500 recipient_name = "J. D."
504 |> assign(:user, user)
506 "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
509 assert json_response(conn, :no_content)
511 token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
513 refute token_record.used
515 notify_email = Pleroma.Config.get([:instance, :notify_email])
516 instance_name = Pleroma.Config.get([:instance, :name])
519 Pleroma.Emails.UserEmail.user_invitation_email(
526 Swoosh.TestAssertions.assert_email_sent(
527 from: {instance_name, notify_email},
528 to: {recipient_name, recipient_email},
529 html_body: email.html_body
533 test "it returns 403 if requested by a non-admin", %{conn: conn} do
534 non_admin_user = insert(:user)
538 |> assign(:user, non_admin_user)
539 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
541 assert json_response(conn, :forbidden)
545 describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
547 [user: insert(:user, info: %{is_admin: true})]
550 clear_config([:instance, :registrations_open])
551 clear_config([:instance, :invites_enabled])
553 test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
554 Pleroma.Config.put([:instance, :registrations_open], false)
555 Pleroma.Config.put([:instance, :invites_enabled], false)
559 |> assign(:user, user)
560 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
562 assert json_response(conn, :internal_server_error)
565 test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
566 Pleroma.Config.put([:instance, :registrations_open], true)
567 Pleroma.Config.put([:instance, :invites_enabled], true)
571 |> assign(:user, user)
572 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
574 assert json_response(conn, :internal_server_error)
578 test "/api/pleroma/admin/users/invite_token" do
579 admin = insert(:user, info: %{is_admin: true})
583 |> assign(:user, admin)
584 |> put_req_header("accept", "application/json")
585 |> get("/api/pleroma/admin/users/invite_token")
587 assert conn.status == 200
590 test "/api/pleroma/admin/users/:nickname/password_reset" do
591 admin = insert(:user, info: %{is_admin: true})
596 |> assign(:user, admin)
597 |> put_req_header("accept", "application/json")
598 |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
600 assert conn.status == 200
603 describe "GET /api/pleroma/admin/users" do
605 admin = insert(:user, info: %{is_admin: true})
609 |> assign(:user, admin)
611 {:ok, conn: conn, admin: admin}
614 test "renders users array for the first page", %{conn: conn, admin: admin} do
615 user = insert(:user, local: false, tags: ["foo", "bar"])
616 conn = get(conn, "/api/pleroma/admin/users?page=1")
621 "deactivated" => admin.info.deactivated,
623 "nickname" => admin.nickname,
624 "roles" => %{"admin" => true, "moderator" => false},
627 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
628 "display_name" => HTML.strip_tags(admin.name || admin.nickname)
631 "deactivated" => user.info.deactivated,
633 "nickname" => user.nickname,
634 "roles" => %{"admin" => false, "moderator" => false},
636 "tags" => ["foo", "bar"],
637 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
638 "display_name" => HTML.strip_tags(user.name || user.nickname)
641 |> Enum.sort_by(& &1["nickname"])
643 assert json_response(conn, 200) == %{
650 test "renders empty array for the second page", %{conn: conn} do
653 conn = get(conn, "/api/pleroma/admin/users?page=2")
655 assert json_response(conn, 200) == %{
662 test "regular search", %{conn: conn} do
663 user = insert(:user, nickname: "bob")
665 conn = get(conn, "/api/pleroma/admin/users?query=bo")
667 assert json_response(conn, 200) == %{
672 "deactivated" => user.info.deactivated,
674 "nickname" => user.nickname,
675 "roles" => %{"admin" => false, "moderator" => false},
678 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
679 "display_name" => HTML.strip_tags(user.name || user.nickname)
685 test "search by domain", %{conn: conn} do
686 user = insert(:user, nickname: "nickname@domain.com")
689 conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
691 assert json_response(conn, 200) == %{
696 "deactivated" => user.info.deactivated,
698 "nickname" => user.nickname,
699 "roles" => %{"admin" => false, "moderator" => false},
702 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
703 "display_name" => HTML.strip_tags(user.name || user.nickname)
709 test "search by full nickname", %{conn: conn} do
710 user = insert(:user, nickname: "nickname@domain.com")
713 conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
715 assert json_response(conn, 200) == %{
720 "deactivated" => user.info.deactivated,
722 "nickname" => user.nickname,
723 "roles" => %{"admin" => false, "moderator" => false},
726 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
727 "display_name" => HTML.strip_tags(user.name || user.nickname)
733 test "search by display name", %{conn: conn} do
734 user = insert(:user, name: "Display name")
737 conn = get(conn, "/api/pleroma/admin/users?name=display")
739 assert json_response(conn, 200) == %{
744 "deactivated" => user.info.deactivated,
746 "nickname" => user.nickname,
747 "roles" => %{"admin" => false, "moderator" => false},
750 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
751 "display_name" => HTML.strip_tags(user.name || user.nickname)
757 test "search by email", %{conn: conn} do
758 user = insert(:user, email: "email@example.com")
761 conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
763 assert json_response(conn, 200) == %{
768 "deactivated" => user.info.deactivated,
770 "nickname" => user.nickname,
771 "roles" => %{"admin" => false, "moderator" => false},
774 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
775 "display_name" => HTML.strip_tags(user.name || user.nickname)
781 test "regular search with page size", %{conn: conn} do
782 user = insert(:user, nickname: "aalice")
783 user2 = insert(:user, nickname: "alice")
785 conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
787 assert json_response(conn1, 200) == %{
792 "deactivated" => user.info.deactivated,
794 "nickname" => user.nickname,
795 "roles" => %{"admin" => false, "moderator" => false},
798 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
799 "display_name" => HTML.strip_tags(user.name || user.nickname)
804 conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
806 assert json_response(conn2, 200) == %{
811 "deactivated" => user2.info.deactivated,
813 "nickname" => user2.nickname,
814 "roles" => %{"admin" => false, "moderator" => false},
817 "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
818 "display_name" => HTML.strip_tags(user2.name || user2.nickname)
824 test "only local users" do
825 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
826 user = insert(:user, nickname: "bob")
828 insert(:user, nickname: "bobb", local: false)
832 |> assign(:user, admin)
833 |> get("/api/pleroma/admin/users?query=bo&filters=local")
835 assert json_response(conn, 200) == %{
840 "deactivated" => user.info.deactivated,
842 "nickname" => user.nickname,
843 "roles" => %{"admin" => false, "moderator" => false},
846 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
847 "display_name" => HTML.strip_tags(user.name || user.nickname)
853 test "only local users with no query", %{admin: old_admin} do
854 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
855 user = insert(:user, nickname: "bob")
857 insert(:user, nickname: "bobb", local: false)
861 |> assign(:user, admin)
862 |> get("/api/pleroma/admin/users?filters=local")
867 "deactivated" => user.info.deactivated,
869 "nickname" => user.nickname,
870 "roles" => %{"admin" => false, "moderator" => false},
873 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
874 "display_name" => HTML.strip_tags(user.name || user.nickname)
877 "deactivated" => admin.info.deactivated,
879 "nickname" => admin.nickname,
880 "roles" => %{"admin" => true, "moderator" => false},
883 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
884 "display_name" => HTML.strip_tags(admin.name || admin.nickname)
887 "deactivated" => false,
888 "id" => old_admin.id,
890 "nickname" => old_admin.nickname,
891 "roles" => %{"admin" => true, "moderator" => false},
893 "avatar" => User.avatar_url(old_admin) |> MediaProxy.url(),
894 "display_name" => HTML.strip_tags(old_admin.name || old_admin.nickname)
897 |> Enum.sort_by(& &1["nickname"])
899 assert json_response(conn, 200) == %{
906 test "load only admins", %{conn: conn, admin: admin} do
907 second_admin = insert(:user, info: %{is_admin: true})
911 conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
916 "deactivated" => false,
918 "nickname" => admin.nickname,
919 "roles" => %{"admin" => true, "moderator" => false},
920 "local" => admin.local,
922 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
923 "display_name" => HTML.strip_tags(admin.name || admin.nickname)
926 "deactivated" => false,
927 "id" => second_admin.id,
928 "nickname" => second_admin.nickname,
929 "roles" => %{"admin" => true, "moderator" => false},
930 "local" => second_admin.local,
932 "avatar" => User.avatar_url(second_admin) |> MediaProxy.url(),
933 "display_name" => HTML.strip_tags(second_admin.name || second_admin.nickname)
936 |> Enum.sort_by(& &1["nickname"])
938 assert json_response(conn, 200) == %{
945 test "load only moderators", %{conn: conn} do
946 moderator = insert(:user, info: %{is_moderator: true})
950 conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
952 assert json_response(conn, 200) == %{
957 "deactivated" => false,
958 "id" => moderator.id,
959 "nickname" => moderator.nickname,
960 "roles" => %{"admin" => false, "moderator" => true},
961 "local" => moderator.local,
963 "avatar" => User.avatar_url(moderator) |> MediaProxy.url(),
964 "display_name" => HTML.strip_tags(moderator.name || moderator.nickname)
970 test "load users with tags list", %{conn: conn} do
971 user1 = insert(:user, tags: ["first"])
972 user2 = insert(:user, tags: ["second"])
976 conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
981 "deactivated" => false,
983 "nickname" => user1.nickname,
984 "roles" => %{"admin" => false, "moderator" => false},
985 "local" => user1.local,
987 "avatar" => User.avatar_url(user1) |> MediaProxy.url(),
988 "display_name" => HTML.strip_tags(user1.name || user1.nickname)
991 "deactivated" => false,
993 "nickname" => user2.nickname,
994 "roles" => %{"admin" => false, "moderator" => false},
995 "local" => user2.local,
996 "tags" => ["second"],
997 "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
998 "display_name" => HTML.strip_tags(user2.name || user2.nickname)
1001 |> Enum.sort_by(& &1["nickname"])
1003 assert json_response(conn, 200) == %{
1010 test "it works with multiple filters" do
1011 admin = insert(:user, nickname: "john", info: %{is_admin: true})
1012 user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
1014 insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
1015 insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
1019 |> assign(:user, admin)
1020 |> get("/api/pleroma/admin/users?filters=deactivated,external")
1022 assert json_response(conn, 200) == %{
1027 "deactivated" => user.info.deactivated,
1029 "nickname" => user.nickname,
1030 "roles" => %{"admin" => false, "moderator" => false},
1031 "local" => user.local,
1033 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
1034 "display_name" => HTML.strip_tags(user.name || user.nickname)
1041 test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
1042 admin = insert(:user, info: %{is_admin: true})
1043 user = insert(:user)
1047 |> assign(:user, admin)
1048 |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
1050 assert json_response(conn, 200) ==
1052 "deactivated" => !user.info.deactivated,
1054 "nickname" => user.nickname,
1055 "roles" => %{"admin" => false, "moderator" => false},
1058 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
1059 "display_name" => HTML.strip_tags(user.name || user.nickname)
1062 log_entry = Repo.one(ModerationLog)
1064 assert ModerationLog.get_log_entry_message(log_entry) ==
1065 "@#{admin.nickname} deactivated user @#{user.nickname}"
1068 describe "GET /api/pleroma/admin/users/invite_token" do
1070 admin = insert(:user, info: %{is_admin: true})
1074 |> assign(:user, admin)
1079 test "without options", %{conn: conn} do
1080 conn = get(conn, "/api/pleroma/admin/users/invite_token")
1082 token = json_response(conn, 200)
1083 invite = UserInviteToken.find_by_token!(token)
1085 refute invite.expires_at
1086 refute invite.max_use
1087 assert invite.invite_type == "one_time"
1090 test "with expires_at", %{conn: conn} do
1092 get(conn, "/api/pleroma/admin/users/invite_token", %{
1093 "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
1096 token = json_response(conn, 200)
1097 invite = UserInviteToken.find_by_token!(token)
1100 assert invite.expires_at == Date.utc_today()
1101 refute invite.max_use
1102 assert invite.invite_type == "date_limited"
1105 test "with max_use", %{conn: conn} do
1107 get(conn, "/api/pleroma/admin/users/invite_token", %{
1108 "invite" => %{"max_use" => 150}
1111 token = json_response(conn, 200)
1112 invite = UserInviteToken.find_by_token!(token)
1114 refute invite.expires_at
1115 assert invite.max_use == 150
1116 assert invite.invite_type == "reusable"
1119 test "with max use and expires_at", %{conn: conn} do
1121 get(conn, "/api/pleroma/admin/users/invite_token", %{
1122 "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
1125 token = json_response(conn, 200)
1126 invite = UserInviteToken.find_by_token!(token)
1128 assert invite.expires_at == Date.utc_today()
1129 assert invite.max_use == 150
1130 assert invite.invite_type == "reusable_date_limited"
1134 describe "GET /api/pleroma/admin/users/invites" do
1136 admin = insert(:user, info: %{is_admin: true})
1140 |> assign(:user, admin)
1145 test "no invites", %{conn: conn} do
1146 conn = get(conn, "/api/pleroma/admin/users/invites")
1148 assert json_response(conn, 200) == %{"invites" => []}
1151 test "with invite", %{conn: conn} do
1152 {:ok, invite} = UserInviteToken.create_invite()
1154 conn = get(conn, "/api/pleroma/admin/users/invites")
1156 assert json_response(conn, 200) == %{
1159 "expires_at" => nil,
1161 "invite_type" => "one_time",
1163 "token" => invite.token,
1172 describe "POST /api/pleroma/admin/users/revoke_invite" do
1173 test "with token" do
1174 admin = insert(:user, info: %{is_admin: true})
1175 {:ok, invite} = UserInviteToken.create_invite()
1179 |> assign(:user, admin)
1180 |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
1182 assert json_response(conn, 200) == %{
1183 "expires_at" => nil,
1185 "invite_type" => "one_time",
1187 "token" => invite.token,
1193 test "with invalid token" do
1194 admin = insert(:user, info: %{is_admin: true})
1198 |> assign(:user, admin)
1199 |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
1201 assert json_response(conn, :not_found) == "Not found"
1205 describe "GET /api/pleroma/admin/reports/:id" do
1206 setup %{conn: conn} do
1207 admin = insert(:user, info: %{is_admin: true})
1209 %{conn: assign(conn, :user, admin)}
1212 test "returns report by its id", %{conn: conn} do
1213 [reporter, target_user] = insert_pair(:user)
1214 activity = insert(:note_activity, user: target_user)
1216 {:ok, %{id: report_id}} =
1217 CommonAPI.report(reporter, %{
1218 "account_id" => target_user.id,
1219 "comment" => "I feel offended",
1220 "status_ids" => [activity.id]
1225 |> get("/api/pleroma/admin/reports/#{report_id}")
1226 |> json_response(:ok)
1228 assert response["id"] == report_id
1231 test "returns 404 when report id is invalid", %{conn: conn} do
1232 conn = get(conn, "/api/pleroma/admin/reports/test")
1234 assert json_response(conn, :not_found) == "Not found"
1238 describe "PUT /api/pleroma/admin/reports/:id" do
1239 setup %{conn: conn} do
1240 admin = insert(:user, info: %{is_admin: true})
1241 [reporter, target_user] = insert_pair(:user)
1242 activity = insert(:note_activity, user: target_user)
1244 {:ok, %{id: report_id}} =
1245 CommonAPI.report(reporter, %{
1246 "account_id" => target_user.id,
1247 "comment" => "I feel offended",
1248 "status_ids" => [activity.id]
1251 %{conn: assign(conn, :user, admin), id: report_id, admin: admin}
1254 test "mark report as resolved", %{conn: conn, id: id, admin: admin} do
1257 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1258 |> json_response(:ok)
1260 assert response["state"] == "resolved"
1262 log_entry = Repo.one(ModerationLog)
1264 assert ModerationLog.get_log_entry_message(log_entry) ==
1265 "@#{admin.nickname} updated report ##{id} with 'resolved' state"
1268 test "closes report", %{conn: conn, id: id, admin: admin} do
1271 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1272 |> json_response(:ok)
1274 assert response["state"] == "closed"
1276 log_entry = Repo.one(ModerationLog)
1278 assert ModerationLog.get_log_entry_message(log_entry) ==
1279 "@#{admin.nickname} updated report ##{id} with 'closed' state"
1282 test "returns 400 when state is unknown", %{conn: conn, id: id} do
1285 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1287 assert json_response(conn, :bad_request) == "Unsupported state"
1290 test "returns 404 when report is not exist", %{conn: conn} do
1293 |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1295 assert json_response(conn, :not_found) == "Not found"
1299 describe "GET /api/pleroma/admin/reports" do
1300 setup %{conn: conn} do
1301 admin = insert(:user, info: %{is_admin: true})
1303 %{conn: assign(conn, :user, admin)}
1306 test "returns empty response when no reports created", %{conn: conn} do
1309 |> get("/api/pleroma/admin/reports")
1310 |> json_response(:ok)
1312 assert Enum.empty?(response["reports"])
1315 test "returns reports", %{conn: conn} do
1316 [reporter, target_user] = insert_pair(:user)
1317 activity = insert(:note_activity, user: target_user)
1319 {:ok, %{id: report_id}} =
1320 CommonAPI.report(reporter, %{
1321 "account_id" => target_user.id,
1322 "comment" => "I feel offended",
1323 "status_ids" => [activity.id]
1328 |> get("/api/pleroma/admin/reports")
1329 |> json_response(:ok)
1331 [report] = response["reports"]
1333 assert length(response["reports"]) == 1
1334 assert report["id"] == report_id
1337 test "returns reports with specified state", %{conn: conn} do
1338 [reporter, target_user] = insert_pair(:user)
1339 activity = insert(:note_activity, user: target_user)
1341 {:ok, %{id: first_report_id}} =
1342 CommonAPI.report(reporter, %{
1343 "account_id" => target_user.id,
1344 "comment" => "I feel offended",
1345 "status_ids" => [activity.id]
1348 {:ok, %{id: second_report_id}} =
1349 CommonAPI.report(reporter, %{
1350 "account_id" => target_user.id,
1351 "comment" => "I don't like this user"
1354 CommonAPI.update_report_state(second_report_id, "closed")
1358 |> get("/api/pleroma/admin/reports", %{
1361 |> json_response(:ok)
1363 [open_report] = response["reports"]
1365 assert length(response["reports"]) == 1
1366 assert open_report["id"] == first_report_id
1370 |> get("/api/pleroma/admin/reports", %{
1373 |> json_response(:ok)
1375 [closed_report] = response["reports"]
1377 assert length(response["reports"]) == 1
1378 assert closed_report["id"] == second_report_id
1382 |> get("/api/pleroma/admin/reports", %{
1383 "state" => "resolved"
1385 |> json_response(:ok)
1387 assert Enum.empty?(response["reports"])
1390 test "returns 403 when requested by a non-admin" do
1391 user = insert(:user)
1395 |> assign(:user, user)
1396 |> get("/api/pleroma/admin/reports")
1398 assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1401 test "returns 403 when requested by anonymous" do
1404 |> get("/api/pleroma/admin/reports")
1406 assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1411 describe "POST /api/pleroma/admin/reports/:id/respond" do
1412 setup %{conn: conn} do
1413 admin = insert(:user, info: %{is_admin: true})
1415 %{conn: assign(conn, :user, admin), admin: admin}
1418 test "returns created dm", %{conn: conn, admin: admin} do
1419 [reporter, target_user] = insert_pair(:user)
1420 activity = insert(:note_activity, user: target_user)
1422 {:ok, %{id: report_id}} =
1423 CommonAPI.report(reporter, %{
1424 "account_id" => target_user.id,
1425 "comment" => "I feel offended",
1426 "status_ids" => [activity.id]
1431 |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1432 "status" => "I will check it out"
1434 |> json_response(:ok)
1436 recipients = Enum.map(response["mentions"], & &1["username"])
1438 assert reporter.nickname in recipients
1439 assert response["content"] == "I will check it out"
1440 assert response["visibility"] == "direct"
1442 log_entry = Repo.one(ModerationLog)
1444 assert ModerationLog.get_log_entry_message(log_entry) ==
1445 "@#{admin.nickname} responded with 'I will check it out' to report ##{
1450 test "returns 400 when status is missing", %{conn: conn} do
1451 conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1453 assert json_response(conn, :bad_request) == "Invalid parameters"
1456 test "returns 404 when report id is invalid", %{conn: conn} do
1458 post(conn, "/api/pleroma/admin/reports/test/respond", %{
1462 assert json_response(conn, :not_found) == "Not found"
1466 describe "PUT /api/pleroma/admin/statuses/:id" do
1467 setup %{conn: conn} do
1468 admin = insert(:user, info: %{is_admin: true})
1469 activity = insert(:note_activity)
1471 %{conn: assign(conn, :user, admin), id: activity.id, admin: admin}
1474 test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
1477 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1478 |> json_response(:ok)
1480 assert response["sensitive"]
1482 log_entry = Repo.one(ModerationLog)
1484 assert ModerationLog.get_log_entry_message(log_entry) ==
1485 "@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"
1489 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1490 |> json_response(:ok)
1492 refute response["sensitive"]
1495 test "change visibility flag", %{conn: conn, id: id, admin: admin} do
1498 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1499 |> json_response(:ok)
1501 assert response["visibility"] == "public"
1503 log_entry = Repo.one(ModerationLog)
1505 assert ModerationLog.get_log_entry_message(log_entry) ==
1506 "@#{admin.nickname} updated status ##{id}, set visibility: 'public'"
1510 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1511 |> json_response(:ok)
1513 assert response["visibility"] == "private"
1517 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1518 |> json_response(:ok)
1520 assert response["visibility"] == "unlisted"
1523 test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1526 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1528 assert json_response(conn, :bad_request) == "Unsupported visibility"
1532 describe "DELETE /api/pleroma/admin/statuses/:id" do
1533 setup %{conn: conn} do
1534 admin = insert(:user, info: %{is_admin: true})
1535 activity = insert(:note_activity)
1537 %{conn: assign(conn, :user, admin), id: activity.id, admin: admin}
1540 test "deletes status", %{conn: conn, id: id, admin: admin} do
1542 |> delete("/api/pleroma/admin/statuses/#{id}")
1543 |> json_response(:ok)
1545 refute Activity.get_by_id(id)
1547 log_entry = Repo.one(ModerationLog)
1549 assert ModerationLog.get_log_entry_message(log_entry) ==
1550 "@#{admin.nickname} deleted status ##{id}"
1553 test "returns error when status is not exist", %{conn: conn} do
1556 |> delete("/api/pleroma/admin/statuses/test")
1558 assert json_response(conn, :bad_request) == "Could not delete"
1562 describe "GET /api/pleroma/admin/config" do
1563 setup %{conn: conn} do
1564 admin = insert(:user, info: %{is_admin: true})
1566 %{conn: assign(conn, :user, admin)}
1569 test "without any settings in db", %{conn: conn} do
1570 conn = get(conn, "/api/pleroma/admin/config")
1572 assert json_response(conn, 200) == %{"configs" => []}
1575 test "with settings in db", %{conn: conn} do
1576 config1 = insert(:config)
1577 config2 = insert(:config)
1579 conn = get(conn, "/api/pleroma/admin/config")
1592 } = json_response(conn, 200)
1594 assert key1 == config1.key
1595 assert key2 == config2.key
1599 describe "POST /api/pleroma/admin/config" do
1600 setup %{conn: conn} do
1601 admin = insert(:user, info: %{is_admin: true})
1603 temp_file = "config/test.exported_from_db.secret.exs"
1606 Application.delete_env(:pleroma, :key1)
1607 Application.delete_env(:pleroma, :key2)
1608 Application.delete_env(:pleroma, :key3)
1609 Application.delete_env(:pleroma, :key4)
1610 Application.delete_env(:pleroma, :keyaa1)
1611 Application.delete_env(:pleroma, :keyaa2)
1612 Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1613 Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1614 :ok = File.rm(temp_file)
1617 %{conn: assign(conn, :user, admin)}
1620 clear_config([:instance, :dynamic_configuration]) do
1621 Pleroma.Config.put([:instance, :dynamic_configuration], true)
1624 test "create new config setting in db", %{conn: conn} do
1626 post(conn, "/api/pleroma/admin/config", %{
1628 %{group: "pleroma", key: "key1", value: "value1"},
1631 key: "Ueberauth.Strategy.Twitter.OAuth",
1632 value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
1638 ":nested_1" => "nested_value1",
1640 %{":nested_22" => "nested_value222"},
1641 %{":nested_33" => %{":nested_44" => "nested_444"}}
1649 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1650 %{"nested_4" => true}
1656 value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
1661 value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1666 assert json_response(conn, 200) == %{
1669 "group" => "pleroma",
1674 "group" => "ueberauth",
1675 "key" => "Ueberauth.Strategy.Twitter.OAuth",
1676 "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
1679 "group" => "pleroma",
1682 ":nested_1" => "nested_value1",
1684 %{":nested_22" => "nested_value222"},
1685 %{":nested_33" => %{":nested_44" => "nested_444"}}
1690 "group" => "pleroma",
1693 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1694 %{"nested_4" => true}
1698 "group" => "pleroma",
1700 "value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"}
1705 "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1710 assert Application.get_env(:pleroma, :key1) == "value1"
1712 assert Application.get_env(:pleroma, :key2) == %{
1713 nested_1: "nested_value1",
1715 %{nested_22: "nested_value222"},
1716 %{nested_33: %{nested_44: "nested_444"}}
1720 assert Application.get_env(:pleroma, :key3) == [
1721 %{"nested_3" => :nested_3, "nested_33" => "nested_33"},
1722 %{"nested_4" => true}
1725 assert Application.get_env(:pleroma, :key4) == %{
1726 "endpoint" => "https://example.com",
1730 assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
1733 test "update config setting & delete", %{conn: conn} do
1734 config1 = insert(:config, key: "keyaa1")
1735 config2 = insert(:config, key: "keyaa2")
1739 key: "Ueberauth.Strategy.Microsoft.OAuth",
1740 value: :erlang.term_to_binary([])
1744 post(conn, "/api/pleroma/admin/config", %{
1746 %{group: config1.group, key: config1.key, value: "another_value"},
1747 %{group: config2.group, key: config2.key, delete: "true"},
1750 key: "Ueberauth.Strategy.Microsoft.OAuth",
1756 assert json_response(conn, 200) == %{
1759 "group" => "pleroma",
1760 "key" => config1.key,
1761 "value" => "another_value"
1766 assert Application.get_env(:pleroma, :keyaa1) == "another_value"
1767 refute Application.get_env(:pleroma, :keyaa2)
1770 test "common config example", %{conn: conn} do
1772 post(conn, "/api/pleroma/admin/config", %{
1775 "group" => "pleroma",
1776 "key" => "Pleroma.Captcha.NotReal",
1778 %{"tuple" => [":enabled", false]},
1779 %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1780 %{"tuple" => [":seconds_valid", 60]},
1781 %{"tuple" => [":path", ""]},
1782 %{"tuple" => [":key1", nil]},
1783 %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}
1789 assert json_response(conn, 200) == %{
1792 "group" => "pleroma",
1793 "key" => "Pleroma.Captcha.NotReal",
1795 %{"tuple" => [":enabled", false]},
1796 %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1797 %{"tuple" => [":seconds_valid", 60]},
1798 %{"tuple" => [":path", ""]},
1799 %{"tuple" => [":key1", nil]},
1800 %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}
1807 test "tuples with more than two values", %{conn: conn} do
1809 post(conn, "/api/pleroma/admin/config", %{
1812 "group" => "pleroma",
1813 "key" => "Pleroma.Web.Endpoint.NotReal",
1829 "/api/v1/streaming",
1830 "Pleroma.Web.MastodonAPI.WebsocketHandler",
1837 "Phoenix.Endpoint.CowboyWebSocket",
1840 "Phoenix.Transports.WebSocket",
1843 "Pleroma.Web.Endpoint",
1844 "Pleroma.Web.UserSocket",
1855 "Phoenix.Endpoint.Cowboy2Handler",
1856 %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1873 assert json_response(conn, 200) == %{
1876 "group" => "pleroma",
1877 "key" => "Pleroma.Web.Endpoint.NotReal",
1893 "/api/v1/streaming",
1894 "Pleroma.Web.MastodonAPI.WebsocketHandler",
1901 "Phoenix.Endpoint.CowboyWebSocket",
1904 "Phoenix.Transports.WebSocket",
1907 "Pleroma.Web.Endpoint",
1908 "Pleroma.Web.UserSocket",
1919 "Phoenix.Endpoint.Cowboy2Handler",
1920 %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1938 test "settings with nesting map", %{conn: conn} do
1940 post(conn, "/api/pleroma/admin/config", %{
1943 "group" => "pleroma",
1946 %{"tuple" => [":key2", "some_val"]},
1951 ":max_options" => 20,
1952 ":max_option_chars" => 200,
1953 ":min_expiration" => 0,
1954 ":max_expiration" => 31_536_000,
1956 ":max_options" => 20,
1957 ":max_option_chars" => 200,
1958 ":min_expiration" => 0,
1959 ":max_expiration" => 31_536_000
1969 assert json_response(conn, 200) ==
1973 "group" => "pleroma",
1976 %{"tuple" => [":key2", "some_val"]},
1981 ":max_expiration" => 31_536_000,
1982 ":max_option_chars" => 200,
1983 ":max_options" => 20,
1984 ":min_expiration" => 0,
1986 ":max_expiration" => 31_536_000,
1987 ":max_option_chars" => 200,
1988 ":max_options" => 20,
1989 ":min_expiration" => 0
2000 test "value as map", %{conn: conn} do
2002 post(conn, "/api/pleroma/admin/config", %{
2005 "group" => "pleroma",
2007 "value" => %{"key" => "some_val"}
2012 assert json_response(conn, 200) ==
2016 "group" => "pleroma",
2018 "value" => %{"key" => "some_val"}
2024 test "dispatch setting", %{conn: conn} do
2026 post(conn, "/api/pleroma/admin/config", %{
2029 "group" => "pleroma",
2030 "key" => "Pleroma.Web.Endpoint.NotReal",
2036 %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2037 %{"tuple" => [":dispatch", ["{:_,
2039 {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
2040 {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
2041 {Phoenix.Transports.WebSocket,
2042 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
2043 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
2054 "{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
2055 "{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
2056 "{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
2057 "{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"
2059 assert json_response(conn, 200) == %{
2062 "group" => "pleroma",
2063 "key" => "Pleroma.Web.Endpoint.NotReal",
2069 %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2087 test "queues key as atom", %{conn: conn} do
2089 post(conn, "/api/pleroma/admin/config", %{
2092 "group" => "pleroma_job_queue",
2095 %{"tuple" => [":federator_incoming", 50]},
2096 %{"tuple" => [":federator_outgoing", 50]},
2097 %{"tuple" => [":web_push", 50]},
2098 %{"tuple" => [":mailer", 10]},
2099 %{"tuple" => [":transmogrifier", 20]},
2100 %{"tuple" => [":scheduled_activities", 10]},
2101 %{"tuple" => [":background", 5]}
2107 assert json_response(conn, 200) == %{
2110 "group" => "pleroma_job_queue",
2113 %{"tuple" => [":federator_incoming", 50]},
2114 %{"tuple" => [":federator_outgoing", 50]},
2115 %{"tuple" => [":web_push", 50]},
2116 %{"tuple" => [":mailer", 10]},
2117 %{"tuple" => [":transmogrifier", 20]},
2118 %{"tuple" => [":scheduled_activities", 10]},
2119 %{"tuple" => [":background", 5]}
2126 test "delete part of settings by atom subkeys", %{conn: conn} do
2130 value: :erlang.term_to_binary(subkey1: "val1", subkey2: "val2", subkey3: "val3")
2134 post(conn, "/api/pleroma/admin/config", %{
2137 group: config.group,
2139 subkeys: [":subkey1", ":subkey3"],
2146 json_response(conn, 200) == %{
2149 "group" => "pleroma",
2151 "value" => [%{"tuple" => [":subkey2", "val2"]}]
2159 describe "config mix tasks run" do
2160 setup %{conn: conn} do
2161 admin = insert(:user, info: %{is_admin: true})
2163 temp_file = "config/test.exported_from_db.secret.exs"
2165 Mix.shell(Mix.Shell.Quiet)
2168 Mix.shell(Mix.Shell.IO)
2169 :ok = File.rm(temp_file)
2172 %{conn: assign(conn, :user, admin), admin: admin}
2175 clear_config([:instance, :dynamic_configuration]) do
2176 Pleroma.Config.put([:instance, :dynamic_configuration], true)
2179 test "transfer settings to DB and to file", %{conn: conn, admin: admin} do
2180 assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2181 conn = get(conn, "/api/pleroma/admin/config/migrate_to_db")
2182 assert json_response(conn, 200) == %{}
2183 assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) > 0
2187 |> assign(:user, admin)
2188 |> get("/api/pleroma/admin/config/migrate_from_db")
2190 assert json_response(conn, 200) == %{}
2191 assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2195 describe "GET /api/pleroma/admin/users/:nickname/statuses" do
2197 admin = insert(:user, info: %{is_admin: true})
2198 user = insert(:user)
2200 date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
2201 date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
2202 date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
2204 insert(:note_activity, user: user, published: date1)
2205 insert(:note_activity, user: user, published: date2)
2206 insert(:note_activity, user: user, published: date3)
2210 |> assign(:user, admin)
2212 {:ok, conn: conn, user: user}
2215 test "renders user's statuses", %{conn: conn, user: user} do
2216 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2218 assert json_response(conn, 200) |> length() == 3
2221 test "renders user's statuses with a limit", %{conn: conn, user: user} do
2222 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")
2224 assert json_response(conn, 200) |> length() == 2
2227 test "doesn't return private statuses by default", %{conn: conn, user: user} do
2228 {:ok, _private_status} =
2229 CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2231 {:ok, _public_status} =
2232 CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2234 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2236 assert json_response(conn, 200) |> length() == 4
2239 test "returns private statuses with godmode on", %{conn: conn, user: user} do
2240 {:ok, _private_status} =
2241 CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2243 {:ok, _public_status} =
2244 CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2246 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
2248 assert json_response(conn, 200) |> length() == 5
2252 describe "GET /api/pleroma/admin/moderation_log" do
2253 setup %{conn: conn} do
2254 admin = insert(:user, info: %{is_admin: true})
2256 %{conn: assign(conn, :user, admin), admin: admin}
2259 test "returns the log", %{conn: conn, admin: admin} do
2260 Repo.insert(%ModerationLog{
2264 "nickname" => admin.nickname,
2267 action: "relay_follow",
2268 target: "https://example.org/relay"
2270 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2273 Repo.insert(%ModerationLog{
2277 "nickname" => admin.nickname,
2280 action: "relay_unfollow",
2281 target: "https://example.org/relay"
2283 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2286 conn = get(conn, "/api/pleroma/admin/moderation_log")
2288 response = json_response(conn, 200)
2289 [first_entry, second_entry] = response
2291 assert response |> length() == 2
2292 assert first_entry["data"]["action"] == "relay_unfollow"
2294 assert first_entry["message"] ==
2295 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2297 assert second_entry["data"]["action"] == "relay_follow"
2299 assert second_entry["message"] ==
2300 "@#{admin.nickname} followed relay: https://example.org/relay"
2303 test "returns the log with pagination", %{conn: conn, admin: admin} do
2304 Repo.insert(%ModerationLog{
2308 "nickname" => admin.nickname,
2311 action: "relay_follow",
2312 target: "https://example.org/relay"
2314 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2317 Repo.insert(%ModerationLog{
2321 "nickname" => admin.nickname,
2324 action: "relay_unfollow",
2325 target: "https://example.org/relay"
2327 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2330 conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
2332 response1 = json_response(conn1, 200)
2333 [first_entry] = response1
2335 assert response1 |> length() == 1
2336 assert first_entry["data"]["action"] == "relay_unfollow"
2338 assert first_entry["message"] ==
2339 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2341 conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
2343 response2 = json_response(conn2, 200)
2344 [second_entry] = response2
2346 assert response2 |> length() == 1
2347 assert second_entry["data"]["action"] == "relay_follow"
2349 assert second_entry["message"] ==
2350 "@#{admin.nickname} followed relay: https://example.org/relay"
2355 # Needed for testing
2356 defmodule Pleroma.Web.Endpoint.NotReal do
2359 defmodule Pleroma.Captcha.NotReal do