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/users/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/users/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")
443 "deactivated" => admin.info.deactivated,
445 "nickname" => admin.nickname,
446 "roles" => %{"admin" => true, "moderator" => false},
451 "deactivated" => user.info.deactivated,
453 "nickname" => user.nickname,
454 "roles" => %{"admin" => false, "moderator" => false},
456 "tags" => ["foo", "bar"]
459 |> Enum.sort_by(& &1["nickname"])
461 assert json_response(conn, 200) == %{
468 test "renders empty array for the second page", %{conn: conn} do
471 conn = get(conn, "/api/pleroma/admin/users?page=2")
473 assert json_response(conn, 200) == %{
480 test "regular search", %{conn: conn} do
481 user = insert(:user, nickname: "bob")
483 conn = get(conn, "/api/pleroma/admin/users?query=bo")
485 assert json_response(conn, 200) == %{
490 "deactivated" => user.info.deactivated,
492 "nickname" => user.nickname,
493 "roles" => %{"admin" => false, "moderator" => false},
501 test "search by domain", %{conn: conn} do
502 user = insert(:user, nickname: "nickname@domain.com")
505 conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
507 assert json_response(conn, 200) == %{
512 "deactivated" => user.info.deactivated,
514 "nickname" => user.nickname,
515 "roles" => %{"admin" => false, "moderator" => false},
523 test "search by full nickname", %{conn: conn} do
524 user = insert(:user, nickname: "nickname@domain.com")
527 conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
529 assert json_response(conn, 200) == %{
534 "deactivated" => user.info.deactivated,
536 "nickname" => user.nickname,
537 "roles" => %{"admin" => false, "moderator" => false},
545 test "search by display name", %{conn: conn} do
546 user = insert(:user, name: "Display name")
549 conn = get(conn, "/api/pleroma/admin/users?name=display")
551 assert json_response(conn, 200) == %{
556 "deactivated" => user.info.deactivated,
558 "nickname" => user.nickname,
559 "roles" => %{"admin" => false, "moderator" => false},
567 test "search by email", %{conn: conn} do
568 user = insert(:user, email: "email@example.com")
571 conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
573 assert json_response(conn, 200) == %{
578 "deactivated" => user.info.deactivated,
580 "nickname" => user.nickname,
581 "roles" => %{"admin" => false, "moderator" => false},
589 test "regular search with page size", %{conn: conn} do
590 user = insert(:user, nickname: "aalice")
591 user2 = insert(:user, nickname: "alice")
593 conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
595 assert json_response(conn1, 200) == %{
600 "deactivated" => user.info.deactivated,
602 "nickname" => user.nickname,
603 "roles" => %{"admin" => false, "moderator" => false},
610 conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
612 assert json_response(conn2, 200) == %{
617 "deactivated" => user2.info.deactivated,
619 "nickname" => user2.nickname,
620 "roles" => %{"admin" => false, "moderator" => false},
628 test "only local users" do
629 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
630 user = insert(:user, nickname: "bob")
632 insert(:user, nickname: "bobb", local: false)
636 |> assign(:user, admin)
637 |> get("/api/pleroma/admin/users?query=bo&filters=local")
639 assert json_response(conn, 200) == %{
644 "deactivated" => user.info.deactivated,
646 "nickname" => user.nickname,
647 "roles" => %{"admin" => false, "moderator" => false},
655 test "only local users with no query", %{admin: old_admin} do
656 admin = insert(:user, info: %{is_admin: true}, nickname: "john")
657 user = insert(:user, nickname: "bob")
659 insert(:user, nickname: "bobb", local: false)
663 |> assign(:user, admin)
664 |> get("/api/pleroma/admin/users?filters=local")
669 "deactivated" => user.info.deactivated,
671 "nickname" => user.nickname,
672 "roles" => %{"admin" => false, "moderator" => false},
677 "deactivated" => admin.info.deactivated,
679 "nickname" => admin.nickname,
680 "roles" => %{"admin" => true, "moderator" => false},
685 "deactivated" => false,
686 "id" => old_admin.id,
688 "nickname" => old_admin.nickname,
689 "roles" => %{"admin" => true, "moderator" => false},
693 |> Enum.sort_by(& &1["nickname"])
695 assert json_response(conn, 200) == %{
702 test "load only admins", %{conn: conn, admin: admin} do
703 second_admin = insert(:user, info: %{is_admin: true})
707 conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
712 "deactivated" => false,
714 "nickname" => admin.nickname,
715 "roles" => %{"admin" => true, "moderator" => false},
716 "local" => admin.local,
720 "deactivated" => false,
721 "id" => second_admin.id,
722 "nickname" => second_admin.nickname,
723 "roles" => %{"admin" => true, "moderator" => false},
724 "local" => second_admin.local,
728 |> Enum.sort_by(& &1["nickname"])
730 assert json_response(conn, 200) == %{
737 test "load only moderators", %{conn: conn} do
738 moderator = insert(:user, info: %{is_moderator: true})
742 conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
744 assert json_response(conn, 200) == %{
749 "deactivated" => false,
750 "id" => moderator.id,
751 "nickname" => moderator.nickname,
752 "roles" => %{"admin" => false, "moderator" => true},
753 "local" => moderator.local,
760 test "load users with tags list", %{conn: conn} do
761 user1 = insert(:user, tags: ["first"])
762 user2 = insert(:user, tags: ["second"])
766 conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
771 "deactivated" => false,
773 "nickname" => user1.nickname,
774 "roles" => %{"admin" => false, "moderator" => false},
775 "local" => user1.local,
779 "deactivated" => false,
781 "nickname" => user2.nickname,
782 "roles" => %{"admin" => false, "moderator" => false},
783 "local" => user2.local,
787 |> Enum.sort_by(& &1["nickname"])
789 assert json_response(conn, 200) == %{
796 test "it works with multiple filters" do
797 admin = insert(:user, nickname: "john", info: %{is_admin: true})
798 user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
800 insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
801 insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
805 |> assign(:user, admin)
806 |> get("/api/pleroma/admin/users?filters=deactivated,external")
808 assert json_response(conn, 200) == %{
813 "deactivated" => user.info.deactivated,
815 "nickname" => user.nickname,
816 "roles" => %{"admin" => false, "moderator" => false},
817 "local" => user.local,
825 test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
826 admin = insert(:user, info: %{is_admin: true})
831 |> assign(:user, admin)
832 |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
834 assert json_response(conn, 200) ==
836 "deactivated" => !user.info.deactivated,
838 "nickname" => user.nickname,
839 "roles" => %{"admin" => false, "moderator" => false},
845 describe "GET /api/pleroma/admin/users/invite_token" do
847 admin = insert(:user, info: %{is_admin: true})
851 |> assign(:user, admin)
856 test "without options", %{conn: conn} do
857 conn = get(conn, "/api/pleroma/admin/users/invite_token")
859 token = json_response(conn, 200)
860 invite = UserInviteToken.find_by_token!(token)
862 refute invite.expires_at
863 refute invite.max_use
864 assert invite.invite_type == "one_time"
867 test "with expires_at", %{conn: conn} do
869 get(conn, "/api/pleroma/admin/users/invite_token", %{
870 "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
873 token = json_response(conn, 200)
874 invite = UserInviteToken.find_by_token!(token)
877 assert invite.expires_at == Date.utc_today()
878 refute invite.max_use
879 assert invite.invite_type == "date_limited"
882 test "with max_use", %{conn: conn} do
884 get(conn, "/api/pleroma/admin/users/invite_token", %{
885 "invite" => %{"max_use" => 150}
888 token = json_response(conn, 200)
889 invite = UserInviteToken.find_by_token!(token)
891 refute invite.expires_at
892 assert invite.max_use == 150
893 assert invite.invite_type == "reusable"
896 test "with max use and expires_at", %{conn: conn} do
898 get(conn, "/api/pleroma/admin/users/invite_token", %{
899 "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
902 token = json_response(conn, 200)
903 invite = UserInviteToken.find_by_token!(token)
905 assert invite.expires_at == Date.utc_today()
906 assert invite.max_use == 150
907 assert invite.invite_type == "reusable_date_limited"
911 describe "GET /api/pleroma/admin/users/invites" do
913 admin = insert(:user, info: %{is_admin: true})
917 |> assign(:user, admin)
922 test "no invites", %{conn: conn} do
923 conn = get(conn, "/api/pleroma/admin/users/invites")
925 assert json_response(conn, 200) == %{"invites" => []}
928 test "with invite", %{conn: conn} do
929 {:ok, invite} = UserInviteToken.create_invite()
931 conn = get(conn, "/api/pleroma/admin/users/invites")
933 assert json_response(conn, 200) == %{
938 "invite_type" => "one_time",
940 "token" => invite.token,
949 describe "POST /api/pleroma/admin/users/revoke_invite" do
951 admin = insert(:user, info: %{is_admin: true})
952 {:ok, invite} = UserInviteToken.create_invite()
956 |> assign(:user, admin)
957 |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
959 assert json_response(conn, 200) == %{
962 "invite_type" => "one_time",
964 "token" => invite.token,
971 describe "GET /api/pleroma/admin/reports/:id" do
972 setup %{conn: conn} do
973 admin = insert(:user, info: %{is_admin: true})
975 %{conn: assign(conn, :user, admin)}
978 test "returns report by its id", %{conn: conn} do
979 [reporter, target_user] = insert_pair(:user)
980 activity = insert(:note_activity, user: target_user)
982 {:ok, %{id: report_id}} =
983 CommonAPI.report(reporter, %{
984 "account_id" => target_user.id,
985 "comment" => "I feel offended",
986 "status_ids" => [activity.id]
991 |> get("/api/pleroma/admin/reports/#{report_id}")
992 |> json_response(:ok)
994 assert response["id"] == report_id
997 test "returns 404 when report id is invalid", %{conn: conn} do
998 conn = get(conn, "/api/pleroma/admin/reports/test")
1000 assert json_response(conn, :not_found) == "Not found"
1004 describe "PUT /api/pleroma/admin/reports/:id" do
1005 setup %{conn: conn} do
1006 admin = insert(:user, info: %{is_admin: true})
1007 [reporter, target_user] = insert_pair(:user)
1008 activity = insert(:note_activity, user: target_user)
1010 {:ok, %{id: report_id}} =
1011 CommonAPI.report(reporter, %{
1012 "account_id" => target_user.id,
1013 "comment" => "I feel offended",
1014 "status_ids" => [activity.id]
1017 %{conn: assign(conn, :user, admin), id: report_id}
1020 test "mark report as resolved", %{conn: conn, id: id} do
1023 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1024 |> json_response(:ok)
1026 assert response["state"] == "resolved"
1029 test "closes report", %{conn: conn, id: id} do
1032 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1033 |> json_response(:ok)
1035 assert response["state"] == "closed"
1038 test "returns 400 when state is unknown", %{conn: conn, id: id} do
1041 |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1043 assert json_response(conn, :bad_request) == "Unsupported state"
1046 test "returns 404 when report is not exist", %{conn: conn} do
1049 |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1051 assert json_response(conn, :not_found) == "Not found"
1055 describe "GET /api/pleroma/admin/reports" do
1056 setup %{conn: conn} do
1057 admin = insert(:user, info: %{is_admin: true})
1059 %{conn: assign(conn, :user, admin)}
1062 test "returns empty response when no reports created", %{conn: conn} do
1065 |> get("/api/pleroma/admin/reports")
1066 |> json_response(:ok)
1068 assert Enum.empty?(response["reports"])
1071 test "returns reports", %{conn: conn} do
1072 [reporter, target_user] = insert_pair(:user)
1073 activity = insert(:note_activity, user: target_user)
1075 {:ok, %{id: report_id}} =
1076 CommonAPI.report(reporter, %{
1077 "account_id" => target_user.id,
1078 "comment" => "I feel offended",
1079 "status_ids" => [activity.id]
1084 |> get("/api/pleroma/admin/reports")
1085 |> json_response(:ok)
1087 [report] = response["reports"]
1089 assert length(response["reports"]) == 1
1090 assert report["id"] == report_id
1093 test "returns reports with specified state", %{conn: conn} do
1094 [reporter, target_user] = insert_pair(:user)
1095 activity = insert(:note_activity, user: target_user)
1097 {:ok, %{id: first_report_id}} =
1098 CommonAPI.report(reporter, %{
1099 "account_id" => target_user.id,
1100 "comment" => "I feel offended",
1101 "status_ids" => [activity.id]
1104 {:ok, %{id: second_report_id}} =
1105 CommonAPI.report(reporter, %{
1106 "account_id" => target_user.id,
1107 "comment" => "I don't like this user"
1110 CommonAPI.update_report_state(second_report_id, "closed")
1114 |> get("/api/pleroma/admin/reports", %{
1117 |> json_response(:ok)
1119 [open_report] = response["reports"]
1121 assert length(response["reports"]) == 1
1122 assert open_report["id"] == first_report_id
1126 |> get("/api/pleroma/admin/reports", %{
1129 |> json_response(:ok)
1131 [closed_report] = response["reports"]
1133 assert length(response["reports"]) == 1
1134 assert closed_report["id"] == second_report_id
1138 |> get("/api/pleroma/admin/reports", %{
1139 "state" => "resolved"
1141 |> json_response(:ok)
1143 assert Enum.empty?(response["reports"])
1146 test "returns 403 when requested by a non-admin" do
1147 user = insert(:user)
1151 |> assign(:user, user)
1152 |> get("/api/pleroma/admin/reports")
1154 assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1157 test "returns 403 when requested by anonymous" do
1160 |> get("/api/pleroma/admin/reports")
1162 assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1166 describe "POST /api/pleroma/admin/reports/:id/respond" do
1167 setup %{conn: conn} do
1168 admin = insert(:user, info: %{is_admin: true})
1170 %{conn: assign(conn, :user, admin)}
1173 test "returns created dm", %{conn: conn} do
1174 [reporter, target_user] = insert_pair(:user)
1175 activity = insert(:note_activity, user: target_user)
1177 {:ok, %{id: report_id}} =
1178 CommonAPI.report(reporter, %{
1179 "account_id" => target_user.id,
1180 "comment" => "I feel offended",
1181 "status_ids" => [activity.id]
1186 |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1187 "status" => "I will check it out"
1189 |> json_response(:ok)
1191 recipients = Enum.map(response["mentions"], & &1["username"])
1193 assert conn.assigns[:user].nickname in recipients
1194 assert reporter.nickname in recipients
1195 assert response["content"] == "I will check it out"
1196 assert response["visibility"] == "direct"
1199 test "returns 400 when status is missing", %{conn: conn} do
1200 conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1202 assert json_response(conn, :bad_request) == "Invalid parameters"
1205 test "returns 404 when report id is invalid", %{conn: conn} do
1207 post(conn, "/api/pleroma/admin/reports/test/respond", %{
1211 assert json_response(conn, :not_found) == "Not found"
1215 describe "PUT /api/pleroma/admin/statuses/:id" do
1216 setup %{conn: conn} do
1217 admin = insert(:user, info: %{is_admin: true})
1218 activity = insert(:note_activity)
1220 %{conn: assign(conn, :user, admin), id: activity.id}
1223 test "toggle sensitive flag", %{conn: conn, id: id} do
1226 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1227 |> json_response(:ok)
1229 assert response["sensitive"]
1233 |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1234 |> json_response(:ok)
1236 refute response["sensitive"]
1239 test "change visibility flag", %{conn: conn, id: id} do
1242 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1243 |> json_response(:ok)
1245 assert response["visibility"] == "public"
1249 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1250 |> json_response(:ok)
1252 assert response["visibility"] == "private"
1256 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1257 |> json_response(:ok)
1259 assert response["visibility"] == "unlisted"
1262 test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1265 |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1267 assert json_response(conn, :bad_request) == "Unsupported visibility"
1271 describe "DELETE /api/pleroma/admin/statuses/:id" do
1272 setup %{conn: conn} do
1273 admin = insert(:user, info: %{is_admin: true})
1274 activity = insert(:note_activity)
1276 %{conn: assign(conn, :user, admin), id: activity.id}
1279 test "deletes status", %{conn: conn, id: id} do
1281 |> delete("/api/pleroma/admin/statuses/#{id}")
1282 |> json_response(:ok)
1284 refute Activity.get_by_id(id)
1287 test "returns error when status is not exist", %{conn: conn} do
1290 |> delete("/api/pleroma/admin/statuses/test")
1292 assert json_response(conn, :bad_request) == "Could not delete"
1296 describe "GET /api/pleroma/admin/config" do
1297 setup %{conn: conn} do
1298 admin = insert(:user, info: %{is_admin: true})
1300 %{conn: assign(conn, :user, admin)}
1303 test "without any settings in db", %{conn: conn} do
1304 conn = get(conn, "/api/pleroma/admin/config")
1306 assert json_response(conn, 200) == %{"configs" => []}
1309 test "with settings in db", %{conn: conn} do
1310 config1 = insert(:config)
1311 config2 = insert(:config)
1313 conn = get(conn, "/api/pleroma/admin/config")
1326 } = json_response(conn, 200)
1328 assert key1 == config1.key
1329 assert key2 == config2.key
1333 describe "POST /api/pleroma/admin/config" do
1334 setup %{conn: conn} do
1335 admin = insert(:user, info: %{is_admin: true})
1337 temp_file = "config/test.exported_from_db.secret.exs"
1340 Application.delete_env(:pleroma, :key1)
1341 Application.delete_env(:pleroma, :key2)
1342 Application.delete_env(:pleroma, :key3)
1343 Application.delete_env(:pleroma, :key4)
1344 Application.delete_env(:pleroma, :keyaa1)
1345 Application.delete_env(:pleroma, :keyaa2)
1346 :ok = File.rm(temp_file)
1349 dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
1351 Pleroma.Config.put([:instance, :dynamic_configuration], true)
1354 Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
1357 %{conn: assign(conn, :user, admin)}
1360 test "create new config setting in db", %{conn: conn} do
1362 post(conn, "/api/pleroma/admin/config", %{
1364 %{key: "key1", value: "value1"},
1368 "nested_1" => "nested_value1",
1370 %{"nested_22" => "nested_value222"},
1371 %{"nested_33" => %{"nested_44" => "nested_444"}}
1378 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1379 %{"nested_4" => ":true"}
1384 value: %{"nested_5" => ":upload", "endpoint" => "https://example.com"}
1389 assert json_response(conn, 200) == %{
1398 %{"nested_1" => "nested_value1"},
1401 %{"nested_22" => "nested_value222"},
1402 %{"nested_33" => %{"nested_44" => "nested_444"}}
1410 [%{"nested_3" => "nested_3"}, %{"nested_33" => "nested_33"}],
1411 %{"nested_4" => true}
1416 "value" => [%{"endpoint" => "https://example.com"}, %{"nested_5" => "upload"}]
1421 assert Application.get_env(:pleroma, :key1) == "value1"
1423 assert Application.get_env(:pleroma, :key2) == [
1424 nested_1: "nested_value1",
1426 [nested_22: "nested_value222"],
1427 [nested_33: [nested_44: "nested_444"]]
1431 assert Application.get_env(:pleroma, :key3) == [
1432 [nested_3: :nested_3, nested_33: "nested_33"],
1436 assert Application.get_env(:pleroma, :key4) == [
1437 endpoint: "https://example.com",
1442 test "update config setting & delete", %{conn: conn} do
1443 config1 = insert(:config, key: "keyaa1")
1444 config2 = insert(:config, key: "keyaa2")
1447 post(conn, "/api/pleroma/admin/config", %{
1449 %{key: config1.key, value: "another_value"},
1450 %{key: config2.key, delete: "true"}
1454 assert json_response(conn, 200) == %{
1457 "key" => config1.key,
1458 "value" => "another_value"
1463 assert Application.get_env(:pleroma, :keyaa1) == "another_value"
1464 refute Application.get_env(:pleroma, :keyaa2)