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

   1 defmodule Pleroma.Web.TwitterAPI.ControllerTest do
   2   use Pleroma.Web.ConnCase
   3   alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
   4   alias Pleroma.Builders.{ActivityBuilder, UserBuilder}
   5   alias Pleroma.{Repo, Activity, User, Object, Notification}
   6   alias Pleroma.Web.ActivityPub.ActivityPub
   7   alias Pleroma.Web.TwitterAPI.UserView
   8   alias Pleroma.Web.TwitterAPI.NotificationView
   9   alias Pleroma.Web.CommonAPI
  10   alias Pleroma.Web.TwitterAPI.TwitterAPI
  11   alias Comeonin.Pbkdf2
  12   alias Ecto.Changeset
  13
  14   import Pleroma.Factory
  15
  16   @banner "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
  17
  18   describe "POST /api/account/update_profile_banner" do
  19     test "it updates the banner", %{conn: conn} do
  20       user = insert(:user)
  21
  22       conn
  23       |> assign(:user, user)
  24       |> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => @banner})
  25       |> json_response(200)
  26
  27       user = refresh_record(user)
  28       assert user.info.banner["type"] == "Image"
  29     end
  30   end
  31
  32   describe "POST /api/qvitter/update_background_image" do
  33     test "it updates the background", %{conn: conn} do
  34       user = insert(:user)
  35
  36       conn
  37       |> assign(:user, user)
  38       |> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => @banner})
  39       |> json_response(200)
  40
  41       user = refresh_record(user)
  42       assert user.info.background["type"] == "Image"
  43     end
  44   end
  45
  46   describe "POST /api/account/verify_credentials" do
  47     setup [:valid_user]
  48
  49     test "without valid credentials", %{conn: conn} do
  50       conn = post(conn, "/api/account/verify_credentials.json")
  51       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  52     end
  53
  54     test "with credentials", %{conn: conn, user: user} do
  55       response =
  56         conn
  57         |> with_credentials(user.nickname, "test")
  58         |> post("/api/account/verify_credentials.json")
  59         |> json_response(200)
  60
  61       assert response == UserView.render("show.json", %{user: user, token: response["token"]})
  62     end
  63   end
  64
  65   describe "POST /statuses/update.json" do
  66     setup [:valid_user]
  67
  68     test "without valid credentials", %{conn: conn} do
  69       conn = post(conn, "/api/statuses/update.json")
  70       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  71     end
  72
  73     test "with credentials", %{conn: conn, user: user} do
  74       conn_with_creds = conn |> with_credentials(user.nickname, "test")
  75       request_path = "/api/statuses/update.json"
  76
  77       error_response = %{
  78         "request" => request_path,
  79         "error" => "Client must provide a 'status' parameter with a value."
  80       }
  81
  82       conn =
  83         conn_with_creds
  84         |> post(request_path)
  85
  86       assert json_response(conn, 400) == error_response
  87
  88       conn =
  89         conn_with_creds
  90         |> post(request_path, %{status: ""})
  91
  92       assert json_response(conn, 400) == error_response
  93
  94       conn =
  95         conn_with_creds
  96         |> post(request_path, %{status: " "})
  97
  98       assert json_response(conn, 400) == error_response
  99
 100       # we post with visibility private in order to avoid triggering relay
 101       conn =
 102         conn_with_creds
 103         |> post(request_path, %{status: "Nice meme.", visibility: "private"})
 104
 105       assert json_response(conn, 200) ==
 106                ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
 107     end
 108   end
 109
 110   describe "GET /statuses/public_timeline.json" do
 111     test "returns statuses", %{conn: conn} do
 112       user = insert(:user)
 113       activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
 114       ActivityBuilder.insert_list(10, %{}, %{user: user})
 115       since_id = List.last(activities).id
 116
 117       conn =
 118         conn
 119         |> get("/api/statuses/public_timeline.json", %{since_id: since_id})
 120
 121       response = json_response(conn, 200)
 122
 123       assert length(response) == 10
 124     end
 125
 126     test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
 127       instance =
 128         Application.get_env(:pleroma, :instance)
 129         |> Keyword.put(:public, false)
 130
 131       Application.put_env(:pleroma, :instance, instance)
 132
 133       conn
 134       |> get("/api/statuses/public_timeline.json")
 135       |> json_response(403)
 136
 137       instance =
 138         Application.get_env(:pleroma, :instance)
 139         |> Keyword.put(:public, true)
 140
 141       Application.put_env(:pleroma, :instance, instance)
 142     end
 143
 144     test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
 145       conn
 146       |> get("/api/statuses/public_timeline.json")
 147       |> json_response(200)
 148     end
 149   end
 150
 151   describe "GET /statuses/public_and_external_timeline.json" do
 152     test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
 153       instance =
 154         Application.get_env(:pleroma, :instance)
 155         |> Keyword.put(:public, false)
 156
 157       Application.put_env(:pleroma, :instance, instance)
 158
 159       conn
 160       |> get("/api/statuses/public_and_external_timeline.json")
 161       |> json_response(403)
 162
 163       instance =
 164         Application.get_env(:pleroma, :instance)
 165         |> Keyword.put(:public, true)
 166
 167       Application.put_env(:pleroma, :instance, instance)
 168     end
 169
 170     test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
 171       conn
 172       |> get("/api/statuses/public_and_external_timeline.json")
 173       |> json_response(200)
 174     end
 175   end
 176
 177   describe "GET /statuses/show/:id.json" do
 178     test "returns one status", %{conn: conn} do
 179       user = insert(:user)
 180       {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
 181       actor = Repo.get_by!(User, ap_id: activity.data["actor"])
 182
 183       conn =
 184         conn
 185         |> get("/api/statuses/show/#{activity.id}.json")
 186
 187       response = json_response(conn, 200)
 188
 189       assert response == ActivityRepresenter.to_map(activity, %{user: actor})
 190     end
 191   end
 192
 193   describe "GET /users/show.json" do
 194     test "gets user with screen_name", %{conn: conn} do
 195       user = insert(:user)
 196
 197       conn =
 198         conn
 199         |> get("/api/users/show.json", %{"screen_name" => user.nickname})
 200
 201       response = json_response(conn, 200)
 202
 203       assert response["id"] == user.id
 204     end
 205
 206     test "gets user with user_id", %{conn: conn} do
 207       user = insert(:user)
 208
 209       conn =
 210         conn
 211         |> get("/api/users/show.json", %{"user_id" => user.id})
 212
 213       response = json_response(conn, 200)
 214
 215       assert response["id"] == user.id
 216     end
 217
 218     test "gets a user for a logged in user", %{conn: conn} do
 219       user = insert(:user)
 220       logged_in = insert(:user)
 221
 222       {:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})
 223
 224       conn =
 225         conn
 226         |> with_credentials(logged_in.nickname, "test")
 227         |> get("/api/users/show.json", %{"user_id" => user.id})
 228
 229       response = json_response(conn, 200)
 230
 231       assert response["following"] == true
 232     end
 233   end
 234
 235   describe "GET /statusnet/conversation/:id.json" do
 236     test "returns the statuses in the conversation", %{conn: conn} do
 237       {:ok, _user} = UserBuilder.insert()
 238       {:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 239       {:ok, _activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 240       {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
 241
 242       conn =
 243         conn
 244         |> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")
 245
 246       response = json_response(conn, 200)
 247
 248       assert length(response) == 2
 249     end
 250   end
 251
 252   describe "GET /statuses/friends_timeline.json" do
 253     setup [:valid_user]
 254
 255     test "without valid credentials", %{conn: conn} do
 256       conn = get(conn, "/api/statuses/friends_timeline.json")
 257       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 258     end
 259
 260     test "with credentials", %{conn: conn, user: current_user} do
 261       user = insert(:user)
 262
 263       activities =
 264         ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
 265
 266       returned_activities =
 267         ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
 268
 269       other_user = insert(:user)
 270       ActivityBuilder.insert_list(10, %{}, %{user: other_user})
 271       since_id = List.last(activities).id
 272
 273       current_user =
 274         Changeset.change(current_user, following: [User.ap_followers(user)])
 275         |> Repo.update!()
 276
 277       conn =
 278         conn
 279         |> with_credentials(current_user.nickname, "test")
 280         |> get("/api/statuses/friends_timeline.json", %{since_id: since_id})
 281
 282       response = json_response(conn, 200)
 283
 284       assert length(response) == 10
 285
 286       assert response ==
 287                Enum.map(returned_activities, fn activity ->
 288                  ActivityRepresenter.to_map(activity, %{
 289                    user: User.get_cached_by_ap_id(activity.data["actor"]),
 290                    for: current_user
 291                  })
 292                end)
 293     end
 294   end
 295
 296   describe "GET /statuses/dm_timeline.json" do
 297     test "it show direct messages", %{conn: conn} do
 298       user_one = insert(:user)
 299       user_two = insert(:user)
 300
 301       {:ok, user_two} = User.follow(user_two, user_one)
 302
 303       {:ok, direct} =
 304         CommonAPI.post(user_one, %{
 305           "status" => "Hi @#{user_two.nickname}!",
 306           "visibility" => "direct"
 307         })
 308
 309       {:ok, direct_two} =
 310         CommonAPI.post(user_two, %{
 311           "status" => "Hi @#{user_one.nickname}!",
 312           "visibility" => "direct"
 313         })
 314
 315       {:ok, _follower_only} =
 316         CommonAPI.post(user_one, %{
 317           "status" => "Hi @#{user_two.nickname}!",
 318           "visibility" => "private"
 319         })
 320
 321       # Only direct should be visible here
 322       res_conn =
 323         conn
 324         |> assign(:user, user_two)
 325         |> get("/api/statuses/dm_timeline.json")
 326
 327       [status, status_two] = json_response(res_conn, 200)
 328       assert status["id"] == direct_two.id
 329       assert status_two["id"] == direct.id
 330     end
 331   end
 332
 333   describe "GET /statuses/mentions.json" do
 334     setup [:valid_user]
 335
 336     test "without valid credentials", %{conn: conn} do
 337       conn = get(conn, "/api/statuses/mentions.json")
 338       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 339     end
 340
 341     test "with credentials", %{conn: conn, user: current_user} do
 342       {:ok, activity} =
 343         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})
 344
 345       conn =
 346         conn
 347         |> with_credentials(current_user.nickname, "test")
 348         |> get("/api/statuses/mentions.json")
 349
 350       response = json_response(conn, 200)
 351
 352       assert length(response) == 1
 353
 354       assert Enum.at(response, 0) ==
 355                ActivityRepresenter.to_map(activity, %{
 356                  user: current_user,
 357                  mentioned: [current_user]
 358                })
 359     end
 360   end
 361
 362   describe "GET /api/qvitter/statuses/notifications.json" do
 363     setup [:valid_user]
 364
 365     test "without valid credentials", %{conn: conn} do
 366       conn = get(conn, "/api/qvitter/statuses/notifications.json")
 367       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 368     end
 369
 370     test "with credentials", %{conn: conn, user: current_user} do
 371       other_user = insert(:user)
 372
 373       {:ok, _activity} =
 374         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
 375
 376       conn =
 377         conn
 378         |> with_credentials(current_user.nickname, "test")
 379         |> get("/api/qvitter/statuses/notifications.json")
 380
 381       response = json_response(conn, 200)
 382
 383       assert length(response) == 1
 384
 385       assert response ==
 386                NotificationView.render("notification.json", %{
 387                  notifications: Notification.for_user(current_user),
 388                  for: current_user
 389                })
 390     end
 391   end
 392
 393   describe "POST /api/qvitter/statuses/notifications/read" do
 394     setup [:valid_user]
 395
 396     test "without valid credentials", %{conn: conn} do
 397       conn = post(conn, "/api/qvitter/statuses/notifications/read", %{"latest_id" => 1_234_567})
 398       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 399     end
 400
 401     test "with credentials, without any params", %{conn: conn, user: current_user} do
 402       conn =
 403         conn
 404         |> with_credentials(current_user.nickname, "test")
 405         |> post("/api/qvitter/statuses/notifications/read")
 406
 407       assert json_response(conn, 400) == %{
 408                "error" => "You need to specify latest_id",
 409                "request" => "/api/qvitter/statuses/notifications/read"
 410              }
 411     end
 412
 413     test "with credentials, with params", %{conn: conn, user: current_user} do
 414       other_user = insert(:user)
 415
 416       {:ok, _activity} =
 417         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
 418
 419       response_conn =
 420         conn
 421         |> with_credentials(current_user.nickname, "test")
 422         |> get("/api/qvitter/statuses/notifications.json")
 423
 424       [notification] = response = json_response(response_conn, 200)
 425
 426       assert length(response) == 1
 427
 428       assert notification["is_seen"] == 0
 429
 430       response_conn =
 431         conn
 432         |> with_credentials(current_user.nickname, "test")
 433         |> post("/api/qvitter/statuses/notifications/read", %{"latest_id" => notification["id"]})
 434
 435       [notification] = response = json_response(response_conn, 200)
 436
 437       assert length(response) == 1
 438
 439       assert notification["is_seen"] == 1
 440     end
 441   end
 442
 443   describe "GET /statuses/user_timeline.json" do
 444     setup [:valid_user]
 445
 446     test "without any params", %{conn: conn} do
 447       conn = get(conn, "/api/statuses/user_timeline.json")
 448
 449       assert json_response(conn, 400) == %{
 450                "error" => "You need to specify screen_name or user_id",
 451                "request" => "/api/statuses/user_timeline.json"
 452              }
 453     end
 454
 455     test "with user_id", %{conn: conn} do
 456       user = insert(:user)
 457       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 458
 459       conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
 460       response = json_response(conn, 200)
 461       assert length(response) == 1
 462       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 463     end
 464
 465     test "with screen_name", %{conn: conn} do
 466       user = insert(:user)
 467       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 468
 469       conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 470       response = json_response(conn, 200)
 471       assert length(response) == 1
 472       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 473     end
 474
 475     test "with credentials", %{conn: conn, user: current_user} do
 476       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
 477
 478       conn =
 479         conn
 480         |> with_credentials(current_user.nickname, "test")
 481         |> get("/api/statuses/user_timeline.json")
 482
 483       response = json_response(conn, 200)
 484
 485       assert length(response) == 1
 486       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
 487     end
 488
 489     test "with credentials with user_id", %{conn: conn, user: current_user} do
 490       user = insert(:user)
 491       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 492
 493       conn =
 494         conn
 495         |> with_credentials(current_user.nickname, "test")
 496         |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
 497
 498       response = json_response(conn, 200)
 499
 500       assert length(response) == 1
 501       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 502     end
 503
 504     test "with credentials screen_name", %{conn: conn, user: current_user} do
 505       user = insert(:user)
 506       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 507
 508       conn =
 509         conn
 510         |> with_credentials(current_user.nickname, "test")
 511         |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 512
 513       response = json_response(conn, 200)
 514
 515       assert length(response) == 1
 516       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 517     end
 518   end
 519
 520   describe "POST /friendships/create.json" do
 521     setup [:valid_user]
 522
 523     test "without valid credentials", %{conn: conn} do
 524       conn = post(conn, "/api/friendships/create.json")
 525       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 526     end
 527
 528     test "with credentials", %{conn: conn, user: current_user} do
 529       followed = insert(:user)
 530
 531       conn =
 532         conn
 533         |> with_credentials(current_user.nickname, "test")
 534         |> post("/api/friendships/create.json", %{user_id: followed.id})
 535
 536       current_user = Repo.get(User, current_user.id)
 537       assert User.ap_followers(followed) in current_user.following
 538
 539       assert json_response(conn, 200) ==
 540                UserView.render("show.json", %{user: followed, for: current_user})
 541     end
 542   end
 543
 544   describe "POST /friendships/destroy.json" do
 545     setup [:valid_user]
 546
 547     test "without valid credentials", %{conn: conn} do
 548       conn = post(conn, "/api/friendships/destroy.json")
 549       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 550     end
 551
 552     test "with credentials", %{conn: conn, user: current_user} do
 553       followed = insert(:user)
 554
 555       {:ok, current_user} = User.follow(current_user, followed)
 556       assert User.ap_followers(followed) in current_user.following
 557       ActivityPub.follow(current_user, followed)
 558
 559       conn =
 560         conn
 561         |> with_credentials(current_user.nickname, "test")
 562         |> post("/api/friendships/destroy.json", %{user_id: followed.id})
 563
 564       current_user = Repo.get(User, current_user.id)
 565       assert current_user.following == [current_user.ap_id]
 566
 567       assert json_response(conn, 200) ==
 568                UserView.render("show.json", %{user: followed, for: current_user})
 569     end
 570   end
 571
 572   describe "POST /blocks/create.json" do
 573     setup [:valid_user]
 574
 575     test "without valid credentials", %{conn: conn} do
 576       conn = post(conn, "/api/blocks/create.json")
 577       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 578     end
 579
 580     test "with credentials", %{conn: conn, user: current_user} do
 581       blocked = insert(:user)
 582
 583       conn =
 584         conn
 585         |> with_credentials(current_user.nickname, "test")
 586         |> post("/api/blocks/create.json", %{user_id: blocked.id})
 587
 588       current_user = Repo.get(User, current_user.id)
 589       assert User.blocks?(current_user, blocked)
 590
 591       assert json_response(conn, 200) ==
 592                UserView.render("show.json", %{user: blocked, for: current_user})
 593     end
 594   end
 595
 596   describe "POST /blocks/destroy.json" do
 597     setup [:valid_user]
 598
 599     test "without valid credentials", %{conn: conn} do
 600       conn = post(conn, "/api/blocks/destroy.json")
 601       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 602     end
 603
 604     test "with credentials", %{conn: conn, user: current_user} do
 605       blocked = insert(:user)
 606
 607       {:ok, current_user, blocked} = TwitterAPI.block(current_user, %{"user_id" => blocked.id})
 608       assert User.blocks?(current_user, blocked)
 609
 610       conn =
 611         conn
 612         |> with_credentials(current_user.nickname, "test")
 613         |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
 614
 615       current_user = Repo.get(User, current_user.id)
 616       assert current_user.info.blocks == []
 617
 618       assert json_response(conn, 200) ==
 619                UserView.render("show.json", %{user: blocked, for: current_user})
 620     end
 621   end
 622
 623   describe "GET /help/test.json" do
 624     test "returns \"ok\"", %{conn: conn} do
 625       conn = get(conn, "/api/help/test.json")
 626       assert json_response(conn, 200) == "ok"
 627     end
 628   end
 629
 630   describe "POST /api/qvitter/update_avatar.json" do
 631     setup [:valid_user]
 632
 633     test "without valid credentials", %{conn: conn} do
 634       conn = post(conn, "/api/qvitter/update_avatar.json")
 635       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 636     end
 637
 638     test "with credentials", %{conn: conn, user: current_user} do
 639       avatar_image = File.read!("test/fixtures/avatar_data_uri")
 640
 641       conn =
 642         conn
 643         |> with_credentials(current_user.nickname, "test")
 644         |> post("/api/qvitter/update_avatar.json", %{img: avatar_image})
 645
 646       current_user = Repo.get(User, current_user.id)
 647       assert is_map(current_user.avatar)
 648
 649       assert json_response(conn, 200) ==
 650                UserView.render("show.json", %{user: current_user, for: current_user})
 651     end
 652   end
 653
 654   describe "GET /api/qvitter/mutes.json" do
 655     setup [:valid_user]
 656
 657     test "unimplemented mutes without valid credentials", %{conn: conn} do
 658       conn = get(conn, "/api/qvitter/mutes.json")
 659       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 660     end
 661
 662     test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
 663       response =
 664         conn
 665         |> with_credentials(current_user.nickname, "test")
 666         |> get("/api/qvitter/mutes.json")
 667         |> json_response(200)
 668
 669       assert [] = response
 670     end
 671   end
 672
 673   describe "POST /api/favorites/create/:id" do
 674     setup [:valid_user]
 675
 676     test "without valid credentials", %{conn: conn} do
 677       note_activity = insert(:note_activity)
 678       conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
 679       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 680     end
 681
 682     test "with credentials", %{conn: conn, user: current_user} do
 683       note_activity = insert(:note_activity)
 684
 685       conn =
 686         conn
 687         |> with_credentials(current_user.nickname, "test")
 688         |> post("/api/favorites/create/#{note_activity.id}.json")
 689
 690       assert json_response(conn, 200)
 691     end
 692
 693     test "with credentials, invalid param", %{conn: conn, user: current_user} do
 694       conn =
 695         conn
 696         |> with_credentials(current_user.nickname, "test")
 697         |> post("/api/favorites/create/wrong.json")
 698
 699       assert json_response(conn, 400)
 700     end
 701
 702     test "with credentials, invalid activity", %{conn: conn, user: current_user} do
 703       conn =
 704         conn
 705         |> with_credentials(current_user.nickname, "test")
 706         |> post("/api/favorites/create/1.json")
 707
 708       assert json_response(conn, 500)
 709     end
 710   end
 711
 712   describe "POST /api/favorites/destroy/:id" do
 713     setup [:valid_user]
 714
 715     test "without valid credentials", %{conn: conn} do
 716       note_activity = insert(:note_activity)
 717       conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
 718       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 719     end
 720
 721     test "with credentials", %{conn: conn, user: current_user} do
 722       note_activity = insert(:note_activity)
 723       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 724       ActivityPub.like(current_user, object)
 725
 726       conn =
 727         conn
 728         |> with_credentials(current_user.nickname, "test")
 729         |> post("/api/favorites/destroy/#{note_activity.id}.json")
 730
 731       assert json_response(conn, 200)
 732     end
 733   end
 734
 735   describe "POST /api/statuses/retweet/:id" do
 736     setup [:valid_user]
 737
 738     test "without valid credentials", %{conn: conn} do
 739       note_activity = insert(:note_activity)
 740       conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
 741       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 742     end
 743
 744     test "with credentials", %{conn: conn, user: current_user} do
 745       note_activity = insert(:note_activity)
 746
 747       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 748
 749       response =
 750         conn
 751         |> with_credentials(current_user.nickname, "test")
 752         |> post(request_path)
 753
 754       activity = Repo.get(Activity, note_activity.id)
 755       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 756
 757       assert json_response(response, 200) ==
 758                ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 759     end
 760   end
 761
 762   describe "POST /api/statuses/unretweet/:id" do
 763     setup [:valid_user]
 764
 765     test "without valid credentials", %{conn: conn} do
 766       note_activity = insert(:note_activity)
 767       conn = post(conn, "/api/statuses/unretweet/#{note_activity.id}.json")
 768       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 769     end
 770
 771     test "with credentials", %{conn: conn, user: current_user} do
 772       note_activity = insert(:note_activity)
 773
 774       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 775
 776       _response =
 777         conn
 778         |> with_credentials(current_user.nickname, "test")
 779         |> post(request_path)
 780
 781       request_path = String.replace(request_path, "retweet", "unretweet")
 782
 783       response =
 784         conn
 785         |> with_credentials(current_user.nickname, "test")
 786         |> post(request_path)
 787
 788       activity = Repo.get(Activity, note_activity.id)
 789       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 790
 791       assert json_response(response, 200) ==
 792                ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 793     end
 794   end
 795
 796   describe "POST /api/account/register" do
 797     test "it creates a new user", %{conn: conn} do
 798       data = %{
 799         "nickname" => "lain",
 800         "email" => "lain@wired.jp",
 801         "fullname" => "lain iwakura",
 802         "bio" => "close the world.",
 803         "password" => "bear",
 804         "confirm" => "bear"
 805       }
 806
 807       conn =
 808         conn
 809         |> post("/api/account/register", data)
 810
 811       user = json_response(conn, 200)
 812
 813       fetched_user = Repo.get_by(User, nickname: "lain")
 814       assert user == UserView.render("show.json", %{user: fetched_user})
 815     end
 816
 817     test "it returns errors on a problem", %{conn: conn} do
 818       data = %{
 819         "email" => "lain@wired.jp",
 820         "fullname" => "lain iwakura",
 821         "bio" => "close the world.",
 822         "password" => "bear",
 823         "confirm" => "bear"
 824       }
 825
 826       conn =
 827         conn
 828         |> post("/api/account/register", data)
 829
 830       errors = json_response(conn, 400)
 831
 832       assert is_binary(errors["error"])
 833     end
 834   end
 835
 836   describe "POST /api/account/password_reset, with valid parameters" do
 837     setup %{conn: conn} do
 838       user = insert(:user)
 839       conn = post(conn, "/api/account/password_reset?email=#{user.email}")
 840       %{conn: conn, user: user}
 841     end
 842
 843     test "it returns 204", %{conn: conn} do
 844       assert json_response(conn, :no_content)
 845     end
 846
 847     test "it creates a PasswordResetToken record for user", %{user: user} do
 848       token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)
 849       assert token_record
 850     end
 851
 852     test "it sends an email to user", %{user: user} do
 853       token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)
 854
 855       Swoosh.TestAssertions.assert_email_sent(
 856         Pleroma.UserEmail.password_reset_email(user, token_record.token)
 857       )
 858     end
 859   end
 860
 861   describe "POST /api/account/password_reset, with invalid parameters" do
 862     setup [:valid_user]
 863
 864     test "it returns 500 when user is not found", %{conn: conn, user: user} do
 865       conn = post(conn, "/api/account/password_reset?email=nonexisting_#{user.email}")
 866       assert json_response(conn, :internal_server_error)
 867     end
 868
 869     test "it returns 500 when user is not local", %{conn: conn, user: user} do
 870       {:ok, user} = Repo.update(Changeset.change(user, local: false))
 871       conn = post(conn, "/api/account/password_reset?email=#{user.email}")
 872       assert json_response(conn, :internal_server_error)
 873     end
 874   end
 875
 876   describe "GET /api/account/confirm_email/:id/:token" do
 877     setup do
 878       user = insert(:user)
 879       info_change = User.Info.confirmation_changeset(user.info, :unconfirmed)
 880
 881       {:ok, user} =
 882         user
 883         |> Changeset.change()
 884         |> Changeset.put_embed(:info, info_change)
 885         |> Repo.update()
 886
 887       assert user.info.confirmation_pending
 888
 889       [user: user]
 890     end
 891
 892     test "it redirects to root url", %{conn: conn, user: user} do
 893       conn = get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}")
 894
 895       assert 302 == conn.status
 896     end
 897
 898     test "it confirms the user account", %{conn: conn, user: user} do
 899       get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}")
 900
 901       user = Repo.get(User, user.id)
 902
 903       refute user.info.confirmation_pending
 904       refute user.info.confirmation_token
 905     end
 906
 907     test "it returns 500 if user cannot be found by id", %{conn: conn, user: user} do
 908       conn = get(conn, "/api/account/confirm_email/0/#{user.info.confirmation_token}")
 909
 910       assert 500 == conn.status
 911     end
 912
 913     test "it returns 500 if token is invalid", %{conn: conn, user: user} do
 914       conn = get(conn, "/api/account/confirm_email/#{user.id}/wrong_token")
 915
 916       assert 500 == conn.status
 917     end
 918   end
 919
 920   describe "POST /api/account/resend_confirmation_email" do
 921     setup do
 922       setting = Pleroma.Config.get([:instance, :account_activation_required])
 923
 924       unless setting do
 925         Pleroma.Config.put([:instance, :account_activation_required], true)
 926         on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
 927       end
 928
 929       user = insert(:user)
 930       info_change = User.Info.confirmation_changeset(user.info, :unconfirmed)
 931
 932       {:ok, user} =
 933         user
 934         |> Changeset.change()
 935         |> Changeset.put_embed(:info, info_change)
 936         |> Repo.update()
 937
 938       assert user.info.confirmation_pending
 939
 940       [user: user]
 941     end
 942
 943     test "it returns 204 No Content", %{conn: conn, user: user} do
 944       conn
 945       |> assign(:user, user)
 946       |> post("/api/account/resend_confirmation_email?email=#{user.email}")
 947       |> json_response(:no_content)
 948     end
 949
 950     test "it sends confirmation email", %{conn: conn, user: user} do
 951       conn
 952       |> assign(:user, user)
 953       |> post("/api/account/resend_confirmation_email?email=#{user.email}")
 954
 955       Swoosh.TestAssertions.assert_email_sent(Pleroma.UserEmail.account_confirmation_email(user))
 956     end
 957   end
 958
 959   describe "GET /api/externalprofile/show" do
 960     test "it returns the user", %{conn: conn} do
 961       user = insert(:user)
 962       other_user = insert(:user)
 963
 964       conn =
 965         conn
 966         |> assign(:user, user)
 967         |> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})
 968
 969       assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
 970     end
 971   end
 972
 973   describe "GET /api/statuses/followers" do
 974     test "it returns a user's followers", %{conn: conn} do
 975       user = insert(:user)
 976       follower_one = insert(:user)
 977       follower_two = insert(:user)
 978       _not_follower = insert(:user)
 979
 980       {:ok, follower_one} = User.follow(follower_one, user)
 981       {:ok, follower_two} = User.follow(follower_two, user)
 982
 983       conn =
 984         conn
 985         |> assign(:user, user)
 986         |> get("/api/statuses/followers")
 987
 988       expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
 989       result = json_response(conn, 200)
 990       assert Enum.sort(expected) == Enum.sort(result)
 991     end
 992
 993     test "it returns a given user's followers with user_id", %{conn: conn} do
 994       user = insert(:user)
 995       follower_one = insert(:user)
 996       follower_two = insert(:user)
 997       not_follower = insert(:user)
 998
 999       {:ok, follower_one} = User.follow(follower_one, user)
