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/pleroma/emoji" do
  81     test "returns json with custom emoji with tags", %{conn: conn} do
  82       emoji =
  83         conn
  84         |> get("/api/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/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/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/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/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/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", %{password: "test", email: "cofe@foobar.com"})
 463
 464       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 465     end
 466   end
 467
 468   describe "POST /api/pleroma/change_password" do
 469     setup do: oauth_access(["write:accounts"])
 470
 471     test "without permissions", %{conn: conn} do
 472       conn =
 473         conn
 474         |> assign(:token, nil)
 475         |> put_req_header("content-type", "multipart/form-data")
 476         |> post("/api/pleroma/change_password", %{
 477           "password" => "hi",
 478           "new_password" => "newpass",
 479           "new_password_confirmation" => "newpass"
 480         })
 481
 482       assert json_response_and_validate_schema(conn, 403) == %{
 483                "error" => "Insufficient permissions: write:accounts."
 484              }
 485     end
 486
 487     test "with proper permissions and invalid password", %{conn: conn} do
 488       conn =
 489         conn
 490         |> put_req_header("content-type", "multipart/form-data")
 491         |> post("/api/pleroma/change_password", %{
 492           "password" => "hi",
 493           "new_password" => "newpass",
 494           "new_password_confirmation" => "newpass"
 495         })
 496
 497       assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
 498     end
 499
 500     test "with proper permissions, valid password and new password and confirmation not matching",
 501          %{
 502            conn: conn
 503          } do
 504       conn =
 505         conn
 506         |> put_req_header("content-type", "multipart/form-data")
 507         |> post("/api/pleroma/change_password", %{
 508           "password" => "test",
 509           "new_password" => "newpass",
 510           "new_password_confirmation" => "notnewpass"
 511         })
 512
 513       assert json_response_and_validate_schema(conn, 200) == %{
 514                "error" => "New password does not match confirmation."
 515              }
 516     end
 517
 518     test "with proper permissions, valid password and invalid new password", %{
 519       conn: conn
 520     } do
 521       conn =
 522         conn
 523         |> put_req_header("content-type", "multipart/form-data")
 524         |> post("/api/pleroma/change_password", %{
 525           password: "test",
 526           new_password: "",
 527           new_password_confirmation: ""
 528         })
 529
 530       assert json_response_and_validate_schema(conn, 200) == %{
 531                "error" => "New password can't be blank."
 532              }
 533     end
 534
 535     test "with proper permissions, valid password and matching new password and confirmation", %{
 536       conn: conn,
 537       user: user
 538     } do
 539       conn =
 540         conn
 541         |> put_req_header("content-type", "multipart/form-data")
 542         |> post(
 543           "/api/pleroma/change_password",
 544           %{
 545             password: "test",
 546             new_password: "newpass",
 547             new_password_confirmation: "newpass"
 548           }
 549         )
 550
 551       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 552       fetched_user = User.get_cached_by_id(user.id)
 553       assert Pleroma.Password.Pbkdf2.verify_pass("newpass", fetched_user.password_hash) == true
 554     end
 555   end
 556
 557   describe "POST /api/pleroma/delete_account" do
 558     setup do: oauth_access(["write:accounts"])
 559
 560     test "without permissions", %{conn: conn} do
 561       conn =
 562         conn
 563         |> assign(:token, nil)
 564         |> post("/api/pleroma/delete_account")
 565
 566       assert json_response_and_validate_schema(conn, 403) ==
 567                %{"error" => "Insufficient permissions: write:accounts."}
 568     end
 569
 570     test "with proper permissions and wrong or missing password", %{conn: conn} do
 571       for params <- [%{"password" => "hi"}, %{}] do
 572         ret_conn =
 573           conn
 574           |> put_req_header("content-type", "application/json")
 575           |> post("/api/pleroma/delete_account", params)
 576
 577         assert json_response_and_validate_schema(ret_conn, 200) == %{
 578                  "error" => "Invalid password."
 579                }
 580       end
 581     end
 582
 583     test "with proper permissions and valid password (URL query)", %{conn: conn, user: user} do
 584       conn =
 585         conn
 586         |> put_req_header("content-type", "application/json")
 587         |> post("/api/pleroma/delete_account?password=test")
 588
 589       ObanHelpers.perform_all()
 590       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 591
 592       user = User.get_by_id(user.id)
 593       refute user.is_active
 594       assert user.name == nil
 595       assert user.bio == ""
 596       assert user.password_hash == nil
 597     end
 598
 599     test "with proper permissions and valid password (JSON body)", %{conn: conn, user: user} do
 600       conn =
 601         conn
 602         |> put_req_header("content-type", "application/json")
 603         |> post("/api/pleroma/delete_account", %{password: "test"})
 604
 605       ObanHelpers.perform_all()
 606       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 607
 608       user = User.get_by_id(user.id)
 609       refute user.is_active
 610       assert user.name == nil
 611       assert user.bio == ""
 612       assert user.password_hash == nil
 613     end
 614   end
 615
 616   describe "POST /api/pleroma/move_account" do
 617     setup do: oauth_access(["write:accounts"])
 618
 619     test "without permissions", %{conn: conn} do
 620       target_user = insert(:user)
 621       target_nick = target_user |> User.full_nickname()
 622
 623       conn =
 624         conn
 625         |> assign(:token, nil)
 626         |> put_req_header("content-type", "multipart/form-data")
 627         |> post("/api/pleroma/move_account", %{
 628           "password" => "hi",
 629           "target_account" => target_nick
 630         })
 631
 632       assert json_response_and_validate_schema(conn, 403) == %{
 633                "error" => "Insufficient permissions: write:accounts."
 634              }
 635     end
 636
 637     test "with proper permissions and invalid password", %{conn: conn} do
 638       target_user = insert(:user)
 639       target_nick = target_user |> User.full_nickname()
 640
 641       conn =
 642         conn
 643         |> put_req_header("content-type", "multipart/form-data")
 644         |> post("/api/pleroma/move_account", %{
 645           "password" => "hi",
 646           "target_account" => target_nick
 647         })
 648
 649       assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
 650     end
 651
 652     test "with proper permissions, valid password and target account does not alias this",
 653          %{
 654            conn: conn
 655          } do
 656       target_user = insert(:user)
 657       target_nick = target_user |> User.full_nickname()
 658
 659       conn =
 660         conn
 661         |> put_req_header("content-type", "multipart/form-data")
 662         |> post("/api/pleroma/move_account", %{
 663           "password" => "test",
 664           "target_account" => target_nick
 665         })
 666
 667       assert json_response_and_validate_schema(conn, 200) == %{
 668                "error" => "Target account must have the origin in `alsoKnownAs`"
 669              }
 670     end
 671
 672     test "with proper permissions, valid password and target account does not exist",
 673          %{
 674            conn: conn
 675          } do
 676       target_nick = "not_found@mastodon.social"
 677
 678       conn =
 679         conn
 680         |> put_req_header("content-type", "multipart/form-data")
 681         |> post("/api/pleroma/move_account", %{
 682           "password" => "test",
 683           "target_account" => target_nick
 684         })
 685
 686       assert json_response_and_validate_schema(conn, 404) == %{
 687                "error" => "Target account not found."
 688              }
 689     end
 690
 691     test "with proper permissions, valid password, remote target account aliases this and local cache does not exist",
 692          %{} do
 693       user = insert(:user, ap_id: "https://lm.kazv.moe/users/testuser")
 694       %{user: _user, conn: conn} = oauth_access(["write:accounts"], user: user)
 695
 696       target_nick = "mewmew@lm.kazv.moe"
 697
 698       conn =
 699         conn
 700         |> put_req_header("content-type", "multipart/form-data")
 701         |> post("/api/pleroma/move_account", %{
 702           "password" => "test",
 703           "target_account" => target_nick
 704         })
 705
 706       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 707     end
 708
 709     test "with proper permissions, valid password, remote target account aliases this and local cache does not alias this",
 710          %{} do
 711       user = insert(:user, ap_id: "https://lm.kazv.moe/users/testuser")
 712       %{user: _user, conn: conn} = oauth_access(["write:accounts"], user: user)
 713
 714       target_user =
 715         insert(
 716           :user,
 717           ap_id: "https://lm.kazv.moe/users/mewmew",
 718           nickname: "mewmew@lm.kazv.moe",
 719           local: false
 720         )
 721
 722       target_nick = target_user |> User.full_nickname()
 723
 724       conn =
 725         conn
 726         |> put_req_header("content-type", "multipart/form-data")
 727         |> post("/api/pleroma/move_account", %{
 728           "password" => "test",
 729           "target_account" => target_nick
 730         })
 731
 732       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 733     end
 734
 735     test "with proper permissions, valid password, remote target account does not alias this and local cache aliases this",
 736          %{
 737            user: user,
 738            conn: conn
 739          } do
 740       target_user =
 741         insert(
 742           :user,
 743           ap_id: "https://lm.kazv.moe/users/mewmew",
 744           nickname: "mewmew@lm.kazv.moe",
 745           local: false,
 746           also_known_as: [user.ap_id]
 747         )
 748
 749       target_nick = target_user |> User.full_nickname()
 750
 751       conn =
 752         conn
 753         |> put_req_header("content-type", "multipart/form-data")
 754         |> post("/api/pleroma/move_account", %{
 755           "password" => "test",
 756           "target_account" => target_nick
 757         })
 758
 759       assert json_response_and_validate_schema(conn, 200) == %{
 760                "error" => "Target account must have the origin in `alsoKnownAs`"
 761              }
 762     end
 763
 764     test "with proper permissions, valid password and target account aliases this", %{
 765       conn: conn,
 766       user: user
 767     } do
 768       target_user = insert(:user, also_known_as: [user.ap_id])
 769       target_nick = target_user |> User.full_nickname()
 770       follower = insert(:user)
 771
 772       User.follow(follower, user)
 773
 774       assert User.following?(follower, user)
 775
 776       conn =
 777         conn
 778         |> put_req_header("content-type", "multipart/form-data")
 779         |> post(
 780           "/api/pleroma/move_account",
 781           %{
 782             password: "test",
 783             target_account: target_nick
 784           }
 785         )
 786
 787       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 788
 789       params = %{
 790         "op" => "move_following",
 791         "origin_id" => user.id,
 792         "target_id" => target_user.id
 793       }
 794
 795       assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
 796
 797       Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})
 798
 799       refute User.following?(follower, user)
 800       assert User.following?(follower, target_user)
 801     end
 802
 803     test "prefix nickname by @ should work", %{
 804       conn: conn,
 805       user: user
 806     } do
 807       target_user = insert(:user, also_known_as: [user.ap_id])
 808       target_nick = target_user |> User.full_nickname()
 809       follower = insert(:user)
 810
 811       User.follow(follower, user)
 812
 813       assert User.following?(follower, user)
 814
 815       conn =
 816         conn
 817         |> put_req_header("content-type", "multipart/form-data")
 818         |> post(
 819           "/api/pleroma/move_account",
 820           %{
 821             password: "test",
 822             target_account: "@" <> target_nick
 823           }
 824         )
 825
 826       assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
 827
 828       params = %{
 829         "op" => "move_following",
 830         "origin_id" => user.id,
 831         "target_id" => target_user.id
 832       }
 833
 834       assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
 835
 836       Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})
 837
 838       refute User.following?(follower, user)
 839       assert User.following?(follower, target_user)
 840     end
 841   end
 842
 843   describe "GET /api/pleroma/aliases" do
 844     setup do: oauth_access(["read:accounts"])
 845
 846     test "without permissions", %{conn: conn} do
 847       conn =
 848         conn
 849         |> assign(:token, nil)
 850         |> get("/api/pleroma/aliases")
 851
 852       assert json_response_and_validate_schema(conn, 403) == %{
 853                "error" => "Insufficient permissions: read:accounts."
 854              }
 855     end
 856
 857     test "with permissions", %{
 858       conn: conn
 859     } do
 860       assert %{"aliases" => []} =
 861                conn
 862                |> get("/api/pleroma/aliases")
 863                |> json_response_and_validate_schema(200)
 864     end
 865
 866     test "with permissions and aliases", %{} do
 867       user = insert(:user)
 868       user2 = insert(:user)
 869
 870       assert {:ok, user} = user |> User.add_alias(user2)
 871
 872       %{user: _user, conn: conn} = oauth_access(["read:accounts"], user: user)
 873
 874       assert %{"aliases" => aliases} =
 875                conn
 876                |> get("/api/pleroma/aliases")
 877                |> json_response_and_validate_schema(200)
 878
 879       assert aliases == [user2 |> User.full_nickname()]
 880     end
 881   end
 882
 883   describe "PUT /api/pleroma/aliases" do
 884     setup do: oauth_access(["write:accounts"])
 885
 886     test "without permissions", %{conn: conn} do
 887       conn =
 888         conn
 889         |> assign(:token, nil)
 890         |> put_req_header("content-type", "application/json")
 891         |> put("/api/pleroma/aliases", %{alias: "none"})
 892
 893       assert json_response_and_validate_schema(conn, 403) == %{
 894                "error" => "Insufficient permissions: write:accounts."
 895              }
 896     end
 897
 898     test "with permissions, no alias param", %{
 899       conn: conn
 900     } do
 901       conn =
 902         conn
 903         |> put_req_header("content-type", "application/json")
 904         |> put("/api/pleroma/aliases", %{})
 905
 906       assert %{"error" => "Missing field: alias."} = json_response_and_validate_schema(conn, 400)
 907     end
 908
 909     test "with permissions, with alias param", %{
 910       conn: conn
 911     } do
 912       user2 = insert(:user)
 913
 914       conn =
 915         conn
 916         |> put_req_header("content-type", "application/json")
 917         |> put("/api/pleroma/aliases", %{alias: user2 |> User.full_nickname()})
 918
 919       assert json_response_and_validate_schema(conn, 200) == %{
 920                "status" => "success"
 921              }
 922     end
 923   end
 924
 925   describe "DELETE /api/pleroma/aliases" do
 926     setup do
 927       alias_user = insert(:user)
 928       non_alias_user = insert(:user)
 929       user = insert(:user, also_known_as: [alias_user.ap_id])
 930
 931       oauth_access(["write:accounts"], user: user)
 932       |> Map.put(:alias_user, alias_user)
 933       |> Map.put(:non_alias_user, non_alias_user)
 934     end
 935
 936     test "without permissions", %{conn: conn} do
 937       conn =
 938         conn
 939         |> assign(:token, nil)
 940         |> put_req_header("content-type", "application/json")
 941         |> delete("/api/pleroma/aliases", %{alias: "none"})
 942
 943       assert json_response_and_validate_schema(conn, 403) == %{
 944                "error" => "Insufficient permissions: write:accounts."
 945              }
 946     end
 947
 948     test "with permissions, no alias param", %{conn: conn} do
 949       conn =
 950         conn
 951         |> put_req_header("content-type", "application/json")
 952         |> delete("/api/pleroma/aliases", %{})
 953
 954       assert %{"error" => "Missing field: alias."} = json_response_and_validate_schema(conn, 400)
 955     end
 956
 957     test "with permissions, account does not have such alias", %{
 958       conn: conn,
 959       non_alias_user: non_alias_user
 960     } do
 961       conn =
 962         conn
 963         |> put_req_header("content-type", "application/json")
 964         |> delete("/api/pleroma/aliases", %{alias: non_alias_user |> User.full_nickname()})
 965
 966       assert %{"error" => "Account has no such alias."} =
 967                json_response_and_validate_schema(conn, 404)
 968     end
 969
 970     test "with permissions, account does have such alias", %{
 971       conn: conn,
 972       alias_user: alias_user
 973     } do
 974       conn =
 975         conn
 976         |> put_req_header("content-type", "application/json")
 977         |> delete("/api/pleroma/aliases", %{alias: alias_user |> User.full_nickname()})
 978
 979       assert %{"status" => "success"} = json_response_and_validate_schema(conn, 200)
 980     end
 981   end
 982 end