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/moderation_log" do
424 moderator = insert(:user, is_moderator: true)
426 %{moderator: moderator}
429 test "returns the log", %{conn: conn, admin: admin} do
430 Repo.insert(%ModerationLog{
434 "nickname" => admin.nickname,
437 action: "relay_follow",
438 target: "https://example.org/relay"
440 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
443 Repo.insert(%ModerationLog{
447 "nickname" => admin.nickname,
450 action: "relay_unfollow",
451 target: "https://example.org/relay"
453 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
456 conn = get(conn, "/api/pleroma/admin/moderation_log")
458 response = json_response(conn, 200)
459 [first_entry, second_entry] = response["items"]
461 assert response["total"] == 2
462 assert first_entry["data"]["action"] == "relay_unfollow"
464 assert first_entry["message"] ==
465 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
467 assert second_entry["data"]["action"] == "relay_follow"
469 assert second_entry["message"] ==
470 "@#{admin.nickname} followed relay: https://example.org/relay"
473 test "returns the log with pagination", %{conn: conn, admin: admin} do
474 Repo.insert(%ModerationLog{
478 "nickname" => admin.nickname,
481 action: "relay_follow",
482 target: "https://example.org/relay"
484 inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
487 Repo.insert(%ModerationLog{
491 "nickname" => admin.nickname,
494 action: "relay_unfollow",
495 target: "https://example.org/relay"
497 inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
500 conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
502 response1 = json_response(conn1, 200)
503 [first_entry] = response1["items"]
505 assert response1["total"] == 2
506 assert response1["items"] |> length() == 1
507 assert first_entry["data"]["action"] == "relay_unfollow"
509 assert first_entry["message"] ==
510 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
512 conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
514 response2 = json_response(conn2, 200)
515 [second_entry] = response2["items"]
517 assert response2["total"] == 2
518 assert response2["items"] |> length() == 1
519 assert second_entry["data"]["action"] == "relay_follow"
521 assert second_entry["message"] ==
522 "@#{admin.nickname} followed relay: https://example.org/relay"
525 test "filters log by date", %{conn: conn, admin: admin} do
526 first_date = "2017-08-15T15:47:06Z"
527 second_date = "2017-08-20T15:47:06Z"
529 Repo.insert(%ModerationLog{
533 "nickname" => admin.nickname,
536 action: "relay_follow",
537 target: "https://example.org/relay"
539 inserted_at: NaiveDateTime.from_iso8601!(first_date)
542 Repo.insert(%ModerationLog{
546 "nickname" => admin.nickname,
549 action: "relay_unfollow",
550 target: "https://example.org/relay"
552 inserted_at: NaiveDateTime.from_iso8601!(second_date)
558 "/api/pleroma/admin/moderation_log?start_date=#{second_date}"
561 response1 = json_response(conn1, 200)
562 [first_entry] = response1["items"]
564 assert response1["total"] == 1
565 assert first_entry["data"]["action"] == "relay_unfollow"
567 assert first_entry["message"] ==
568 "@#{admin.nickname} unfollowed relay: https://example.org/relay"
571 test "returns log filtered by user", %{conn: conn, admin: admin, moderator: moderator} do
572 Repo.insert(%ModerationLog{
576 "nickname" => admin.nickname,
579 action: "relay_follow",
580 target: "https://example.org/relay"
584 Repo.insert(%ModerationLog{
587 "id" => moderator.id,
588 "nickname" => moderator.nickname,
591 action: "relay_unfollow",
592 target: "https://example.org/relay"
596 conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")
598 response1 = json_response(conn1, 200)
599 [first_entry] = response1["items"]
601 assert response1["total"] == 1
602 assert get_in(first_entry, ["data", "actor", "id"]) == moderator.id
605 test "returns log filtered by search", %{conn: conn, moderator: moderator} do
606 ModerationLog.insert_log(%{
608 action: "relay_follow",
609 target: "https://example.org/relay"
612 ModerationLog.insert_log(%{
614 action: "relay_unfollow",
615 target: "https://example.org/relay"
618 conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")
620 response1 = json_response(conn1, 200)
621 [first_entry] = response1["items"]
623 assert response1["total"] == 1
625 assert get_in(first_entry, ["data", "message"]) ==
626 "@#{moderator.nickname} unfollowed relay: https://example.org/relay"
630 test "gets a remote users when [:instance, :limit_to_local_content] is set to :unauthenticated",
632 clear_config(Pleroma.Config.get([:instance, :limit_to_local_content]), :unauthenticated)
633 user = insert(:user, %{local: false, nickname: "u@peer1.com"})
634 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
636 assert json_response(conn, 200)
639 describe "GET /users/:nickname/credentials" do
640 test "gets the user credentials", %{conn: conn} do
642 conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")
644 response = assert json_response(conn, 200)
645 assert response["email"] == user.email
648 test "returns 403 if requested by a non-admin" do
653 |> assign(:user, user)
654 |> get("/api/pleroma/admin/users/#{user.nickname}/credentials")
656 assert json_response(conn, :forbidden)
660 describe "PATCH /users/:nickname/credentials" do
666 test "changes password and email", %{conn: conn, admin: admin, user: user} do
667 assert user.password_reset_pending == false
670 patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
671 "password" => "new_password",
672 "email" => "new_email@example.com",
676 assert json_response(conn, 200) == %{"status" => "success"}
678 ObanHelpers.perform_all()
680 updated_user = User.get_by_id(user.id)
682 assert updated_user.email == "new_email@example.com"
683 assert updated_user.name == "new_name"
684 assert updated_user.password_hash != user.password_hash
685 assert updated_user.password_reset_pending == true
687 [log_entry2, log_entry1] = ModerationLog |> Repo.all() |> Enum.sort()
689 assert ModerationLog.get_log_entry_message(log_entry1) ==
690 "@#{admin.nickname} updated users: @#{user.nickname}"
692 assert ModerationLog.get_log_entry_message(log_entry2) ==
693 "@#{admin.nickname} forced password reset for users: @#{user.nickname}"
696 test "returns 403 if requested by a non-admin", %{user: user} do
699 |> assign(:user, user)
700 |> patch("/api/pleroma/admin/users/#{user.nickname}/credentials", %{
701 "password" => "new_password",
702 "email" => "new_email@example.com",
706 assert json_response(conn, :forbidden)
709 test "changes actor type from permitted list", %{conn: conn, user: user} do
710 assert user.actor_type == "Person"
712 assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
713 "actor_type" => "Service"
715 |> json_response(200) == %{"status" => "success"}
717 updated_user = User.get_by_id(user.id)
719 assert updated_user.actor_type == "Service"
721 assert patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
722 "actor_type" => "Application"
724 |> json_response(400) == %{"errors" => %{"actor_type" => "is invalid"}}
727 test "update non existing user", %{conn: conn} do
728 assert patch(conn, "/api/pleroma/admin/users/non-existing/credentials", %{
729 "password" => "new_password"
731 |> json_response(404) == %{"error" => "Not found"}
735 describe "PATCH /users/:nickname/force_password_reset" do
736 test "sets password_reset_pending to true", %{conn: conn} do
738 assert user.password_reset_pending == false
741 patch(conn, "/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})
743 assert empty_json_response(conn) == ""
745 ObanHelpers.perform_all()
747 assert User.get_by_id(user.id).password_reset_pending == true
751 describe "PATCH /confirm_email" do
752 test "it confirms emails of two users", %{conn: conn, admin: admin} do
753 [first_user, second_user] = insert_pair(:user, is_confirmed: false)
755 refute first_user.is_confirmed
756 refute second_user.is_confirmed
759 patch(conn, "/api/pleroma/admin/users/confirm_email", %{
766 assert ret_conn.status == 200
768 first_user = User.get_by_id(first_user.id)
769 second_user = User.get_by_id(second_user.id)
771 assert first_user.is_confirmed
772 assert second_user.is_confirmed
774 log_entry = Repo.one(ModerationLog)
776 assert ModerationLog.get_log_entry_message(log_entry) ==
777 "@#{admin.nickname} confirmed email for users: @#{first_user.nickname}, @#{second_user.nickname}"
781 describe "PATCH /resend_confirmation_email" do
782 test "it resend emails for two users", %{conn: conn, admin: admin} do
783 [first_user, second_user] = insert_pair(:user, is_confirmed: false)
786 patch(conn, "/api/pleroma/admin/users/resend_confirmation_email", %{
793 assert ret_conn.status == 200
795 log_entry = Repo.one(ModerationLog)
797 assert ModerationLog.get_log_entry_message(log_entry) ==
798 "@#{admin.nickname} re-sent confirmation email for users: @#{first_user.nickname}, @#{second_user.nickname}"
800 ObanHelpers.perform_all()
802 Pleroma.Emails.UserEmail.account_confirmation_email(first_user)
803 # temporary hackney fix until hackney max_connections bug is fixed
804 # https://git.pleroma.social/pleroma/pleroma/-/issues/2101
805 |> Swoosh.Email.put_private(:hackney_options, ssl_options: [versions: [:"tlsv1.2"]])
806 |> assert_email_sent()
810 describe "/api/pleroma/admin/stats" do
811 test "status visibility count", %{conn: conn} do
813 CommonAPI.post(user, %{visibility: "public", status: "hey"})
814 CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
815 CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
819 |> get("/api/pleroma/admin/stats")
820 |> json_response(200)
822 assert %{"direct" => 0, "private" => 0, "public" => 1, "unlisted" => 2} =
823 response["status_visibility"]
826 test "by instance", %{conn: conn} do
827 user1 = insert(:user)
828 instance2 = "instance2.tld"
829 user2 = insert(:user, %{ap_id: "https://#{instance2}/@actor"})
831 CommonAPI.post(user1, %{visibility: "public", status: "hey"})
832 CommonAPI.post(user2, %{visibility: "unlisted", status: "hey"})
833 CommonAPI.post(user2, %{visibility: "private", status: "hey"})
837 |> get("/api/pleroma/admin/stats", instance: instance2)
838 |> json_response(200)
840 assert %{"direct" => 0, "private" => 1, "public" => 0, "unlisted" => 1} =
841 response["status_visibility"]
845 describe "/api/pleroma/backups" do
846 test "it creates a backup", %{conn: conn} do
847 admin = %{id: admin_id, nickname: admin_nickname} = insert(:user, is_admin: true)
848 token = insert(:oauth_admin_token, user: admin)
849 user = %{id: user_id, nickname: user_nickname} = insert(:user)
853 |> assign(:user, admin)
854 |> assign(:token, token)
855 |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
856 |> json_response(200)
858 assert [backup] = Repo.all(Pleroma.User.Backup)
860 ObanHelpers.perform_all()
862 email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup, admin.id)
864 assert String.contains?(email.html_body, "Admin @#{admin.nickname} requested a full backup")
865 assert_email_sent(to: {user.name, user.email}, html_body: email.html_body)
867 log_message = "@#{admin_nickname} requested account backup for @#{user_nickname}"
872 "action" => "create_backup",
875 "nickname" => ^admin_nickname
877 "message" => ^log_message,
880 "nickname" => ^user_nickname
884 ] = Pleroma.ModerationLog |> Repo.all()
887 test "it doesn't limit admins", %{conn: conn} do
888 admin = insert(:user, is_admin: true)
889 token = insert(:oauth_admin_token, user: admin)
894 |> assign(:user, admin)
895 |> assign(:token, token)
896 |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
897 |> json_response(200)
899 assert [_backup] = Repo.all(Pleroma.User.Backup)
903 |> assign(:user, admin)
904 |> assign(:token, token)
905 |> post("/api/pleroma/admin/backups", %{nickname: user.nickname})
906 |> json_response(200)
908 assert Repo.aggregate(Pleroma.User.Backup, :count) == 2
914 defmodule Pleroma.Web.Endpoint.NotReal do
917 defmodule Pleroma.Captcha.NotReal do