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.TwitterAPI.UtilControllerTest do
6 use Pleroma.Web.ConnCase
7 use Oban.Testing, repo: Pleroma.Repo
9 alias Pleroma.Tests.ObanHelpers
12 import Pleroma.Factory
16 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
20 setup do: clear_config([:instance])
21 setup do: clear_config([:frontend_configurations, :pleroma_fe])
23 describe "PUT /api/pleroma/notification_settings" do
24 setup do: oauth_access(["write:accounts"])
26 test "it updates notification settings", %{user: user, conn: conn} do
29 "/api/pleroma/notification_settings?#{URI.encode_query(%{block_from_strangers: true})}"
31 |> json_response_and_validate_schema(:ok)
33 user = refresh_record(user)
35 assert %Pleroma.User.NotificationSetting{
36 block_from_strangers: true,
37 hide_notification_contents: false
38 } == user.notification_settings
41 test "it updates notification settings to enable hiding contents", %{user: user, conn: conn} do
44 "/api/pleroma/notification_settings?#{URI.encode_query(%{hide_notification_contents: 1})}"
46 |> json_response_and_validate_schema(:ok)
48 user = refresh_record(user)
50 assert %Pleroma.User.NotificationSetting{
51 block_from_strangers: false,
52 hide_notification_contents: true
53 } == user.notification_settings
57 describe "GET /api/pleroma/frontend_configurations" do
58 test "returns everything in :pleroma, :frontend_configurations", %{conn: conn} do
69 clear_config(:frontend_configurations, config)
73 |> get("/api/pleroma/frontend_configurations")
74 |> json_response_and_validate_schema(:ok)
76 assert response == Jason.encode!(config |> Enum.into(%{})) |> Jason.decode!()
80 describe "/api/v1/pleroma/emoji" do
81 test "returns json with custom emoji with tags", %{conn: conn} do
84 |> get("/api/v1/pleroma/emoji")
85 |> json_response_and_validate_schema(200)
87 assert Enum.all?(emoji, fn
93 is_binary(url) and is_list(tags)
98 describe "GET /api/v1/pleroma/healthcheck" do
99 setup do: clear_config([:instance, :healthcheck])
101 test "returns 503 when healthcheck disabled", %{conn: conn} do
102 clear_config([:instance, :healthcheck], false)
106 |> get("/api/v1/pleroma/healthcheck")
107 |> json_response_and_validate_schema(503)
109 assert response == %{}
112 test "returns 200 when healthcheck enabled and all ok", %{conn: conn} do
113 clear_config([:instance, :healthcheck], true)
115 with_mock Pleroma.Healthcheck,
116 system_info: fn -> %Pleroma.Healthcheck{healthy: true} end do
119 |> get("/api/v1/pleroma/healthcheck")
120 |> json_response_and_validate_schema(200)
132 test "returns 503 when healthcheck enabled and health is false", %{conn: conn} do
133 clear_config([:instance, :healthcheck], true)
135 with_mock Pleroma.Healthcheck,
136 system_info: fn -> %Pleroma.Healthcheck{healthy: false} end do
139 |> get("/api/v1/pleroma/healthcheck")
140 |> json_response_and_validate_schema(503)
153 describe "POST /api/pleroma/disable_account" do
154 setup do: oauth_access(["write:accounts"])
156 test "with valid permissions and password, it disables the account", %{conn: conn, user: user} do
159 |> post("/api/pleroma/disable_account?password=test")
160 |> json_response_and_validate_schema(:ok)
162 assert response == %{"status" => "success"}
163 ObanHelpers.perform_all()
165 user = User.get_cached_by_id(user.id)
167 refute user.is_active
170 test "with valid permissions and invalid password, it returns an error", %{conn: conn} do
175 |> post("/api/pleroma/disable_account?password=test1")
176 |> json_response_and_validate_schema(:ok)
178 assert response == %{"error" => "Invalid password."}
179 user = User.get_cached_by_id(user.id)
181 assert user.is_active
185 describe "POST /main/ostatus - remote_subscribe/2" do
186 setup do: clear_config([:instance, :federating], true)
188 test "renders subscribe form", %{conn: conn} do
193 |> post("/main/ostatus", %{"nickname" => user.nickname, "profile" => ""})
196 refute response =~ "Could not find user"
197 assert response =~ "Remotely follow #{user.nickname}"
200 test "renders subscribe form with error when user not found", %{conn: conn} do
203 |> post("/main/ostatus", %{"nickname" => "nickname", "profile" => ""})
206 assert response =~ "Could not find user"
207 refute response =~ "Remotely follow"
210 test "it redirect to webfinger url", %{conn: conn} do
212 user2 = insert(:user, ap_id: "shp@social.heldscal.la")
216 |> post("/main/ostatus", %{
217 "user" => %{"nickname" => user.nickname, "profile" => user2.ap_id}
220 assert redirected_to(conn) ==
221 "https://social.heldscal.la/main/ostatussub?profile=#{user.ap_id}"
224 test "it renders form with error when user not found", %{conn: conn} do
225 user2 = insert(:user, ap_id: "shp@social.heldscal.la")
229 |> post("/main/ostatus", %{"user" => %{"nickname" => "jimm", "profile" => user2.ap_id}})
232 assert response =~ "Something went wrong."
236 describe "POST /main/ostatus - remote_subscribe/2 - with statuses" do
237 setup do: clear_config([:instance, :federating], true)
239 test "renders subscribe form", %{conn: conn} do
241 status = insert(:note_activity, %{user: user})
242 status_id = status.id
244 assert is_binary(status_id)
248 |> post("/main/ostatus", %{"status_id" => status_id, "profile" => ""})
251 refute response =~ "Could not find status"
252 assert response =~ "Interacting with"
255 test "renders subscribe form with error when status not found", %{conn: conn} do
258 |> post("/main/ostatus", %{"status_id" => "somerandomid", "profile" => ""})
261 assert response =~ "Could not find status"
262 refute response =~ "Interacting with"
265 test "it redirect to webfinger url", %{conn: conn} do
267 status = insert(:note_activity, %{user: user})
268 status_id = status.id
269 status_ap_id = status.data["object"]
271 assert is_binary(status_id)
272 assert is_binary(status_ap_id)
274 user2 = insert(:user, ap_id: "shp@social.heldscal.la")
278 |> post("/main/ostatus", %{
279 "status" => %{"status_id" => status_id, "profile" => user2.ap_id}
282 assert redirected_to(conn) ==
283 "https://social.heldscal.la/main/ostatussub?profile=#{status_ap_id}"
286 test "it renders form with error when status not found", %{conn: conn} do
287 user2 = insert(:user, ap_id: "shp@social.heldscal.la")
291 |> post("/main/ostatus", %{
292 "status" => %{"status_id" => "somerandomid", "profile" => user2.ap_id}
296 assert response =~ "Something went wrong."
300 describe "GET /main/ostatus - show_subscribe_form/2" do
301 setup do: clear_config([:instance, :federating], true)
303 test "it works with users", %{conn: conn} do
308 |> get("/main/ostatus", %{"nickname" => user.nickname})
311 refute response =~ "Could not find user"
312 assert response =~ "Remotely follow #{user.nickname}"
315 test "it works with statuses", %{conn: conn} do
317 status = insert(:note_activity, %{user: user})
318 status_id = status.id
320 assert is_binary(status_id)
324 |> get("/main/ostatus", %{"status_id" => status_id})
327 refute response =~ "Could not find status"
328 assert response =~ "Interacting with"
332 test "it returns new captcha", %{conn: conn} do
333 with_mock Pleroma.Captcha,
334 new: fn -> "test_captcha" end do
337 |> get("/api/v1/pleroma/captcha")
340 assert resp == "\"test_captcha\""
341 assert called(Pleroma.Captcha.new())
345 describe "POST /api/pleroma/change_email" do
346 setup do: oauth_access(["write:accounts"])
348 test "without permissions", %{conn: conn} do
351 |> assign(:token, nil)
352 |> put_req_header("content-type", "multipart/form-data")
353 |> post("/api/pleroma/change_email", %{password: "hi", email: "test@test.com"})
355 assert json_response_and_validate_schema(conn, 403) == %{
356 "error" => "Insufficient permissions: write:accounts."
360 test "with proper permissions and invalid password", %{conn: conn} do
363 |> put_req_header("content-type", "multipart/form-data")
364 |> post("/api/pleroma/change_email", %{password: "hi", email: "test@test.com"})
366 assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
369 test "with proper permissions, valid password and invalid email", %{
374 |> put_req_header("content-type", "multipart/form-data")
375 |> post("/api/pleroma/change_email", %{password: "test", email: "foobar"})
377 assert json_response_and_validate_schema(conn, 200) == %{
378 "error" => "Email has invalid format."
382 test "with proper permissions, valid password and no email", %{
387 |> put_req_header("content-type", "multipart/form-data")
388 |> post("/api/pleroma/change_email", %{password: "test"})
390 assert %{"error" => "Missing field: email."} = json_response_and_validate_schema(conn, 400)
393 test "with proper permissions, valid password and blank email, when instance requires user email",
397 orig_account_activation_required =
398 Pleroma.Config.get([:instance, :account_activation_required])
400 Pleroma.Config.put([:instance, :account_activation_required], true)
404 [:instance, :account_activation_required],
405 orig_account_activation_required
411 |> put_req_header("content-type", "multipart/form-data")
412 |> post("/api/pleroma/change_email", %{password: "test", email: ""})
414 assert json_response_and_validate_schema(conn, 200) == %{"error" => "Email can't be blank."}
417 test "with proper permissions, valid password and blank email, when instance does not require user email",
421 orig_account_activation_required =
422 Pleroma.Config.get([:instance, :account_activation_required])
424 Pleroma.Config.put([:instance, :account_activation_required], false)
428 [:instance, :account_activation_required],
429 orig_account_activation_required
435 |> put_req_header("content-type", "multipart/form-data")
436 |> post("/api/pleroma/change_email", %{password: "test", email: ""})
438 assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
441 test "with proper permissions, valid password and non unique email", %{
448 |> put_req_header("content-type", "multipart/form-data")
449 |> post("/api/pleroma/change_email", %{password: "test", email: user.email})
451 assert json_response_and_validate_schema(conn, 200) == %{
452 "error" => "Email has already been taken."
456 test "with proper permissions, valid password and valid email", %{
461 |> put_req_header("content-type", "multipart/form-data")
462 |> post("/api/pleroma/change_email", %{
464 email: "cofe@foobar.com"
467 assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
471 describe "POST /api/pleroma/change_password" do
472 setup do: oauth_access(["write:accounts"])
474 test "without permissions", %{conn: conn} do
477 |> assign(:token, nil)
478 |> put_req_header("content-type", "multipart/form-data")
479 |> post("/api/pleroma/change_password", %{
481 "new_password" => "newpass",
482 "new_password_confirmation" => "newpass"
485 assert json_response_and_validate_schema(conn, 403) == %{
486 "error" => "Insufficient permissions: write:accounts."
490 test "with proper permissions and invalid password", %{conn: conn} do
493 |> put_req_header("content-type", "multipart/form-data")
494 |> post("/api/pleroma/change_password", %{
496 "new_password" => "newpass",
497 "new_password_confirmation" => "newpass"
500 assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
503 test "with proper permissions, valid password and new password and confirmation not matching",
509 |> put_req_header("content-type", "multipart/form-data")
510 |> post("/api/pleroma/change_password", %{
511 "password" => "test",
512 "new_password" => "newpass",
513 "new_password_confirmation" => "notnewpass"
516 assert json_response_and_validate_schema(conn, 200) == %{
517 "error" => "New password does not match confirmation."
521 test "with proper permissions, valid password and invalid new password", %{
526 |> put_req_header("content-type", "multipart/form-data")
527 |> post("/api/pleroma/change_password", %{
530 new_password_confirmation: ""
533 assert json_response_and_validate_schema(conn, 200) == %{
534 "error" => "New password can't be blank."
538 test "with proper permissions, valid password and matching new password and confirmation", %{
544 |> put_req_header("content-type", "multipart/form-data")
546 "/api/pleroma/change_password",
549 new_password: "newpass",
550 new_password_confirmation: "newpass"
554 assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
555 fetched_user = User.get_cached_by_id(user.id)
556 assert Pleroma.Password.checkpw("newpass", fetched_user.password_hash) == true
560 describe "POST /api/pleroma/delete_account" do
561 setup do: oauth_access(["write:accounts"])
563 test "without permissions", %{conn: conn} do
566 |> assign(:token, nil)
567 |> post("/api/pleroma/delete_account")
569 assert json_response_and_validate_schema(conn, 403) ==
570 %{"error" => "Insufficient permissions: write:accounts."}
573 test "with proper permissions and wrong or missing password", %{conn: conn} do
574 for params <- [%{"password" => "hi"}, %{}] do
577 |> put_req_header("content-type", "application/json")
578 |> post("/api/pleroma/delete_account", params)
580 assert json_response_and_validate_schema(ret_conn, 200) == %{
581 "error" => "Invalid password."
586 test "with proper permissions and valid password (URL query)", %{conn: conn, user: user} do
589 |> put_req_header("content-type", "application/json")
590 |> post("/api/pleroma/delete_account?password=test")
592 ObanHelpers.perform_all()
593 assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
595 user = User.get_by_id(user.id)
596 refute user.is_active
597 assert user.name == nil
598 assert user.bio == ""
599 assert user.password_hash == nil
602 test "with proper permissions and valid password (JSON body)", %{conn: conn, user: user} do
605 |> put_req_header("content-type", "application/json")
606 |> post("/api/pleroma/delete_account", %{password: "test"})
608 ObanHelpers.perform_all()
609 assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
611 user = User.get_by_id(user.id)
612 refute user.is_active
613 assert user.name == nil
614 assert user.bio == ""
615 assert user.password_hash == nil
619 describe "POST /api/pleroma/move_account" do
620 setup do: oauth_access(["write:accounts"])
622 test "without permissions", %{conn: conn} do
623 target_user = insert(:user)
624 target_nick = target_user |> User.full_nickname()
628 |> assign(:token, nil)
629 |> put_req_header("content-type", "multipart/form-data")
630 |> post("/api/pleroma/move_account", %{
632 "target_account" => target_nick
635 assert json_response_and_validate_schema(conn, 403) == %{
636 "error" => "Insufficient permissions: write:accounts."
640 test "with proper permissions and invalid password", %{conn: conn} do
641 target_user = insert(:user)
642 target_nick = target_user |> User.full_nickname()
646 |> put_req_header("content-type", "multipart/form-data")
647 |> post("/api/pleroma/move_account", %{
649 "target_account" => target_nick
652 assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
655 test "with proper permissions, valid password and target account does not alias this",
659 target_user = insert(:user)
660 target_nick = target_user |> User.full_nickname()
664 |> put_req_header("content-type", "multipart/form-data")
665 |> post("/api/pleroma/move_account", %{
666 "password" => "test",
667 "target_account" => target_nick
670 assert json_response_and_validate_schema(conn, 200) == %{
671 "error" => "Target account must have the origin in `alsoKnownAs`"
675 test "with proper permissions, valid password and target account does not exist",
679 target_nick = "not_found@mastodon.social"
683 |> put_req_header("content-type", "multipart/form-data")
684 |> post("/api/pleroma/move_account", %{
685 "password" => "test",
686 "target_account" => target_nick
689 assert json_response_and_validate_schema(conn, 404) == %{
690 "error" => "Target account not found."
694 test "with proper permissions, valid password, remote target account aliases this and local cache does not exist",
696 user = insert(:user, ap_id: "https://lm.kazv.moe/users/testuser")
697 %{user: _user, conn: conn} = oauth_access(["write:accounts"], user: user)
699 target_nick = "mewmew@lm.kazv.moe"
703 |> put_req_header("content-type", "multipart/form-data")
704 |> post("/api/pleroma/move_account", %{
705 "password" => "test",
706 "target_account" => target_nick
709 assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
712 test "with proper permissions, valid password, remote target account aliases this and local cache does not alias this",
714 user = insert(:user, ap_id: "https://lm.kazv.moe/users/testuser")
715 %{user: _user, conn: conn} = oauth_access(["write:accounts"], user: user)
720 ap_id: "https://lm.kazv.moe/users/mewmew",
721 nickname: "mewmew@lm.kazv.moe",
725 target_nick = target_user |> User.full_nickname()
729 |> put_req_header("content-type", "multipart/form-data")
730 |> post("/api/pleroma/move_account", %{
731 "password" => "test",
732 "target_account" => target_nick
735 assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
738 test "with proper permissions, valid password, remote target account does not alias this and local cache aliases this",
746 ap_id: "https://lm.kazv.moe/users/mewmew",
747 nickname: "mewmew@lm.kazv.moe",
749 also_known_as: [user.ap_id]
752 target_nick = target_user |> User.full_nickname()
756 |> put_req_header("content-type", "multipart/form-data")
757 |> post("/api/pleroma/move_account", %{
758 "password" => "test",
759 "target_account" => target_nick
762 assert json_response_and_validate_schema(conn, 200) == %{
763 "error" => "Target account must have the origin in `alsoKnownAs`"
767 test "with proper permissions, valid password and target account aliases this", %{
771 target_user = insert(:user, also_known_as: [user.ap_id])
772 target_nick = target_user |> User.full_nickname()
773 follower = insert(:user)
775 User.follow(follower, user)
777 assert User.following?(follower, user)
781 |> put_req_header("content-type", "multipart/form-data")
783 "/api/pleroma/move_account",
786 target_account: target_nick
790 assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
793 "op" => "move_following",
794 "origin_id" => user.id,
795 "target_id" => target_user.id
798 assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
800 Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})
802 refute User.following?(follower, user)
803 assert User.following?(follower, target_user)
806 test "prefix nickname by @ should work", %{
810 target_user = insert(:user, also_known_as: [user.ap_id])
811 target_nick = target_user |> User.full_nickname()
812 follower = insert(:user)
814 User.follow(follower, user)
816 assert User.following?(follower, user)
820 |> put_req_header("content-type", "multipart/form-data")
822 "/api/pleroma/move_account",
825 target_account: "@" <> target_nick
829 assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
832 "op" => "move_following",
833 "origin_id" => user.id,
834 "target_id" => target_user.id
837 assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
839 Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})
841 refute User.following?(follower, user)
842 assert User.following?(follower, target_user)
846 describe "GET /api/pleroma/aliases" do
847 setup do: oauth_access(["read:accounts"])
849 test "without permissions", %{conn: conn} do
852 |> assign(:token, nil)
853 |> get("/api/pleroma/aliases")
855 assert json_response_and_validate_schema(conn, 403) == %{
856 "error" => "Insufficient permissions: read:accounts."
860 test "with permissions", %{
863 assert %{"aliases" => []} =
865 |> get("/api/pleroma/aliases")
866 |> json_response_and_validate_schema(200)
869 test "with permissions and aliases", %{} do
871 user2 = insert(:user)
873 assert {:ok, user} = user |> User.add_alias(user2)
875 %{user: _user, conn: conn} = oauth_access(["read:accounts"], user: user)
877 assert %{"aliases" => aliases} =
879 |> get("/api/pleroma/aliases")
880 |> json_response_and_validate_schema(200)
882 assert aliases == [user2 |> User.full_nickname()]
886 describe "PUT /api/pleroma/aliases" do
887 setup do: oauth_access(["write:accounts"])
889 test "without permissions", %{conn: conn} do
892 |> assign(:token, nil)
893 |> put_req_header("content-type", "application/json")
894 |> put("/api/pleroma/aliases", %{alias: "none"})
896 assert json_response_and_validate_schema(conn, 403) == %{
897 "error" => "Insufficient permissions: write:accounts."
901 test "with permissions, no alias param", %{
906 |> put_req_header("content-type", "application/json")
907 |> put("/api/pleroma/aliases", %{})
909 assert %{"error" => "Missing field: alias."} = json_response_and_validate_schema(conn, 400)
912 test "with permissions, with alias param", %{
915 user2 = insert(:user)
919 |> put_req_header("content-type", "application/json")
920 |> put("/api/pleroma/aliases", %{alias: user2 |> User.full_nickname()})
922 assert json_response_and_validate_schema(conn, 200) == %{
923 "status" => "success"
928 describe "DELETE /api/pleroma/aliases" do
930 alias_user = insert(:user)
931 non_alias_user = insert(:user)
932 user = insert(:user, also_known_as: [alias_user.ap_id])
934 oauth_access(["write:accounts"], user: user)
935 |> Map.put(:alias_user, alias_user)
936 |> Map.put(:non_alias_user, non_alias_user)
939 test "without permissions", %{conn: conn} do
942 |> assign(:token, nil)
943 |> put_req_header("content-type", "application/json")
944 |> delete("/api/pleroma/aliases", %{alias: "none"})
946 assert json_response_and_validate_schema(conn, 403) == %{
947 "error" => "Insufficient permissions: write:accounts."
951 test "with permissions, no alias param", %{conn: conn} do
954 |> put_req_header("content-type", "application/json")
955 |> delete("/api/pleroma/aliases", %{})
957 assert %{"error" => "Missing field: alias."} = json_response_and_validate_schema(conn, 400)
960 test "with permissions, account does not have such alias", %{
962 non_alias_user: non_alias_user
966 |> put_req_header("content-type", "application/json")
967 |> delete("/api/pleroma/aliases", %{
968 alias: non_alias_user |> User.full_nickname()
971 assert %{"error" => "Account has no such alias."} =
972 json_response_and_validate_schema(conn, 404)
975 test "with permissions, account does have such alias", %{
977 alias_user: alias_user
981 |> put_req_header("content-type", "application/json")
982 |> delete("/api/pleroma/aliases", %{alias: alias_user |> User.full_nickname()})
984 assert %{"status" => "success"} = json_response_and_validate_schema(conn, 200)