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
  13   import Pleroma.Factory
  14
  15   describe "POST /api/account/update_profile_banner" do
  16     test "it updates the banner", %{conn: conn} do
  17       user = insert(:user)
  18
  19       new_banner =
  20         "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
  21
  22       response =
  23         conn
  24         |> assign(:user, user)
  25         |> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => new_banner})
  26         |> json_response(200)
  27     end
  28   end
  29
  30   describe "POST /api/qvitter/update_background_image" do
  31     test "it updates the background", %{conn: conn} do
  32       user = insert(:user)
  33
  34       new_bg =
  35         "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
  36
  37       response =
  38         conn
  39         |> assign(:user, user)
  40         |> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => new_bg})
  41         |> json_response(200)
  42     end
  43   end
  44
  45   describe "POST /api/account/verify_credentials" do
  46     setup [:valid_user]
  47
  48     test "without valid credentials", %{conn: conn} do
  49       conn = post(conn, "/api/account/verify_credentials.json")
  50       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  51     end
  52
  53     test "with credentials", %{conn: conn, user: user} do
  54       conn =
  55         conn
  56         |> with_credentials(user.nickname, "test")
  57         |> post("/api/account/verify_credentials.json")
  58
  59       assert response = json_response(conn, 200)
  60       assert response == UserView.render("show.json", %{user: user, token: response["token"]})
  61     end
  62   end
  63
  64   describe "POST /statuses/update.json" do
  65     setup [:valid_user]
  66
  67     test "without valid credentials", %{conn: conn} do
  68       conn = post(conn, "/api/statuses/update.json")
  69       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  70     end
  71
  72     test "with credentials", %{conn: conn, user: user} do
  73       conn_with_creds = conn |> with_credentials(user.nickname, "test")
  74       request_path = "/api/statuses/update.json"
  75
  76       error_response = %{
  77         "request" => request_path,
  78         "error" => "Client must provide a 'status' parameter with a value."
  79       }
  80
  81       conn = conn_with_creds |> post(request_path)
  82       assert json_response(conn, 400) == error_response
  83
  84       conn = conn_with_creds |> post(request_path, %{status: ""})
  85       assert json_response(conn, 400) == error_response
  86
  87       conn = conn_with_creds |> post(request_path, %{status: " "})
  88       assert json_response(conn, 400) == error_response
  89
  90       # we post with visibility private in order to avoid triggering relay
  91       conn = conn_with_creds |> post(request_path, %{status: "Nice meme.", visibility: "private"})
  92
  93       assert json_response(conn, 200) ==
  94                ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
  95     end
  96   end
  97
  98   describe "GET /statuses/public_timeline.json" do
  99     test "returns statuses", %{conn: conn} do
 100       user = insert(:user)
 101       activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
 102       ActivityBuilder.insert_list(10, %{}, %{user: user})
 103       since_id = List.last(activities).id
 104
 105       conn =
 106         conn
 107         |> get("/api/statuses/public_timeline.json", %{since_id: since_id})
 108
 109       response = json_response(conn, 200)
 110
 111       assert length(response) == 10
 112     end
 113
 114     test "returns 403 to unauthenticated request when the instance is not public" do
 115       instance =
 116         Application.get_env(:pleroma, :instance)
 117         |> Keyword.put(:public, false)
 118
 119       Application.put_env(:pleroma, :instance, instance)
 120
 121       conn
 122       |> get("/api/statuses/public_timeline.json")
 123       |> json_response(403)
 124
 125       instance =
 126         Application.get_env(:pleroma, :instance)
 127         |> Keyword.put(:public, true)
 128
 129       Application.put_env(:pleroma, :instance, instance)
 130     end
 131
 132     test "returns 200 to unauthenticated request when the instance is public" do
 133       conn
 134       |> get("/api/statuses/public_timeline.json")
 135       |> json_response(200)
 136     end
 137   end
 138
 139   describe "GET /statuses/public_and_external_timeline.json" do
 140     test "returns 403 to unauthenticated request when the instance is not public" do
 141       instance =
 142         Application.get_env(:pleroma, :instance)
 143         |> Keyword.put(:public, false)
 144
 145       Application.put_env(:pleroma, :instance, instance)
 146
 147       conn
 148       |> get("/api/statuses/public_and_external_timeline.json")
 149       |> json_response(403)
 150
 151       instance =
 152         Application.get_env(:pleroma, :instance)
 153         |> Keyword.put(:public, true)
 154
 155       Application.put_env(:pleroma, :instance, instance)
 156     end
 157
 158     test "returns 200 to unauthenticated request when the instance is public" do
 159       conn
 160       |> get("/api/statuses/public_and_external_timeline.json")
 161       |> json_response(200)
 162     end
 163   end
 164
 165   describe "GET /statuses/show/:id.json" do
 166     test "returns one status", %{conn: conn} do
 167       user = insert(:user)
 168       {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
 169       actor = Repo.get_by!(User, ap_id: activity.data["actor"])
 170
 171       conn =
 172         conn
 173         |> get("/api/statuses/show/#{activity.id}.json")
 174
 175       response = json_response(conn, 200)
 176
 177       assert response == ActivityRepresenter.to_map(activity, %{user: actor})
 178     end
 179   end
 180
 181   describe "GET /users/show.json" do
 182     test "gets user with screen_name", %{conn: conn} do
 183       user = insert(:user)
 184
 185       conn =
 186         conn
 187         |> get("/api/users/show.json", %{"screen_name" => user.nickname})
 188
 189       response = json_response(conn, 200)
 190
 191       assert response["id"] == user.id
 192     end
 193
 194     test "gets user with user_id", %{conn: conn} do
 195       user = insert(:user)
 196
 197       conn =
 198         conn
 199         |> get("/api/users/show.json", %{"user_id" => user.id})
 200
 201       response = json_response(conn, 200)
 202
 203       assert response["id"] == user.id
 204     end
 205
 206     test "gets a user for a logged in user", %{conn: conn} do
 207       user = insert(:user)
 208       logged_in = insert(:user)
 209
 210       {:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})
 211
 212       conn =
 213         conn
 214         |> with_credentials(logged_in.nickname, "test")
 215         |> get("/api/users/show.json", %{"user_id" => user.id})
 216
 217       response = json_response(conn, 200)
 218
 219       assert response["following"] == true
 220     end
 221   end
 222
 223   describe "GET /statusnet/conversation/:id.json" do
 224     test "returns the statuses in the conversation", %{conn: conn} do
 225       {:ok, _user} = UserBuilder.insert()
 226       {:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 227       {:ok, _activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 228       {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
 229
 230       conn =
 231         conn
 232         |> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")
 233
 234       response = json_response(conn, 200)
 235
 236       assert length(response) == 2
 237     end
 238   end
 239
 240   describe "GET /statuses/friends_timeline.json" do
 241     setup [:valid_user]
 242
 243     test "without valid credentials", %{conn: conn} do
 244       conn = get(conn, "/api/statuses/friends_timeline.json")
 245       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 246     end
 247
 248     test "with credentials", %{conn: conn, user: current_user} do
 249       user = insert(:user)
 250
 251       activities =
 252         ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
 253
 254       returned_activities =
 255         ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
 256
 257       other_user = insert(:user)
 258       ActivityBuilder.insert_list(10, %{}, %{user: other_user})
 259       since_id = List.last(activities).id
 260
 261       current_user =
 262         Ecto.Changeset.change(current_user, following: [User.ap_followers(user)])
 263         |> Repo.update!()
 264
 265       conn =
 266         conn
 267         |> with_credentials(current_user.nickname, "test")
 268         |> get("/api/statuses/friends_timeline.json", %{since_id: since_id})
 269
 270       response = json_response(conn, 200)
 271
 272       assert length(response) == 10
 273
 274       assert response ==
 275                Enum.map(returned_activities, fn activity ->
 276                  ActivityRepresenter.to_map(activity, %{
 277                    user: User.get_cached_by_ap_id(activity.data["actor"]),
 278                    for: current_user
 279                  })
 280                end)
 281     end
 282   end
 283
 284   describe "GET /statuses/dm_timeline.json" do
 285     test "it show direct messages", %{conn: conn} do
 286       user_one = insert(:user)
 287       user_two = insert(:user)
 288
 289       {:ok, user_two} = User.follow(user_two, user_one)
 290
 291       {:ok, direct} =
 292         CommonAPI.post(user_one, %{
 293           "status" => "Hi @#{user_two.nickname}!",
 294           "visibility" => "direct"
 295         })
 296
 297       {:ok, direct_two} =
 298         CommonAPI.post(user_two, %{
 299           "status" => "Hi @#{user_one.nickname}!",
 300           "visibility" => "direct"
 301         })
 302
 303       {:ok, _follower_only} =
 304         CommonAPI.post(user_one, %{
 305           "status" => "Hi @#{user_two.nickname}!",
 306           "visibility" => "private"
 307         })
 308
 309       # Only direct should be visible here
 310       res_conn =
 311         conn
 312         |> assign(:user, user_two)
 313         |> get("/api/statuses/dm_timeline.json")
 314
 315       [status, status_two] = json_response(res_conn, 200)
 316       assert status["id"] == direct_two.id
 317       assert status_two["id"] == direct.id
 318     end
 319   end
 320
 321   describe "GET /statuses/mentions.json" do
 322     setup [:valid_user]
 323
 324     test "without valid credentials", %{conn: conn} do
 325       conn = get(conn, "/api/statuses/mentions.json")
 326       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 327     end
 328
 329     test "with credentials", %{conn: conn, user: current_user} do
 330       {:ok, activity} =
 331         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})
 332
 333       conn =
 334         conn
 335         |> with_credentials(current_user.nickname, "test")
 336         |> get("/api/statuses/mentions.json")
 337
 338       response = json_response(conn, 200)
 339
 340       assert length(response) == 1
 341
 342       assert Enum.at(response, 0) ==
 343                ActivityRepresenter.to_map(activity, %{
 344                  user: current_user,
 345                  mentioned: [current_user]
 346                })
 347     end
 348   end
 349
 350   describe "GET /api/qvitter/statuses/notifications.json" do
 351     setup [:valid_user]
 352
 353     test "without valid credentials", %{conn: conn} do
 354       conn = get(conn, "/api/qvitter/statuses/notifications.json")
 355       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 356     end
 357
 358     test "with credentials", %{conn: conn, user: current_user} do
 359       other_user = insert(:user)
 360
 361       {:ok, _activity} =
 362         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
 363
 364       conn =
 365         conn
 366         |> with_credentials(current_user.nickname, "test")
 367         |> get("/api/qvitter/statuses/notifications.json")
 368
 369       response = json_response(conn, 200)
 370
 371       assert length(response) == 1
 372
 373       assert response ==
 374                NotificationView.render("notification.json", %{
 375                  notifications: Notification.for_user(current_user),
 376                  for: current_user
 377                })
 378     end
 379   end
 380
 381   describe "POST /api/qvitter/statuses/notifications/read" do
 382     setup [:valid_user]
 383
 384     test "without valid credentials", %{conn: conn} do
 385       conn = post(conn, "/api/qvitter/statuses/notifications/read", %{"latest_id" => 1_234_567})
 386       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 387     end
 388
 389     test "with credentials, without any params", %{conn: conn, user: current_user} do
 390       conn =
 391         conn
 392         |> with_credentials(current_user.nickname, "test")
 393         |> post("/api/qvitter/statuses/notifications/read")
 394
 395       assert json_response(conn, 400) == %{
 396                "error" => "You need to specify latest_id",
 397                "request" => "/api/qvitter/statuses/notifications/read"
 398              }
 399     end
 400
 401     test "with credentials, with params", %{conn: conn, user: current_user} do
 402       other_user = insert(:user)
 403
 404       {:ok, _activity} =
 405         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
 406
 407       response_conn =
 408         conn
 409         |> with_credentials(current_user.nickname, "test")
 410         |> get("/api/qvitter/statuses/notifications.json")
 411
 412       [notification] = response = json_response(response_conn, 200)
 413
 414       assert length(response) == 1
 415
 416       assert notification["is_seen"] == 0
 417
 418       response_conn =
 419         conn
 420         |> with_credentials(current_user.nickname, "test")
 421         |> post("/api/qvitter/statuses/notifications/read", %{"latest_id" => notification["id"]})
 422
 423       [notification] = response = json_response(response_conn, 200)
 424
 425       assert length(response) == 1
 426
 427       assert notification["is_seen"] == 1
 428     end
 429   end
 430
 431   describe "GET /statuses/user_timeline.json" do
 432     setup [:valid_user]
 433
 434     test "without any params", %{conn: conn} do
 435       conn = get(conn, "/api/statuses/user_timeline.json")
 436
 437       assert json_response(conn, 400) == %{
 438                "error" => "You need to specify screen_name or user_id",
 439                "request" => "/api/statuses/user_timeline.json"
 440              }
 441     end
 442
 443     test "with user_id", %{conn: conn} do
 444       user = insert(:user)
 445       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 446
 447       conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
 448       response = json_response(conn, 200)
 449       assert length(response) == 1
 450       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 451     end
 452
 453     test "with screen_name", %{conn: conn} do
 454       user = insert(:user)
 455       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 456
 457       conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 458       response = json_response(conn, 200)
 459       assert length(response) == 1
 460       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 461     end
 462
 463     test "with credentials", %{conn: conn, user: current_user} do
 464       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
 465
 466       conn =
 467         conn
 468         |> with_credentials(current_user.nickname, "test")
 469         |> get("/api/statuses/user_timeline.json")
 470
 471       response = json_response(conn, 200)
 472
 473       assert length(response) == 1
 474       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
 475     end
 476
 477     test "with credentials with user_id", %{conn: conn, user: current_user} do
 478       user = insert(:user)
 479       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 480
 481       conn =
 482         conn
 483         |> with_credentials(current_user.nickname, "test")
 484         |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
 485
 486       response = json_response(conn, 200)
 487
 488       assert length(response) == 1
 489       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 490     end
 491
 492     test "with credentials screen_name", %{conn: conn, user: current_user} do
 493       user = insert(:user)
 494       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 495
 496       conn =
 497         conn
 498         |> with_credentials(current_user.nickname, "test")
 499         |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 500
 501       response = json_response(conn, 200)
 502
 503       assert length(response) == 1
 504       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 505     end
 506   end
 507
 508   describe "POST /friendships/create.json" do
 509     setup [:valid_user]
 510
 511     test "without valid credentials", %{conn: conn} do
 512       conn = post(conn, "/api/friendships/create.json")
 513       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 514     end
 515
 516     test "with credentials", %{conn: conn, user: current_user} do
 517       followed = insert(:user)
 518
 519       conn =
 520         conn
 521         |> with_credentials(current_user.nickname, "test")
 522         |> post("/api/friendships/create.json", %{user_id: followed.id})
 523
 524       current_user = Repo.get(User, current_user.id)
 525       assert User.ap_followers(followed) in current_user.following
 526
 527       assert json_response(conn, 200) ==
 528                UserView.render("show.json", %{user: followed, for: current_user})
 529     end
 530   end
 531
 532   describe "POST /friendships/destroy.json" do
 533     setup [:valid_user]
 534
 535     test "without valid credentials", %{conn: conn} do
 536       conn = post(conn, "/api/friendships/destroy.json")
 537       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 538     end
 539
 540     test "with credentials", %{conn: conn, user: current_user} do
 541       followed = insert(:user)
 542
 543       {:ok, current_user} = User.follow(current_user, followed)
 544       assert User.ap_followers(followed) in current_user.following
 545       ActivityPub.follow(current_user, followed)
 546
 547       conn =
 548         conn
 549         |> with_credentials(current_user.nickname, "test")
 550         |> post("/api/friendships/destroy.json", %{user_id: followed.id})
 551
 552       current_user = Repo.get(User, current_user.id)
 553       assert current_user.following == [current_user.ap_id]
 554
 555       assert json_response(conn, 200) ==
 556                UserView.render("show.json", %{user: followed, for: current_user})
 557     end
 558   end
 559
 560   describe "POST /blocks/create.json" do
 561     setup [:valid_user]
 562
 563     test "without valid credentials", %{conn: conn} do
 564       conn = post(conn, "/api/blocks/create.json")
 565       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 566     end
 567
 568     test "with credentials", %{conn: conn, user: current_user} do
 569       blocked = insert(:user)
 570
 571       conn =
 572         conn
 573         |> with_credentials(current_user.nickname, "test")
 574         |> post("/api/blocks/create.json", %{user_id: blocked.id})
 575
 576       current_user = Repo.get(User, current_user.id)
 577       assert User.blocks?(current_user, blocked)
 578
 579       assert json_response(conn, 200) ==
 580                UserView.render("show.json", %{user: blocked, for: current_user})
 581     end
 582   end
 583
 584   describe "POST /blocks/destroy.json" do
 585     setup [:valid_user]
 586
 587     test "without valid credentials", %{conn: conn} do
 588       conn = post(conn, "/api/blocks/destroy.json")
 589       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 590     end
 591
 592     test "with credentials", %{conn: conn, user: current_user} do
 593       blocked = insert(:user)
 594
 595       {:ok, current_user, blocked} = TwitterAPI.block(current_user, %{"user_id" => blocked.id})
 596       assert User.blocks?(current_user, blocked)
 597
 598       conn =
 599         conn
 600         |> with_credentials(current_user.nickname, "test")
 601         |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
 602
 603       current_user = Repo.get(User, current_user.id)
 604       assert current_user.info.blocks == []
 605
 606       assert json_response(conn, 200) ==
 607                UserView.render("show.json", %{user: blocked, for: current_user})
 608     end
 609   end
 610
 611   describe "GET /help/test.json" do
 612     test "returns \"ok\"", %{conn: conn} do
 613       conn = get(conn, "/api/help/test.json")
 614       assert json_response(conn, 200) == "ok"
 615     end
 616   end
 617
 618   describe "POST /api/qvitter/update_avatar.json" do
 619     setup [:valid_user]
 620
 621     test "without valid credentials", %{conn: conn} do
 622       conn = post(conn, "/api/qvitter/update_avatar.json")
 623       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 624     end
 625
 626     test "with credentials", %{conn: conn, user: current_user} do
 627       avatar_image = File.read!("test/fixtures/avatar_data_uri")
 628
 629       conn =
 630         conn
 631         |> with_credentials(current_user.nickname, "test")
 632         |> post("/api/qvitter/update_avatar.json", %{img: avatar_image})
 633
 634       current_user = Repo.get(User, current_user.id)
 635       assert is_map(current_user.avatar)
 636
 637       assert json_response(conn, 200) ==
 638                UserView.render("show.json", %{user: current_user, for: current_user})
 639     end
 640   end
 641
 642   describe "GET /api/qvitter/mutes.json" do
 643     setup [:valid_user]
 644
 645     test "unimplemented mutes without valid credentials", %{conn: conn} do
 646       conn = get(conn, "/api/qvitter/mutes.json")
 647       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 648     end
 649
 650     test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
 651       conn =
 652         conn
 653         |> with_credentials(current_user.nickname, "test")
 654         |> get("/api/qvitter/mutes.json")
 655
 656       current_user = Repo.get(User, current_user.id)
 657
 658       assert [] = json_response(conn, 200)
 659     end
 660   end
 661
 662   describe "POST /api/favorites/create/:id" do
 663     setup [:valid_user]
 664
 665     test "without valid credentials", %{conn: conn} do
 666       note_activity = insert(:note_activity)
 667       conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
 668       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 669     end
 670
 671     test "with credentials", %{conn: conn, user: current_user} do
 672       note_activity = insert(:note_activity)
 673
 674       conn =
 675         conn
 676         |> with_credentials(current_user.nickname, "test")
 677         |> post("/api/favorites/create/#{note_activity.id}.json")
 678
 679       assert json_response(conn, 200)
 680     end
 681
 682     test "with credentials, invalid param", %{conn: conn, user: current_user} do
 683       conn =
 684         conn
 685         |> with_credentials(current_user.nickname, "test")
 686         |> post("/api/favorites/create/wrong.json")
 687
 688       assert json_response(conn, 400)
 689     end
 690
 691     test "with credentials, invalid activity", %{conn: conn, user: current_user} do
 692       conn =
 693         conn
 694         |> with_credentials(current_user.nickname, "test")
 695         |> post("/api/favorites/create/1.json")
 696
 697       assert json_response(conn, 500)
 698     end
 699   end
 700
 701   describe "POST /api/favorites/destroy/:id" do
 702     setup [:valid_user]
 703
 704     test "without valid credentials", %{conn: conn} do
 705       note_activity = insert(:note_activity)
 706       conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
 707       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 708     end
 709
 710     test "with credentials", %{conn: conn, user: current_user} do
 711       note_activity = insert(:note_activity)
 712       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 713       ActivityPub.like(current_user, object)
 714
 715       conn =
 716         conn
 717         |> with_credentials(current_user.nickname, "test")
 718         |> post("/api/favorites/destroy/#{note_activity.id}.json")
 719
 720       assert json_response(conn, 200)
 721     end
 722   end
 723
 724   describe "POST /api/statuses/retweet/:id" do
 725     setup [:valid_user]
 726
 727     test "without valid credentials", %{conn: conn} do
 728       note_activity = insert(:note_activity)
 729       conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
 730       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 731     end
 732
 733     test "with credentials", %{conn: conn, user: current_user} do
 734       note_activity = insert(:note_activity)
 735
 736       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 737
 738       response =
 739         conn
 740         |> with_credentials(current_user.nickname, "test")
 741         |> post(request_path)
 742
 743       activity = Repo.get(Activity, note_activity.id)
 744       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 745
 746       assert json_response(response, 200) ==
 747                ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 748     end
 749   end
 750
 751   describe "POST /api/statuses/unretweet/:id" do
 752     setup [:valid_user]
 753
 754     test "without valid credentials", %{conn: conn} do
 755       note_activity = insert(:note_activity)
 756       conn = post(conn, "/api/statuses/unretweet/#{note_activity.id}.json")
 757       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 758     end
 759
 760     test "with credentials", %{conn: conn, user: current_user} do
 761       note_activity = insert(:note_activity)
 762
 763       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 764
 765       _response =
 766         conn
 767         |> with_credentials(current_user.nickname, "test")
 768         |> post(request_path)
 769
 770       request_path = String.replace(request_path, "retweet", "unretweet")
 771
 772       response =
 773         conn
 774         |> with_credentials(current_user.nickname, "test")
 775         |> post(request_path)
 776
 777       activity = Repo.get(Activity, note_activity.id)
 778       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 779
 780       assert json_response(response, 200) ==
 781                ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 782     end
 783   end
 784
 785   describe "POST /api/account/register" do
 786     test "it creates a new user", %{conn: conn} do
 787       data = %{
 788         "nickname" => "lain",
 789         "email" => "lain@wired.jp",
 790         "fullname" => "lain iwakura",
 791         "bio" => "close the world.",
 792         "password" => "bear",
 793         "confirm" => "bear"
 794       }
 795
 796       conn =
 797         conn
 798         |> post("/api/account/register", data)
 799
 800       user = json_response(conn, 200)
 801
 802       fetched_user = Repo.get_by(User, nickname: "lain")
 803       assert user == UserView.render("show.json", %{user: fetched_user})
 804     end
 805
 806     test "it returns errors on a problem", %{conn: conn} do
 807       data = %{
 808         "email" => "lain@wired.jp",
 809         "fullname" => "lain iwakura",
 810         "bio" => "close the world.",
 811         "password" => "bear",
 812         "confirm" => "bear"
 813       }
 814
 815       conn =
 816         conn
 817         |> post("/api/account/register", data)
 818
 819       errors = json_response(conn, 400)
 820
 821       assert is_binary(errors["error"])
 822     end
 823   end
 824
 825   describe "GET /api/externalprofile/show" do
 826     test "it returns the user", %{conn: conn} do
 827       user = insert(:user)
 828       other_user = insert(:user)
 829
 830       conn =
 831         conn
 832         |> assign(:user, user)
 833         |> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})
 834
 835       assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
 836     end
 837   end
 838
 839   describe "GET /api/statuses/followers" do
 840     test "it returns a user's followers", %{conn: conn} do
 841       user = insert(:user)
 842       follower_one = insert(:user)
 843       follower_two = insert(:user)
 844       _not_follower = insert(:user)
 845
 846       {:ok, follower_one} = User.follow(follower_one, user)
 847       {:ok, follower_two} = User.follow(follower_two, user)
 848
 849       conn =
 850         conn
 851         |> assign(:user, user)
 852         |> get("/api/statuses/followers")
 853
 854       expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
 855       result = json_response(conn, 200)
 856       assert Enum.sort(expected) == Enum.sort(result)
 857     end
 858   end
 859
 860   describe "GET /api/statuses/friends" do
 861     test "it returns the logged in user's friends", %{conn: conn} do
 862       user = insert(:user)
 863       followed_one = insert(:user)
 864       followed_two = insert(:user)
 865       _not_followed = insert(:user)
 866
 867       {:ok, user} = User.follow(user, followed_one)
 868       {:ok, user} = User.follow(user, followed_two)
 869
 870       conn =
 871         conn
 872         |> assign(:user, user)
 873         |> get("/api/statuses/friends")
 874
 875       expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 876       result = json_response(conn, 200)
 877       assert Enum.sort(expected) == Enum.sort(result)
 878     end
 879
 880     test "it returns a given user's friends with user_id", %{conn: conn} do
 881       user = insert(:user)
 882       followed_one = insert(:user)
 883       followed_two = insert(:user)
 884       _not_followed = insert(:user)
 885
 886       {:ok, user} = User.follow(user, followed_one)
 887       {:ok, user} = User.follow(user, followed_two)
 888
 889       conn =
 890         conn
 891         |> assign(:user, user)
 892         |> get("/api/statuses/friends", %{"user_id" => user.id})
 893
 894       assert MapSet.equal?(
 895                MapSet.new(json_response(conn, 200)),
 896                MapSet.new(
 897                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 898                )
 899              )
 900     end
 901
 902     test "it returns a given user's friends with screen_name", %{conn: conn} do
 903       user = insert(:user)
 904       followed_one = insert(:user)
 905       followed_two = insert(:user)
 906       _not_followed = insert(:user)
 907
 908       {:ok, user} = User.follow(user, followed_one)
 909       {:ok, user} = User.follow(user, followed_two)
 910
 911       conn =
 912         conn
 913         |> assign(:user, user)
 914         |> get("/api/statuses/friends", %{"screen_name" => user.nickname})
 915
 916       assert MapSet.equal?(
 917                MapSet.new(json_response(conn, 200)),
 918                MapSet.new(
 919                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 920                )
 921              )
 922     end
 923   end
 924
 925   describe "GET /friends/ids" do
 926     test "it returns a user's friends", %{conn: conn} do
 927       user = insert(:user)
 928       followed_one = insert(:user)
 929       followed_two = insert(:user)
 930       _not_followed = insert(:user)
 931
 932       {:ok, user} = User.follow(user, followed_one)
 933       {:ok, user} = User.follow(user, followed_two)
 934
 935       conn =
 936         conn
 937         |> assign(:user, user)
 938         |> get("/api/friends/ids")
 939
 940       expected = [followed_one.id, followed_two.id]
 941
 942       assert MapSet.equal?(
 943                MapSet.new(Poison.decode!(json_response(conn, 200))),
 944                MapSet.new(expected)
 945              )
 946     end
 947   end
 948
 949   describe "POST /api/account/update_profile.json" do
 950     test "it updates a user's profile", %{conn: conn} do
 951       user = insert(:user)
 952
 953       conn =
 954         conn
 955         |> assign(:user, user)
 956         |> post("/api/account/update_profile.json", %{
 957           "name" => "new name",
 958           "description" => "new description"
 959         })
 960
 961       user = Repo.get!(User, user.id)
 962       assert user.name == "new name"
 963       assert user.bio == "new description"
 964
 965       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 966     end
 967
 968     test "it locks an account", %{conn: conn} do
 969       user = insert(:user)
 970
 971       conn =
 972         conn
 973         |> assign(:user, user)
 974         |> post("/api/account/update_profile.json", %{
 975           "locked" => "true"
 976         })
 977
 978       user = Repo.get!(User, user.id)
 979       assert user.info.locked == true
 980
 981       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 982     end
 983
 984     test "it unlocks an account", %{conn: conn} do
 985       user = insert(:user)
 986
 987       conn =
 988         conn
 989         |> assign(:user, user)
 990         |> post("/api/account/update_profile.json", %{
 991           "locked" => "false"
 992         })
 993
 994       user = Repo.get!(User, user.id)
 995       assert user.info.locked == false
 996
 997       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 998     end
 999   end
