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", %{
37 "email" => "lain@example.org",
41 assert json_response(conn, 200) == "lain"
45 describe "/api/pleroma/admin/users/:nickname" do
46 test "Show", %{conn: conn} do
47 admin = insert(:user, info: %{is_admin: true})
52 |> assign(:user, admin)
53 |> get("/api/pleroma/admin/users/#{user.nickname}")
56 "deactivated" => false,
57 "id" => to_string(user.id),
59 "nickname" => user.nickname,
60 "roles" => %{"admin" => false, "moderator" => false},
64 assert expected == json_response(conn, 200)
67 test "when the user doesn't exist", %{conn: conn} do
68 admin = insert(:user, info: %{is_admin: true})
73 |> assign(:user, admin)
74 |> get("/api/pleroma/admin/users/#{user.nickname}")
76 assert "Not found" == json_response(conn, 404)
80 describe "/api/pleroma/admin/users/follow" do
81 test "allows to force-follow another user" do
82 admin = insert(:user, info: %{is_admin: true})
84 follower = insert(:user)
87 |> assign(:user, admin)
88 |> put_req_header("accept", "application/json")
89 |> post("/api/pleroma/admin/users/follow", %{
90 "follower" => follower.nickname,
91 "followed" => user.nickname
94 user = User.get_cached_by_id(user.id)
95 follower = User.get_cached_by_id(follower.id)
97 assert User.following?(follower, user)
101 describe "/api/pleroma/admin/users/unfollow" do
102 test "allows to force-unfollow another user" do
103 admin = insert(:user, info: %{is_admin: true})
105 follower = insert(:user)
107 User.follow(follower, user)
110 |> assign(:user, admin)
111 |> put_req_header("accept", "application/json")
112 |> post("/api/pleroma/admin/users/unfollow", %{
113 "follower" => follower.nickname,
114 "followed" => user.nickname
117 user = User.get_cached_by_id(user.id)
118 follower = User.get_cached_by_id(follower.id)
120 refute User.following?(follower, user)
124 describe "PUT /api/pleroma/admin/users/tag" do
126 admin = insert(:user, info: %{is_admin: true})
127 user1 = insert(:user, %{tags: ["x"]})
128 user2 = insert(:user, %{tags: ["y"]})
129 user3 = insert(:user, %{tags: ["unchanged"]})
133 |> assign(:user, admin)
134 |> put_req_header("accept", "application/json")
136 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
138 }&tags[]=foo&tags[]=bar"
141 %{conn: conn, user1: user1, user2: user2, user3: user3}
144 test "it appends specified tags to users with specified nicknames", %{
149 assert json_response(conn, :no_content)
150 assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
151 assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
154 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
155 assert json_response(conn, :no_content)
156 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
160 describe "DELETE /api/pleroma/admin/users/tag" do
162 admin = insert(:user, info: %{is_admin: true})
163 user1 = insert(:user, %{tags: ["x"]})
164 user2 = insert(:user, %{tags: ["y", "z"]})
165 user3 = insert(:user, %{tags: ["unchanged"]})
169 |> assign(:user, admin)
170 |> put_req_header("accept", "application/json")
172 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
177 %{conn: conn, user1: user1, user2: user2, user3: user3}
180 test "it removes specified tags from users with specified nicknames", %{
185 assert json_response(conn, :no_content)
186 assert User.get_cached_by_id(user1.id).tags == []
187 assert User.get_cached_by_id(user2.id).tags == ["y"]
190 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
191 assert json_response(conn, :no_content)
192 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
196 describe "/api/pleroma/admin/users/:nickname/permission_group" do
197 test "GET is giving user_info" do
198 admin = insert(:user, info: %{is_admin: true})
202 |> assign(:user, admin)
203 |> put_req_header("accept", "application/json")
204 |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
206 assert json_response(conn, 200) == %{
208 "is_moderator" => false
212 test "/:right POST, can add to a permission group" do
213 admin = insert(:user, info: %{is_admin: true})
218 |> assign(:user, admin)
219 |> put_req_header("accept", "application/json")
220 |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
222 assert json_response(conn, 200) == %{
227 test "/:right DELETE, can remove from a permission group" do
228 admin = insert(:user, info: %{is_admin: true})
229 user = insert(:user, info: %{is_admin: true})
233 |> assign(:user, admin)
234 |> put_req_header("accept", "application/json")
235 |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
237 assert json_response(conn, 200) == %{
243 describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
244 setup %{conn: conn} do
245 admin = insert(:user, info: %{is_admin: true})
249 |> assign(:user, admin)
250 |> put_req_header("accept", "application/json")
255 test "deactivates the user", %{conn: conn} do
260 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
262 user = User.get_cached_by_id(user.id)
263 assert user.info.deactivated == true
264 assert json_response(conn, :no_content)
267 test "activates the user", %{conn: conn} do
268 user = insert(:user, info: %{deactivated: true})
272 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})
274 user = User.get_cached_by_id(user.id)
275 assert user.info.deactivated == false
276 assert json_response(conn, :no_content)
279 test "returns 403 when requested by a non-admin", %{conn: conn} do
284 |> assign(:user, user)
285 |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
287 assert json_response(conn, :forbidden)
291 describe "POST /api/pleroma/admin/email_invite, with valid config" do
293 registrations_open = Pleroma.Config.get([:instance, :registrations_open])
294 invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
295 Pleroma.Config.put([:instance, :registrations_open], false)
296 Pleroma.Config.put([:instance, :invites_enabled], true)
299 Pleroma.Config.put([:instance, :registrations_open], registrations_open)
300 Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
304 [user: insert(:user, info: %{is_admin: true})]
307 test "sends invitation and returns 204", %{conn: conn, user: user} do
308 recipient_email = "foo@bar.com"
309 recipient_name = "J. D."
313 |> assign(:user, user)
315 "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
318 assert json_response(conn, :no_content)
320 token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
322 refute token_record.used
324 notify_email = Pleroma.Config.get([:instance, :notify_email])
325 instance_name = Pleroma.Config.get([:instance, :name])
328 Pleroma.Emails.UserEmail.user_invitation_email(
335 Swoosh.TestAssertions.assert_email_sent(
336 from: {instance_name, notify_email},
337 to: {recipient_name, recipient_email},
338 html_body: email.html_body
342 test "it returns 403 if requested by a non-admin", %{conn: conn} do
343 non_admin_user = insert(:user)
347 |> assign(:user, non_admin_user)
348 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
350 assert json_response(conn, :forbidden)
354 describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
356 [user: insert(:user, info: %{is_admin: true})]
359 test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
360 registrations_open = Pleroma.Config.get([:instance, :registrations_open])
361 invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
362 Pleroma.Config.put([:instance, :registrations_open], false)
363 Pleroma.Config.put([:instance, :invites_enabled], false)
366 Pleroma.Config.put([:instance, :registrations_open], registrations_open)
367 Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
373 |> assign(:user, user)
374 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
376 assert json_response(conn, :internal_server_error)
379 test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
380 registrations_open = Pleroma.Config.get([:instance, :registrations_open])
381 invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
382 Pleroma.Config.put([:instance, :registrations_open], true)
383 Pleroma.Config.put([:instance, :invites_enabled], true)
386 Pleroma.Config.put([:instance, :registrations_open], registrations_open)
387 Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
393 |> assign(:user, user)
394 |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
396 assert json_response(conn, :internal_server_error)
400 test "/api/pleroma/admin/invite_token" do
401 admin = insert(:user, info: %{is_admin: true})
405 |> assign(:user, admin)
406 |> put_req_header("accept", "application/json")
407 |> get("/api/pleroma/admin/invite_token")
409 assert conn.status == 200
412 test "/api/pleroma/admin/users/:nickname/password_reset" do
413 admin = insert(:user, info: %{is_admin: true})
418 |> assign(:user, admin)
419 |> put_req_header("accept", "application/json")
420 |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
422 assert conn.status == 200
425 describe "GET /api/pleroma/admin/users" do
427 admin = insert(:user, info: %{is_admin: true})
431 |> assign(:user, admin)
433 {:ok, conn: conn, admin: admin}
436 test "renders users array for the first page", %{conn: conn, admin: admin} do
437 user = insert(:user, local: false, tags: ["foo", "bar"])
438 conn = get(conn, "/api/pleroma/admin/users?page=1")
440 assert json_response(conn, 200) == %{
445 "deactivated" => admin.info.deactivated,
447 "nickname" => admin.nickname,
448 "roles" => %{"admin" => true, "moderator" => false},
453 "deactivated" => user.info.deactivated,
455 "nickname" => user.nickname,
456 "roles" => %{"admin" => false, "moderator" => false},
458 "tags" => ["foo", "bar"]
464 test "renders empty array for the second page", %{conn: conn} do
467 conn = get(conn, "/api/pleroma/admin/users?page=2")
469 assert json_response(conn, 200) == %{
476 test "regular search", %{conn: conn} do
477 user = insert(:user, nickname: "bob")
479 conn = get(conn, "/api/pleroma/admin/users?query=bo")
481 assert json_response(conn, 200) == %{
486 "deactivated" => user.info.deactivated,
488 "nickname" => user.nickname,
489 "roles" => %{"admin" => false, "moderator" => false},
497 test "search by domain", %{conn: conn} do
498 user = insert(:user, nickname: "nickname@domain.com")
501 conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
503 assert json_response(conn, 200) == %{
508 "deactivated" => user.info.deactivated,
510 "nickname" => user.nickname,
511 "roles" => %{"admin" => false, "moderator" => false},
519 test "search by full nickname", %{conn: conn} do
520 user = insert(:user, nickname: "nickname@domain.com")
523 conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
525 assert json_response(conn, 200) == %{
530 "deactivated" => user.info.deactivated,
532 "nickname" => user.nickname,
533 "roles" => %{"admin" => false, "moderator" => false},
541 test "search by display name", %{conn: conn} do
542 user = insert(:user, name: "Display name")
545 conn = get(conn, "/api/pleroma/admin/users?name=display")
547 assert json_response(conn, 200) == %{
552 "deactivated" => user.info.deactivated,
554 "nickname" => user.nickname,
555 "roles" => %{"admin" => false, "moderator" => false},
563 test "search by email", %{conn: conn} do
564 user = insert(:user, email: "email@example.com")
567 conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
569 assert json_response(conn, 200) == %{
574 "deactivated" => user.info.deactivated,
576 "nickname" => user.nickname,
577 "roles" => %{"admin" => false, "moderator" => false},
585 test "regular search with page size", %{conn: conn} do
586 user = insert(:user, nickname: "aalice")
587 user2 = insert(:user, nickname: "alice")
589 conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
591 assert json_response(conn1, 200) == %{
596 "deactivated" => user.info.deactivated,
598 "nickname" => user.nickname,
599 "roles" => %{"admin" => false, "moderator" => false},
606 conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
608 assert json_response(conn2, 200) == %{
613 "deactivated" => user2.info.deactivated,
615 "nickname" => user2.nickname,
616 "roles" => %{"admin" => false, "moderator" => false},
624 test "only local users" do
625 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
626 user = insert(:user, nickname: "bob")
628 insert(:user, nickname: "bobb", local: false)
632 |> assign(:user, admin)
633 |> get("/api/pleroma/admin/users?query=bo&filters=local")
635 assert json_response(conn, 200) == %{
640 "deactivated" => user.info.deactivated,
642 "nickname" => user.nickname,
643 "roles" => %{"admin" => false, "moderator" => false},
651 test "only local users with no query", %{admin: old_admin} do
652 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
653 user = insert(:user, nickname: "bob")
655 insert(:user, nickname: "bobb", local: false)
659 |> assign(:user, admin)
660 |> get("/api/pleroma/admin/users?filters=local")
662 assert json_response(conn, 200) == %{
667 "deactivated" => user.info.deactivated,
669 "nickname" => user.nickname,
670 "roles" => %{"admin" => false, "moderator" => false},
675 "deactivated" => admin.info.deactivated,
677 "nickname" => admin.nickname,
678 "roles" => %{"admin" => true, "moderator" => false},
683 "deactivated" => false,
684 "id" => old_admin.id,
686 "nickname" => old_admin.nickname,
687 "roles" => %{"admin" => true, "moderator" => false},
694 test "load only admins", %{conn: conn, admin: admin} do
695 second_admin = insert(:user, info: %{is_admin: true})
699 conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
701 assert json_response(conn, 200) == %{
706 "deactivated" => false,
708 "nickname" => admin.nickname,
709 "roles" => %{"admin" => true, "moderator" => false},
710 "local" => admin.local,
714 "deactivated" => false,
715 "id" => second_admin.id,
716 "nickname" => second_admin.nickname,
717 "roles" => %{"admin" => true, "moderator" => false},
718 "local" => second_admin.local,
725 test "load only moderators", %{conn: conn} do
726 moderator = insert(:user, info: %{is_moderator: true})
730 conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
732 assert json_response(conn, 200) == %{
737 "deactivated" => false,
738 "id" => moderator.id,
739 "nickname" => moderator.nickname,
740 "roles" => %{"admin" => false, "moderator" => true},
741 "local" => moderator.local,
748 test "load users with tags list", %{conn: conn} do
749 user1 = insert(:user, tags: ["first"])
750 user2 = insert(:user, tags: ["second"])
754 conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
756 assert json_response(conn, 200) == %{
761 "deactivated" => false,
763 "nickname" => user1.nickname,
764 "roles" => %{"admin" => false, "moderator" => false},
765 "local" => user1.local,
769 "deactivated" => false,
771 "nickname" => user2.nickname,
772 "roles" => %{"admin" => false, "moderator" => false},
773 "local" => user2.local,
780 test "it works with multiple filters" do
781 admin = insert(:user, nickname: "john", info: %{is_admin: true})
782 user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
784 insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
785 insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
789 |> assign(:user, admin)
790 |> get("/api/pleroma/admin/users?filters=deactivated,external")
792 assert json_response(conn, 200) == %{
797 "deactivated" => user.info.deactivated,
799 "nickname" => user.nickname,
800 "roles" => %{"admin" => false, "moderator" => false},
801 "local" => user.local,
809 test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
810 admin = insert(:user, info: %{is_admin: true})
815 |> assign(:user, admin)
816 |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
818 assert json_response(conn, 200) ==
820 "deactivated" => !user.info.deactivated,
822 "nickname" => user.nickname,
823 "roles" => %{"admin" => false, "moderator" => false},
829 describe "GET /api/pleroma/admin/users/invite_token" do
831 admin = insert(:user, info: %{is_admin: true})
835 |> assign(:user, admin)
840 test "without options", %{conn: conn} do
841 conn = get(conn, "/api/pleroma/admin/users/invite_token")
843 token = json_response(conn, 200)
844 invite = UserInviteToken.find_by_token!(token)
846 refute invite.expires_at
847 refute invite.max_use
848 assert invite.invite_type == "one_time"
851 test "with expires_at", %{conn: conn} do
853 get(conn, "/api/pleroma/admin/users/invite_token", %{
854 "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
857 token = json_response(conn, 200)
858 invite = UserInviteToken.find_by_token!(token)
861 assert invite.expires_at == Date.utc_today()
862 refute invite.max_use
863 assert invite.invite_type == "date_limited"
866 test "with max_use", %{conn: conn} do
868 get(conn, "/api/pleroma/admin/users/invite_token", %{
869 "invite" => %{"max_use" => 150}
872 token = json_response(conn, 200)
873 invite = UserInviteToken.find_by_token!(token)
875 refute invite.expires_at
876 assert invite.max_use == 150
877 assert invite.invite_type == "reusable"
880 test "with max use and expires_at", %{conn: conn} do
882 get(conn, "/api/pleroma/admin/users/invite_token", %{
883 "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
886 token = json_response(conn, 200)
887 invite = UserInviteToken.find_by_token!(token)
889 assert invite.expires_at == Date.utc_today()
890 assert invite.max_use == 150
891 assert invite.invite_type == "reusable_date_limited"
895 describe "GET /api/pleroma/admin/users/invites" do
897 admin = insert(:user, info: %{is_admin: true})
901 |> assign(:user, admin)
906 test "no invites", %{conn: conn} do
907 conn = get(conn, "/api/pleroma/admin/users/invites")
909 assert json_response(conn, 200) == %{"invites" => []}
912 test "with invite", %{conn: conn} do
913 {:ok, invite} = UserInviteToken.create_invite()
915 conn = get(conn, "/api/pleroma/admin/users/invites")
917 assert json_response(conn, 200) == %{
922 "invite_type" => "one_time",
924 "token" => invite.token,
933 describe "POST /api/pleroma/admin/users/revoke_invite" do
935 admin = insert(:user, info: %{is_admin: true})
936 {:ok, invite} = UserInviteToken.create_invite()
940 |> assign(:user, admin)
941 |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
943 assert json_response(conn, 200) == %{
946 "invite_type" => "one_time",
948 "token" => invite.token,
955 describe "GET /api/pleroma/admin/reports/:id" do
956 setup %{conn: conn} do
957 admin = insert(:user, info: %{is_admin: true})
959 %{conn: assign(conn, :user, admin)}
962 test "returns report by its id", %{conn: conn} do
963 [reporter, target_user] = insert_pair(:user)
964 activity = insert(:note_activity, user: target_user)
966 {:ok, %{id: report_id}} =
967 CommonAPI.report(reporter, %{
968 "account_id" => target_user.id,
969 "comment" => "I feel offended",
970 "status_ids" => [activity.id]
975 |> get("/api/pleroma/admin/reports/#{report_id}")
976 |> json_response(:ok)
978 assert response["id"] == report_id
981 test "returns 404 when report id is invalid", %{conn: conn} do
982 conn = get(conn, "/api/pleroma/admin/reports/test")
984 assert json_response(conn, :not_found) == "Not found"
988 describe "PUT /api/pleroma/admin/reports/:id" do
989 setup %{conn: conn} do
990 admin = insert(:user, info: %{is_admin: true})
991 [reporter, target_user] = insert_pair(:user)
992 activity = insert(:note_activity, user: target_user)
994 {:ok, %{id: report_id}} =
995 CommonAPI.report(reporter, %{
996 "account_id" => target_user.id,
997 "comment" => "I feel offended",
998 "status_ids" => [activity.id]
1001 %{conn: assign(conn, :user, admin), id: report_id}
1004 test "mark report as resolved", %{conn: conn, id: id} do
1007 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1008 |> json_response(:ok)
1010 assert response["state"] == "resolved"
1013 test "closes report", %{conn: conn, id: id} do
1016 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1017 |> json_response(:ok)
1019 assert response["state"] == "closed"
1022 test "returns 400 when state is unknown", %{conn: conn, id: id} do
1025 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1027 assert json_response(conn, :bad_request) == "Unsupported state"
1030 test "returns 404 when report is not exist", %{conn: conn} do
1033 |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1035 assert json_response(conn, :not_found) == "Not found"
1039 describe "GET /api/pleroma/admin/reports" do
1040 setup %{conn: conn} do
1041 admin = insert(:user, info: %{is_admin: true})
1043 %{conn: assign(conn, :user, admin)}
1046 test "returns empty response when no reports created", %{conn: conn} do
1049 |> get("/api/pleroma/admin/reports")
1050 |> json_response(:ok)
1052 assert Enum.empty?(response["reports"])
1055 test "returns reports", %{conn: conn} do
1056 [reporter, target_user] = insert_pair(:user)
1057 activity = insert(:note_activity, user: target_user)
1059 {:ok, %{id: report_id}} =
1060 CommonAPI.report(reporter, %{
1061 "account_id" => target_user.id,
1062 "comment" => "I feel offended",
1063 "status_ids" => [activity.id]
1068 |> get("/api/pleroma/admin/reports")
1069 |> json_response(:ok)
1071 [report] = response["reports"]
1073 assert length(response["reports"]) == 1
1074 assert report["id"] == report_id
1077 test "returns reports with specified state", %{conn: conn} do
1078 [reporter, target_user] = insert_pair(:user)
1079 activity = insert(:note_activity, user: target_user)
1081 {:ok, %{id: first_report_id}} =
1082 CommonAPI.report(reporter, %{
1083 "account_id" => target_user.id,
1084 "comment" => "I feel offended",
1085 "status_ids" => [activity.id]
1088 {:ok, %{id: second_report_id}} =
1089 CommonAPI.report(reporter, %{
1090 "account_id" => target_user.id,
1091 "comment" => "I don't like this user"
1094 CommonAPI.update_report_state(second_report_id, "closed")
1098 |> get("/api/pleroma/admin/reports", %{
1101 |> json_response(:ok)
1103 [open_report] = response["reports"]
1105 assert length(response["reports"]) == 1
1106 assert open_report["id"] == first_report_id
1110 |> get("/api/pleroma/admin/reports", %{
1113 |> json_response(:ok)
1115 [closed_report] = response["reports"]
1117 assert length(response["reports"]) == 1
1118 assert closed_report["id"] == second_report_id
1122 |> get("/api/pleroma/admin/reports", %{
1123 "state" => "resolved"
1125 |> json_response(:ok)
1127 assert Enum.empty?(response["reports"])
1130 test "returns 403 when requested by a non-admin" do
1131 user = insert(:user)
1135 |> assign(:user, user)
1136 |> get("/api/pleroma/admin/reports")
1138 assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1141 test "returns 403 when requested by anonymous" do
1144 |> get("/api/pleroma/admin/reports")
1146 assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1150 describe "POST /api/pleroma/admin/reports/:id/respond" do
1151 setup %{conn: conn} do
1152 admin = insert(:user, info: %{is_admin: true})
1154 %{conn: assign(conn, :user, admin)}
1157 test "returns created dm", %{conn: conn} do
1158 [reporter, target_user] = insert_pair(:user)
1159 activity = insert(:note_activity, user: target_user)
1161 {:ok, %{id: report_id}} =
1162 CommonAPI.report(reporter, %{
1163 "account_id" => target_user.id,
1164 "comment" => "I feel offended",
1165 "status_ids" => [activity.id]
1170 |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1171 "status" => "I will check it out"
1173 |> json_response(:ok)
1175 recipients = Enum.map(response["mentions"], & &1["username"])
1177 assert conn.assigns[:user].nickname in recipients
1178 assert reporter.nickname in recipients
1179 assert response["content"] == "I will check it out"
1180 assert response["visibility"] == "direct"
1183 test "returns 400 when status is missing", %{conn: conn} do
1184 conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1186 assert json_response(conn, :bad_request) == "Invalid parameters"
1189 test "returns 404 when report id is invalid", %{conn: conn} do
1191 post(conn, "/api/pleroma/admin/reports/test/respond", %{
1195 assert json_response(conn, :not_found) == "Not found"
1199 describe "PUT /api/pleroma/admin/statuses/:id" do
1200 setup %{conn: conn} do
1201 admin = insert(:user, info: %{is_admin: true})
1202 activity = insert(:note_activity)
1204 %{conn: assign(conn, :user, admin), id: activity.id}
1207 test "toggle sensitive flag", %{conn: conn, id: id} do
1210 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1211 |> json_response(:ok)
1213 assert response["sensitive"]
1217 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1218 |> json_response(:ok)
1220 refute response["sensitive"]
1223 test "change visibility flag", %{conn: conn, id: id} do
1226 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1227 |> json_response(:ok)
1229 assert response["visibility"] == "public"
1233 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1234 |> json_response(:ok)
1236 assert response["visibility"] == "private"
1240 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1241 |> json_response(:ok)
1243 assert response["visibility"] == "unlisted"
1246 test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1249 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1251 assert json_response(conn, :bad_request) == "Unsupported visibility"
1255 describe "DELETE /api/pleroma/admin/statuses/:id" do
1256 setup %{conn: conn} do
1257 admin = insert(:user, info: %{is_admin: true})
1258 activity = insert(:note_activity)
1260 %{conn: assign(conn, :user, admin), id: activity.id}
1263 test "deletes status", %{conn: conn, id: id} do
1265 |> delete("/api/pleroma/admin/statuses/#{id}")
1266 |> json_response(:ok)
1268 refute Activity.get_by_id(id)
1271 test "returns error when status is not exist", %{conn: conn} do
1274 |> delete("/api/pleroma/admin/statuses/test")
1276 assert json_response(conn, :bad_request) == "Could not delete"