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}, @#{user_two.nickname}"
274 test "/api/pleroma/admin/users/:nickname/password_reset", %{conn: conn} do
279 |> put_req_header("accept", "application/json")
280 |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
282 resp = json_response(conn, 200)
284 assert Regex.match?(~r/(http:\/\/|https:\/\/)/, resp["link"])
287 describe "PUT disable_mfa" do
288 test "returns 200 and disable 2fa", %{conn: conn} do
291 multi_factor_authentication_settings: %MFA.Settings{
293 totp: %MFA.Settings.TOTP{secret: "otp_secret", confirmed: true}
299 |> put("/api/pleroma/admin/users/disable_mfa", %{nickname: user.nickname})
300 |> json_response(200)
302 assert response == user.nickname
303 mfa_settings = refresh_record(user).multi_factor_authentication_settings
305 refute mfa_settings.enabled
306 refute mfa_settings.totp.confirmed
309 test "returns 404 if user not found", %{conn: conn} do
312 |> put("/api/pleroma/admin/users/disable_mfa", %{nickname: "nickname"})
313 |> json_response(404)
315 assert response == %{"error" => "Not found"}
319 describe "GET /api/pleroma/admin/restart" do
320 setup do: clear_config(:configurable_from_database, true)
322 test "pleroma restarts", %{conn: conn} do
324 assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) == %{}
325 end) =~ "pleroma restarted"
327 refute Restarter.Pleroma.need_reboot?()
331 test "need_reboot flag", %{conn: conn} do
333 |> get("/api/pleroma/admin/need_reboot")
334 |> json_response(200) == %{"need_reboot" => false}
336 Restarter.Pleroma.need_reboot()
339 |> get("/api/pleroma/admin/need_reboot")
340 |> json_response(200) == %{"need_reboot" => true}
342 on_exit(fn -> Restarter.Pleroma.refresh() end)
345 describe "GET /api/pleroma/admin/users/:nickname/statuses" do
349 insert(:note_activity, user: user)
350 insert(:note_activity, user: user)
351 insert(:note_activity, user: user)
356 test "renders user's statuses", %{conn: conn, user: user} do
357 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
359 assert %{"total" => 3, "activities" => activities} = json_response(conn, 200)
360 assert length(activities) == 3
363 test "renders user's statuses with pagination", %{conn: conn, user: user} do
364 %{"total" => 3, "activities" => [activity1]} =
366 |> get("/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=1")
367 |> json_response(200)
369 %{"total" => 3, "activities" => [activity2]} =
371 |> get("/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=1&page=2")
372 |> json_response(200)
374 refute activity1 == activity2
377 test "doesn't return private statuses by default", %{conn: conn, user: user} do
378 {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
380 {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
382 %{"total" => 4, "activities" => activities} =
384 |> get("/api/pleroma/admin/users/#{user.nickname}/statuses")
385 |> json_response(200)
387 assert length(activities) == 4
390 test "returns private statuses with godmode on", %{conn: conn, user: user} do
391 {:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})
393 {:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})
395 %{"total" => 5, "activities" => activities} =
397 |> get("/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
398 |> json_response(200)
400 assert length(activities) == 5
403 test "excludes reblogs by default", %{conn: conn, user: user} do
404 other_user = insert(:user)
405 {:ok, activity} = CommonAPI.post(user, %{status: "."})
406 {:ok, %Activity{}} = CommonAPI.repeat(activity.id, other_user)
408 assert %{"total" => 0, "activities" => []} ==
410 |> get("/api/pleroma/admin/users/#{other_user.nickname}/statuses")
411 |> json_response(200)
413 assert %{"total" => 1, "activities" => [_]} =
416 "/api/pleroma/admin/users/#{other_user.nickname}/statuses?with_reblogs=true"
418 |> json_response(200)
422 describe "GET /api/pleroma/admin/users/:nickname/chats" do
425 recipients = insert_list(3, :user)
427 Enum.each(recipients, fn recipient ->
428 CommonAPI.post_chat_message(user, recipient, "yo")
434 test "renders user's chats", %{conn: conn, user: user} do
435 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/chats")
437 assert json_response(conn, 200) |> length() == 3
441 describe "GET /api/pleroma/admin/users/:nickname/chats unauthorized" do
444 recipient = insert(:user)
445 CommonAPI.post_chat_message(user, recipient, "yo")
446 %{conn: conn} = oauth_access(["read:chats"])
447 %{conn: conn, user: user}
450 test "returns 403", %{conn: conn, user: user} do
452 |> get("/api/pleroma/admin/users/#{user.nickname}/chats")
453 |> json_response(403)
457 describe "GET /api/pleroma/admin/users/:nickname/chats unauthenticated" do
460 recipient = insert(:user)
461 CommonAPI.post_chat_message(user, recipient, "yo")
462 %{conn: build_conn(), user: user}
465 test "returns 403", %{conn: conn, user: user} do
467 |> get("/api/pleroma/admin/users/#{user.nickname}/chats")
468 |> json_response(403)
472 describe "GET /api/pleroma/admin/moderation_log" do
474 moderator = insert(:user, is_moderator: true)
476 %{moderator: moderator}
479 test "returns the log", %{conn: conn, admin: admin} do
480 Repo.insert(%ModerationLog{
484 "nickname" => admin.nickname,
487 action: "relay_follow",
488 target: "https://example.org/relay"
490 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
493 Repo.insert(%ModerationLog{
497 "nickname" => admin.nickname,
500 action: "relay_unfollow",
501 target: "https://example.org/relay"
503 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
506 conn = get(conn, "/api/pleroma/admin/moderation_log")
508 response = json_response(conn, 200)
509 [first_entry, second_entry] = response["items"]
511 assert response["total"] == 2
512 assert first_entry["data"]["action"] == "relay_unfollow"
514 assert first_entry["message"] ==
515 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
517 assert second_entry["data"]["action"] == "relay_follow"
519 assert second_entry["message"] ==
520 "@#{admin.nickname} followed relay: https://example.org/relay"
523 test "returns the log with pagination", %{conn: conn, admin: admin} do
524 Repo.insert(%ModerationLog{
528 "nickname" => admin.nickname,
531 action: "relay_follow",
532 target: "https://example.org/relay"
534 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
537 Repo.insert(%ModerationLog{
541 "nickname" => admin.nickname,
544 action: "relay_unfollow",
545 target: "https://example.org/relay"
547 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
550 conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
552 response1 = json_response(conn1, 200)
553 [first_entry] = response1["items"]
555 assert response1["total"] == 2
556 assert response1["items"] |> length() == 1
557 assert first_entry["data"]["action"] == "relay_unfollow"
559 assert first_entry["message"] ==
560 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
562 conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
564 response2 = json_response(conn2, 200)
565 [second_entry] = response2["items"]
567 assert response2["total"] == 2
568 assert response2["items"] |> length() == 1
569 assert second_entry["data"]["action"] == "relay_follow"
571 assert second_entry["message"] ==
572 "@#{admin.nickname} followed relay: https://example.org/relay"
575 test "filters log by date", %{conn: conn, admin: admin} do
576 first_date = "2017-08-15T15:47:06Z"
577 second_date = "2017-08-20T15:47:06Z"
579 Repo.insert(%ModerationLog{
583 "nickname" => admin.nickname,
586 action: "relay_follow",
587 target: "https://example.org/relay"
589 inserted_at: NaiveDateTime.from_iso8601!(first_date)
592 Repo.insert(%ModerationLog{
596 "nickname" => admin.nickname,
599 action: "relay_unfollow",
600 target: "https://example.org/relay"
602 inserted_at: NaiveDateTime.from_iso8601!(second_date)
608 "/api/pleroma/admin/moderation_log?start_date=#{second_date}"
611 response1 = json_response(conn1, 200)
612 [first_entry] = response1["items"]
614 assert response1["total"] == 1
615 assert first_entry["data"]["action"] == "relay_unfollow"
617 assert first_entry["message"] ==
618 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
621 test "returns log filtered by user", %{conn: conn, admin: admin, moderator: moderator} do
622 Repo.insert(%ModerationLog{
626 "nickname" => admin.nickname,
629 action: "relay_follow",
630 target: "https://example.org/relay"
634 Repo.insert(%ModerationLog{
637 "id" => moderator.id,
638 "nickname" => moderator.nickname,
641 action: "relay_unfollow",
642 target: "https://example.org/relay"
646 conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")
648 response1 = json_response(conn1, 200)
649 [first_entry] = response1["items"]
651 assert response1["total"] == 1
652 assert get_in(first_entry, ["data", "actor", "id"]) == moderator.id
655 test "returns log filtered by search", %{conn: conn, moderator: moderator} do
656 ModerationLog.insert_log(%{
658 action: "relay_follow",
659 target: "https://example.org/relay"
662 ModerationLog.insert_log(%{
664 action: "relay_unfollow",
665 target: "https://example.org/relay"
668 conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")
670 response1 = json_response(conn1, 200)
671 [first_entry] = response1["items"]
673 assert response1["total"] == 1
675 assert get_in(first_entry, ["data", "message"]) ==
676 "@#{moderator.nickname} unfollowed relay: https://example.org/relay"
680 test "gets a remote users when [:instance, :limit_to_local_content] is set to :unauthenticated",
682 clear_config(Pleroma.Config.get([:instance, :limit_to_local_content]), :unauthenticated)
683 user = insert(:user, %{local: false, nickname: "u@peer1.com"})
684 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
686 assert json_response(conn, 200)
689 describe "GET /users/:nickname/credentials" do
690 test "gets the user credentials", %{conn: conn} do
692 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
694 response = assert json_response(conn, 200)
695 assert response["email"] == user.email
698 test "returns 403 if requested by a non-admin" do
703 |> assign(:user, user)
704 |> get("/api/pleroma/admin/users/#{user.nickname}/credentials")
706 assert json_response(conn, :forbidden)
710 describe "PATCH /users/:nickname/credentials" do
716 test "changes password and email", %{conn: conn, admin: admin, user: user} do
717 assert user.password_reset_pending == false
720 patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
721 "password" => "new_password",
722 "email" => "new_email@example.com",
726 assert json_response(conn, 200) == %{"status" => "success"}
728 ObanHelpers.perform_all()
730 updated_user = User.get_by_id(user.id)
732 assert updated_user.email == "new_email@example.com"
733 assert updated_user.name == "new_name"
734 assert updated_user.password_hash != user.password_hash
735 assert updated_user.password_reset_pending == true
737 [log_entry2, log_entry1] = ModerationLog |> Repo.all() |> Enum.sort()
739 assert ModerationLog.get_log_entry_message(log_entry1) ==
740 "@#{admin.nickname} updated users: @#{user.nickname}"
742 assert ModerationLog.get_log_entry_message(log_entry2) ==
743 "@#{admin.nickname} forced password reset for users: @#{user.nickname}"
746 test "returns 403 if requested by a non-admin", %{user: user} do
749 |> assign(:user, user)
750 |> patch("/api/pleroma/admin/users/#{user.nickname}/credentials", %{
751 "password" => "new_password",
752 "email" => "new_email@example.com",
756 assert json_response(conn, :forbidden)
759 test "changes actor type from permitted list", %{conn: conn, user: user} do
760 assert user.actor_type == "Person"
762 assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
763 "actor_type" => "Service"
765 |> json_response(200) == %{"status" => "success"}
767 updated_user = User.get_by_id(user.id)
769 assert updated_user.actor_type == "Service"
771 assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
772 "actor_type" => "Application"
774 |> json_response(400) == %{"errors" => %{"actor_type" => "is invalid"}}
777 test "update non existing user", %{conn: conn} do
778 assert patch(conn, "/api/pleroma/admin/users/non-existing/credentials", %{
779 "password" => "new_password"
781 |> json_response(404) == %{"error" => "Not found"}
785 describe "PATCH /users/:nickname/force_password_reset" do
786 test "sets password_reset_pending to true", %{conn: conn} do
788 assert user.password_reset_pending == false
791 patch(conn, "/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})
793 assert empty_json_response(conn) == ""
795 ObanHelpers.perform_all()
797 assert User.get_by_id(user.id).password_reset_pending == true
801 describe "PATCH /confirm_email" do
802 test "it confirms emails of two users", %{conn: conn, admin: admin} do
803 [first_user, second_user] = insert_pair(:user, is_confirmed: false)
805 refute first_user.is_confirmed
806 refute second_user.is_confirmed
809 patch(conn, "/api/pleroma/admin/users/confirm_email", %{
816 assert ret_conn.status == 200
818 first_user = User.get_by_id(first_user.id)
819 second_user = User.get_by_id(second_user.id)
821 assert first_user.is_confirmed
822 assert second_user.is_confirmed
824 log_entry = Repo.one(ModerationLog)
826 assert ModerationLog.get_log_entry_message(log_entry) ==
827 "@#{admin.nickname} confirmed email for users: @#{first_user.nickname}, @#{second_user.nickname}"
831 describe "PATCH /resend_confirmation_email" do
832 test "it resend emails for two users", %{conn: conn, admin: admin} do
833 [first_user, second_user] = insert_pair(:user, is_confirmed: false)
836 patch(conn, "/api/pleroma/admin/users/resend_confirmation_email", %{
843 assert ret_conn.status == 200
845 log_entry = Repo.one(ModerationLog)
847 assert ModerationLog.get_log_entry_message(log_entry) ==
848 "@#{admin.nickname} re-sent confirmation email for users: @#{first_user.nickname}, @#{second_user.nickname}"
850 ObanHelpers.perform_all()
852 Pleroma.Emails.UserEmail.account_confirmation_email(first_user)
853 # temporary hackney fix until hackney max_connections bug is fixed
854 # https://git.pleroma.social/pleroma/pleroma/-/issues/2101
855 |> Swoosh.Email.put_private(:hackney_options, ssl_options: [versions: [:"tlsv1.2"]])
856 |> assert_email_sent()
860 describe "/api/pleroma/admin/stats" do
861 test "status visibility count", %{conn: conn} do
863 CommonAPI.post(user, %{visibility: "public", status: "hey"})
864 CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
865 CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
869 |> get("/api/pleroma/admin/stats")
870 |> json_response(200)
872 assert %{"direct" => 0, "private" => 0, "public" => 1, "unlisted" => 2} =
873 response["status_visibility"]
876 test "by instance", %{conn: conn} do
877 user1 = insert(:user)
878 instance2 = "instance2.tld"
879 user2 = insert(:user, %{ap_id: "https://#{instance2}/@actor"})
881 CommonAPI.post(user1, %{visibility: "public", status: "hey"})
882 CommonAPI.post(user2, %{visibility: "unlisted", status: "hey"})
883 CommonAPI.post(user2, %{visibility: "private", status: "hey"})
887 |> get("/api/pleroma/admin/stats", instance: instance2)
888 |> json_response(200)
890 assert %{"direct" => 0, "private" => 1, "public" => 0, "unlisted" => 1} =
891 response["status_visibility"]
895 describe "/api/pleroma/backups" do
896 test "it creates a backup", %{conn: conn} do
897 admin = %{id: admin_id, nickname: admin_nickname} = insert(:user, is_admin: true)
898 token = insert(:oauth_admin_token, user: admin)
899 user = %{id: user_id, nickname: user_nickname} = insert(:user)
903 |> assign(:user, admin)
904 |> assign(:token, token)
905 |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
906 |> json_response(200)
908 assert [backup] = Repo.all(Pleroma.User.Backup)
910 ObanHelpers.perform_all()
912 email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup, admin.id)
914 assert String.contains?(email.html_body, "Admin @#{admin.nickname} requested a full backup")
915 assert_email_sent(to: {user.name, user.email}, html_body: email.html_body)
917 log_message = "@#{admin_nickname} requested account backup for @#{user_nickname}"
922 "action" => "create_backup",
925 "nickname" => ^admin_nickname
927 "message" => ^log_message,
930 "nickname" => ^user_nickname
934 ] = Pleroma.ModerationLog |> Repo.all()
937 test "it doesn't limit admins", %{conn: conn} do
938 admin = insert(:user, is_admin: true)
939 token = insert(:oauth_admin_token, user: admin)
944 |> assign(:user, admin)
945 |> assign(:token, token)
946 |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
947 |> json_response(200)
949 assert [_backup] = Repo.all(Pleroma.User.Backup)
953 |> assign(:user, admin)
954 |> assign(:token, token)
955 |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
956 |> json_response(200)
958 assert Repo.aggregate(Pleroma.User.Backup, :count) == 2
964 defmodule Pleroma.Web.Endpoint.NotReal do
967 defmodule Pleroma.Captcha.NotReal do