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