1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 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
7 use Oban.Testing, repo: Pleroma.Repo
9 import ExUnit.CaptureLog
10 import Pleroma.Factory
11 import Swoosh.TestAssertions
13 alias Pleroma.Activity
15 alias Pleroma.ModerationLog
17 alias Pleroma.Tests.ObanHelpers
19 alias Pleroma.Web.CommonAPI
22 Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
28 admin = insert(:user, is_admin: true)
29 token = insert(:oauth_admin_token, user: admin)
33 |> assign(:user, admin)
34 |> assign(:token, token)
36 {:ok, %{admin: admin, token: token, conn: conn}}
39 test "with valid `admin_token` query parameter, skips OAuth scopes check" do
40 clear_config([:admin_token], "password123")
44 conn = get(build_conn(), "/api/pleroma/admin/users/#{user.nickname}?admin_token=password123")
46 assert json_response(conn, 200)
49 test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
52 url = "/api/pleroma/admin/users/#{user.nickname}"
54 good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
55 good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
56 good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])
58 bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
59 bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
62 for good_token <- [good_token1, good_token2, good_token3] do
65 |> assign(:user, admin)
66 |> assign(:token, good_token)
69 assert json_response(conn, 200)
72 for good_token <- [good_token1, good_token2, good_token3] do
76 |> assign(:token, good_token)
79 assert json_response(conn, :forbidden)
82 for bad_token <- [bad_token1, bad_token2, bad_token3] do
85 |> assign(:user, admin)
86 |> assign(:token, bad_token)
89 assert json_response(conn, :forbidden)
93 describe "PUT /api/pleroma/admin/users/tag" do
94 setup %{conn: conn} do
95 user1 = insert(:user, %{tags: ["x"]})
96 user2 = insert(:user, %{tags: ["y"]})
97 user3 = insert(:user, %{tags: ["unchanged"]})
101 |> put_req_header("accept", "application/json")
103 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
104 "#{user2.nickname}&tags[]=foo&tags[]=bar"
107 %{conn: conn, user1: user1, user2: user2, user3: user3}
110 test "it appends specified tags to users with specified nicknames", %{
116 assert empty_json_response(conn)
117 assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
118 assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
120 log_entry = Repo.one(ModerationLog)
123 [user1.nickname, user2.nickname]
124 |> Enum.map(&"@#{&1}")
127 tags = ["foo", "bar"] |> Enum.join(", ")
129 assert ModerationLog.get_log_entry_message(log_entry) ==
130 "@#{admin.nickname} added tags: #{tags} to users: #{users}"
133 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
134 assert empty_json_response(conn)
135 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
139 describe "DELETE /api/pleroma/admin/users/tag" do
140 setup %{conn: conn} do
141 user1 = insert(:user, %{tags: ["x"]})
142 user2 = insert(:user, %{tags: ["y", "z"]})
143 user3 = insert(:user, %{tags: ["unchanged"]})
147 |> put_req_header("accept", "application/json")
149 "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
150 "#{user2.nickname}&tags[]=x&tags[]=z"
153 %{conn: conn, user1: user1, user2: user2, user3: user3}
156 test "it removes specified tags from users with specified nicknames", %{
162 assert empty_json_response(conn)
163 assert User.get_cached_by_id(user1.id).tags == []
164 assert User.get_cached_by_id(user2.id).tags == ["y"]
166 log_entry = Repo.one(ModerationLog)
169 [user1.nickname, user2.nickname]
170 |> Enum.map(&"@#{&1}")
173 tags = ["x", "z"] |> Enum.join(", ")
175 assert ModerationLog.get_log_entry_message(log_entry) ==
176 "@#{admin.nickname} removed tags: #{tags} from users: #{users}"
179 test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
180 assert empty_json_response(conn)
181 assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
185 describe "/api/pleroma/admin/users/:nickname/permission_group" do
186 test "GET is giving user_info", %{admin: admin, conn: conn} do
189 |> put_req_header("accept", "application/json")
190 |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
192 assert json_response(conn, 200) == %{
194 "is_moderator" => false
198 test "/:right POST, can add to a permission group", %{admin: admin, conn: conn} do
203 |> put_req_header("accept", "application/json")
204 |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
206 assert json_response(conn, 200) == %{
210 log_entry = Repo.one(ModerationLog)
212 assert ModerationLog.get_log_entry_message(log_entry) ==
213 "@#{admin.nickname} made @#{user.nickname} admin"
216 test "/:right POST, can add to a permission group (multiple)", %{admin: admin, conn: conn} do
217 user_one = insert(:user)
218 user_two = insert(:user)
222 |> put_req_header("accept", "application/json")
223 |> post("/api/pleroma/admin/users/permission_group/admin", %{
224 nicknames: [user_one.nickname, user_two.nickname]
227 assert json_response(conn, 200) == %{"is_admin" => true}
229 log_entry = Repo.one(ModerationLog)
231 assert ModerationLog.get_log_entry_message(log_entry) ==
232 "@#{admin.nickname} made @#{user_one.nickname}, @#{user_two.nickname} admin"
235 test "/:right DELETE, can remove from a permission group", %{admin: admin, conn: conn} do
236 user = insert(:user, is_admin: true)
240 |> put_req_header("accept", "application/json")
241 |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
243 assert json_response(conn, 200) == %{"is_admin" => false}
245 log_entry = Repo.one(ModerationLog)
247 assert ModerationLog.get_log_entry_message(log_entry) ==
248 "@#{admin.nickname} revoked admin role from @#{user.nickname}"
251 test "/:right DELETE, can remove from a permission group (multiple)", %{
255 user_one = insert(:user, is_admin: true)
256 user_two = insert(:user, is_admin: true)
260 |> put_req_header("accept", "application/json")
261 |> delete("/api/pleroma/admin/users/permission_group/admin", %{
262 nicknames: [user_one.nickname, user_two.nickname]
265 assert json_response(conn, 200) == %{"is_admin" => false}
267 log_entry = Repo.one(ModerationLog)
269 assert ModerationLog.get_log_entry_message(log_entry) ==
270 "@#{admin.nickname} revoked admin role from @#{user_one.nickname}, @#{
276 test "/api/pleroma/admin/users/:nickname/password_reset", %{conn: conn} do
281 |> put_req_header("accept", "application/json")
282 |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
284 resp = json_response(conn, 200)
286 assert Regex.match?(~r/(http:\/\/|https:\/\/)/, resp["link"])
289 describe "PUT disable_mfa" do
290 test "returns 200 and disable 2fa", %{conn: conn} do
293 multi_factor_authentication_settings: %MFA.Settings{
295 totp: %MFA.Settings.TOTP{secret: "otp_secret", confirmed: true}
301 |> put("/api/pleroma/admin/users/disable_mfa", %{nickname: user.nickname})
302 |> json_response(200)
304 assert response == user.nickname
305 mfa_settings = refresh_record(user).multi_factor_authentication_settings
307 refute mfa_settings.enabled
308 refute mfa_settings.totp.confirmed
311 test "returns 404 if user not found", %{conn: conn} do
314 |> put("/api/pleroma/admin/users/disable_mfa", %{nickname: "nickname"})
315 |> json_response(404)
317 assert response == %{"error" => "Not found"}
321 describe "GET /api/pleroma/admin/restart" do
322 setup do: clear_config(:configurable_from_database, true)
324 test "pleroma restarts", %{conn: conn} do
326 assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) == %{}
327 end) =~ "pleroma restarted"
329 refute Restarter.Pleroma.need_reboot?()
333 test "need_reboot flag", %{conn: conn} do
335 |> get("/api/pleroma/admin/need_reboot")
336 |> json_response(200) == %{"need_reboot" => false}
338 Restarter.Pleroma.need_reboot()
341 |> get("/api/pleroma/admin/need_reboot")
342 |> json_response(200) == %{"need_reboot" => true}
344 on_exit(fn -> Restarter.Pleroma.refresh() end)
347 describe "GET /api/pleroma/admin/users/:nickname/statuses" do
351 insert(:note_activity, user: user)
352 insert(:note_activity, user: user)
353 insert(:note_activity, user: user)
358 test "renders user's statuses", %{conn: conn, user: user} do
359 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
361 assert %{"total" => 3, "activities" => activities} = json_response(conn, 200)
362 assert length(activities) == 3
365 test "renders user's statuses with pagination", %{conn: conn, user: user} do
366 %{"total" => 3, "activities" => [activity1]} =
368 |> get("/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=1")
369 |> json_response(200)
371 %{"total" => 3, "activities" => [activity2]} =
373 |> get("/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=2")
374 |> json_response(200)
376 refute activity1 == activity2
379 test "doesn't return private statuses by default", %{conn: conn, user: user} do
380 {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
382 {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
384 %{"total" => 4, "activities" => activities} =
386 |> get("/api/pleroma/admin/users/#{user.nickname}/statuses")
387 |> json_response(200)
389 assert length(activities) == 4
392 test "returns private statuses with godmode on", %{conn: conn, user: user} do
393 {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
395 {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
397 %{"total" => 5, "activities" => activities} =
399 |> get("/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
400 |> json_response(200)
402 assert length(activities) == 5
405 test "excludes reblogs by default", %{conn: conn, user: user} do
406 other_user = insert(:user)
407 {:ok, activity} = CommonAPI.post(user, %{status: "."})
408 {:ok, %Activity{}} = CommonAPI.repeat(activity.id, other_user)
410 assert %{"total" => 0, "activities" => []} ==
412 |> get("/api/pleroma/admin/users/#{other_user.nickname}/statuses")
413 |> json_response(200)
415 assert %{"total" => 1, "activities" => [_]} =
418 "/api/pleroma/admin/users/#{other_user.nickname}/statuses?with_reblogs=true"
420 |> json_response(200)
424 describe "GET /api/pleroma/admin/users/:nickname/chats" do
427 recipients = insert_list(3, :user)
429 Enum.each(recipients, fn recipient ->
430 CommonAPI.post_chat_message(user, recipient, "yo")
436 test "renders user's chats", %{conn: conn, user: user} do
437 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/chats")
439 assert json_response(conn, 200) |> length() == 3
443 describe "GET /api/pleroma/admin/users/:nickname/chats unauthorized" do
446 recipient = insert(:user)
447 CommonAPI.post_chat_message(user, recipient, "yo")
448 %{conn: conn} = oauth_access(["read:chats"])
449 %{conn: conn, user: user}
452 test "returns 403", %{conn: conn, user: user} do
454 |> get("/api/pleroma/admin/users/#{user.nickname}/chats")
455 |> json_response(403)
459 describe "GET /api/pleroma/admin/users/:nickname/chats unauthenticated" do
462 recipient = insert(:user)
463 CommonAPI.post_chat_message(user, recipient, "yo")
464 %{conn: build_conn(), user: user}
467 test "returns 403", %{conn: conn, user: user} do
469 |> get("/api/pleroma/admin/users/#{user.nickname}/chats")
470 |> json_response(403)
474 describe "GET /api/pleroma/admin/moderation_log" do
476 moderator = insert(:user, is_moderator: true)
478 %{moderator: moderator}
481 test "returns the log", %{conn: conn, admin: admin} do
482 Repo.insert(%ModerationLog{
486 "nickname" => admin.nickname,
489 action: "relay_follow",
490 target: "https://example.org/relay"
492 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
495 Repo.insert(%ModerationLog{
499 "nickname" => admin.nickname,
502 action: "relay_unfollow",
503 target: "https://example.org/relay"
505 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
508 conn = get(conn, "/api/pleroma/admin/moderation_log")
510 response = json_response(conn, 200)
511 [first_entry, second_entry] = response["items"]
513 assert response["total"] == 2
514 assert first_entry["data"]["action"] == "relay_unfollow"
516 assert first_entry["message"] ==
517 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
519 assert second_entry["data"]["action"] == "relay_follow"
521 assert second_entry["message"] ==
522 "@#{admin.nickname} followed relay: https://example.org/relay"
525 test "returns the log with pagination", %{conn: conn, admin: admin} do
526 Repo.insert(%ModerationLog{
530 "nickname" => admin.nickname,
533 action: "relay_follow",
534 target: "https://example.org/relay"
536 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
539 Repo.insert(%ModerationLog{
543 "nickname" => admin.nickname,
546 action: "relay_unfollow",
547 target: "https://example.org/relay"
549 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
552 conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
554 response1 = json_response(conn1, 200)
555 [first_entry] = response1["items"]
557 assert response1["total"] == 2
558 assert response1["items"] |> length() == 1
559 assert first_entry["data"]["action"] == "relay_unfollow"
561 assert first_entry["message"] ==
562 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
564 conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
566 response2 = json_response(conn2, 200)
567 [second_entry] = response2["items"]
569 assert response2["total"] == 2
570 assert response2["items"] |> length() == 1
571 assert second_entry["data"]["action"] == "relay_follow"
573 assert second_entry["message"] ==
574 "@#{admin.nickname} followed relay: https://example.org/relay"
577 test "filters log by date", %{conn: conn, admin: admin} do
578 first_date = "2017-08-15T15:47:06Z"
579 second_date = "2017-08-20T15:47:06Z"
581 Repo.insert(%ModerationLog{
585 "nickname" => admin.nickname,
588 action: "relay_follow",
589 target: "https://example.org/relay"
591 inserted_at: NaiveDateTime.from_iso8601!(first_date)
594 Repo.insert(%ModerationLog{
598 "nickname" => admin.nickname,
601 action: "relay_unfollow",
602 target: "https://example.org/relay"
604 inserted_at: NaiveDateTime.from_iso8601!(second_date)
610 "/api/pleroma/admin/moderation_log?start_date=#{second_date}"
613 response1 = json_response(conn1, 200)
614 [first_entry] = response1["items"]
616 assert response1["total"] == 1
617 assert first_entry["data"]["action"] == "relay_unfollow"
619 assert first_entry["message"] ==
620 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
623 test "returns log filtered by user", %{conn: conn, admin: admin, moderator: moderator} do
624 Repo.insert(%ModerationLog{
628 "nickname" => admin.nickname,
631 action: "relay_follow",
632 target: "https://example.org/relay"
636 Repo.insert(%ModerationLog{
639 "id" => moderator.id,
640 "nickname" => moderator.nickname,
643 action: "relay_unfollow",
644 target: "https://example.org/relay"
648 conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")
650 response1 = json_response(conn1, 200)
651 [first_entry] = response1["items"]
653 assert response1["total"] == 1
654 assert get_in(first_entry, ["data", "actor", "id"]) == moderator.id
657 test "returns log filtered by search", %{conn: conn, moderator: moderator} do
658 ModerationLog.insert_log(%{
660 action: "relay_follow",
661 target: "https://example.org/relay"
664 ModerationLog.insert_log(%{
666 action: "relay_unfollow",
667 target: "https://example.org/relay"
670 conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")
672 response1 = json_response(conn1, 200)
673 [first_entry] = response1["items"]
675 assert response1["total"] == 1
677 assert get_in(first_entry, ["data", "message"]) ==
678 "@#{moderator.nickname} unfollowed relay: https://example.org/relay"
682 test "gets a remote users when [:instance, :limit_to_local_content] is set to :unauthenticated",
684 clear_config(Pleroma.Config.get([:instance, :limit_to_local_content]), :unauthenticated)
685 user = insert(:user, %{local: false, nickname: "u@peer1.com"})
686 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
688 assert json_response(conn, 200)
691 describe "GET /users/:nickname/credentials" do
692 test "gets the user credentials", %{conn: conn} do
694 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
696 response = assert json_response(conn, 200)
697 assert response["email"] == user.email
700 test "returns 403 if requested by a non-admin" do
705 |> assign(:user, user)
706 |> get("/api/pleroma/admin/users/#{user.nickname}/credentials")
708 assert json_response(conn, :forbidden)
712 describe "PATCH /users/:nickname/credentials" do
718 test "changes password and email", %{conn: conn, admin: admin, user: user} do
719 assert user.password_reset_pending == false
722 patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
723 "password" => "new_password",
724 "email" => "new_email@example.com",
728 assert json_response(conn, 200) == %{"status" => "success"}
730 ObanHelpers.perform_all()
732 updated_user = User.get_by_id(user.id)
734 assert updated_user.email == "new_email@example.com"
735 assert updated_user.name == "new_name"
736 assert updated_user.password_hash != user.password_hash
737 assert updated_user.password_reset_pending == true
739 [log_entry2, log_entry1] = ModerationLog |> Repo.all() |> Enum.sort()
741 assert ModerationLog.get_log_entry_message(log_entry1) ==
742 "@#{admin.nickname} updated users: @#{user.nickname}"
744 assert ModerationLog.get_log_entry_message(log_entry2) ==
745 "@#{admin.nickname} forced password reset for users: @#{user.nickname}"
748 test "returns 403 if requested by a non-admin", %{user: user} do
751 |> assign(:user, user)
752 |> patch("/api/pleroma/admin/users/#{user.nickname}/credentials", %{
753 "password" => "new_password",
754 "email" => "new_email@example.com",
758 assert json_response(conn, :forbidden)
761 test "changes actor type from permitted list", %{conn: conn, user: user} do
762 assert user.actor_type == "Person"
764 assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
765 "actor_type" => "Service"
767 |> json_response(200) == %{"status" => "success"}
769 updated_user = User.get_by_id(user.id)
771 assert updated_user.actor_type == "Service"
773 assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
774 "actor_type" => "Application"
776 |> json_response(400) == %{"errors" => %{"actor_type" => "is invalid"}}
779 test "update non existing user", %{conn: conn} do
780 assert patch(conn, "/api/pleroma/admin/users/non-existing/credentials", %{
781 "password" => "new_password"
783 |> json_response(404) == %{"error" => "Not found"}
787 describe "PATCH /users/:nickname/force_password_reset" do
788 test "sets password_reset_pending to true", %{conn: conn} do
790 assert user.password_reset_pending == false
793 patch(conn, "/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})
795 assert empty_json_response(conn) == ""
797 ObanHelpers.perform_all()
799 assert User.get_by_id(user.id).password_reset_pending == true
803 describe "instances" do
804 test "GET /instances/:instance/statuses", %{conn: conn} do
805 user = insert(:user, local: false, ap_id: "https://archae.me/users/archaeme")
806 user2 = insert(:user, local: false, ap_id: "https://test.com/users/test")
807 insert_pair(:note_activity, user: user)
808 activity = insert(:note_activity, user: user2)
810 %{"total" => 2, "activities" => activities} =
811 conn |> get("/api/pleroma/admin/instances/archae.me/statuses") |> json_response(200)
813 assert length(activities) == 2
815 %{"total" => 1, "activities" => [_]} =
816 conn |> get("/api/pleroma/admin/instances/test.com/statuses") |> json_response(200)
818 %{"total" => 0, "activities" => []} =
819 conn |> get("/api/pleroma/admin/instances/nonexistent.com/statuses") |> json_response(200)
821 CommonAPI.repeat(activity.id, user)
823 %{"total" => 2, "activities" => activities} =
824 conn |> get("/api/pleroma/admin/instances/archae.me/statuses") |> json_response(200)
826 assert length(activities) == 2
828 %{"total" => 3, "activities" => activities} =
830 |> get("/api/pleroma/admin/instances/archae.me/statuses?with_reblogs=true")
831 |> json_response(200)
833 assert length(activities) == 3
837 describe "PATCH /confirm_email" do
838 test "it confirms emails of two users", %{conn: conn, admin: admin} do
839 [first_user, second_user] = insert_pair(:user, is_confirmed: false)
841 refute first_user.is_confirmed
842 refute second_user.is_confirmed
845 patch(conn, "/api/pleroma/admin/users/confirm_email", %{
852 assert ret_conn.status == 200
854 first_user = User.get_by_id(first_user.id)
855 second_user = User.get_by_id(second_user.id)
857 assert first_user.is_confirmed
858 assert second_user.is_confirmed
860 log_entry = Repo.one(ModerationLog)
862 assert ModerationLog.get_log_entry_message(log_entry) ==
863 "@#{admin.nickname} confirmed email for users: @#{first_user.nickname}, @#{
869 describe "PATCH /resend_confirmation_email" do
870 test "it resend emails for two users", %{conn: conn, admin: admin} do
871 [first_user, second_user] = insert_pair(:user, is_confirmed: false)
874 patch(conn, "/api/pleroma/admin/users/resend_confirmation_email", %{
881 assert ret_conn.status == 200
883 log_entry = Repo.one(ModerationLog)
885 assert ModerationLog.get_log_entry_message(log_entry) ==
886 "@#{admin.nickname} re-sent confirmation email for users: @#{first_user.nickname}, @#{
890 ObanHelpers.perform_all()
892 Pleroma.Emails.UserEmail.account_confirmation_email(first_user)
893 # temporary hackney fix until hackney max_connections bug is fixed
894 # https://git.pleroma.social/pleroma/pleroma/-/issues/2101
895 |> Swoosh.Email.put_private(:hackney_options, ssl_options: [versions: [:"tlsv1.2"]])
896 |> assert_email_sent()
900 describe "/api/pleroma/admin/stats" do
901 test "status visibility count", %{conn: conn} do
903 CommonAPI.post(user, %{visibility: "public", status: "hey"})
904 CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
905 CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
909 |> get("/api/pleroma/admin/stats")
910 |> json_response(200)
912 assert %{"direct" => 0, "private" => 0, "public" => 1, "unlisted" => 2} =
913 response["status_visibility"]
916 test "by instance", %{conn: conn} do
917 user1 = insert(:user)
918 instance2 = "instance2.tld"
919 user2 = insert(:user, %{ap_id: "https://#{instance2}/@actor"})
921 CommonAPI.post(user1, %{visibility: "public", status: "hey"})
922 CommonAPI.post(user2, %{visibility: "unlisted", status: "hey"})
923 CommonAPI.post(user2, %{visibility: "private", status: "hey"})
927 |> get("/api/pleroma/admin/stats", instance: instance2)
928 |> json_response(200)
930 assert %{"direct" => 0, "private" => 1, "public" => 0, "unlisted" => 1} =
931 response["status_visibility"]
935 describe "/api/pleroma/backups" do
936 test "it creates a backup", %{conn: conn} do
937 admin = %{id: admin_id, nickname: admin_nickname} = insert(:user, is_admin: true)
938 token = insert(:oauth_admin_token, user: admin)
939 user = %{id: user_id, nickname: user_nickname} = insert(:user)
943 |> assign(:user, admin)
944 |> assign(:token, token)
945 |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
946 |> json_response(200)
948 assert [backup] = Repo.all(Pleroma.User.Backup)
950 ObanHelpers.perform_all()
952 email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup, admin.id)
954 assert String.contains?(email.html_body, "Admin @#{admin.nickname} requested a full backup")
955 assert_email_sent(to: {user.name, user.email}, html_body: email.html_body)
957 log_message = "@#{admin_nickname} requested account backup for @#{user_nickname}"
962 "action" => "create_backup",
965 "nickname" => ^admin_nickname
967 "message" => ^log_message,
970 "nickname" => ^user_nickname
974 ] = Pleroma.ModerationLog |> Repo.all()
977 test "it doesn't limit admins", %{conn: conn} do
978 admin = insert(:user, is_admin: true)
979 token = insert(:oauth_admin_token, user: admin)
984 |> assign(:user, admin)
985 |> assign(:token, token)
986 |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
987 |> json_response(200)
989 assert [_backup] = Repo.all(Pleroma.User.Backup)
993 |> assign(:user, admin)
994 |> assign(:token, token)
995 |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
996 |> json_response(200)
998 assert Repo.aggregate(Pleroma.User.Backup, :count) == 2
1003 # Needed for testing
1004 defmodule Pleroma.Web.Endpoint.NotReal do
1007 defmodule Pleroma.Captcha.NotReal do