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
11 alias Pleroma.UserInviteToken
12 alias Pleroma.Web.CommonAPI
13 alias Pleroma.Web.MediaProxy
14 import Pleroma.Factory
16 describe "/api/pleroma/admin/users" do
18 admin = insert(:user, info: %{is_admin: true})
23 |> assign(:user, admin)
24 |> put_req_header("accept", "application/json")
25 |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
27 assert json_response(conn, 200) == user.nickname
31 admin = insert(:user, info: %{is_admin: true})
35 |> assign(:user, admin)
36 |> put_req_header("accept", "application/json")
37 |> post("/api/pleroma/admin/users", %{
39 "email" => "lain@example.org",
43 assert json_response(conn, 200) == "lain"
47 describe "/api/pleroma/admin/users/:nickname" do
48 test "Show", %{conn: conn} do
49 admin = insert(:user, info: %{is_admin: true})
54 |> assign(:user, admin)
55 |> get("/api/pleroma/admin/users/#{user.nickname}")
58 "deactivated" => false,
59 "id" => to_string(user.id),
61 "nickname" => user.nickname,
62 "roles" => %{"admin" => false, "moderator" => false},
64 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
65 "display_name" => HTML.strip_tags(user.name || user.nickname)
68 assert expected == json_response(conn, 200)
71 test "when the user doesn't exist", %{conn: conn} do
72 admin = insert(:user, info: %{is_admin: true})
77 |> assign(:user, admin)
78 |> get("/api/pleroma/admin/users/#{user.nickname}")
80 assert "Not found" == json_response(conn, 404)
84 describe "/api/pleroma/admin/users/follow" do
85 test "allows to force-follow another user" do
86 admin = insert(:user, info: %{is_admin: true})
88 follower = insert(:user)
91 |> assign(:user, admin)
92 |> put_req_header("accept", "application/json")
93 |> post("/api/pleroma/admin/users/follow", %{
94 "follower" => follower.nickname,
95 "followed" => user.nickname
98 user = User.get_cached_by_id(user.id)
99 follower = User.get_cached_by_id(follower.id)
101 assert User.following?(follower, user)
105 describe "/api/pleroma/admin/users/unfollow" do
106 test "allows to force-unfollow another user" do
107 admin = insert(:user, info: %{is_admin: true})
109 follower = insert(:user)
111 User.follow(follower, user)
114 |> assign(:user, admin)
115 |> put_req_header("accept", "application/json")
116 |> post("/api/pleroma/admin/users/unfollow", %{
117 "follower" => follower.nickname,
118 "followed" => user.nickname
121 user = User.get_cached_by_id(user.id)
122 follower = User.get_cached_by_id(follower.id)
124 refute User.following?(follower, user)
128 describe "PUT /api/pleroma/admin/users/tag" do
130 admin = insert(:user, info: %{is_admin: true})
131 user1 = insert(:user, %{tags: ["x"]})
132 user2 = insert(:user, %{tags: ["y"]})
133 user3 = insert(:user, %{tags: ["unchanged"]})
137 |> assign(:user, admin)
138 |> put_req_header("accept", "application/json")
140 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
142 }&tags[]=foo&tags[]=bar"
145 %{conn: conn, user1: user1, user2: user2, user3: user3}
148 test "it appends specified tags to users with specified nicknames", %{
153 assert json_response(conn, :no_content)
154 assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
155 assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
158 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
159 assert json_response(conn, :no_content)
160 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
164 describe "DELETE /api/pleroma/admin/users/tag" do
166 admin = insert(:user, info: %{is_admin: true})
167 user1 = insert(:user, %{tags: ["x"]})
168 user2 = insert(:user, %{tags: ["y", "z"]})
169 user3 = insert(:user, %{tags: ["unchanged"]})
173 |> assign(:user, admin)
174 |> put_req_header("accept", "application/json")
176 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
181 %{conn: conn, user1: user1, user2: user2, user3: user3}
184 test "it removes specified tags from users with specified nicknames", %{
189 assert json_response(conn, :no_content)
190 assert User.get_cached_by_id(user1.id).tags == []
191 assert User.get_cached_by_id(user2.id).tags == ["y"]
194 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
195 assert json_response(conn, :no_content)
196 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
200 describe "/api/pleroma/admin/users/:nickname/permission_group" do
201 test "GET is giving user_info" do
202 admin = insert(:user, info: %{is_admin: true})
206 |> assign(:user, admin)
207 |> put_req_header("accept", "application/json")
208 |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
210 assert json_response(conn, 200) == %{
212 "is_moderator" => false
216 test "/:right POST, can add to a permission group" do
217 admin = insert(:user, info: %{is_admin: true})
222 |> assign(:user, admin)
223 |> put_req_header("accept", "application/json")
224 |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
226 assert json_response(conn, 200) == %{
231 test "/:right DELETE, can remove from a permission group" do
232 admin = insert(:user, info: %{is_admin: true})
233 user = insert(:user, info: %{is_admin: true})
237 |> assign(:user, admin)
238 |> put_req_header("accept", "application/json")
239 |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
241 assert json_response(conn, 200) == %{
247 describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
248 setup %{conn: conn} do
249 admin = insert(:user, info: %{is_admin: true})
253 |> assign(:user, admin)
254 |> put_req_header("accept", "application/json")
259 test "deactivates the user", %{conn: conn} do
264 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
266 user = User.get_cached_by_id(user.id)
267 assert user.info.deactivated == true
268 assert json_response(conn, :no_content)
271 test "activates the user", %{conn: conn} do
272 user = insert(:user, info: %{deactivated: true})
276 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})
278 user = User.get_cached_by_id(user.id)
279 assert user.info.deactivated == false
280 assert json_response(conn, :no_content)
283 test "returns 403 when requested by a non-admin", %{conn: conn} do
288 |> assign(:user, user)
289 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
291 assert json_response(conn, :forbidden)
295 describe "POST /api/pleroma/admin/email_invite, with valid config" do
297 registrations_open = Pleroma.Config.get([:instance, :registrations_open])
298 invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
299 Pleroma.Config.put([:instance, :registrations_open], false)
300 Pleroma.Config.put([:instance, :invites_enabled], true)
303 Pleroma.Config.put([:instance, :registrations_open], registrations_open)
304 Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
308 [user: insert(:user, info: %{is_admin: true})]
311 test "sends invitation and returns 204", %{conn: conn, user: user} do
312 recipient_email = "foo@bar.com"
313 recipient_name = "J. D."
317 |> assign(:user, user)
319 "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
322 assert json_response(conn, :no_content)
324 token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
326 refute token_record.used
328 notify_email = Pleroma.Config.get([:instance, :notify_email])
329 instance_name = Pleroma.Config.get([:instance, :name])
332 Pleroma.Emails.UserEmail.user_invitation_email(
339 Swoosh.TestAssertions.assert_email_sent(
340 from: {instance_name, notify_email},
341 to: {recipient_name, recipient_email},
342 html_body: email.html_body
346 test "it returns 403 if requested by a non-admin", %{conn: conn} do
347 non_admin_user = insert(:user)
351 |> assign(:user, non_admin_user)
352 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
354 assert json_response(conn, :forbidden)
358 describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
360 [user: insert(:user, info: %{is_admin: true})]
363 test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
364 registrations_open = Pleroma.Config.get([:instance, :registrations_open])
365 invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
366 Pleroma.Config.put([:instance, :registrations_open], false)
367 Pleroma.Config.put([:instance, :invites_enabled], false)
370 Pleroma.Config.put([:instance, :registrations_open], registrations_open)
371 Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
377 |> assign(:user, user)
378 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
380 assert json_response(conn, :internal_server_error)
383 test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
384 registrations_open = Pleroma.Config.get([:instance, :registrations_open])
385 invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
386 Pleroma.Config.put([:instance, :registrations_open], true)
387 Pleroma.Config.put([:instance, :invites_enabled], true)
390 Pleroma.Config.put([:instance, :registrations_open], registrations_open)
391 Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
397 |> assign(:user, user)
398 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
400 assert json_response(conn, :internal_server_error)
404 test "/api/pleroma/admin/users/invite_token" do
405 admin = insert(:user, info: %{is_admin: true})
409 |> assign(:user, admin)
410 |> put_req_header("accept", "application/json")
411 |> get("/api/pleroma/admin/users/invite_token")
413 assert conn.status == 200
416 test "/api/pleroma/admin/users/:nickname/password_reset" do
417 admin = insert(:user, info: %{is_admin: true})
422 |> assign(:user, admin)
423 |> put_req_header("accept", "application/json")
424 |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
426 assert conn.status == 200
429 describe "GET /api/pleroma/admin/users" do
431 admin = insert(:user, info: %{is_admin: true})
435 |> assign(:user, admin)
437 {:ok, conn: conn, admin: admin}
440 test "renders users array for the first page", %{conn: conn, admin: admin} do
441 user = insert(:user, local: false, tags: ["foo", "bar"])
442 conn = get(conn, "/api/pleroma/admin/users?page=1")
447 "deactivated" => admin.info.deactivated,
449 "nickname" => admin.nickname,
450 "roles" => %{"admin" => true, "moderator" => false},
453 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
454 "display_name" => HTML.strip_tags(admin.name || admin.nickname)
457 "deactivated" => user.info.deactivated,
459 "nickname" => user.nickname,
460 "roles" => %{"admin" => false, "moderator" => false},
462 "tags" => ["foo", "bar"],
463 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
464 "display_name" => HTML.strip_tags(user.name || user.nickname)
467 |> Enum.sort_by(& &1["nickname"])
469 assert json_response(conn, 200) == %{
476 test "renders empty array for the second page", %{conn: conn} do
479 conn = get(conn, "/api/pleroma/admin/users?page=2")
481 assert json_response(conn, 200) == %{
488 test "regular search", %{conn: conn} do
489 user = insert(:user, nickname: "bob")
491 conn = get(conn, "/api/pleroma/admin/users?query=bo")
493 assert json_response(conn, 200) == %{
498 "deactivated" => user.info.deactivated,
500 "nickname" => user.nickname,
501 "roles" => %{"admin" => false, "moderator" => false},
504 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
505 "display_name" => HTML.strip_tags(user.name || user.nickname)
511 test "search by domain", %{conn: conn} do
512 user = insert(:user, nickname: "nickname@domain.com")
515 conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
517 assert json_response(conn, 200) == %{
522 "deactivated" => user.info.deactivated,
524 "nickname" => user.nickname,
525 "roles" => %{"admin" => false, "moderator" => false},
528 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
529 "display_name" => HTML.strip_tags(user.name || user.nickname)
535 test "search by full nickname", %{conn: conn} do
536 user = insert(:user, nickname: "nickname@domain.com")
539 conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
541 assert json_response(conn, 200) == %{
546 "deactivated" => user.info.deactivated,
548 "nickname" => user.nickname,
549 "roles" => %{"admin" => false, "moderator" => false},
552 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
553 "display_name" => HTML.strip_tags(user.name || user.nickname)
559 test "search by display name", %{conn: conn} do
560 user = insert(:user, name: "Display name")
563 conn = get(conn, "/api/pleroma/admin/users?name=display")
565 assert json_response(conn, 200) == %{
570 "deactivated" => user.info.deactivated,
572 "nickname" => user.nickname,
573 "roles" => %{"admin" => false, "moderator" => false},
576 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
577 "display_name" => HTML.strip_tags(user.name || user.nickname)
583 test "search by email", %{conn: conn} do
584 user = insert(:user, email: "email@example.com")
587 conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
589 assert json_response(conn, 200) == %{
594 "deactivated" => user.info.deactivated,
596 "nickname" => user.nickname,
597 "roles" => %{"admin" => false, "moderator" => false},
600 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
601 "display_name" => HTML.strip_tags(user.name || user.nickname)
607 test "regular search with page size", %{conn: conn} do
608 user = insert(:user, nickname: "aalice")
609 user2 = insert(:user, nickname: "alice")
611 conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
613 assert json_response(conn1, 200) == %{
618 "deactivated" => user.info.deactivated,
620 "nickname" => user.nickname,
621 "roles" => %{"admin" => false, "moderator" => false},
624 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
625 "display_name" => HTML.strip_tags(user.name || user.nickname)
630 conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
632 assert json_response(conn2, 200) == %{
637 "deactivated" => user2.info.deactivated,
639 "nickname" => user2.nickname,
640 "roles" => %{"admin" => false, "moderator" => false},
643 "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
644 "display_name" => HTML.strip_tags(user2.name || user2.nickname)
650 test "only local users" do
651 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
652 user = insert(:user, nickname: "bob")
654 insert(:user, nickname: "bobb", local: false)
658 |> assign(:user, admin)
659 |> get("/api/pleroma/admin/users?query=bo&filters=local")
661 assert json_response(conn, 200) == %{
666 "deactivated" => user.info.deactivated,
668 "nickname" => user.nickname,
669 "roles" => %{"admin" => false, "moderator" => false},
672 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
673 "display_name" => HTML.strip_tags(user.name || user.nickname)
679 test "only local users with no query", %{admin: old_admin} do
680 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
681 user = insert(:user, nickname: "bob")
683 insert(:user, nickname: "bobb", local: false)
687 |> assign(:user, admin)
688 |> get("/api/pleroma/admin/users?filters=local")
693 "deactivated" => user.info.deactivated,
695 "nickname" => user.nickname,
696 "roles" => %{"admin" => false, "moderator" => false},
699 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
700 "display_name" => HTML.strip_tags(user.name || user.nickname)
703 "deactivated" => admin.info.deactivated,
705 "nickname" => admin.nickname,
706 "roles" => %{"admin" => true, "moderator" => false},
709 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
710 "display_name" => HTML.strip_tags(admin.name || admin.nickname)
713 "deactivated" => false,
714 "id" => old_admin.id,
716 "nickname" => old_admin.nickname,
717 "roles" => %{"admin" => true, "moderator" => false},
719 "avatar" => User.avatar_url(old_admin) |> MediaProxy.url(),
720 "display_name" => HTML.strip_tags(old_admin.name || old_admin.nickname)
723 |> Enum.sort_by(& &1["nickname"])
725 assert json_response(conn, 200) == %{
732 test "load only admins", %{conn: conn, admin: admin} do
733 second_admin = insert(:user, info: %{is_admin: true})
737 conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
742 "deactivated" => false,
744 "nickname" => admin.nickname,
745 "roles" => %{"admin" => true, "moderator" => false},
746 "local" => admin.local,
748 "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
749 "display_name" => HTML.strip_tags(admin.name || admin.nickname)
752 "deactivated" => false,
753 "id" => second_admin.id,
754 "nickname" => second_admin.nickname,
755 "roles" => %{"admin" => true, "moderator" => false},
756 "local" => second_admin.local,
758 "avatar" => User.avatar_url(second_admin) |> MediaProxy.url(),
759 "display_name" => HTML.strip_tags(second_admin.name || second_admin.nickname)
762 |> Enum.sort_by(& &1["nickname"])
764 assert json_response(conn, 200) == %{
771 test "load only moderators", %{conn: conn} do
772 moderator = insert(:user, info: %{is_moderator: true})
776 conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
778 assert json_response(conn, 200) == %{
783 "deactivated" => false,
784 "id" => moderator.id,
785 "nickname" => moderator.nickname,
786 "roles" => %{"admin" => false, "moderator" => true},
787 "local" => moderator.local,
789 "avatar" => User.avatar_url(moderator) |> MediaProxy.url(),
790 "display_name" => HTML.strip_tags(moderator.name || moderator.nickname)
796 test "load users with tags list", %{conn: conn} do
797 user1 = insert(:user, tags: ["first"])
798 user2 = insert(:user, tags: ["second"])
802 conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
807 "deactivated" => false,
809 "nickname" => user1.nickname,
810 "roles" => %{"admin" => false, "moderator" => false},
811 "local" => user1.local,
813 "avatar" => User.avatar_url(user1) |> MediaProxy.url(),
814 "display_name" => HTML.strip_tags(user1.name || user1.nickname)
817 "deactivated" => false,
819 "nickname" => user2.nickname,
820 "roles" => %{"admin" => false, "moderator" => false},
821 "local" => user2.local,
822 "tags" => ["second"],
823 "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
824 "display_name" => HTML.strip_tags(user2.name || user2.nickname)
827 |> Enum.sort_by(& &1["nickname"])
829 assert json_response(conn, 200) == %{
836 test "it works with multiple filters" do
837 admin = insert(:user, nickname: "john", info: %{is_admin: true})
838 user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
840 insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
841 insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
845 |> assign(:user, admin)
846 |> get("/api/pleroma/admin/users?filters=deactivated,external")
848 assert json_response(conn, 200) == %{
853 "deactivated" => user.info.deactivated,
855 "nickname" => user.nickname,
856 "roles" => %{"admin" => false, "moderator" => false},
857 "local" => user.local,
859 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
860 "display_name" => HTML.strip_tags(user.name || user.nickname)
867 test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
868 admin = insert(:user, info: %{is_admin: true})
873 |> assign(:user, admin)
874 |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
876 assert json_response(conn, 200) ==
878 "deactivated" => !user.info.deactivated,
880 "nickname" => user.nickname,
881 "roles" => %{"admin" => false, "moderator" => false},
884 "avatar" => User.avatar_url(user) |> MediaProxy.url(),
885 "display_name" => HTML.strip_tags(user.name || user.nickname)
889 describe "GET /api/pleroma/admin/users/invite_token" do
891 admin = insert(:user, info: %{is_admin: true})
895 |> assign(:user, admin)
900 test "without options", %{conn: conn} do
901 conn = get(conn, "/api/pleroma/admin/users/invite_token")
903 token = json_response(conn, 200)
904 invite = UserInviteToken.find_by_token!(token)
906 refute invite.expires_at
907 refute invite.max_use
908 assert invite.invite_type == "one_time"
911 test "with expires_at", %{conn: conn} do
913 get(conn, "/api/pleroma/admin/users/invite_token", %{
914 "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
917 token = json_response(conn, 200)
918 invite = UserInviteToken.find_by_token!(token)
921 assert invite.expires_at == Date.utc_today()
922 refute invite.max_use
923 assert invite.invite_type == "date_limited"
926 test "with max_use", %{conn: conn} do
928 get(conn, "/api/pleroma/admin/users/invite_token", %{
929 "invite" => %{"max_use" => 150}
932 token = json_response(conn, 200)
933 invite = UserInviteToken.find_by_token!(token)
935 refute invite.expires_at
936 assert invite.max_use == 150
937 assert invite.invite_type == "reusable"
940 test "with max use and expires_at", %{conn: conn} do
942 get(conn, "/api/pleroma/admin/users/invite_token", %{
943 "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
946 token = json_response(conn, 200)
947 invite = UserInviteToken.find_by_token!(token)
949 assert invite.expires_at == Date.utc_today()
950 assert invite.max_use == 150
951 assert invite.invite_type == "reusable_date_limited"
955 describe "GET /api/pleroma/admin/users/invites" do
957 admin = insert(:user, info: %{is_admin: true})
961 |> assign(:user, admin)
966 test "no invites", %{conn: conn} do
967 conn = get(conn, "/api/pleroma/admin/users/invites")
969 assert json_response(conn, 200) == %{"invites" => []}
972 test "with invite", %{conn: conn} do
973 {:ok, invite} = UserInviteToken.create_invite()
975 conn = get(conn, "/api/pleroma/admin/users/invites")
977 assert json_response(conn, 200) == %{
982 "invite_type" => "one_time",
984 "token" => invite.token,
993 describe "POST /api/pleroma/admin/users/revoke_invite" do
995 admin = insert(:user, info: %{is_admin: true})
996 {:ok, invite} = UserInviteToken.create_invite()
1000 |> assign(:user, admin)
1001 |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
1003 assert json_response(conn, 200) == %{
1004 "expires_at" => nil,
1006 "invite_type" => "one_time",
1008 "token" => invite.token,
1015 describe "GET /api/pleroma/admin/reports/:id" do
1016 setup %{conn: conn} do
1017 admin = insert(:user, info: %{is_admin: true})
1019 %{conn: assign(conn, :user, admin)}
1022 test "returns report by its id", %{conn: conn} do
1023 [reporter, target_user] = insert_pair(:user)
1024 activity = insert(:note_activity, user: target_user)
1026 {:ok, %{id: report_id}} =
1027 CommonAPI.report(reporter, %{
1028 "account_id" => target_user.id,
1029 "comment" => "I feel offended",
1030 "status_ids" => [activity.id]
1035 |> get("/api/pleroma/admin/reports/#{report_id}")
1036 |> json_response(:ok)
1038 assert response["id"] == report_id
1041 test "returns 404 when report id is invalid", %{conn: conn} do
1042 conn = get(conn, "/api/pleroma/admin/reports/test")
1044 assert json_response(conn, :not_found) == "Not found"
1048 describe "PUT /api/pleroma/admin/reports/:id" do
1049 setup %{conn: conn} do
1050 admin = insert(:user, info: %{is_admin: true})
1051 [reporter, target_user] = insert_pair(:user)
1052 activity = insert(:note_activity, user: target_user)
1054 {:ok, %{id: report_id}} =
1055 CommonAPI.report(reporter, %{
1056 "account_id" => target_user.id,
1057 "comment" => "I feel offended",
1058 "status_ids" => [activity.id]
1061 %{conn: assign(conn, :user, admin), id: report_id}
1064 test "mark report as resolved", %{conn: conn, id: id} do
1067 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1068 |> json_response(:ok)
1070 assert response["state"] == "resolved"
1073 test "closes report", %{conn: conn, id: id} do
1076 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1077 |> json_response(:ok)
1079 assert response["state"] == "closed"
1082 test "returns 400 when state is unknown", %{conn: conn, id: id} do
1085 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1087 assert json_response(conn, :bad_request) == "Unsupported state"
1090 test "returns 404 when report is not exist", %{conn: conn} do
1093 |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1095 assert json_response(conn, :not_found) == "Not found"
1099 describe "GET /api/pleroma/admin/reports" do
1100 setup %{conn: conn} do
1101 admin = insert(:user, info: %{is_admin: true})
1103 %{conn: assign(conn, :user, admin)}
1106 test "returns empty response when no reports created", %{conn: conn} do
1109 |> get("/api/pleroma/admin/reports")
1110 |> json_response(:ok)
1112 assert Enum.empty?(response["reports"])
1115 test "returns reports", %{conn: conn} do
1116 [reporter, target_user] = insert_pair(:user)
1117 activity = insert(:note_activity, user: target_user)
1119 {:ok, %{id: report_id}} =
1120 CommonAPI.report(reporter, %{
1121 "account_id" => target_user.id,
1122 "comment" => "I feel offended",
1123 "status_ids" => [activity.id]
1128 |> get("/api/pleroma/admin/reports")
1129 |> json_response(:ok)
1131 [report] = response["reports"]
1133 assert length(response["reports"]) == 1
1134 assert report["id"] == report_id
1137 test "returns reports with specified state", %{conn: conn} do
1138 [reporter, target_user] = insert_pair(:user)
1139 activity = insert(:note_activity, user: target_user)
1141 {:ok, %{id: first_report_id}} =
1142 CommonAPI.report(reporter, %{
1143 "account_id" => target_user.id,
1144 "comment" => "I feel offended",
1145 "status_ids" => [activity.id]
1148 {:ok, %{id: second_report_id}} =
1149 CommonAPI.report(reporter, %{
1150 "account_id" => target_user.id,
1151 "comment" => "I don't like this user"
1154 CommonAPI.update_report_state(second_report_id, "closed")
1158 |> get("/api/pleroma/admin/reports", %{
1161 |> json_response(:ok)
1163 [open_report] = response["reports"]
1165 assert length(response["reports"]) == 1
1166 assert open_report["id"] == first_report_id
1170 |> get("/api/pleroma/admin/reports", %{
1173 |> json_response(:ok)
1175 [closed_report] = response["reports"]
1177 assert length(response["reports"]) == 1
1178 assert closed_report["id"] == second_report_id
1182 |> get("/api/pleroma/admin/reports", %{
1183 "state" => "resolved"
1185 |> json_response(:ok)
1187 assert Enum.empty?(response["reports"])
1190 test "returns 403 when requested by a non-admin" do
1191 user = insert(:user)
1195 |> assign(:user, user)
1196 |> get("/api/pleroma/admin/reports")
1198 assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1201 test "returns 403 when requested by anonymous" do
1204 |> get("/api/pleroma/admin/reports")
1206 assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1210 describe "POST /api/pleroma/admin/reports/:id/respond" do
1211 setup %{conn: conn} do
1212 admin = insert(:user, info: %{is_admin: true})
1214 %{conn: assign(conn, :user, admin)}
1217 test "returns created dm", %{conn: conn} do
1218 [reporter, target_user] = insert_pair(:user)
1219 activity = insert(:note_activity, user: target_user)
1221 {:ok, %{id: report_id}} =
1222 CommonAPI.report(reporter, %{
1223 "account_id" => target_user.id,
1224 "comment" => "I feel offended",
1225 "status_ids" => [activity.id]
1230 |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1231 "status" => "I will check it out"
1233 |> json_response(:ok)
1235 recipients = Enum.map(response["mentions"], & &1["username"])
1237 assert reporter.nickname in recipients
1238 assert response["content"] == "I will check it out"
1239 assert response["visibility"] == "direct"
1242 test "returns 400 when status is missing", %{conn: conn} do
1243 conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1245 assert json_response(conn, :bad_request) == "Invalid parameters"
1248 test "returns 404 when report id is invalid", %{conn: conn} do
1250 post(conn, "/api/pleroma/admin/reports/test/respond", %{
1254 assert json_response(conn, :not_found) == "Not found"
1258 describe "PUT /api/pleroma/admin/statuses/:id" do
1259 setup %{conn: conn} do
1260 admin = insert(:user, info: %{is_admin: true})
1261 activity = insert(:note_activity)
1263 %{conn: assign(conn, :user, admin), id: activity.id}
1266 test "toggle sensitive flag", %{conn: conn, id: id} do
1269 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1270 |> json_response(:ok)
1272 assert response["sensitive"]
1276 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1277 |> json_response(:ok)
1279 refute response["sensitive"]
1282 test "change visibility flag", %{conn: conn, id: id} do
1285 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1286 |> json_response(:ok)
1288 assert response["visibility"] == "public"
1292 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1293 |> json_response(:ok)
1295 assert response["visibility"] == "private"
1299 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1300 |> json_response(:ok)
1302 assert response["visibility"] == "unlisted"
1305 test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1308 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1310 assert json_response(conn, :bad_request) == "Unsupported visibility"
1314 describe "DELETE /api/pleroma/admin/statuses/:id" do
1315 setup %{conn: conn} do
1316 admin = insert(:user, info: %{is_admin: true})
1317 activity = insert(:note_activity)
1319 %{conn: assign(conn, :user, admin), id: activity.id}
1322 test "deletes status", %{conn: conn, id: id} do
1324 |> delete("/api/pleroma/admin/statuses/#{id}")
1325 |> json_response(:ok)
1327 refute Activity.get_by_id(id)
1330 test "returns error when status is not exist", %{conn: conn} do
1333 |> delete("/api/pleroma/admin/statuses/test")
1335 assert json_response(conn, :bad_request) == "Could not delete"
1339 describe "GET /api/pleroma/admin/config" do
1340 setup %{conn: conn} do
1341 admin = insert(:user, info: %{is_admin: true})
1343 %{conn: assign(conn, :user, admin)}
1346 test "without any settings in db", %{conn: conn} do
1347 conn = get(conn, "/api/pleroma/admin/config")
1349 assert json_response(conn, 200) == %{"configs" => []}
1352 test "with settings in db", %{conn: conn} do
1353 config1 = insert(:config)
1354 config2 = insert(:config)
1356 conn = get(conn, "/api/pleroma/admin/config")
1369 } = json_response(conn, 200)
1371 assert key1 == config1.key
1372 assert key2 == config2.key
1376 describe "POST /api/pleroma/admin/config" do
1377 setup %{conn: conn} do
1378 admin = insert(:user, info: %{is_admin: true})
1380 temp_file = "config/test.exported_from_db.secret.exs"
1383 Application.delete_env(:pleroma, :key1)
1384 Application.delete_env(:pleroma, :key2)
1385 Application.delete_env(:pleroma, :key3)
1386 Application.delete_env(:pleroma, :key4)
1387 Application.delete_env(:pleroma, :keyaa1)
1388 Application.delete_env(:pleroma, :keyaa2)
1389 Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1390 Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1391 :ok = File.rm(temp_file)
1394 dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
1396 Pleroma.Config.put([:instance, :dynamic_configuration], true)
1399 Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
1402 %{conn: assign(conn, :user, admin)}
1405 test "create new config setting in db", %{conn: conn} do
1407 post(conn, "/api/pleroma/admin/config", %{
1409 %{group: "pleroma", key: "key1", value: "value1"},
1414 "nested_1" => "nested_value1",
1416 %{"nested_22" => "nested_value222"},
1417 %{"nested_33" => %{"nested_44" => "nested_444"}}
1425 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1426 %{"nested_4" => ":true"}
1432 value: %{"nested_5" => ":upload", "endpoint" => "https://example.com"}
1437 value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1442 assert json_response(conn, 200) == %{
1445 "group" => "pleroma",
1450 "group" => "pleroma",
1453 %{"nested_1" => "nested_value1"},
1456 %{"nested_22" => "nested_value222"},
1457 %{"nested_33" => %{"nested_44" => "nested_444"}}
1463 "group" => "pleroma",
1466 [%{"nested_3" => "nested_3"}, %{"nested_33" => "nested_33"}],
1467 %{"nested_4" => true}
1471 "group" => "pleroma",
1473 "value" => [%{"endpoint" => "https://example.com"}, %{"nested_5" => "upload"}]
1478 "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1483 assert Application.get_env(:pleroma, :key1) == "value1"
1485 assert Application.get_env(:pleroma, :key2) == [
1486 nested_1: "nested_value1",
1488 [nested_22: "nested_value222"],
1489 [nested_33: [nested_44: "nested_444"]]
1493 assert Application.get_env(:pleroma, :key3) == [
1494 [nested_3: :nested_3, nested_33: "nested_33"],
1498 assert Application.get_env(:pleroma, :key4) == [
1499 endpoint: "https://example.com",
1503 assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
1506 test "update config setting & delete", %{conn: conn} do
1507 config1 = insert(:config, key: "keyaa1")
1508 config2 = insert(:config, key: "keyaa2")
1511 post(conn, "/api/pleroma/admin/config", %{
1513 %{group: config1.group, key: config1.key, value: "another_value"},
1514 %{group: config2.group, key: config2.key, delete: "true"}
1518 assert json_response(conn, 200) == %{
1521 "group" => "pleroma",
1522 "key" => config1.key,
1523 "value" => "another_value"
1528 assert Application.get_env(:pleroma, :keyaa1) == "another_value"
1529 refute Application.get_env(:pleroma, :keyaa2)
1532 test "common config example", %{conn: conn} do
1534 post(conn, "/api/pleroma/admin/config", %{
1537 "group" => "pleroma",
1538 "key" => "Pleroma.Captcha.NotReal",
1540 "enabled" => ":false",
1541 "method" => "Pleroma.Captcha.Kocaptcha",
1542 "seconds_valid" => "i:60"
1548 assert json_response(conn, 200) == %{
1551 "group" => "pleroma",
1552 "key" => "Pleroma.Captcha.NotReal",
1554 %{"enabled" => false},
1555 %{"method" => "Pleroma.Captcha.Kocaptcha"},
1556 %{"seconds_valid" => 60}
1563 test "tuples with more than two values", %{conn: conn} do
1565 post(conn, "/api/pleroma/admin/config", %{
1568 "group" => "pleroma",
1569 "key" => "Pleroma.Web.Endpoint.NotReal",
1580 "/api/v1/streaming",
1581 "Pleroma.Web.MastodonAPI.WebsocketHandler",
1588 "Phoenix.Endpoint.CowboyWebSocket",
1591 "Phoenix.Transports.WebSocket",
1594 "Pleroma.Web.Endpoint",
1595 "Pleroma.Web.UserSocket",
1606 "Phoenix.Endpoint.Cowboy2Handler",
1608 "tuple" => ["Pleroma.Web.Endpoint", []]
1623 assert json_response(conn, 200) == %{
1626 "group" => "pleroma",
1627 "key" => "Pleroma.Web.Endpoint.NotReal",
1635 "/api/v1/streaming",
1636 "Pleroma.Web.MastodonAPI.WebsocketHandler",
1643 "Phoenix.Endpoint.CowboyWebSocket",
1645 "Elixir.Phoenix.Transports.WebSocket" => %{
1647 "Pleroma.Web.Endpoint",
1648 "Pleroma.Web.UserSocket",
1658 "Phoenix.Endpoint.Cowboy2Handler",
1659 %{"Elixir.Pleroma.Web.Endpoint" => []}
1674 # Needed for testing
1675 defmodule Pleroma.Web.Endpoint.NotReal do
1678 defmodule Pleroma.Captcha.NotReal do