1000       {:ok, follower_two} = User.follow(follower_two, user)
1001
1002       conn =
1003         conn
1004         |> assign(:user, not_follower)
1005         |> get("/api/statuses/followers", %{"user_id" => user.id})
1006
1007       assert MapSet.equal?(
1008                MapSet.new(json_response(conn, 200)),
1009                MapSet.new(
1010                  UserView.render("index.json", %{
1011                    users: [follower_one, follower_two],
1012                    for: not_follower
1013                  })
1014                )
1015              )
1016     end
1017
1018     test "it returns empty for a hidden network", %{conn: conn} do
1019       user = insert(:user, %{info: %{hide_network: true}})
1020       follower_one = insert(:user)
1021       follower_two = insert(:user)
1022       not_follower = insert(:user)
1023
1024       {:ok, _follower_one} = User.follow(follower_one, user)
1025       {:ok, _follower_two} = User.follow(follower_two, user)
1026
1027       response =
1028         conn
1029         |> assign(:user, not_follower)
1030         |> get("/api/statuses/followers", %{"user_id" => user.id})
1031         |> json_response(200)
1032
1033       assert [] == response
1034     end
1035
1036     test "it returns the followers for a hidden network if requested by the user themselves", %{
1037       conn: conn
1038     } do
1039       user = insert(:user, %{info: %{hide_network: true}})
1040       follower_one = insert(:user)
1041       follower_two = insert(:user)
1042       _not_follower = insert(:user)
1043
1044       {:ok, _follower_one} = User.follow(follower_one, user)
1045       {:ok, _follower_two} = User.follow(follower_two, user)
1046
1047       conn =
1048         conn
1049         |> assign(:user, user)
1050         |> get("/api/statuses/followers", %{"user_id" => user.id})
1051
1052       refute [] == json_response(conn, 200)
1053     end
1054   end
1055
1056   describe "GET /api/statuses/friends" do
1057     test "it returns the logged in user's friends", %{conn: conn} do
1058       user = insert(:user)
1059       followed_one = insert(:user)
1060       followed_two = insert(:user)
1061       _not_followed = insert(:user)
1062
1063       {:ok, user} = User.follow(user, followed_one)
1064       {:ok, user} = User.follow(user, followed_two)
1065
1066       conn =
1067         conn
1068         |> assign(:user, user)
1069         |> get("/api/statuses/friends")
1070
1071       expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
1072       result = json_response(conn, 200)
1073       assert Enum.sort(expected) == Enum.sort(result)
1074     end
1075
1076     test "it returns a given user's friends with user_id", %{conn: conn} do
1077       user = insert(:user)
1078       followed_one = insert(:user)
1079       followed_two = insert(:user)
1080       _not_followed = insert(:user)
1081
1082       {:ok, user} = User.follow(user, followed_one)
1083       {:ok, user} = User.follow(user, followed_two)
1084
1085       conn =
1086         conn
1087         |> assign(:user, user)
1088         |> get("/api/statuses/friends", %{"user_id" => user.id})
1089
1090       assert MapSet.equal?(
1091                MapSet.new(json_response(conn, 200)),
1092                MapSet.new(
1093                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
1094                )
1095              )
1096     end
1097
1098     test "it returns empty for a hidden network", %{conn: conn} do
1099       user = insert(:user, %{info: %{hide_network: true}})
1100       followed_one = insert(:user)
1101       followed_two = insert(:user)
1102       not_followed = insert(:user)
1103
1104       {:ok, user} = User.follow(user, followed_one)
1105       {:ok, user} = User.follow(user, followed_two)
1106
1107       conn =
1108         conn
1109         |> assign(:user, not_followed)
1110         |> get("/api/statuses/friends", %{"user_id" => user.id})
1111
1112       assert [] == json_response(conn, 200)
1113     end
1114
1115     test "it returns friends for a hidden network if the user themselves request it", %{
1116       conn: conn
1117     } do
1118       user = insert(:user, %{info: %{hide_network: true}})
1119       followed_one = insert(:user)
1120       followed_two = insert(:user)
1121       _not_followed = insert(:user)
1122
1123       {:ok, _user} = User.follow(user, followed_one)
1124       {:ok, _user} = User.follow(user, followed_two)
1125
1126       response =
1127         conn
1128         |> assign(:user, user)
1129         |> get("/api/statuses/friends", %{"user_id" => user.id})
1130         |> json_response(200)
1131
1132       refute [] == response
1133     end
1134
1135     test "it returns a given user's friends with screen_name", %{conn: conn} do
1136       user = insert(:user)
1137       followed_one = insert(:user)
1138       followed_two = insert(:user)
1139       _not_followed = insert(:user)
1140
1141       {:ok, user} = User.follow(user, followed_one)
1142       {:ok, user} = User.follow(user, followed_two)
1143
1144       conn =
1145         conn
1146         |> assign(:user, user)
1147         |> get("/api/statuses/friends", %{"screen_name" => user.nickname})
1148
1149       assert MapSet.equal?(
1150                MapSet.new(json_response(conn, 200)),
1151                MapSet.new(
1152                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
1153                )
1154              )
1155     end
1156   end
1157
1158   describe "GET /friends/ids" do
1159     test "it returns a user's friends", %{conn: conn} do
1160       user = insert(:user)
1161       followed_one = insert(:user)
1162       followed_two = insert(:user)
1163       _not_followed = insert(:user)
1164
1165       {:ok, user} = User.follow(user, followed_one)
1166       {:ok, user} = User.follow(user, followed_two)
1167
1168       conn =
1169         conn
1170         |> assign(:user, user)
1171         |> get("/api/friends/ids")
1172
1173       expected = [followed_one.id, followed_two.id]
1174
1175       assert MapSet.equal?(
1176                MapSet.new(Poison.decode!(json_response(conn, 200))),
1177                MapSet.new(expected)
1178              )
1179     end
1180   end
1181
1182   describe "POST /api/account/update_profile.json" do
1183     test "it updates a user's profile", %{conn: conn} do
1184       user = insert(:user)
1185       user2 = insert(:user)
1186
1187       conn =
1188         conn
1189         |> assign(:user, user)
1190         |> post("/api/account/update_profile.json", %{
1191           "name" => "new name",
1192           "description" => "hi @#{user2.nickname}"
1193         })
1194
1195       user = Repo.get!(User, user.id)
1196       assert user.name == "new name"
1197
1198       assert user.bio ==
1199                "hi <span><a data-user='#{user2.id}' class='mention' href='#{user2.ap_id}'>@<span>#{
1200                  user2.nickname
1201                }</span></a></span>"
1202
1203       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
1204     end
1205
1206     test "it sets and un-sets hide_network", %{conn: conn} do
1207       user = insert(:user)
1208
1209       conn
1210       |> assign(:user, user)
1211       |> post("/api/account/update_profile.json", %{
1212         "hide_network" => "true"
1213       })
1214
1215       user = Repo.get!(User, user.id)
1216       assert user.info.hide_network == true
1217
1218       conn =
1219         conn
1220         |> assign(:user, user)
1221         |> post("/api/account/update_profile.json", %{
1222           "hide_network" => "false"
1223         })
1224
1225       user = Repo.get!(User, user.id)
1226       assert user.info.hide_network == false
1227       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
1228     end
1229
1230     test "it locks an account", %{conn: conn} do
1231       user = insert(:user)
1232
1233       conn =
1234         conn
1235         |> assign(:user, user)
1236         |> post("/api/account/update_profile.json", %{
1237           "locked" => "true"
1238         })
1239
1240       user = Repo.get!(User, user.id)
1241       assert user.info.locked == true
1242
1243       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
1244     end
1245
1246     test "it unlocks an account", %{conn: conn} do
1247       user = insert(:user)
1248
1249       conn =
1250         conn
1251         |> assign(:user, user)
1252         |> post("/api/account/update_profile.json", %{
1253           "locked" => "false"
1254         })
1255
1256       user = Repo.get!(User, user.id)
1257       assert user.info.locked == false
1258
1259       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
1260     end
1261   end
1262
1263   defp valid_user(_context) do
1264     user = insert(:user)
1265     [user: user]
1266   end
1267
1268   defp with_credentials(conn, username, password) do
1269     header_content = "Basic " <> Base.encode64("#{username}:#{password}")
1270     put_req_header(conn, "authorization", header_content)
1271   end
1272
1273   describe "GET /api/search.json" do
1274     test "it returns search results", %{conn: conn} do
1275       user = insert(:user)
1276       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1277
1278       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1279       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1280
1281       conn =
1282         conn
1283         |> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})
1284
1285       assert [status] = json_response(conn, 200)
1286       assert status["id"] == activity.id
1287     end
1288   end
1289
1290   describe "GET /api/statusnet/tags/timeline/:tag.json" do
1291     test "it returns the tags timeline", %{conn: conn} do
1292       user = insert(:user)
1293       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1294
1295       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
1296       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1297
1298       conn =
1299         conn
1300         |> get("/api/statusnet/tags/timeline/2hu.json")
1301
1302       assert [status] = json_response(conn, 200)
1303       assert status["id"] == activity.id
1304     end
1305   end
1306
1307   test "Convert newlines to <br> in bio", %{conn: conn} do
1308     user = insert(:user)
1309
1310     _conn =
1311       conn
1312       |> assign(:user, user)
1313       |> post("/api/account/update_profile.json", %{
1314         "description" => "Hello,\r\nWorld! I\n am a test."
1315       })
1316
1317     user = Repo.get!(User, user.id)
1318     assert user.bio == "Hello,<br>World! I<br> am a test."
1319   end
1320
1321   describe "POST /api/pleroma/change_password" do
1322     setup [:valid_user]
1323
1324     test "without credentials", %{conn: conn} do
1325       conn = post(conn, "/api/pleroma/change_password")
1326       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
1327     end
1328
1329     test "with credentials and invalid password", %{conn: conn, user: current_user} do
1330       conn =
1331         conn
1332         |> with_credentials(current_user.nickname, "test")
1333         |> post("/api/pleroma/change_password", %{
1334           "password" => "hi",
1335           "new_password" => "newpass",
1336           "new_password_confirmation" => "newpass"
1337         })
1338
1339       assert json_response(conn, 200) == %{"error" => "Invalid password."}
1340     end
1341
1342     test "with credentials, valid password and new password and confirmation not matching", %{
1343       conn: conn,
1344       user: current_user
1345     } do
1346       conn =
1347         conn
1348         |> with_credentials(current_user.nickname, "test")
1349         |> post("/api/pleroma/change_password", %{
1350           "password" => "test",
1351           "new_password" => "newpass",
1352           "new_password_confirmation" => "notnewpass"
1353         })
1354
1355       assert json_response(conn, 200) == %{
1356                "error" => "New password does not match confirmation."
1357              }
1358     end
1359
1360     test "with credentials, valid password and invalid new password", %{
1361       conn: conn,
1362       user: current_user
1363     } do
1364       conn =
1365         conn
1366         |> with_credentials(current_user.nickname, "test")
1367         |> post("/api/pleroma/change_password", %{
1368           "password" => "test",
1369           "new_password" => "",
1370           "new_password_confirmation" => ""
1371         })
1372
1373       assert json_response(conn, 200) == %{
1374                "error" => "New password can't be blank."
1375              }
1376     end
1377
1378     test "with credentials, valid password and matching new password and confirmation", %{
1379       conn: conn,
1380       user: current_user
1381     } do
1382       conn =
1383         conn
1384         |> with_credentials(current_user.nickname, "test")
1385         |> post("/api/pleroma/change_password", %{
1386           "password" => "test",
1387           "new_password" => "newpass",
1388           "new_password_confirmation" => "newpass"
1389         })
1390
1391       assert json_response(conn, 200) == %{"status" => "success"}
1392       fetched_user = Repo.get(User, current_user.id)
1393       assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
1394     end
1395   end
1396
1397   describe "POST /api/pleroma/delete_account" do
1398     setup [:valid_user]
1399
1400     test "without credentials", %{conn: conn} do
1401       conn = post(conn, "/api/pleroma/delete_account")
1402       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
1403     end
1404
1405     test "with credentials and invalid password", %{conn: conn, user: current_user} do
1406       conn =
1407         conn
1408         |> with_credentials(current_user.nickname, "test")
1409         |> post("/api/pleroma/delete_account", %{"password" => "hi"})
1410
1411       assert json_response(conn, 200) == %{"error" => "Invalid password."}
1412     end
1413
1414     test "with credentials and valid password", %{conn: conn, user: current_user} do
1415       conn =
1416         conn
1417         |> with_credentials(current_user.nickname, "test")
1418         |> post("/api/pleroma/delete_account", %{"password" => "test"})
1419
1420       assert json_response(conn, 200) == %{"status" => "success"}
1421       # Wait a second for the started task to end
1422       :timer.sleep(1000)
1423     end
1424   end
1425
1426   describe "GET /api/pleroma/friend_requests" do
1427     test "it lists friend requests" do
1428       user = insert(:user)
1429       other_user = insert(:user)
1430
1431       {:ok, _activity} = ActivityPub.follow(other_user, user)
1432
1433       user = Repo.get(User, user.id)
1434       other_user = Repo.get(User, other_user.id)
1435
1436       assert User.following?(other_user, user) == false
1437
1438       conn =
1439         build_conn()
1440         |> assign(:user, user)
1441         |> get("/api/pleroma/friend_requests")
1442
1443       assert [relationship] = json_response(conn, 200)
1444       assert other_user.id == relationship["id"]
1445     end
1446   end
1447
1448   describe "POST /api/pleroma/friendships/approve" do
1449     test "it approves a friend request" do
1450       user = insert(:user)
1451       other_user = insert(:user)
1452
1453       {:ok, _activity} = ActivityPub.follow(other_user, user)
1454
1455       user = Repo.get(User, user.id)
1456       other_user = Repo.get(User, other_user.id)
1457
1458       assert User.following?(other_user, user) == false
1459
1460       conn =
1461         build_conn()
1462         |> assign(:user, user)
1463         |> post("/api/pleroma/friendships/approve", %{"user_id" => to_string(other_user.id)})
1464
1465       assert relationship = json_response(conn, 200)
1466       assert other_user.id == relationship["id"]
1467       assert relationship["follows_you"] == true
1468     end
1469   end
1470
1471   describe "POST /api/pleroma/friendships/deny" do
1472     test "it denies a friend request" do
1473       user = insert(:user)
1474       other_user = insert(:user)
1475
1476       {:ok, _activity} = ActivityPub.follow(other_user, user)
1477
1478       user = Repo.get(User, user.id)
1479       other_user = Repo.get(User, other_user.id)
1480
1481       assert User.following?(other_user, user) == false
1482
1483       conn =
1484         build_conn()
1485         |> assign(:user, user)
1486         |> post("/api/pleroma/friendships/deny", %{"user_id" => to_string(other_user.id)})
1487
1488       assert relationship = json_response(conn, 200)
1489       assert other_user.id == relationship["id"]
1490       assert relationship["follows_you"] == false
1491     end
1492   end
1493
1494   describe "GET /api/pleroma/search_user" do
1495     test "it returns users, ordered by similarity", %{conn: conn} do
1496       user = insert(:user, %{name: "eal"})
1497       user_two = insert(:user, %{name: "ean"})
1498       user_three = insert(:user, %{name: "ebn"})
1499
1500       resp =
1501         conn
1502         |> get(twitter_api_search__path(conn, :search_user), query: "eal")
1503         |> json_response(200)
1504
1505       assert length(resp) == 3
1506       assert [user.id, user_two.id, user_three.id] == Enum.map(resp, fn %{"id" => id} -> id end)
1507     end
1508   end
1509
1510   describe "POST /api/media/upload" do
1511     setup context do
1512       Pleroma.DataCase.ensure_local_uploader(context)
1513     end
1514
1515     test "it performs the upload and sets `data[actor]` with AP id of uploader user", %{
1516       conn: conn
1517     } do
1518       user = insert(:user)
1519
1520       upload_filename = "test/fixtures/image_tmp.jpg"
1521       File.cp!("test/fixtures/image.jpg", upload_filename)
1522
1523       file = %Plug.Upload{
1524         content_type: "image/jpg",
1525         path: Path.absname(upload_filename),
1526         filename: "image.jpg"
1527       }
1528
1529       response =
1530         conn
1531         |> assign(:user, user)
1532         |> put_req_header("content-type", "application/octet-stream")
1533         |> post("/api/media/upload", %{
1534           "media" => file
1535         })
1536         |> json_response(:ok)
1537
1538       assert response["media_id"]
1539       object = Repo.get(Object, response["media_id"])
1540       assert object
1541       assert object.data["actor"] == User.ap_id(user)
1542     end
1543   end
1544
1545   describe "POST /api/media/metadata/create" do
1546     setup do
1547       object = insert(:note)
1548       user = User.get_by_ap_id(object.data["actor"])
1549       %{object: object, user: user}
1550     end
1551
1552     test "it returns :forbidden status on attempt to modify someone else's upload", %{
1553       conn: conn,
1554       object: object
1555     } do
1556       initial_description = object.data["name"]
1557       another_user = insert(:user)
1558
1559       conn
1560       |> assign(:user, another_user)
1561       |> post("/api/media/metadata/create", %{"media_id" => object.id})
1562       |> json_response(:forbidden)
1563
1564       object = Repo.get(Object, object.id)
1565       assert object.data["name"] == initial_description
1566     end
1567
1568     test "it updates `data[name]` of referenced Object with provided value", %{
1569       conn: conn,
1570       object: object,
1571       user: user
1572     } do
1573       description = "Informative description of the image. Initial value: #{object.data["name"]}}"
1574
1575       conn
1576       |> assign(:user, user)
1577       |> post("/api/media/metadata/create", %{
1578         "media_id" => object.id,
1579         "alt_text" => %{"text" => description}
1580       })
1581       |> json_response(:no_content)
1582
1583       object = Repo.get(Object, object.id)
1584       assert object.data["name"] == description
1585     end
1586   end
1587 end