1000
1001   defp valid_user(_context) do
1002     user = insert(:user)
1003     [user: user]
1004   end
1005
1006   defp with_credentials(conn, username, password) do
1007     header_content = "Basic " <> Base.encode64("#{username}:#{password}")
1008     put_req_header(conn, "authorization", header_content)
1009   end
1010
1011   describe "GET /api/search.json" do
1012     test "it returns search results", %{conn: conn} do
1013       user = insert(:user)
1014       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1015
1016       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1017       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1018
1019       conn =
1020         conn
1021         |> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})
1022
1023       assert [status] = json_response(conn, 200)
1024       assert status["id"] == activity.id
1025     end
1026   end
1027
1028   describe "GET /api/statusnet/tags/timeline/:tag.json" do
1029     test "it returns the tags timeline", %{conn: conn} do
1030       user = insert(:user)
1031       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1032
1033       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
1034       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1035
1036       conn =
1037         conn
1038         |> get("/api/statusnet/tags/timeline/2hu.json")
1039
1040       assert [status] = json_response(conn, 200)
1041       assert status["id"] == activity.id
1042     end
1043   end
1044
1045   test "Convert newlines to <br> in bio", %{conn: conn} do
1046     user = insert(:user)
1047
1048     _conn =
1049       conn
1050       |> assign(:user, user)
1051       |> post("/api/account/update_profile.json", %{
1052         "description" => "Hello,\r\nWorld! I\n am a test."
1053       })
1054
1055     user = Repo.get!(User, user.id)
1056     assert user.bio == "Hello,<br>World! I<br> am a test."
1057   end
1058
1059   describe "POST /api/pleroma/change_password" do
1060     setup [:valid_user]
1061
1062     test "without credentials", %{conn: conn} do
1063       conn = post(conn, "/api/pleroma/change_password")
1064       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
1065     end
1066
1067     test "with credentials and invalid password", %{conn: conn, user: current_user} do
1068       conn =
1069         conn
1070         |> with_credentials(current_user.nickname, "test")
1071         |> post("/api/pleroma/change_password", %{
1072           "password" => "hi",
1073           "new_password" => "newpass",
1074           "new_password_confirmation" => "newpass"
1075         })
1076
1077       assert json_response(conn, 200) == %{"error" => "Invalid password."}
1078     end
1079
1080     test "with credentials, valid password and new password and confirmation not matching", %{
1081       conn: conn,
1082       user: current_user
1083     } do
1084       conn =
1085         conn
1086         |> with_credentials(current_user.nickname, "test")
1087         |> post("/api/pleroma/change_password", %{
1088           "password" => "test",
1089           "new_password" => "newpass",
1090           "new_password_confirmation" => "notnewpass"
1091         })
1092
1093       assert json_response(conn, 200) == %{
1094                "error" => "New password does not match confirmation."
1095              }
1096     end
1097
1098     test "with credentials, valid password and invalid new password", %{
1099       conn: conn,
1100       user: current_user
1101     } do
1102       conn =
1103         conn
1104         |> with_credentials(current_user.nickname, "test")
1105         |> post("/api/pleroma/change_password", %{
1106           "password" => "test",
1107           "new_password" => "",
1108           "new_password_confirmation" => ""
1109         })
1110
1111       assert json_response(conn, 200) == %{
1112                "error" => "New password can't be blank."
1113              }
1114     end
1115
1116     test "with credentials, valid password and matching new password and confirmation", %{
1117       conn: conn,
1118       user: current_user
1119     } do
1120       conn =
1121         conn
1122         |> with_credentials(current_user.nickname, "test")
1123         |> post("/api/pleroma/change_password", %{
1124           "password" => "test",
1125           "new_password" => "newpass",
1126           "new_password_confirmation" => "newpass"
1127         })
1128
1129       assert json_response(conn, 200) == %{"status" => "success"}
1130       fetched_user = Repo.get(User, current_user.id)
1131       assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
1132     end
1133   end
1134
1135   describe "POST /api/pleroma/delete_account" do
1136     setup [:valid_user]
1137
1138     test "without credentials", %{conn: conn} do
1139       conn = post(conn, "/api/pleroma/delete_account")
1140       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
1141     end
1142
1143     test "with credentials and invalid password", %{conn: conn, user: current_user} do
1144       conn =
1145         conn
1146         |> with_credentials(current_user.nickname, "test")
1147         |> post("/api/pleroma/delete_account", %{"password" => "hi"})
1148
1149       assert json_response(conn, 200) == %{"error" => "Invalid password."}
1150     end
1151
1152     test "with credentials and valid password", %{conn: conn, user: current_user} do
1153       conn =
1154         conn
1155         |> with_credentials(current_user.nickname, "test")
1156         |> post("/api/pleroma/delete_account", %{"password" => "test"})
1157
1158       assert json_response(conn, 200) == %{"status" => "success"}
1159       # Wait a second for the started task to end
1160       :timer.sleep(1000)
1161     end
1162   end
1163
1164   describe "GET /api/pleroma/friend_requests" do
1165     test "it lists friend requests" do
1166       user = insert(:user)
1167       other_user = insert(:user)
1168
1169       {:ok, _activity} = ActivityPub.follow(other_user, user)
1170
1171       user = Repo.get(User, user.id)
1172       other_user = Repo.get(User, other_user.id)
1173
1174       assert User.following?(other_user, user) == false
1175
1176       conn =
1177         build_conn()
1178         |> assign(:user, user)
1179         |> get("/api/pleroma/friend_requests")
1180
1181       assert [relationship] = json_response(conn, 200)
1182       assert other_user.id == relationship["id"]
1183     end
1184   end
1185
1186   describe "POST /api/pleroma/friendships/approve" do
1187     test "it approves a friend request" do
1188       user = insert(:user)
1189       other_user = insert(:user)
1190
1191       {:ok, _activity} = ActivityPub.follow(other_user, user)
1192
1193       user = Repo.get(User, user.id)
1194       other_user = Repo.get(User, other_user.id)
1195
1196       assert User.following?(other_user, user) == false
1197
1198       conn =
1199         build_conn()
1200         |> assign(:user, user)
1201         |> post("/api/pleroma/friendships/approve", %{"user_id" => to_string(other_user.id)})
1202
1203       assert relationship = json_response(conn, 200)
1204       assert other_user.id == relationship["id"]
1205       assert relationship["follows_you"] == true
1206     end
1207   end
1208
1209   describe "POST /api/pleroma/friendships/deny" do
1210     test "it denies a friend request" do
1211       user = insert(:user)
1212       other_user = insert(:user)
1213
1214       {:ok, _activity} = ActivityPub.follow(other_user, user)
1215
1216       user = Repo.get(User, user.id)
1217       other_user = Repo.get(User, other_user.id)
1218
1219       assert User.following?(other_user, user) == false
1220
1221       conn =
1222         build_conn()
1223         |> assign(:user, user)
1224         |> post("/api/pleroma/friendships/deny", %{"user_id" => to_string(other_user.id)})
1225
1226       assert relationship = json_response(conn, 200)
1227       assert other_user.id == relationship["id"]
1228       assert relationship["follows_you"] == false
1229     end
1230   end
1231
1232   describe "GET /api/pleroma/search_user" do
1233     test "it returns users, ordered by similarity", %{conn: conn} do
1234       user = insert(:user, %{name: "eal"})
1235       user_two = insert(:user, %{name: "ean"})
1236       user_three = insert(:user, %{name: "ebn"})
1237
1238       resp =
1239         conn
1240         |> get(twitter_api_search__path(conn, :search_user), query: "eal")
1241         |> json_response(200)
1242
1243       assert length(resp) == 3
1244       assert [user.id, user_two.id, user_three.id] == Enum.map(resp, fn %{"id" => id} -> id end)
1245     end
1246   end
1247 end