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