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