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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 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.Repo
  10   alias Pleroma.Tests.ObanHelpers
  11   alias Pleroma.User
  12   alias Pleroma.Web.CommonAPI
  13   import ExUnit.CaptureLog
  14   import Pleroma.Factory
  15   import Mock
  16
  17   setup do
  18     Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  19     :ok
  20   end
  21
  22   clear_config([:instance])
  23   clear_config([:frontend_configurations, :pleroma_fe])
  24   clear_config([:user, :deny_follow_blocked])
  25
  26   describe "POST /api/pleroma/follow_import" do
  27     test "it returns HTTP 200", %{conn: conn} do
  28       user1 = insert(:user)
  29       user2 = insert(:user)
  30
  31       response =
  32         conn
  33         |> assign(:user, user1)
  34         |> post("/api/pleroma/follow_import", %{"list" => "#{user2.ap_id}"})
  35         |> json_response(:ok)
  36
  37       assert response == "job started"
  38     end
  39
  40     test "it imports follow lists from file", %{conn: conn} do
  41       user1 = insert(:user)
  42       user2 = insert(:user)
  43
  44       with_mocks([
  45         {File, [],
  46          read!: fn "follow_list.txt" ->
  47            "Account address,Show boosts\n#{user2.ap_id},true"
  48          end}
  49       ]) do
  50         response =
  51           conn
  52           |> assign(:user, user1)
  53           |> post("/api/pleroma/follow_import", %{"list" => %Plug.Upload{path: "follow_list.txt"}})
  54           |> json_response(:ok)
  55
  56         assert response == "job started"
  57
  58         assert ObanHelpers.member?(
  59                  %{
  60                    "op" => "follow_import",
  61                    "follower_id" => user1.id,
  62                    "followed_identifiers" => [user2.ap_id]
  63                  },
  64                  all_enqueued(worker: Pleroma.Workers.BackgroundWorker)
  65                )
  66       end
  67     end
  68
  69     test "it imports new-style mastodon follow lists", %{conn: conn} do
  70       user1 = insert(:user)
  71       user2 = insert(:user)
  72
  73       response =
  74         conn
  75         |> assign(:user, user1)
  76         |> post("/api/pleroma/follow_import", %{
  77           "list" => "Account address,Show boosts\n#{user2.ap_id},true"
  78         })
  79         |> json_response(:ok)
  80
  81       assert response == "job started"
  82     end
  83
  84     test "requires 'follow' or 'write:follows' permissions", %{conn: conn} do
  85       token1 = insert(:oauth_token, scopes: ["read", "write"])
  86       token2 = insert(:oauth_token, scopes: ["follow"])
  87       token3 = insert(:oauth_token, scopes: ["something"])
  88       another_user = insert(:user)
  89
  90       for token <- [token1, token2, token3] do
  91         conn =
  92           conn
  93           |> put_req_header("authorization", "Bearer #{token.token}")
  94           |> post("/api/pleroma/follow_import", %{"list" => "#{another_user.ap_id}"})
  95
  96         if token == token3 do
  97           assert %{"error" => "Insufficient permissions: follow | write:follows."} ==
  98                    json_response(conn, 403)
  99         else
 100           assert json_response(conn, 200)
 101         end
 102       end
 103     end
 104   end
 105
 106   describe "POST /api/pleroma/blocks_import" do
 107     test "it returns HTTP 200", %{conn: conn} do
 108       user1 = insert(:user)
 109       user2 = insert(:user)
 110
 111       response =
 112         conn
 113         |> assign(:user, user1)
 114         |> post("/api/pleroma/blocks_import", %{"list" => "#{user2.ap_id}"})
 115         |> json_response(:ok)
 116
 117       assert response == "job started"
 118     end
 119
 120     test "it imports blocks users from file", %{conn: conn} do
 121       user1 = insert(:user)
 122       user2 = insert(:user)
 123       user3 = insert(:user)
 124
 125       with_mocks([
 126         {File, [], read!: fn "blocks_list.txt" -> "#{user2.ap_id} #{user3.ap_id}" end}
 127       ]) do
 128         response =
 129           conn
 130           |> assign(:user, user1)
 131           |> post("/api/pleroma/blocks_import", %{"list" => %Plug.Upload{path: "blocks_list.txt"}})
 132           |> json_response(:ok)
 133
 134         assert response == "job started"
 135
 136         assert ObanHelpers.member?(
 137                  %{
 138                    "op" => "blocks_import",
 139                    "blocker_id" => user1.id,
 140                    "blocked_identifiers" => [user2.ap_id, user3.ap_id]
 141                  },
 142                  all_enqueued(worker: Pleroma.Workers.BackgroundWorker)
 143                )
 144       end
 145     end
 146   end
 147
 148   describe "PUT /api/pleroma/notification_settings" do
 149     test "it updates notification settings", %{conn: conn} do
 150       user = insert(:user)
 151
 152       conn
 153       |> assign(:user, user)
 154       |> put("/api/pleroma/notification_settings", %{
 155         "followers" => false,
 156         "bar" => 1
 157       })
 158       |> json_response(:ok)
 159
 160       user = Repo.get(User, user.id)
 161
 162       assert %{
 163                "followers" => false,
 164                "follows" => true,
 165                "non_follows" => true,
 166                "non_followers" => true
 167              } == user.notification_settings
 168     end
 169   end
 170
 171   describe "GET /api/statusnet/config" do
 172     test "it returns config in xml format", %{conn: conn} do
 173       instance = Pleroma.Config.get(:instance)
 174
 175       response =
 176         conn
 177         |> put_req_header("accept", "application/xml")
 178         |> get("/api/statusnet/config")
 179         |> response(:ok)
 180
 181       assert response ==
 182                "<config>\n<site>\n<name>#{Keyword.get(instance, :name)}</name>\n<site>#{
 183                  Pleroma.Web.base_url()
 184                }</site>\n<textlimit>#{Keyword.get(instance, :limit)}</textlimit>\n<closed>#{
 185                  !Keyword.get(instance, :registrations_open)
 186                }</closed>\n</site>\n</config>\n"
 187     end
 188
 189     test "it returns config in json format", %{conn: conn} do
 190       instance = Pleroma.Config.get(:instance)
 191       Pleroma.Config.put([:instance, :managed_config], true)
 192       Pleroma.Config.put([:instance, :registrations_open], false)
 193       Pleroma.Config.put([:instance, :invites_enabled], true)
 194       Pleroma.Config.put([:instance, :public], false)
 195       Pleroma.Config.put([:frontend_configurations, :pleroma_fe], %{theme: "asuka-hospital"})
 196
 197       response =
 198         conn
 199         |> put_req_header("accept", "application/json")
 200         |> get("/api/statusnet/config")
 201         |> json_response(:ok)
 202
 203       expected_data = %{
 204         "site" => %{
 205           "accountActivationRequired" => "0",
 206           "closed" => "1",
 207           "description" => Keyword.get(instance, :description),
 208           "invitesEnabled" => "1",
 209           "name" => Keyword.get(instance, :name),
 210           "pleromafe" => %{"theme" => "asuka-hospital"},
 211           "private" => "1",
 212           "safeDMMentionsEnabled" => "0",
 213           "server" => Pleroma.Web.base_url(),
 214           "textlimit" => to_string(Keyword.get(instance, :limit)),
 215           "uploadlimit" => %{
 216             "avatarlimit" => to_string(Keyword.get(instance, :avatar_upload_limit)),
 217             "backgroundlimit" => to_string(Keyword.get(instance, :background_upload_limit)),
 218             "bannerlimit" => to_string(Keyword.get(instance, :banner_upload_limit)),
 219             "uploadlimit" => to_string(Keyword.get(instance, :upload_limit))
 220           },
 221           "vapidPublicKey" => Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
 222         }
 223       }
 224
 225       assert response == expected_data
 226     end
 227
 228     test "returns the state of safe_dm_mentions flag", %{conn: conn} do
 229       Pleroma.Config.put([:instance, :safe_dm_mentions], true)
 230
 231       response =
 232         conn
 233         |> get("/api/statusnet/config.json")
 234         |> json_response(:ok)
 235
 236       assert response["site"]["safeDMMentionsEnabled"] == "1"
 237
 238       Pleroma.Config.put([:instance, :safe_dm_mentions], false)
 239
 240       response =
 241         conn
 242         |> get("/api/statusnet/config.json")
 243         |> json_response(:ok)
 244
 245       assert response["site"]["safeDMMentionsEnabled"] == "0"
 246     end
 247
 248     test "it returns the managed config", %{conn: conn} do
 249       Pleroma.Config.put([:instance, :managed_config], false)
 250       Pleroma.Config.put([:frontend_configurations, :pleroma_fe], %{theme: "asuka-hospital"})
 251
 252       response =
 253         conn
 254         |> get("/api/statusnet/config.json")
 255         |> json_response(:ok)
 256
 257       refute response["site"]["pleromafe"]
 258
 259       Pleroma.Config.put([:instance, :managed_config], true)
 260
 261       response =
 262         conn
 263         |> get("/api/statusnet/config.json")
 264         |> json_response(:ok)
 265
 266       assert response["site"]["pleromafe"] == %{"theme" => "asuka-hospital"}
 267     end
 268   end
 269
 270   describe "GET /api/pleroma/frontend_configurations" do
 271     test "returns everything in :pleroma, :frontend_configurations", %{conn: conn} do
 272       config = [
 273         frontend_a: %{
 274           x: 1,
 275           y: 2
 276         },
 277         frontend_b: %{
 278           z: 3
 279         }
 280       ]
 281
 282       Pleroma.Config.put(:frontend_configurations, config)
 283
 284       response =
 285         conn
 286         |> get("/api/pleroma/frontend_configurations")
 287         |> json_response(:ok)
 288
 289       assert response == Jason.encode!(config |> Enum.into(%{})) |> Jason.decode!()
 290     end
 291   end
 292
 293   describe "/api/pleroma/emoji" do
 294     test "returns json with custom emoji with tags", %{conn: conn} do
 295       emoji =
 296         conn
 297         |> get("/api/pleroma/emoji")
 298         |> json_response(200)
 299
 300       assert Enum.all?(emoji, fn
 301                {_key,
 302                 %{
 303                   "image_url" => url,
 304                   "tags" => tags
 305                 }} ->
 306                  is_binary(url) and is_list(tags)
 307              end)
 308     end
 309   end
 310
 311   describe "GET /ostatus_subscribe - remote_follow/2" do
 312     test "adds status to pleroma instance if the `acct` is a status", %{conn: conn} do
 313       conn =
 314         get(
 315           conn,
 316           "/ostatus_subscribe?acct=https://mastodon.social/users/emelie/statuses/101849165031453009"
 317         )
 318
 319       assert redirected_to(conn) =~ "/notice/"
 320     end
 321
 322     test "show follow account page if the `acct` is a account link", %{conn: conn} do
 323       response =
 324         get(
 325           conn,
 326           "/ostatus_subscribe?acct=https://mastodon.social/users/emelie"
 327         )
 328
 329       assert html_response(response, 200) =~ "Log in to follow"
 330     end
 331
 332     test "show follow page if the `acct` is a account link", %{conn: conn} do
 333       user = insert(:user)
 334
 335       response =
 336         conn
 337         |> assign(:user, user)
 338         |> get("/ostatus_subscribe?acct=https://mastodon.social/users/emelie")
 339
 340       assert html_response(response, 200) =~ "Remote follow"
 341     end
 342
 343     test "show follow page with error when user cannot fecth by `acct` link", %{conn: conn} do
 344       user = insert(:user)
 345
 346       assert capture_log(fn ->
 347                response =
 348                  conn
 349                  |> assign(:user, user)
 350                  |> get("/ostatus_subscribe?acct=https://mastodon.social/users/not_found")
 351
 352                assert html_response(response, 200) =~ "Error fetching user"
 353              end) =~ "Object has been deleted"
 354     end
 355   end
 356
 357   describe "POST /ostatus_subscribe - do_remote_follow/2 with assigned user " do
 358     test "follows user", %{conn: conn} do
 359       user = insert(:user)
 360       user2 = insert(:user)
 361
 362       response =
 363         conn
 364         |> assign(:user, user)
 365         |> post("/ostatus_subscribe", %{"user" => %{"id" => user2.id}})
 366         |> response(200)
 367
 368       assert response =~ "Account followed!"
 369       assert user2.follower_address in User.following(user)
 370     end
 371
 372     test "returns error when user is deactivated", %{conn: conn} do
 373       user = insert(:user, deactivated: true)
 374       user2 = insert(:user)
 375
 376       response =
 377         conn
 378         |> assign(:user, user)
 379         |> post("/ostatus_subscribe", %{"user" => %{"id" => user2.id}})
 380         |> response(200)
 381
 382       assert response =~ "Error following account"
 383     end
 384
 385     test "returns error when user is blocked", %{conn: conn} do
 386       Pleroma.Config.put([:user, :deny_follow_blocked], true)
 387       user = insert(:user)
 388       user2 = insert(:user)
 389
 390       {:ok, _user_block} = Pleroma.User.block(user2, user)
 391
 392       response =
 393         conn
 394         |> assign(:user, user)
 395         |> post("/ostatus_subscribe", %{"user" => %{"id" => user2.id}})
 396         |> response(200)
 397
 398       assert response =~ "Error following account"
 399     end
 400
 401     test "returns error when followee not found", %{conn: conn} do
 402       user = insert(:user)
 403
 404       response =
 405         conn
 406         |> assign(:user, user)
 407         |> post("/ostatus_subscribe", %{"user" => %{"id" => "jimm"}})
 408         |> response(200)
 409
 410       assert response =~ "Error following account"
 411     end
 412
 413     test "returns success result when user already in followers", %{conn: conn} do
 414       user = insert(:user)
 415       user2 = insert(:user)
 416       {:ok, _, _, _} = CommonAPI.follow(user, user2)
 417
 418       response =
 419         conn
 420         |> assign(:user, refresh_record(user))
 421         |> post("/ostatus_subscribe", %{"user" => %{"id" => user2.id}})
 422         |> response(200)
 423
 424       assert response =~ "Account followed!"
 425     end
 426   end
 427
 428   describe "POST /ostatus_subscribe - do_remote_follow/2 without assigned user " do
 429     test "follows", %{conn: conn} do
 430       user = insert(:user)
 431       user2 = insert(:user)
 432
 433       response =
 434         conn
 435         |> post("/ostatus_subscribe", %{
 436           "authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
 437         })
 438         |> response(200)
 439
 440       assert response =~ "Account followed!"
 441       assert user2.follower_address in User.following(user)
 442     end
 443
 444     test "returns error when followee not found", %{conn: conn} do
 445       user = insert(:user)
 446
 447       response =
 448         conn
 449         |> post("/ostatus_subscribe", %{
 450           "authorization" => %{"name" => user.nickname, "password" => "test", "id" => "jimm"}
 451         })
 452         |> response(200)
 453
 454       assert response =~ "Error following account"
 455     end
 456
 457     test "returns error when login invalid", %{conn: conn} do
 458       user = insert(:user)
 459
 460       response =
 461         conn
 462         |> post("/ostatus_subscribe", %{
 463           "authorization" => %{"name" => "jimm", "password" => "test", "id" => user.id}
 464         })
 465         |> response(200)
 466
 467       assert response =~ "Wrong username or password"
 468     end
 469
 470     test "returns error when password invalid", %{conn: conn} do
 471       user = insert(:user)
 472       user2 = insert(:user)
 473
 474       response =
 475         conn
 476         |> post("/ostatus_subscribe", %{
 477           "authorization" => %{"name" => user.nickname, "password" => "42", "id" => user2.id}
 478         })
 479         |> response(200)
 480
 481       assert response =~ "Wrong username or password"
 482     end
 483
 484     test "returns error when user is blocked", %{conn: conn} do
 485       Pleroma.Config.put([:user, :deny_follow_blocked], true)
 486       user = insert(:user)
 487       user2 = insert(:user)
 488       {:ok, _user_block} = Pleroma.User.block(user2, user)
 489
 490       response =
 491         conn
 492         |> post("/ostatus_subscribe", %{
 493           "authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
 494         })
 495         |> response(200)
 496
 497       assert response =~ "Error following account"
 498     end
 499   end
 500
 501   describe "GET /api/pleroma/healthcheck" do
 502     clear_config([:instance, :healthcheck])
 503
 504     test "returns 503 when healthcheck disabled", %{conn: conn} do
 505       Pleroma.Config.put([:instance, :healthcheck], false)
 506
 507       response =
 508         conn
 509         |> get("/api/pleroma/healthcheck")
 510         |> json_response(503)
 511
 512       assert response == %{}
 513     end
 514
 515     test "returns 200 when healthcheck enabled and all ok", %{conn: conn} do
 516       Pleroma.Config.put([:instance, :healthcheck], true)
 517
 518       with_mock Pleroma.Healthcheck,
 519         system_info: fn -> %Pleroma.Healthcheck{healthy: true} end do
 520         response =
 521           conn
 522           |> get("/api/pleroma/healthcheck")
 523           |> json_response(200)
 524
 525         assert %{
 526                  "active" => _,
 527                  "healthy" => true,
 528                  "idle" => _,
 529                  "memory_used" => _,
 530                  "pool_size" => _
 531                } = response
 532       end
 533     end
 534
 535     test "returns 503 when healthcheck enabled and  health is false", %{conn: conn} do
 536       Pleroma.Config.put([:instance, :healthcheck], true)
 537
 538       with_mock Pleroma.Healthcheck,
 539         system_info: fn -> %Pleroma.Healthcheck{healthy: false} end do
 540         response =
 541           conn
 542           |> get("/api/pleroma/healthcheck")
 543           |> json_response(503)
 544
 545         assert %{
 546                  "active" => _,
 547                  "healthy" => false,
 548                  "idle" => _,
 549                  "memory_used" => _,
 550                  "pool_size" => _
 551                } = response
 552       end
 553     end
 554   end
 555
 556   describe "POST /api/pleroma/disable_account" do
 557     test "it returns HTTP 200", %{conn: conn} do
 558       user = insert(:user)
 559
 560       response =
 561         conn
 562         |> assign(:user, user)
 563         |> post("/api/pleroma/disable_account", %{"password" => "test"})
 564         |> json_response(:ok)
 565
 566       assert response == %{"status" => "success"}
 567       ObanHelpers.perform_all()
 568
 569       user = User.get_cached_by_id(user.id)
 570
 571       assert user.deactivated == true
 572     end
 573
 574     test "it returns returns when password invalid", %{conn: conn} do
 575       user = insert(:user)
 576
 577       response =
 578         conn
 579         |> assign(:user, user)
 580         |> post("/api/pleroma/disable_account", %{"password" => "test1"})
 581         |> json_response(:ok)
 582
 583       assert response == %{"error" => "Invalid password."}
 584       user = User.get_cached_by_id(user.id)
 585
 586       refute user.deactivated
 587     end
 588   end
 589
 590   describe "GET /api/statusnet/version" do
 591     test "it returns version in xml format", %{conn: conn} do
 592       response =
 593         conn
 594         |> put_req_header("accept", "application/xml")
 595         |> get("/api/statusnet/version")
 596         |> response(:ok)
 597
 598       assert response == "<version>#{Pleroma.Application.named_version()}</version>"
 599     end
 600
 601     test "it returns version in json format", %{conn: conn} do
 602       response =
 603         conn
 604         |> put_req_header("accept", "application/json")
 605         |> get("/api/statusnet/version")
 606         |> json_response(:ok)
 607
 608       assert response == "#{Pleroma.Application.named_version()}"
 609     end
 610   end
 611
 612   describe "POST /main/ostatus - remote_subscribe/2" do
 613     test "renders subscribe form", %{conn: conn} do
 614       user = insert(:user)
 615
 616       response =
 617         conn
 618         |> post("/main/ostatus", %{"nickname" => user.nickname, "profile" => ""})
 619         |> response(:ok)
 620
 621       refute response =~ "Could not find user"
 622       assert response =~ "Remotely follow #{user.nickname}"
 623     end
 624
 625     test "renders subscribe form with error when user not found", %{conn: conn} do
 626       response =
 627         conn
 628         |> post("/main/ostatus", %{"nickname" => "nickname", "profile" => ""})
 629         |> response(:ok)
 630
 631       assert response =~ "Could not find user"
 632       refute response =~ "Remotely follow"
 633     end
 634
 635     test "it redirect to webfinger url", %{conn: conn} do
 636       user = insert(:user)
 637       user2 = insert(:user, ap_id: "shp@social.heldscal.la")
 638
 639       conn =
 640         conn
 641         |> post("/main/ostatus", %{
 642           "user" => %{"nickname" => user.nickname, "profile" => user2.ap_id}
 643         })
 644
 645       assert redirected_to(conn) ==
 646                "https://social.heldscal.la/main/ostatussub?profile=#{user.ap_id}"
 647     end
 648
 649     test "it renders form with error when use not found", %{conn: conn} do
 650       user2 = insert(:user, ap_id: "shp@social.heldscal.la")
 651
 652       response =
 653         conn
 654         |> post("/main/ostatus", %{"user" => %{"nickname" => "jimm", "profile" => user2.ap_id}})
 655         |> response(:ok)
 656
 657       assert response =~ "Something went wrong."
 658     end
 659   end
 660
 661   test "it returns new captcha", %{conn: conn} do
 662     with_mock Pleroma.Captcha,
 663       new: fn -> "test_captcha" end do
 664       resp =
 665         conn
 666         |> get("/api/pleroma/captcha")
 667         |> response(200)
 668
 669       assert resp == "\"test_captcha\""
 670       assert called(Pleroma.Captcha.new())
 671     end
 672   end
 673
 674   defp with_credentials(conn, username, password) do
 675     header_content = "Basic " <> Base.encode64("#{username}:#{password}")
 676     put_req_header(conn, "authorization", header_content)
 677   end
 678
 679   defp valid_user(_context) do
 680     user = insert(:user)
 681     [user: user]
 682   end
 683
 684   describe "POST /api/pleroma/change_email" do
 685     setup [:valid_user]
 686
 687     test "without credentials", %{conn: conn} do
 688       conn = post(conn, "/api/pleroma/change_email")
 689       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 690     end
 691
 692     test "with credentials and invalid password", %{conn: conn, user: current_user} do
 693       conn =
 694         conn
 695         |> with_credentials(current_user.nickname, "test")
 696         |> post("/api/pleroma/change_email", %{
 697           "password" => "hi",
 698           "email" => "test@test.com"
 699         })
 700
 701       assert json_response(conn, 200) == %{"error" => "Invalid password."}
 702     end
 703
 704     test "with credentials, valid password and invalid email", %{
 705       conn: conn,
 706       user: current_user
 707     } do
 708       conn =
 709         conn
 710         |> with_credentials(current_user.nickname, "test")
 711         |> post("/api/pleroma/change_email", %{
 712           "password" => "test",
 713           "email" => "foobar"
 714         })
 715
 716       assert json_response(conn, 200) == %{"error" => "Email has invalid format."}
 717     end
 718
 719     test "with credentials, valid password and no email", %{
 720       conn: conn,
 721       user: current_user
 722     } do
 723       conn =
 724         conn
 725         |> with_credentials(current_user.nickname, "test")
 726         |> post("/api/pleroma/change_email", %{
 727           "password" => "test"
 728         })
 729
 730       assert json_response(conn, 200) == %{"error" => "Email can't be blank."}
 731     end
 732
 733     test "with credentials, valid password and blank email", %{
 734       conn: conn,
 735       user: current_user
 736     } do
 737       conn =
 738         conn
 739         |> with_credentials(current_user.nickname, "test")
 740         |> post("/api/pleroma/change_email", %{
 741           "password" => "test",
 742           "email" => ""
 743         })
 744
 745       assert json_response(conn, 200) == %{"error" => "Email can't be blank."}
 746     end
 747
 748     test "with credentials, valid password and non unique email", %{
 749       conn: conn,
 750       user: current_user
 751     } do
 752       user = insert(:user)
 753
 754       conn =
 755         conn
 756         |> with_credentials(current_user.nickname, "test")
 757         |> post("/api/pleroma/change_email", %{
 758           "password" => "test",
 759           "email" => user.email
 760         })
 761
 762       assert json_response(conn, 200) == %{"error" => "Email has already been taken."}
 763     end
 764
 765     test "with credentials, valid password and valid email", %{
 766       conn: conn,
 767       user: current_user
 768     } do
 769       conn =
 770         conn
 771         |> with_credentials(current_user.nickname, "test")
 772         |> post("/api/pleroma/change_email", %{
 773           "password" => "test",
 774           "email" => "cofe@foobar.com"
 775         })
 776
 777       assert json_response(conn, 200) == %{"status" => "success"}
 778     end
 779   end
 780
 781   describe "POST /api/pleroma/change_password" do
 782     setup [:valid_user]
 783
 784     test "without credentials", %{conn: conn} do
 785       conn = post(conn, "/api/pleroma/change_password")
 786       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 787     end
 788
 789     test "with credentials and invalid password", %{conn: conn, user: current_user} do
 790       conn =
 791         conn
 792         |> with_credentials(current_user.nickname, "test")
 793         |> post("/api/pleroma/change_password", %{
 794           "password" => "hi",
 795           "new_password" => "newpass",
 796           "new_password_confirmation" => "newpass"
 797         })
 798
 799       assert json_response(conn, 200) == %{"error" => "Invalid password."}
 800     end
 801
 802     test "with credentials, valid password and new password and confirmation not matching", %{
 803       conn: conn,
 804       user: current_user
 805     } do
 806       conn =
 807         conn
 808         |> with_credentials(current_user.nickname, "test")
 809         |> post("/api/pleroma/change_password", %{
 810           "password" => "test",
 811           "new_password" => "newpass",
 812           "new_password_confirmation" => "notnewpass"
 813         })
 814
 815       assert json_response(conn, 200) == %{
 816                "error" => "New password does not match confirmation."
 817              }
 818     end
 819
 820     test "with credentials, valid password and invalid new password", %{
 821       conn: conn,
 822       user: current_user
 823     } do
 824       conn =
 825         conn
 826         |> with_credentials(current_user.nickname, "test")
 827         |> post("/api/pleroma/change_password", %{
 828           "password" => "test",
 829           "new_password" => "",
 830           "new_password_confirmation" => ""
 831         })
 832
 833       assert json_response(conn, 200) == %{
 834                "error" => "New password can't be blank."
 835              }
 836     end
 837
 838     test "with credentials, valid password and matching new password and confirmation", %{
 839       conn: conn,
 840       user: current_user
 841     } do
 842       conn =
 843         conn
 844         |> with_credentials(current_user.nickname, "test")
 845         |> post("/api/pleroma/change_password", %{
 846           "password" => "test",
 847           "new_password" => "newpass",
 848           "new_password_confirmation" => "newpass"
 849         })
 850
 851       assert json_response(conn, 200) == %{"status" => "success"}
 852       fetched_user = User.get_cached_by_id(current_user.id)
 853       assert Comeonin.Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
 854     end
 855   end
 856
 857   describe "POST /api/pleroma/delete_account" do
 858     setup [:valid_user]
 859
 860     test "without credentials", %{conn: conn} do
 861       conn = post(conn, "/api/pleroma/delete_account")
 862       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 863     end
 864
 865     test "with credentials and invalid password", %{conn: conn, user: current_user} do
 866       conn =
 867         conn
 868         |> with_credentials(current_user.nickname, "test")
 869         |> post("/api/pleroma/delete_account", %{"password" => "hi"})
 870
 871       assert json_response(conn, 200) == %{"error" => "Invalid password."}
 872     end
 873
 874     test "with credentials and valid password", %{conn: conn, user: current_user} do
 875       conn =
 876         conn
 877         |> with_credentials(current_user.nickname, "test")
 878         |> post("/api/pleroma/delete_account", %{"password" => "test"})
 879
 880       assert json_response(conn, 200) == %{"status" => "success"}
 881       # Wait a second for the started task to end
 882       :timer.sleep(1000)
 883     end
 884   end
 885 end