git.squeep.com Git - akkoma/blob - test/pleroma/web/twitter_api/util_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
   6   use Pleroma.Web.ConnCase
   7   use Oban.Testing, repo: Pleroma.Repo
   8
   9   alias Pleroma.Tests.ObanHelpers
  10   alias Pleroma.User
  11
  12   import Pleroma.Factory
  13   import Mock
  14
  15   setup do
  16     Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  17     :ok
  18   end
  19
  20   setup do: clear_config([:instance])
  21   setup do: clear_config([:frontend_configurations, :pleroma_fe])
  22
  23   describe "PUT /api/pleroma/notification_settings" do
  24     setup do: oauth_access(["write:accounts"])
  25
  26     test "it updates notification settings", %{user: user, conn: conn} do
  27       conn
  28       |> put(
  29         "/api/pleroma/notification_settings?#{URI.encode_query(%{block_from_strangers: true})}"
  30       )
  31       |> json_response_and_validate_schema(:ok)
  32
  33       user = refresh_record(user)
  34
  35       assert %Pleroma.User.NotificationSetting{
  36                block_from_strangers: true,
  37                hide_notification_contents: false
  38              } == user.notification_settings
  39     end
  40
  41     test "it updates notification settings to enable hiding contents", %{user: user, conn: conn} do
  42       conn
  43       |> put(
  44         "/api/pleroma/notification_settings?#{URI.encode_query(%{hide_notification_contents: 1})}"
  45       )
  46       |> json_response_and_validate_schema(:ok)
  47
  48       user = refresh_record(user)
  49
  50       assert %Pleroma.User.NotificationSetting{
  51                block_from_strangers: false,
  52                hide_notification_contents: true
  53              } == user.notification_settings
  54     end
  55   end
  56
  57   describe "GET /api/pleroma/frontend_configurations" do
  58     test "returns everything in :pleroma, :frontend_configurations", %{conn: conn} do
  59       config = [
  60         frontend_a: %{
  61           x: 1,
  62           y: 2
  63         },
  64         frontend_b: %{
  65           z: 3
  66         }
  67       ]
  68
  69       clear_config(:frontend_configurations, config)
  70
  71       response =
  72         conn
  73         |> get("/api/pleroma/frontend_configurations")
  74         |> json_response_and_validate_schema(:ok)
  75
  76       assert response == Jason.encode!(config |> Enum.into(%{})) |> Jason.decode!()
  77     end
  78   end
  79
  80   describe "/api/v1/pleroma/emoji" do
  81     test "returns json with custom emoji with tags", %{conn: conn} do
  82       emoji =
  83         conn
  84         |> get("/api/v1/pleroma/emoji")
  85         |> json_response_and_validate_schema(200)
  86
  87       assert Enum.all?(emoji, fn
  88                {_key,
  89                 %{
  90                   "image_url" => url,
  91                   "tags" => tags
  92                 }} ->
  93                  is_binary(url) and is_list(tags)
  94              end)
  95     end
  96   end
  97
  98   describe "GET /api/v1/pleroma/healthcheck" do
  99     setup do: clear_config([:instance, :healthcheck])
 100
 101     test "returns 503 when healthcheck disabled", %{conn: conn} do
 102       clear_config([:instance, :healthcheck], false)
 103
 104       response =
 105         conn
 106         |> get("/api/v1/pleroma/healthcheck")
 107         |> json_response_and_validate_schema(503)
 108
 109       assert response == %{}
 110     end
 111
 112     test "returns 200 when healthcheck enabled and all ok", %{conn: conn} do
 113       clear_config([:instance, :healthcheck], true)
 114
 115       with_mock Pleroma.Healthcheck,
 116         system_info: fn -> %Pleroma.Healthcheck{healthy: true} end do
 117         response =
 118           conn
 119           |> get("/api/v1/pleroma/healthcheck")
 120           |> json_response_and_validate_schema(200)
 121
 122         assert %{
 123                  "active" => _,
 124                  "healthy" => true,
 125                  "idle" => _,
 126                  "memory_used" => _,
 127                  "pool_size" => _
 128                } = response
 129       end
 130     end
 131
 132     test "returns 503 when healthcheck enabled and health is false", %{conn: conn} do
 133       clear_config([:instance, :healthcheck], true)
 134
 135       with_mock Pleroma.Healthcheck,
 136         system_info: fn -> %Pleroma.Healthcheck{healthy: false} end do
 137         response =
 138           conn
 139           |> get("/api/v1/pleroma/healthcheck")
 140           |> json_response_and_validate_schema(503)
 141
 142         assert %{
 143                  "active" => _,
 144                  "healthy" => false,
 145                  "idle" => _,
 146                  "memory_used" => _,
 147                  "pool_size" => _
 148                } = response
 149       end
 150     end
 151   end
 152
 153   describe "POST /api/pleroma/disable_account" do
 154     setup do: oauth_access(["write:accounts"])
 155
 156     test "with valid permissions and password, it disables the account", %{conn: conn, user: user} do
 157       response =
 158         conn
 159         |> post("/api/pleroma/disable_account?password=test")
 160         |> json_response_and_validate_schema(:ok)
 161
 162       assert response == %{"status" => "success"}
 163       ObanHelpers.perform_all()
 164
 165       user = User.get_cached_by_id(user.id)
 166
 167       refute user.is_active
 168     end
 169
 170     test "with valid permissions and invalid password, it returns an error", %{conn: conn} do
 171       user = insert(:user)
 172
 173       response =
 174         conn
 175         |> post("/api/pleroma/disable_account?password=test1")
 176         |> json_response_and_validate_schema(:ok)
 177
 178       assert response == %{"error" => "Invalid password."}
 179       user = User.get_cached_by_id(user.id)
 180
 181       assert user.is_active
 182     end
 183   end
 184
 185   describe "POST /main/ostatus - remote_subscribe/2" do
 186     setup do: clear_config([:instance, :federating], true)
 187
 188     test "renders subscribe form", %{conn: conn} do
 189       user = insert(:user)
 190
 191       response =
 192         conn
 193         |> post("/main/ostatus", %{"nickname" => user.nickname, "profile" => ""})
 194         |> response(:ok)
 195
 196       refute response =~ "Could not find user"
 197       assert response =~ "Remotely follow #{user.nickname}"
 198     end
 199
 200     test "renders subscribe form with error when user not found", %{conn: conn} do
 201       response =
 202         conn
 203         |> post("/main/ostatus", %{"nickname" => "nickname", "profile" => ""})
 204         |> response(:ok)
 205
 206       assert response =~ "Could not find user"
 207       refute response =~ "Remotely follow"
 208     end
 209
 210     test "it redirect to webfinger url", %{conn: conn} do
 211       user = insert(:user)
 212       user2 = insert(:user, ap_id: "shp@social.heldscal.la")
 213
 214       conn =
 215         conn
 216         |> post("/main/ostatus", %{
 217           "user" => %{"nickname" => user.nickname, "profile" => user2.ap_id}
 218         })
 219
 220       assert redirected_to(conn) ==
 221                "https://social.heldscal.la/main/ostatussub?profile=#{user.ap_id}"
 222     end
 223
 224     test "it renders form with error when user not found", %{conn: conn} do
 225       user2 = insert(:user, ap_id: "shp@social.heldscal.la")
 226
 227       response =
 228         conn
 229         |> post("/main/ostatus", %{"user" => %{"nickname" => "jimm", "profile" => user2.ap_id}})
 230         |> response(:ok)
 231
 232       assert response =~ "Something went wrong."
 233     end
 234   end
 235
 236   describe "POST /main/ostatus - remote_subscribe/2 - with statuses" do
 237     setup do: clear_config([:instance, :federating], true)
 238
 239     test "renders subscribe form", %{conn: conn} do
 240       user = insert(:user)
 241       status = insert(:note_activity, %{user: user})
 242       status_id = status.id
 243
 244       assert is_binary(status_id)
 245
 246       response =
 247         conn
 248         |> post("/main/ostatus", %{"status_id" => status_id, "profile" => ""})
 249         |> response(:ok)
 250
 251       refute response =~ "Could not find status"
 252       assert response =~ "Interacting with"
 253     end
 254
 255     test "renders subscribe form with error when status not found", %{conn: conn} do
 256       response =
 257         conn
 258         |> post("/main/ostatus", %{"status_id" => "somerandomid", "profile" => ""})
 259         |> response(:ok)
 260
 261       assert response =~ "Could not find status"
 262       refute response =~ "Interacting with"
 263     end
 264
 265     test "it redirect to webfinger url", %{conn: conn} do
 266       user = insert(:user)
 267       status = insert(:note_activity, %{user: user})
 268       status_id = status.id
 269       status_ap_id = status.data["object"]
 270
 271       assert is_binary(status_id)
 272       assert is_binary(status_ap_id)
 273
 274       user2 = insert(:user, ap_id: "shp@social.heldscal.la")
 275
 276       conn =
 277         conn
 278         |> post("/main/ostatus", %{
 279           "status" => %{"status_id" => status_id, "profile" => user2.ap_id}
 280         })
 281
 282       assert redirected_to(conn) ==
 283                "https://social.heldscal.la/main/ostatussub?profile=#{status_ap_id}"
 284     end
 285
 286     test "it renders form with error when status not found", %{conn: conn} do
 287       user2 = insert(:user, ap_id: "shp@social.heldscal.la")
 288
 289       response =
 290         conn
 291         |> post("/main/ostatus", %{
 292           "status" => %{"status_id" => "somerandomid", "profile" => user2.ap_id}
 293         })
 294         |> response(:ok)
 295
 296       assert response =~ "Something went wrong."
 297     end
 298   end
 299
 300   describe "GET /main/ostatus - show_subscribe_form/2" do
 301     setup do: clear_config([:instance, :federating], true)
 302
 303     test "it works with users", %{conn: conn} do
 304       user = insert(:user)
 305
 306       response =
 307         conn
 308         |> get("/main/ostatus", %{"nickname" => user.nickname})
 309         |> response(:ok)
 310
 311       refute response =~ "Could not find user"
 312       assert response =~ "Remotely follow #{user.nickname}"
 313     end
 314
 315     test "it works with statuses", %{conn: conn} do
 316       user = insert(:user)
 317       status = insert(:note_activity, %{user: user})
 318       status_id = status.id
 319
 320       assert is_binary(status_id)
 321
 322       response =
 323         conn
 324         |> get("/main/ostatus", %{"status_id" => status_id})
 325         |> response(:ok)
 326
 327       refute response =~ "Could not find status"
 328       assert response =~ "Interacting with"
 329     end
 330   end
 331
 332   test "it returns new captcha", %{conn: conn} do
 333     with_mock Pleroma.Captcha,
 334       new: fn -> "test_captcha" end do
 335       resp =
 336         conn
 337         |> get("/api/v1/pleroma/captcha")
 338         |> response(200)
 339
 340       assert resp == "\"test_captcha\""
 341       assert called(Pleroma.Captcha.new())
 342     end
 343   end
 344
 345   describe "POST /api/pleroma/change_email" do
 346     setup do: oauth_access(["write:accounts"])
 347
 348     test "without permissions", %{conn: conn} do
 349       conn =
 350         conn
 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"})
 354
 355       assert json_response_and_validate_schema(conn, 403) == %{
 356                "error" => "Insufficient permissions: write:accounts."
 357              }
 358     end
 359
 360     test "with proper permissions and invalid password", %{conn: conn} do
 361       conn =
 362         conn
 363         |> put_req_header("content-type", "multipart/form-data")
 364         |> post("/api/pleroma/change_email", %{password: "hi", email: "test@test.com"})
 365
 366       assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
 367     end
 368
 369     test "with proper permissions, valid password and invalid email", %{
 370       conn: conn
 371     } do
 372       conn =
 373         conn
 374         |> put_req_header("content-type", "multipart/form-data")
 375         |> post("/api/pleroma/change_email", %{password: "test", email: "foobar"})
 376
 377       assert json_response_and_validate_schema(conn, 200) == %{
 378                "error" => "Email has invalid format."
 379              }
 380     end
 381
 382     test "with proper permissions, valid password and no email", %{
 383       conn: conn
 384     } do
 385       conn =
 386         conn
 387         |> put_req_header("content-type", "multipart/form-data")
 388         |> post("/api/pleroma/change_email", %{password: "test"})
 389
 390       assert %{"error" => "Missing field: email."} = json_response_and_validate_schema(conn, 400)
 391     end
 392
 393     test "with proper permissions, valid password and blank email, when instance requires user email",
 394          %{
 395            conn: conn
 396          } do
 397       orig_account_activation_required =
 398         Pleroma.Config.get([:instance, :account_activation_required])
 399
 400       Pleroma.Config.put([:instance, :account_activation_required], true)
 401
 402       on_exit(fn ->
 403         Pleroma.Config.put(
 404           [:instance, :account_activation_required],
 405           orig_account_activation_required
 406         )
 407       end)
 408
 409       conn =
 410         conn
 411         |> put_req_header("content-type", "multipart/form-data")
 412         |> post("/api/pleroma/change_email", %{password: "test", email: ""})
 413
 414       assert json_response_and_validate_schema(conn, 200) == %{"error" => "Email can't be blank."}
 415     end
 416
 417     test "with proper permissions, valid password and blank email, when instance does not require user email",
 418          %{
 419            conn: conn
 420          } do
 421       orig_account_activation_required =
 422         Pleroma.Config.get([:instance, :account_activation_required])
 423
 424       Pleroma.Config.put([:instance, :account_activation_required], false)
 425
 426       on_exit(fn ->
 427         Pleroma.Config.put(
 428           [:instance, :account_activation_required],
 429           orig_account_activation_required
 430         )
 431       end)
 432
 433       conn =
 434         conn
 435         |> put_req_header("content-type", "multipart/form-data")
 436         |> post("/api/pleroma/change_email", %{password: "test", email: ""})
 437
 438       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 439     end
 440
 441     test "with proper permissions, valid password and non unique email", %{
 442       conn: conn
 443     } do
 444       user = insert(:user)
 445
 446       conn =
 447         conn
 448         |> put_req_header("content-type", "multipart/form-data")
 449         |> post("/api/pleroma/change_email", %{password: "test", email: user.email})
 450
 451       assert json_response_and_validate_schema(conn, 200) == %{
 452                "error" => "Email has already been taken."
 453              }
 454     end
 455
 456     test "with proper permissions, valid password and valid email", %{
 457       conn: conn
 458     } do
 459       conn =
 460         conn
 461         |> put_req_header("content-type", "multipart/form-data")
 462         |> post("/api/pleroma/change_email", %{
 463           password: "test",
 464           email: "cofe@foobar.com"
 465         })
 466
 467       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 468     end
 469   end
 470
 471   describe "POST /api/pleroma/change_password" do
 472     setup do: oauth_access(["write:accounts"])
 473
 474     test "without permissions", %{conn: conn} do
 475       conn =
 476         conn
 477         |> assign(:token, nil)
 478         |> put_req_header("content-type", "multipart/form-data")
 479         |> post("/api/pleroma/change_password", %{
 480           "password" => "hi",
 481           "new_password" => "newpass",
 482           "new_password_confirmation" => "newpass"
 483         })
 484
 485       assert json_response_and_validate_schema(conn, 403) == %{
 486                "error" => "Insufficient permissions: write:accounts."
 487              }
 488     end
 489
 490     test "with proper permissions and invalid password", %{conn: conn} do
 491       conn =
 492         conn
 493         |> put_req_header("content-type", "multipart/form-data")
 494         |> post("/api/pleroma/change_password", %{
 495           "password" => "hi",
 496           "new_password" => "newpass",
 497           "new_password_confirmation" => "newpass"
 498         })
 499
 500       assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
 501     end
 502
 503     test "with proper permissions, valid password and new password and confirmation not matching",
 504          %{
 505            conn: conn
 506          } do
 507       conn =
 508         conn
 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"
 514         })
 515
 516       assert json_response_and_validate_schema(conn, 200) == %{
 517                "error" => "New password does not match confirmation."
 518              }
 519     end
 520
 521     test "with proper permissions, valid password and invalid new password", %{
 522       conn: conn
 523     } do
 524       conn =
 525         conn
 526         |> put_req_header("content-type", "multipart/form-data")
 527         |> post("/api/pleroma/change_password", %{
 528           password: "test",
 529           new_password: "",
 530           new_password_confirmation: ""
 531         })
 532
 533       assert json_response_and_validate_schema(conn, 200) == %{
 534                "error" => "New password can't be blank."
 535              }
 536     end
 537
 538     test "with proper permissions, valid password and matching new password and confirmation", %{
 539       conn: conn,
 540       user: user
 541     } do
 542       conn =
 543         conn
 544         |> put_req_header("content-type", "multipart/form-data")
 545         |> post(
 546           "/api/pleroma/change_password",
 547           %{
 548             password: "test",
 549             new_password: "newpass",
 550             new_password_confirmation: "newpass"
 551           }
 552         )
 553
 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.Pbkdf2.verify_pass("newpass", fetched_user.password_hash) == true
 557     end
 558   end
 559
 560   describe "POST /api/pleroma/delete_account" do
 561     setup do: oauth_access(["write:accounts"])
 562
 563     test "without permissions", %{conn: conn} do
 564       conn =
 565         conn
 566         |> assign(:token, nil)
 567         |> post("/api/pleroma/delete_account")
 568
 569       assert json_response_and_validate_schema(conn, 403) ==
 570                %{"error" => "Insufficient permissions: write:accounts."}
 571     end
 572
 573     test "with proper permissions and wrong or missing password", %{conn: conn} do
 574       for params <- [%{"password" => "hi"}, %{}] do
 575         ret_conn =
 576           conn
 577           |> put_req_header("content-type", "application/json")
 578           |> post("/api/pleroma/delete_account", params)
 579
 580         assert json_response_and_validate_schema(ret_conn, 200) == %{
 581                  "error" => "Invalid password."
 582                }
 583       end
 584     end
 585
 586     test "with proper permissions and valid password (URL query)", %{conn: conn, user: user} do
 587       conn =
 588         conn
 589         |> put_req_header("content-type", "application/json")
 590         |> post("/api/pleroma/delete_account?password=test")
 591
 592       ObanHelpers.perform_all()
 593       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 594
 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
 600     end
 601
 602     test "with proper permissions and valid password (JSON body)", %{conn: conn, user: user} do
 603       conn =
 604         conn
 605         |> put_req_header("content-type", "application/json")
 606         |> post("/api/pleroma/delete_account", %{password: "test"})
 607
 608       ObanHelpers.perform_all()
 609       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 610
 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
 616     end
 617   end
 618
 619   describe "POST /api/pleroma/move_account" do
 620     setup do: oauth_access(["write:accounts"])
 621
 622     test "without permissions", %{conn: conn} do
 623       target_user = insert(:user)
 624       target_nick = target_user |> User.full_nickname()
 625
 626       conn =
 627         conn
 628         |> assign(:token, nil)
 629         |> put_req_header("content-type", "multipart/form-data")
 630         |> post("/api/pleroma/move_account", %{
 631           "password" => "hi",
 632           "target_account" => target_nick
 633         })
 634
 635       assert json_response_and_validate_schema(conn, 403) == %{
 636                "error" => "Insufficient permissions: write:accounts."
 637              }
 638     end
 639
 640     test "with proper permissions and invalid password", %{conn: conn} do
 641       target_user = insert(:user)
 642       target_nick = target_user |> User.full_nickname()
 643
 644       conn =
 645         conn
 646         |> put_req_header("content-type", "multipart/form-data")
 647         |> post("/api/pleroma/move_account", %{
 648           "password" => "hi",
 649           "target_account" => target_nick
 650         })
 651
 652       assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
 653     end
 654
 655     test "with proper permissions, valid password and target account does not alias this",
 656          %{
 657            conn: conn
 658          } do
 659       target_user = insert(:user)
 660       target_nick = target_user |> User.full_nickname()
 661
 662       conn =
 663         conn
 664         |> put_req_header("content-type", "multipart/form-data")
 665         |> post("/api/pleroma/move_account", %{
 666           "password" => "test",
 667           "target_account" => target_nick
 668         })
 669
 670       assert json_response_and_validate_schema(conn, 200) == %{
 671                "error" => "Target account must have the origin in `alsoKnownAs`"
 672              }
 673     end
 674
 675     test "with proper permissions, valid password and target account does not exist",
 676          %{
 677            conn: conn
 678          } do
 679       target_nick = "not_found@mastodon.social"
 680
 681       conn =
 682         conn
 683         |> put_req_header("content-type", "multipart/form-data")
 684         |> post("/api/pleroma/move_account", %{
 685           "password" => "test",
 686           "target_account" => target_nick
 687         })
 688
 689       assert json_response_and_validate_schema(conn, 404) == %{
 690                "error" => "Target account not found."
 691              }
 692     end
 693
 694     test "with proper permissions, valid password, remote target account aliases this and local cache does not exist",
 695          %{} do
 696       user = insert(:user, ap_id: "https://lm.kazv.moe/users/testuser")
 697       %{user: _user, conn: conn} = oauth_access(["write:accounts"], user: user)
 698
 699       target_nick = "mewmew@lm.kazv.moe"
 700
 701       conn =
 702         conn
 703         |> put_req_header("content-type", "multipart/form-data")
 704         |> post("/api/pleroma/move_account", %{
 705           "password" => "test",
 706           "target_account" => target_nick
 707         })
 708
 709       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 710     end
 711
 712     test "with proper permissions, valid password, remote target account aliases this and local cache does not alias this",
 713          %{} do
 714       user = insert(:user, ap_id: "https://lm.kazv.moe/users/testuser")
 715       %{user: _user, conn: conn} = oauth_access(["write:accounts"], user: user)
 716
 717       target_user =
 718         insert(
 719           :user,
 720           ap_id: "https://lm.kazv.moe/users/mewmew",
 721           nickname: "mewmew@lm.kazv.moe",
 722           local: false
 723         )
 724
 725       target_nick = target_user |> User.full_nickname()
 726
 727       conn =
 728         conn
 729         |> put_req_header("content-type", "multipart/form-data")
 730         |> post("/api/pleroma/move_account", %{
 731           "password" => "test",
 732           "target_account" => target_nick
 733         })
 734
 735       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 736     end
 737
 738     test "with proper permissions, valid password, remote target account does not alias this and local cache aliases this",
 739          %{
 740            user: user,
 741            conn: conn
 742          } do
 743       target_user =
 744         insert(
 745           :user,
 746           ap_id: "https://lm.kazv.moe/users/mewmew",
 747           nickname: "mewmew@lm.kazv.moe",
 748           local: false,
 749           also_known_as: [user.ap_id]
 750         )
 751
 752       target_nick = target_user |> User.full_nickname()
 753
 754       conn =
 755         conn
 756         |> put_req_header("content-type", "multipart/form-data")
 757         |> post("/api/pleroma/move_account", %{
 758           "password" => "test",
 759           "target_account" => target_nick
 760         })
 761
 762       assert json_response_and_validate_schema(conn, 200) == %{
 763                "error" => "Target account must have the origin in `alsoKnownAs`"
 764              }
 765     end
 766
 767     test "with proper permissions, valid password and target account aliases this", %{
 768       conn: conn,
 769       user: user
 770     } do
 771       target_user = insert(:user, also_known_as: [user.ap_id])
 772       target_nick = target_user |> User.full_nickname()
 773       follower = insert(:user)
 774
 775       User.follow(follower, user)
 776
 777       assert User.following?(follower, user)
 778
 779       conn =
 780         conn
 781         |> put_req_header("content-type", "multipart/form-data")
 782         |> post(
 783           "/api/pleroma/move_account",
 784           %{
 785             password: "test",
 786             target_account: target_nick
 787           }
 788         )
 789
 790       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 791
 792       params = %{
 793         "op" => "move_following",
 794         "origin_id" => user.id,
 795         "target_id" => target_user.id
 796       }
 797
 798       assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
 799
 800       Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})
 801
 802       refute User.following?(follower, user)
 803       assert User.following?(follower, target_user)
 804     end
 805
 806     test "prefix nickname by @ should work", %{
 807       conn: conn,
 808       user: user
 809     } do
 810       target_user = insert(:user, also_known_as: [user.ap_id])
 811       target_nick = target_user |> User.full_nickname()
 812       follower = insert(:user)
 813
 814       User.follow(follower, user)
 815
 816       assert User.following?(follower, user)
 817
 818       conn =
 819         conn
 820         |> put_req_header("content-type", "multipart/form-data")
 821         |> post(
 822           "/api/pleroma/move_account",
 823           %{
 824             password: "test",
 825             target_account: "@" <> target_nick
 826           }
 827         )
 828
 829       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 830
 831       params = %{
 832         "op" => "move_following",
 833         "origin_id" => user.id,
 834         "target_id" => target_user.id
 835       }
 836
 837       assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
 838
 839       Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})
 840
 841       refute User.following?(follower, user)
 842       assert User.following?(follower, target_user)
 843     end
 844   end
 845
 846   describe "GET /api/pleroma/aliases" do
 847     setup do: oauth_access(["read:accounts"])
 848
 849     test "without permissions", %{conn: conn} do
 850       conn =
 851         conn
 852         |> assign(:token, nil)
 853         |> get("/api/pleroma/aliases")
 854
 855       assert json_response_and_validate_schema(conn, 403) == %{
 856                "error" => "Insufficient permissions: read:accounts."
 857              }
 858     end
 859
 860     test "with permissions", %{
 861       conn: conn
 862     } do
 863       assert %{"aliases" => []} =
 864                conn
 865                |> get("/api/pleroma/aliases")
 866                |> json_response_and_validate_schema(200)
 867     end
 868
 869     test "with permissions and aliases", %{} do
 870       user = insert(:user)
 871       user2 = insert(:user)
 872
 873       assert {:ok, user} = user |> User.add_alias(user2)
 874
 875       %{user: _user, conn: conn} = oauth_access(["read:accounts"], user: user)
 876
 877       assert %{"aliases" => aliases} =
 878                conn
 879                |> get("/api/pleroma/aliases")
 880                |> json_response_and_validate_schema(200)
 881
 882       assert aliases == [user2 |> User.full_nickname()]
 883     end
 884   end
 885
 886   describe "PUT /api/pleroma/aliases" do
 887     setup do: oauth_access(["write:accounts"])
 888
 889     test "without permissions", %{conn: conn} do
 890       conn =
 891         conn
 892         |> assign(:token, nil)
 893         |> put_req_header("content-type", "application/json")
 894         |> put("/api/pleroma/aliases", %{alias: "none"})
 895
 896       assert json_response_and_validate_schema(conn, 403) == %{
 897                "error" => "Insufficient permissions: write:accounts."
 898              }
 899     end
 900
 901     test "with permissions, no alias param", %{
 902       conn: conn
 903     } do
 904       conn =
 905         conn
 906         |> put_req_header("content-type", "application/json")
 907         |> put("/api/pleroma/aliases", %{})
 908
 909       assert %{"error" => "Missing field: alias."} = json_response_and_validate_schema(conn, 400)
 910     end
 911
 912     test "with permissions, with alias param", %{
 913       conn: conn
 914     } do
 915       user2 = insert(:user)
 916
 917       conn =
 918         conn
 919         |> put_req_header("content-type", "application/json")
 920         |> put("/api/pleroma/aliases", %{alias: user2 |> User.full_nickname()})
 921
 922       assert json_response_and_validate_schema(conn, 200) == %{
 923                "status" => "success"
 924              }
 925     end
 926   end
 927
 928   describe "DELETE /api/pleroma/aliases" do
 929     setup do
 930       alias_user = insert(:user)
 931       non_alias_user = insert(:user)
 932       user = insert(:user, also_known_as: [alias_user.ap_id])
 933
 934       oauth_access(["write:accounts"], user: user)
 935       |> Map.put(:alias_user, alias_user)
 936       |> Map.put(:non_alias_user, non_alias_user)
 937     end
 938
 939     test "without permissions", %{conn: conn} do
 940       conn =
 941         conn
 942         |> assign(:token, nil)
 943         |> put_req_header("content-type", "application/json")
 944         |> delete("/api/pleroma/aliases", %{alias: "none"})
 945
 946       assert json_response_and_validate_schema(conn, 403) == %{
 947                "error" => "Insufficient permissions: write:accounts."
 948              }
 949     end
 950
 951     test "with permissions, no alias param", %{conn: conn} do
 952       conn =
 953         conn
 954         |> put_req_header("content-type", "application/json")
 955         |> delete("/api/pleroma/aliases", %{})
 956
 957       assert %{"error" => "Missing field: alias."} = json_response_and_validate_schema(conn, 400)
 958     end
 959
 960     test "with permissions, account does not have such alias", %{
 961       conn: conn,
 962       non_alias_user: non_alias_user
 963     } do
 964       conn =
 965         conn
 966         |> put_req_header("content-type", "application/json")
 967         |> delete("/api/pleroma/aliases", %{
 968           alias: non_alias_user |> User.full_nickname()
 969         })
 970
 971       assert %{"error" => "Account has no such alias."} =
 972                json_response_and_validate_schema(conn, 404)
 973     end
 974
 975     test "with permissions, account does have such alias", %{
 976       conn: conn,
 977       alias_user: alias_user
 978     } do
 979       conn =
 980         conn
 981         |> put_req_header("content-type", "application/json")
 982         |> delete("/api/pleroma/aliases", %{alias: alias_user |> User.full_nickname()})
 983
 984       assert %{"status" => "success"} = json_response_and_validate_schema(conn, 200)
 985     end
 986   end
 987 end