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