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.UserInviteToken
11 alias Pleroma.Web.CommonAPI
12 import Pleroma.Factory
14 describe "/api/pleroma/admin/users" do
16 admin = insert(:user, info: %{is_admin: true})
21 |> assign(:user, admin)
22 |> put_req_header("accept", "application/json")
23 |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
25 assert json_response(conn, 200) == user.nickname
29 admin = insert(:user, info: %{is_admin: true})
33 |> assign(:user, admin)
34 |> put_req_header("accept", "application/json")
35 |> post("/api/pleroma/admin/users", %{
39 "email" => "lain@example.org",
43 "nickname" => "lain2",
44 "email" => "lain2@example.org",
50 assert json_response(conn, 200) == [
54 "email" => "lain@example.org",
62 "email" => "lain2@example.org",
70 test "Cannot create user with exisiting email" do
71 admin = insert(:user, info: %{is_admin: true})
76 |> assign(:user, admin)
77 |> put_req_header("accept", "application/json")
78 |> post("/api/pleroma/admin/users", %{
82 "email" => user.email,
88 assert json_response(conn, 409) == [
92 "email" => user.email,
95 "error" => "email has already been taken",
101 test "Cannot create user with exisiting nickname" do
102 admin = insert(:user, info: %{is_admin: true})
107 |> assign(:user, admin)
108 |> put_req_header("accept", "application/json")
109 |> post("/api/pleroma/admin/users", %{
112 "nickname" => user.nickname,
113 "email" => "someuser@plerama.social",
119 assert json_response(conn, 409) == [
123 "email" => "someuser@plerama.social",
124 "nickname" => user.nickname
126 "error" => "nickname has already been taken",
132 test "Multiple user creation works in transaction" do
133 admin = insert(:user, info: %{is_admin: true})
138 |> assign(:user, admin)
139 |> put_req_header("accept", "application/json")
140 |> post("/api/pleroma/admin/users", %{
143 "nickname" => "newuser",
144 "email" => "newuser@pleroma.social",
148 "nickname" => "lain",
149 "email" => user.email,
155 assert json_response(conn, 409) == [
159 "email" => user.email,
162 "error" => "email has already been taken",
168 "email" => "newuser@pleroma.social",
169 "nickname" => "newuser"
176 assert User.get_by_nickname("newuser") === nil
180 describe "/api/pleroma/admin/users/:nickname" do
181 test "Show", %{conn: conn} do
182 admin = insert(:user, info: %{is_admin: true})
187 |> assign(:user, admin)
188 |> get("/api/pleroma/admin/users/#{user.nickname}")
191 "deactivated" => false,
192 "id" => to_string(user.id),
194 "nickname" => user.nickname,
195 "roles" => %{"admin" => false, "moderator" => false},
199 assert expected == json_response(conn, 200)
202 test "when the user doesn't exist", %{conn: conn} do
203 admin = insert(:user, info: %{is_admin: true})
208 |> assign(:user, admin)
209 |> get("/api/pleroma/admin/users/#{user.nickname}")
211 assert "Not found" == json_response(conn, 404)
215 describe "/api/pleroma/admin/users/follow" do
216 test "allows to force-follow another user" do
217 admin = insert(:user, info: %{is_admin: true})
219 follower = insert(:user)
222 |> assign(:user, admin)
223 |> put_req_header("accept", "application/json")
224 |> post("/api/pleroma/admin/users/follow", %{
225 "follower" => follower.nickname,
226 "followed" => user.nickname
229 user = User.get_cached_by_id(user.id)
230 follower = User.get_cached_by_id(follower.id)
232 assert User.following?(follower, user)
236 describe "/api/pleroma/admin/users/unfollow" do
237 test "allows to force-unfollow another user" do
238 admin = insert(:user, info: %{is_admin: true})
240 follower = insert(:user)
242 User.follow(follower, user)
245 |> assign(:user, admin)
246 |> put_req_header("accept", "application/json")
247 |> post("/api/pleroma/admin/users/unfollow", %{
248 "follower" => follower.nickname,
249 "followed" => user.nickname
252 user = User.get_cached_by_id(user.id)
253 follower = User.get_cached_by_id(follower.id)
255 refute User.following?(follower, user)
259 describe "PUT /api/pleroma/admin/users/tag" do
261 admin = insert(:user, info: %{is_admin: true})
262 user1 = insert(:user, %{tags: ["x"]})
263 user2 = insert(:user, %{tags: ["y"]})
264 user3 = insert(:user, %{tags: ["unchanged"]})
268 |> assign(:user, admin)
269 |> put_req_header("accept", "application/json")
271 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
273 }&tags[]=foo&tags[]=bar"
276 %{conn: conn, user1: user1, user2: user2, user3: user3}
279 test "it appends specified tags to users with specified nicknames", %{
284 assert json_response(conn, :no_content)
285 assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
286 assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
289 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
290 assert json_response(conn, :no_content)
291 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
295 describe "DELETE /api/pleroma/admin/users/tag" do
297 admin = insert(:user, info: %{is_admin: true})
298 user1 = insert(:user, %{tags: ["x"]})
299 user2 = insert(:user, %{tags: ["y", "z"]})
300 user3 = insert(:user, %{tags: ["unchanged"]})
304 |> assign(:user, admin)
305 |> put_req_header("accept", "application/json")
307 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
312 %{conn: conn, user1: user1, user2: user2, user3: user3}
315 test "it removes specified tags from users with specified nicknames", %{
320 assert json_response(conn, :no_content)
321 assert User.get_cached_by_id(user1.id).tags == []
322 assert User.get_cached_by_id(user2.id).tags == ["y"]
325 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
326 assert json_response(conn, :no_content)
327 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
331 describe "/api/pleroma/admin/users/:nickname/permission_group" do
332 test "GET is giving user_info" do
333 admin = insert(:user, info: %{is_admin: true})
337 |> assign(:user, admin)
338 |> put_req_header("accept", "application/json")
339 |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
341 assert json_response(conn, 200) == %{
343 "is_moderator" => false
347 test "/:right POST, can add to a permission group" do
348 admin = insert(:user, info: %{is_admin: true})
353 |> assign(:user, admin)
354 |> put_req_header("accept", "application/json")
355 |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
357 assert json_response(conn, 200) == %{
362 test "/:right DELETE, can remove from a permission group" do
363 admin = insert(:user, info: %{is_admin: true})
364 user = insert(:user, info: %{is_admin: true})
368 |> assign(:user, admin)
369 |> put_req_header("accept", "application/json")
370 |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
372 assert json_response(conn, 200) == %{
378 describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
379 setup %{conn: conn} do
380 admin = insert(:user, info: %{is_admin: true})
384 |> assign(:user, admin)
385 |> put_req_header("accept", "application/json")
390 test "deactivates the user", %{conn: conn} do
395 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
397 user = User.get_cached_by_id(user.id)
398 assert user.info.deactivated == true
399 assert json_response(conn, :no_content)
402 test "activates the user", %{conn: conn} do
403 user = insert(:user, info: %{deactivated: true})
407 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})
409 user = User.get_cached_by_id(user.id)
410 assert user.info.deactivated == false
411 assert json_response(conn, :no_content)
414 test "returns 403 when requested by a non-admin", %{conn: conn} do
419 |> assign(:user, user)
420 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
422 assert json_response(conn, :forbidden)
426 describe "POST /api/pleroma/admin/email_invite, with valid config" do
428 registrations_open = Pleroma.Config.get([:instance, :registrations_open])
429 invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
430 Pleroma.Config.put([:instance, :registrations_open], false)
431 Pleroma.Config.put([:instance, :invites_enabled], true)
434 Pleroma.Config.put([:instance, :registrations_open], registrations_open)
435 Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
439 [user: insert(:user, info: %{is_admin: true})]
442 test "sends invitation and returns 204", %{conn: conn, user: user} do
443 recipient_email = "foo@bar.com"
444 recipient_name = "J. D."
448 |> assign(:user, user)
450 "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
453 assert json_response(conn, :no_content)
455 token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
457 refute token_record.used
459 notify_email = Pleroma.Config.get([:instance, :notify_email])
460 instance_name = Pleroma.Config.get([:instance, :name])
463 Pleroma.Emails.UserEmail.user_invitation_email(
470 Swoosh.TestAssertions.assert_email_sent(
471 from: {instance_name, notify_email},
472 to: {recipient_name, recipient_email},
473 html_body: email.html_body
477 test "it returns 403 if requested by a non-admin", %{conn: conn} do
478 non_admin_user = insert(:user)
482 |> assign(:user, non_admin_user)
483 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
485 assert json_response(conn, :forbidden)
489 describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
491 [user: insert(:user, info: %{is_admin: true})]
494 test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
495 registrations_open = Pleroma.Config.get([:instance, :registrations_open])
496 invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
497 Pleroma.Config.put([:instance, :registrations_open], false)
498 Pleroma.Config.put([:instance, :invites_enabled], false)
501 Pleroma.Config.put([:instance, :registrations_open], registrations_open)
502 Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
508 |> assign(:user, user)
509 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
511 assert json_response(conn, :internal_server_error)
514 test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
515 registrations_open = Pleroma.Config.get([:instance, :registrations_open])
516 invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
517 Pleroma.Config.put([:instance, :registrations_open], true)
518 Pleroma.Config.put([:instance, :invites_enabled], true)
521 Pleroma.Config.put([:instance, :registrations_open], registrations_open)
522 Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
528 |> assign(:user, user)
529 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
531 assert json_response(conn, :internal_server_error)
535 test "/api/pleroma/admin/users/invite_token" do
536 admin = insert(:user, info: %{is_admin: true})
540 |> assign(:user, admin)
541 |> put_req_header("accept", "application/json")
542 |> get("/api/pleroma/admin/users/invite_token")
544 assert conn.status == 200
547 test "/api/pleroma/admin/users/:nickname/password_reset" do
548 admin = insert(:user, info: %{is_admin: true})
553 |> assign(:user, admin)
554 |> put_req_header("accept", "application/json")
555 |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
557 assert conn.status == 200
560 describe "GET /api/pleroma/admin/users" do
562 admin = insert(:user, info: %{is_admin: true})
566 |> assign(:user, admin)
568 {:ok, conn: conn, admin: admin}
571 test "renders users array for the first page", %{conn: conn, admin: admin} do
572 user = insert(:user, local: false, tags: ["foo", "bar"])
573 conn = get(conn, "/api/pleroma/admin/users?page=1")
578 "deactivated" => admin.info.deactivated,
580 "nickname" => admin.nickname,
581 "roles" => %{"admin" => true, "moderator" => false},
586 "deactivated" => user.info.deactivated,
588 "nickname" => user.nickname,
589 "roles" => %{"admin" => false, "moderator" => false},
591 "tags" => ["foo", "bar"]
594 |> Enum.sort_by(& &1["nickname"])
596 assert json_response(conn, 200) == %{
603 test "renders empty array for the second page", %{conn: conn} do
606 conn = get(conn, "/api/pleroma/admin/users?page=2")
608 assert json_response(conn, 200) == %{
615 test "regular search", %{conn: conn} do
616 user = insert(:user, nickname: "bob")
618 conn = get(conn, "/api/pleroma/admin/users?query=bo")
620 assert json_response(conn, 200) == %{
625 "deactivated" => user.info.deactivated,
627 "nickname" => user.nickname,
628 "roles" => %{"admin" => false, "moderator" => false},
636 test "search by domain", %{conn: conn} do
637 user = insert(:user, nickname: "nickname@domain.com")
640 conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
642 assert json_response(conn, 200) == %{
647 "deactivated" => user.info.deactivated,
649 "nickname" => user.nickname,
650 "roles" => %{"admin" => false, "moderator" => false},
658 test "search by full nickname", %{conn: conn} do
659 user = insert(:user, nickname: "nickname@domain.com")
662 conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
664 assert json_response(conn, 200) == %{
669 "deactivated" => user.info.deactivated,
671 "nickname" => user.nickname,
672 "roles" => %{"admin" => false, "moderator" => false},
680 test "search by display name", %{conn: conn} do
681 user = insert(:user, name: "Display name")
684 conn = get(conn, "/api/pleroma/admin/users?name=display")
686 assert json_response(conn, 200) == %{
691 "deactivated" => user.info.deactivated,
693 "nickname" => user.nickname,
694 "roles" => %{"admin" => false, "moderator" => false},
702 test "search by email", %{conn: conn} do
703 user = insert(:user, email: "email@example.com")
706 conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
708 assert json_response(conn, 200) == %{
713 "deactivated" => user.info.deactivated,
715 "nickname" => user.nickname,
716 "roles" => %{"admin" => false, "moderator" => false},
724 test "regular search with page size", %{conn: conn} do
725 user = insert(:user, nickname: "aalice")
726 user2 = insert(:user, nickname: "alice")
728 conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
730 assert json_response(conn1, 200) == %{
735 "deactivated" => user.info.deactivated,
737 "nickname" => user.nickname,
738 "roles" => %{"admin" => false, "moderator" => false},
745 conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
747 assert json_response(conn2, 200) == %{
752 "deactivated" => user2.info.deactivated,
754 "nickname" => user2.nickname,
755 "roles" => %{"admin" => false, "moderator" => false},
763 test "only local users" do
764 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
765 user = insert(:user, nickname: "bob")
767 insert(:user, nickname: "bobb", local: false)
771 |> assign(:user, admin)
772 |> get("/api/pleroma/admin/users?query=bo&filters=local")
774 assert json_response(conn, 200) == %{
779 "deactivated" => user.info.deactivated,
781 "nickname" => user.nickname,
782 "roles" => %{"admin" => false, "moderator" => false},
790 test "only local users with no query", %{admin: old_admin} do
791 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
792 user = insert(:user, nickname: "bob")
794 insert(:user, nickname: "bobb", local: false)
798 |> assign(:user, admin)
799 |> get("/api/pleroma/admin/users?filters=local")
804 "deactivated" => user.info.deactivated,
806 "nickname" => user.nickname,
807 "roles" => %{"admin" => false, "moderator" => false},
812 "deactivated" => admin.info.deactivated,
814 "nickname" => admin.nickname,
815 "roles" => %{"admin" => true, "moderator" => false},
820 "deactivated" => false,
821 "id" => old_admin.id,
823 "nickname" => old_admin.nickname,
824 "roles" => %{"admin" => true, "moderator" => false},
828 |> Enum.sort_by(& &1["nickname"])
830 assert json_response(conn, 200) == %{
837 test "load only admins", %{conn: conn, admin: admin} do
838 second_admin = insert(:user, info: %{is_admin: true})
842 conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
847 "deactivated" => false,
849 "nickname" => admin.nickname,
850 "roles" => %{"admin" => true, "moderator" => false},
851 "local" => admin.local,
855 "deactivated" => false,
856 "id" => second_admin.id,
857 "nickname" => second_admin.nickname,
858 "roles" => %{"admin" => true, "moderator" => false},
859 "local" => second_admin.local,
863 |> Enum.sort_by(& &1["nickname"])
865 assert json_response(conn, 200) == %{
872 test "load only moderators", %{conn: conn} do
873 moderator = insert(:user, info: %{is_moderator: true})
877 conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
879 assert json_response(conn, 200) == %{
884 "deactivated" => false,
885 "id" => moderator.id,
886 "nickname" => moderator.nickname,
887 "roles" => %{"admin" => false, "moderator" => true},
888 "local" => moderator.local,
895 test "load users with tags list", %{conn: conn} do
896 user1 = insert(:user, tags: ["first"])
897 user2 = insert(:user, tags: ["second"])
901 conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
906 "deactivated" => false,
908 "nickname" => user1.nickname,
909 "roles" => %{"admin" => false, "moderator" => false},
910 "local" => user1.local,
914 "deactivated" => false,
916 "nickname" => user2.nickname,
917 "roles" => %{"admin" => false, "moderator" => false},
918 "local" => user2.local,
922 |> Enum.sort_by(& &1["nickname"])
924 assert json_response(conn, 200) == %{
931 test "it works with multiple filters" do
932 admin = insert(:user, nickname: "john", info: %{is_admin: true})
933 user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
935 insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
936 insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
940 |> assign(:user, admin)
941 |> get("/api/pleroma/admin/users?filters=deactivated,external")
943 assert json_response(conn, 200) == %{
948 "deactivated" => user.info.deactivated,
950 "nickname" => user.nickname,
951 "roles" => %{"admin" => false, "moderator" => false},
952 "local" => user.local,
960 test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
961 admin = insert(:user, info: %{is_admin: true})
966 |> assign(:user, admin)
967 |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
969 assert json_response(conn, 200) ==
971 "deactivated" => !user.info.deactivated,
973 "nickname" => user.nickname,
974 "roles" => %{"admin" => false, "moderator" => false},
980 describe "GET /api/pleroma/admin/users/invite_token" do
982 admin = insert(:user, info: %{is_admin: true})
986 |> assign(:user, admin)
991 test "without options", %{conn: conn} do
992 conn = get(conn, "/api/pleroma/admin/users/invite_token")
994 token = json_response(conn, 200)
995 invite = UserInviteToken.find_by_token!(token)
997 refute invite.expires_at
998 refute invite.max_use
999 assert invite.invite_type == "one_time"
1002 test "with expires_at", %{conn: conn} do
1004 get(conn, "/api/pleroma/admin/users/invite_token", %{
1005 "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
1008 token = json_response(conn, 200)
1009 invite = UserInviteToken.find_by_token!(token)
1012 assert invite.expires_at == Date.utc_today()
1013 refute invite.max_use
1014 assert invite.invite_type == "date_limited"
1017 test "with max_use", %{conn: conn} do
1019 get(conn, "/api/pleroma/admin/users/invite_token", %{
1020 "invite" => %{"max_use" => 150}
1023 token = json_response(conn, 200)
1024 invite = UserInviteToken.find_by_token!(token)
1026 refute invite.expires_at
1027 assert invite.max_use == 150
1028 assert invite.invite_type == "reusable"
1031 test "with max use and expires_at", %{conn: conn} do
1033 get(conn, "/api/pleroma/admin/users/invite_token", %{
1034 "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
1037 token = json_response(conn, 200)
1038 invite = UserInviteToken.find_by_token!(token)
1040 assert invite.expires_at == Date.utc_today()
1041 assert invite.max_use == 150
1042 assert invite.invite_type == "reusable_date_limited"
1046 describe "GET /api/pleroma/admin/users/invites" do
1048 admin = insert(:user, info: %{is_admin: true})
1052 |> assign(:user, admin)
1057 test "no invites", %{conn: conn} do
1058 conn = get(conn, "/api/pleroma/admin/users/invites")
1060 assert json_response(conn, 200) == %{"invites" => []}
1063 test "with invite", %{conn: conn} do
1064 {:ok, invite} = UserInviteToken.create_invite()
1066 conn = get(conn, "/api/pleroma/admin/users/invites")
1068 assert json_response(conn, 200) == %{
1071 "expires_at" => nil,
1073 "invite_type" => "one_time",
1075 "token" => invite.token,
1084 describe "POST /api/pleroma/admin/users/revoke_invite" do
1085 test "with token" do
1086 admin = insert(:user, info: %{is_admin: true})
1087 {:ok, invite} = UserInviteToken.create_invite()
1091 |> assign(:user, admin)
1092 |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
1094 assert json_response(conn, 200) == %{
1095 "expires_at" => nil,
1097 "invite_type" => "one_time",
1099 "token" => invite.token,
1106 describe "GET /api/pleroma/admin/reports/:id" do
1107 setup %{conn: conn} do
1108 admin = insert(:user, info: %{is_admin: true})
1110 %{conn: assign(conn, :user, admin)}
1113 test "returns report by its id", %{conn: conn} do
1114 [reporter, target_user] = insert_pair(:user)
1115 activity = insert(:note_activity, user: target_user)
1117 {:ok, %{id: report_id}} =
1118 CommonAPI.report(reporter, %{
1119 "account_id" => target_user.id,
1120 "comment" => "I feel offended",
1121 "status_ids" => [activity.id]
1126 |> get("/api/pleroma/admin/reports/#{report_id}")
1127 |> json_response(:ok)
1129 assert response["id"] == report_id
1132 test "returns 404 when report id is invalid", %{conn: conn} do
1133 conn = get(conn, "/api/pleroma/admin/reports/test")
1135 assert json_response(conn, :not_found) == "Not found"
1139 describe "PUT /api/pleroma/admin/reports/:id" do
1140 setup %{conn: conn} do
1141 admin = insert(:user, info: %{is_admin: true})
1142 [reporter, target_user] = insert_pair(:user)
1143 activity = insert(:note_activity, user: target_user)
1145 {:ok, %{id: report_id}} =
1146 CommonAPI.report(reporter, %{
1147 "account_id" => target_user.id,
1148 "comment" => "I feel offended",
1149 "status_ids" => [activity.id]
1152 %{conn: assign(conn, :user, admin), id: report_id}
1155 test "mark report as resolved", %{conn: conn, id: id} do
1158 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1159 |> json_response(:ok)
1161 assert response["state"] == "resolved"
1164 test "closes report", %{conn: conn, id: id} do
1167 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1168 |> json_response(:ok)
1170 assert response["state"] == "closed"
1173 test "returns 400 when state is unknown", %{conn: conn, id: id} do
1176 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1178 assert json_response(conn, :bad_request) == "Unsupported state"
1181 test "returns 404 when report is not exist", %{conn: conn} do
1184 |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1186 assert json_response(conn, :not_found) == "Not found"
1190 describe "GET /api/pleroma/admin/reports" do
1191 setup %{conn: conn} do
1192 admin = insert(:user, info: %{is_admin: true})
1194 %{conn: assign(conn, :user, admin)}
1197 test "returns empty response when no reports created", %{conn: conn} do
1200 |> get("/api/pleroma/admin/reports")
1201 |> json_response(:ok)
1203 assert Enum.empty?(response["reports"])
1206 test "returns reports", %{conn: conn} do
1207 [reporter, target_user] = insert_pair(:user)
1208 activity = insert(:note_activity, user: target_user)
1210 {:ok, %{id: report_id}} =
1211 CommonAPI.report(reporter, %{
1212 "account_id" => target_user.id,
1213 "comment" => "I feel offended",
1214 "status_ids" => [activity.id]
1219 |> get("/api/pleroma/admin/reports")
1220 |> json_response(:ok)
1222 [report] = response["reports"]
1224 assert length(response["reports"]) == 1
1225 assert report["id"] == report_id
1228 test "returns reports with specified state", %{conn: conn} do
1229 [reporter, target_user] = insert_pair(:user)
1230 activity = insert(:note_activity, user: target_user)
1232 {:ok, %{id: first_report_id}} =
1233 CommonAPI.report(reporter, %{
1234 "account_id" => target_user.id,
1235 "comment" => "I feel offended",
1236 "status_ids" => [activity.id]
1239 {:ok, %{id: second_report_id}} =
1240 CommonAPI.report(reporter, %{
1241 "account_id" => target_user.id,
1242 "comment" => "I don't like this user"
1245 CommonAPI.update_report_state(second_report_id, "closed")
1249 |> get("/api/pleroma/admin/reports", %{
1252 |> json_response(:ok)
1254 [open_report] = response["reports"]
1256 assert length(response["reports"]) == 1
1257 assert open_report["id"] == first_report_id
1261 |> get("/api/pleroma/admin/reports", %{
1264 |> json_response(:ok)
1266 [closed_report] = response["reports"]
1268 assert length(response["reports"]) == 1
1269 assert closed_report["id"] == second_report_id
1273 |> get("/api/pleroma/admin/reports", %{
1274 "state" => "resolved"
1276 |> json_response(:ok)
1278 assert Enum.empty?(response["reports"])
1281 test "returns 403 when requested by a non-admin" do
1282 user = insert(:user)
1286 |> assign(:user, user)
1287 |> get("/api/pleroma/admin/reports")
1289 assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1292 test "returns 403 when requested by anonymous" do
1295 |> get("/api/pleroma/admin/reports")
1297 assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1301 describe "POST /api/pleroma/admin/reports/:id/respond" do
1302 setup %{conn: conn} do
1303 admin = insert(:user, info: %{is_admin: true})
1305 %{conn: assign(conn, :user, admin)}
1308 test "returns created dm", %{conn: conn} do
1309 [reporter, target_user] = insert_pair(:user)
1310 activity = insert(:note_activity, user: target_user)
1312 {:ok, %{id: report_id}} =
1313 CommonAPI.report(reporter, %{
1314 "account_id" => target_user.id,
1315 "comment" => "I feel offended",
1316 "status_ids" => [activity.id]
1321 |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1322 "status" => "I will check it out"
1324 |> json_response(:ok)
1326 recipients = Enum.map(response["mentions"], & &1["username"])
1328 assert conn.assigns[:user].nickname in recipients
1329 assert reporter.nickname in recipients
1330 assert response["content"] == "I will check it out"
1331 assert response["visibility"] == "direct"
1334 test "returns 400 when status is missing", %{conn: conn} do
1335 conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1337 assert json_response(conn, :bad_request) == "Invalid parameters"
1340 test "returns 404 when report id is invalid", %{conn: conn} do
1342 post(conn, "/api/pleroma/admin/reports/test/respond", %{
1346 assert json_response(conn, :not_found) == "Not found"
1350 describe "PUT /api/pleroma/admin/statuses/:id" do
1351 setup %{conn: conn} do
1352 admin = insert(:user, info: %{is_admin: true})
1353 activity = insert(:note_activity)
1355 %{conn: assign(conn, :user, admin), id: activity.id}
1358 test "toggle sensitive flag", %{conn: conn, id: id} do
1361 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1362 |> json_response(:ok)
1364 assert response["sensitive"]
1368 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1369 |> json_response(:ok)
1371 refute response["sensitive"]
1374 test "change visibility flag", %{conn: conn, id: id} do
1377 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1378 |> json_response(:ok)
1380 assert response["visibility"] == "public"
1384 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1385 |> json_response(:ok)
1387 assert response["visibility"] == "private"
1391 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1392 |> json_response(:ok)
1394 assert response["visibility"] == "unlisted"
1397 test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1400 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1402 assert json_response(conn, :bad_request) == "Unsupported visibility"
1406 describe "DELETE /api/pleroma/admin/statuses/:id" do
1407 setup %{conn: conn} do
1408 admin = insert(:user, info: %{is_admin: true})
1409 activity = insert(:note_activity)
1411 %{conn: assign(conn, :user, admin), id: activity.id}
1414 test "deletes status", %{conn: conn, id: id} do
1416 |> delete("/api/pleroma/admin/statuses/#{id}")
1417 |> json_response(:ok)
1419 refute Activity.get_by_id(id)
1422 test "returns error when status is not exist", %{conn: conn} do
1425 |> delete("/api/pleroma/admin/statuses/test")
1427 assert json_response(conn, :bad_request) == "Could not delete"