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
  12   import Pleroma.Factory
  13
  14   describe "POST /api/account/verify_credentials" do
  15     setup [:valid_user]
  16
  17     test "without valid credentials", %{conn: conn} do
  18       conn = post(conn, "/api/account/verify_credentials.json")
  19       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  20     end
  21
  22     test "with credentials", %{conn: conn, user: user} do
  23       conn =
  24         conn
  25         |> with_credentials(user.nickname, "test")
  26         |> post("/api/account/verify_credentials.json")
  27
  28       assert response = json_response(conn, 200)
  29       assert response == UserView.render("show.json", %{user: user, token: response["token"]})
  30     end
  31   end
  32
  33   describe "POST /api/account/most_recent_notification" do
  34     setup [:valid_user]
  35
  36     test "without valid credentials", %{conn: conn} do
  37       conn = post(conn, "/api/account/most_recent_notification.json")
  38       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  39     end
  40
  41     test "with credentials", %{conn: conn, user: user} do
  42       conn =
  43         conn
  44         |> with_credentials(user.nickname, "test")
  45         |> post("/api/account/most_recent_notification.json", %{id: "200"})
  46
  47       assert json_response(conn, 200)
  48       user = User.get_by_nickname(user.nickname)
  49       assert user.info["most_recent_notification"] == 200
  50     end
  51   end
  52
  53   describe "POST /statuses/update.json" do
  54     setup [:valid_user]
  55
  56     test "without valid credentials", %{conn: conn} do
  57       conn = post(conn, "/api/statuses/update.json")
  58       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  59     end
  60
  61     test "with credentials", %{conn: conn, user: user} do
  62       conn_with_creds = conn |> with_credentials(user.nickname, "test")
  63       request_path = "/api/statuses/update.json"
  64
  65       error_response = %{
  66         "request" => request_path,
  67         "error" => "Client must provide a 'status' parameter with a value."
  68       }
  69
  70       conn = conn_with_creds |> post(request_path)
  71       assert json_response(conn, 400) == error_response
  72
  73       conn = conn_with_creds |> post(request_path, %{status: ""})
  74       assert json_response(conn, 400) == error_response
  75
  76       conn = conn_with_creds |> post(request_path, %{status: " "})
  77       assert json_response(conn, 400) == error_response
  78
  79       conn = conn_with_creds |> post(request_path, %{status: "Nice meme."})
  80
  81       assert json_response(conn, 200) ==
  82                ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
  83     end
  84   end
  85
  86   describe "GET /statuses/public_timeline.json" do
  87     test "returns statuses", %{conn: conn} do
  88       {:ok, user} = UserBuilder.insert()
  89       activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
  90       ActivityBuilder.insert_list(10, %{}, %{user: user})
  91       since_id = List.last(activities).id
  92
  93       conn =
  94         conn
  95         |> get("/api/statuses/public_timeline.json", %{since_id: since_id})
  96
  97       response = json_response(conn, 200)
  98
  99       assert length(response) == 10
 100     end
 101   end
 102
 103   describe "GET /statuses/show/:id.json" do
 104     test "returns one status", %{conn: conn} do
 105       user = insert(:user)
 106       {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
 107       actor = Repo.get_by!(User, ap_id: activity.data["actor"])
 108
 109       conn =
 110         conn
 111         |> get("/api/statuses/show/#{activity.id}.json")
 112
 113       response = json_response(conn, 200)
 114
 115       assert response == ActivityRepresenter.to_map(activity, %{user: actor})
 116     end
 117   end
 118
 119   describe "GET /users/show.json" do
 120     test "gets user with screen_name", %{conn: conn} do
 121       user = insert(:user)
 122
 123       conn =
 124         conn
 125         |> get("/api/users/show.json", %{"screen_name" => user.nickname})
 126
 127       response = json_response(conn, 200)
 128
 129       assert response["id"] == user.id
 130     end
 131
 132     test "gets user with user_id", %{conn: conn} do
 133       user = insert(:user)
 134
 135       conn =
 136         conn
 137         |> get("/api/users/show.json", %{"user_id" => user.id})
 138
 139       response = json_response(conn, 200)
 140
 141       assert response["id"] == user.id
 142     end
 143
 144     test "gets a user for a logged in user", %{conn: conn} do
 145       user = insert(:user)
 146       logged_in = insert(:user)
 147
 148       {:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})
 149
 150       conn =
 151         conn
 152         |> with_credentials(logged_in.nickname, "test")
 153         |> get("/api/users/show.json", %{"user_id" => user.id})
 154
 155       response = json_response(conn, 200)
 156
 157       assert response["following"] == true
 158     end
 159   end
 160
 161   describe "GET /statusnet/conversation/:id.json" do
 162     test "returns the statuses in the conversation", %{conn: conn} do
 163       {:ok, _user} = UserBuilder.insert()
 164       {:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 165       {:ok, _activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 166       {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
 167
 168       conn =
 169         conn
 170         |> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")
 171
 172       response = json_response(conn, 200)
 173
 174       assert length(response) == 2
 175     end
 176   end
 177
 178   describe "GET /statuses/friends_timeline.json" do
 179     setup [:valid_user]
 180
 181     test "without valid credentials", %{conn: conn} do
 182       conn = get(conn, "/api/statuses/friends_timeline.json")
 183       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 184     end
 185
 186     test "with credentials", %{conn: conn, user: current_user} do
 187       user = insert(:user)
 188
 189       activities =
 190         ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
 191
 192       returned_activities =
 193         ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
 194
 195       other_user = insert(:user)
 196       ActivityBuilder.insert_list(10, %{}, %{user: other_user})
 197       since_id = List.last(activities).id
 198
 199       current_user =
 200         Ecto.Changeset.change(current_user, following: [User.ap_followers(user)])
 201         |> Repo.update!()
 202
 203       conn =
 204         conn
 205         |> with_credentials(current_user.nickname, "test")
 206         |> get("/api/statuses/friends_timeline.json", %{since_id: since_id})
 207
 208       response = json_response(conn, 200)
 209
 210       assert length(response) == 10
 211
 212       assert response ==
 213                Enum.map(returned_activities, fn activity ->
 214                  ActivityRepresenter.to_map(activity, %{
 215                    user: User.get_cached_by_ap_id(activity.data["actor"]),
 216                    for: current_user
 217                  })
 218                end)
 219     end
 220   end
 221
 222   describe "GET /statuses/mentions.json" do
 223     setup [:valid_user]
 224
 225     test "without valid credentials", %{conn: conn} do
 226       conn = get(conn, "/api/statuses/mentions.json")
 227       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 228     end
 229
 230     test "with credentials", %{conn: conn, user: current_user} do
 231       {:ok, activity} =
 232         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})
 233
 234       conn =
 235         conn
 236         |> with_credentials(current_user.nickname, "test")
 237         |> get("/api/statuses/mentions.json")
 238
 239       response = json_response(conn, 200)
 240
 241       assert length(response) == 1
 242
 243       assert Enum.at(response, 0) ==
 244                ActivityRepresenter.to_map(activity, %{
 245                  user: current_user,
 246                  mentioned: [current_user]
 247                })
 248     end
 249   end
 250
 251   describe "GET /api/qvitter/statuses/notifications.json" do
 252     setup [:valid_user]
 253
 254     test "without valid credentials", %{conn: conn} do
 255       conn = get(conn, "/api/qvitter/statuses/notifications.json")
 256       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 257     end
 258
 259     test "with credentials", %{conn: conn, user: current_user} do
 260       {:ok, activity} =
 261         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})
 262
 263       conn =
 264         conn
 265         |> with_credentials(current_user.nickname, "test")
 266         |> get("/api/qvitter/statuses/notifications.json")
 267
 268       response = json_response(conn, 200)
 269
 270       assert length(response) == 1
 271
 272       assert response ==
 273                NotificationView.render("notification.json", %{
 274                  notifications: Notification.for_user(current_user),
 275                  for: current_user
 276                })
 277     end
 278   end
 279
 280   describe "GET /statuses/user_timeline.json" do
 281     setup [:valid_user]
 282
 283     test "without any params", %{conn: conn} do
 284       conn = get(conn, "/api/statuses/user_timeline.json")
 285
 286       assert json_response(conn, 400) == %{
 287                "error" => "You need to specify screen_name or user_id",
 288                "request" => "/api/statuses/user_timeline.json"
 289              }
 290     end
 291
 292     test "with user_id", %{conn: conn} do
 293       user = insert(:user)
 294       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 295
 296       conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
 297       response = json_response(conn, 200)
 298       assert length(response) == 1
 299       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 300     end
 301
 302     test "with screen_name", %{conn: conn} do
 303       user = insert(:user)
 304       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 305
 306       conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 307       response = json_response(conn, 200)
 308       assert length(response) == 1
 309       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 310     end
 311
 312     test "with credentials", %{conn: conn, user: current_user} do
 313       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
 314
 315       conn =
 316         conn
 317         |> with_credentials(current_user.nickname, "test")
 318         |> get("/api/statuses/user_timeline.json")
 319
 320       response = json_response(conn, 200)
 321
 322       assert length(response) == 1
 323       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
 324     end
 325
 326     test "with credentials with user_id", %{conn: conn, user: current_user} do
 327       user = insert(:user)
 328       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 329
 330       conn =
 331         conn
 332         |> with_credentials(current_user.nickname, "test")
 333         |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
 334
 335       response = json_response(conn, 200)
 336
 337       assert length(response) == 1
 338       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 339     end
 340
 341     test "with credentials screen_name", %{conn: conn, user: current_user} do
 342       user = insert(:user)
 343       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 344
 345       conn =
 346         conn
 347         |> with_credentials(current_user.nickname, "test")
 348         |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 349
 350       response = json_response(conn, 200)
 351
 352       assert length(response) == 1
 353       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 354     end
 355   end
 356
 357   describe "POST /friendships/create.json" do
 358     setup [:valid_user]
 359
 360     test "without valid credentials", %{conn: conn} do
 361       conn = post(conn, "/api/friendships/create.json")
 362       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 363     end
 364
 365     test "with credentials", %{conn: conn, user: current_user} do
 366       followed = insert(:user)
 367
 368       conn =
 369         conn
 370         |> with_credentials(current_user.nickname, "test")
 371         |> post("/api/friendships/create.json", %{user_id: followed.id})
 372
 373       current_user = Repo.get(User, current_user.id)
 374       assert User.ap_followers(followed) in current_user.following
 375
 376       assert json_response(conn, 200) ==
 377                UserView.render("show.json", %{user: followed, for: current_user})
 378     end
 379   end
 380
 381   describe "POST /friendships/destroy.json" do
 382     setup [:valid_user]
 383
 384     test "without valid credentials", %{conn: conn} do
 385       conn = post(conn, "/api/friendships/destroy.json")
 386       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 387     end
 388
 389     test "with credentials", %{conn: conn, user: current_user} do
 390       followed = insert(:user)
 391
 392       {:ok, current_user} = User.follow(current_user, followed)
 393       assert User.ap_followers(followed) in current_user.following
 394       ActivityPub.follow(current_user, followed)
 395
 396       conn =
 397         conn
 398         |> with_credentials(current_user.nickname, "test")
 399         |> post("/api/friendships/destroy.json", %{user_id: followed.id})
 400
 401       current_user = Repo.get(User, current_user.id)
 402       assert current_user.following == [current_user.ap_id]
 403
 404       assert json_response(conn, 200) ==
 405                UserView.render("show.json", %{user: followed, for: current_user})
 406     end
 407   end
 408
 409   describe "POST /blocks/create.json" do
 410     setup [:valid_user]
 411
 412     test "without valid credentials", %{conn: conn} do
 413       conn = post(conn, "/api/blocks/create.json")
 414       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 415     end
 416
 417     test "with credentials", %{conn: conn, user: current_user} do
 418       blocked = insert(:user)
 419
 420       conn =
 421         conn
 422         |> with_credentials(current_user.nickname, "test")
 423         |> post("/api/blocks/create.json", %{user_id: blocked.id})
 424
 425       current_user = Repo.get(User, current_user.id)
 426       assert User.blocks?(current_user, blocked)
 427
 428       assert json_response(conn, 200) ==
 429                UserView.render("show.json", %{user: blocked, for: current_user})
 430     end
 431   end
 432
 433   describe "POST /blocks/destroy.json" do
 434     setup [:valid_user]
 435
 436     test "without valid credentials", %{conn: conn} do
 437       conn = post(conn, "/api/blocks/destroy.json")
 438       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 439     end
 440
 441     test "with credentials", %{conn: conn, user: current_user} do
 442       blocked = insert(:user)
 443
 444       {:ok, current_user} = User.block(current_user, blocked)
 445       assert User.blocks?(current_user, blocked)
 446
 447       conn =
 448         conn
 449         |> with_credentials(current_user.nickname, "test")
 450         |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
 451
 452       current_user = Repo.get(User, current_user.id)
 453       assert current_user.info["blocks"] == []
 454
 455       assert json_response(conn, 200) ==
 456                UserView.render("show.json", %{user: blocked, for: current_user})
 457     end
 458   end
 459
 460   describe "GET /help/test.json" do
 461     test "returns \"ok\"", %{conn: conn} do
 462       conn = get(conn, "/api/help/test.json")
 463       assert json_response(conn, 200) == "ok"
 464     end
 465   end
 466
 467   describe "POST /api/qvitter/update_avatar.json" do
 468     setup [:valid_user]
 469
 470     test "without valid credentials", %{conn: conn} do
 471       conn = post(conn, "/api/qvitter/update_avatar.json")
 472       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 473     end
 474
 475     test "with credentials", %{conn: conn, user: current_user} do
 476       avatar_image = File.read!("test/fixtures/avatar_data_uri")
 477
 478       conn =
 479         conn
 480         |> with_credentials(current_user.nickname, "test")
 481         |> post("/api/qvitter/update_avatar.json", %{img: avatar_image})
 482
 483       current_user = Repo.get(User, current_user.id)
 484       assert is_map(current_user.avatar)
 485
 486       assert json_response(conn, 200) ==
 487                UserView.render("show.json", %{user: current_user, for: current_user})
 488     end
 489   end
 490
 491   describe "POST /api/favorites/create/:id" do
 492     setup [:valid_user]
 493
 494     test "without valid credentials", %{conn: conn} do
 495       note_activity = insert(:note_activity)
 496       conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
 497       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 498     end
 499
 500     test "with credentials", %{conn: conn, user: current_user} do
 501       note_activity = insert(:note_activity)
 502
 503       conn =
 504         conn
 505         |> with_credentials(current_user.nickname, "test")
 506         |> post("/api/favorites/create/#{note_activity.id}.json")
 507
 508       assert json_response(conn, 200)
 509     end
 510   end
 511
 512   describe "POST /api/favorites/destroy/:id" do
 513     setup [:valid_user]
 514
 515     test "without valid credentials", %{conn: conn} do
 516       note_activity = insert(:note_activity)
 517       conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
 518       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 519     end
 520
 521     test "with credentials", %{conn: conn, user: current_user} do
 522       note_activity = insert(:note_activity)
 523       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 524       ActivityPub.like(current_user, object)
 525
 526       conn =
 527         conn
 528         |> with_credentials(current_user.nickname, "test")
 529         |> post("/api/favorites/destroy/#{note_activity.id}.json")
 530
 531       assert json_response(conn, 200)
 532     end
 533   end
 534
 535   describe "POST /api/statuses/retweet/:id" do
 536     setup [:valid_user]
 537
 538     test "without valid credentials", %{conn: conn} do
 539       note_activity = insert(:note_activity)
 540       conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
 541       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 542     end
 543
 544     test "with credentials", %{conn: conn, user: current_user} do
 545       note_activity = insert(:note_activity)
 546
 547       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 548
 549       response =
 550         conn
 551         |> with_credentials(current_user.nickname, "test")
 552         |> post(request_path)
 553
 554       activity = Repo.get(Activity, note_activity.id)
 555       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 556
 557       assert json_response(response, 200) ==
 558                ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 559     end
 560   end
 561
 562   describe "POST /api/account/register" do
 563     test "it creates a new user", %{conn: conn} do
 564       data = %{
 565         "nickname" => "lain",
 566         "email" => "lain@wired.jp",
 567         "fullname" => "lain iwakura",
 568         "bio" => "close the world.",
 569         "password" => "bear",
 570         "confirm" => "bear"
 571       }
 572
 573       conn =
 574         conn
 575         |> post("/api/account/register", data)
 576
 577       user = json_response(conn, 200)
 578
 579       fetched_user = Repo.get_by(User, nickname: "lain")
 580       assert user == UserView.render("show.json", %{user: fetched_user})
 581     end
 582
 583     test "it returns errors on a problem", %{conn: conn} do
 584       data = %{
 585         "email" => "lain@wired.jp",
 586         "fullname" => "lain iwakura",
 587         "bio" => "close the world.",
 588         "password" => "bear",
 589         "confirm" => "bear"
 590       }
 591
 592       conn =
 593         conn
 594         |> post("/api/account/register", data)
 595
 596       errors = json_response(conn, 400)
 597
 598       assert is_binary(errors["error"])
 599     end
 600   end
 601
 602   describe "GET /api/externalprofile/show" do
 603     test "it returns the user", %{conn: conn} do
 604       user = insert(:user)
 605       other_user = insert(:user)
 606
 607       conn =
 608         conn
 609         |> assign(:user, user)
 610         |> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})
 611
 612       assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
 613     end
 614   end
 615
 616   describe "GET /api/statuses/followers" do
 617     test "it returns a user's followers", %{conn: conn} do
 618       user = insert(:user)
 619       follower_one = insert(:user)
 620       follower_two = insert(:user)
 621       _not_follower = insert(:user)
 622
 623       {:ok, follower_one} = User.follow(follower_one, user)
 624       {:ok, follower_two} = User.follow(follower_two, user)
 625
 626       conn =
 627         conn
 628         |> assign(:user, user)
 629         |> get("/api/statuses/followers")
 630
 631       expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
 632       result = json_response(conn, 200)
 633       assert Enum.sort(expected) == Enum.sort(result)
 634     end
 635   end
 636
 637   describe "GET /api/statuses/friends" do
 638     test "it returns the logged in user's friends", %{conn: conn} do
 639       user = insert(:user)
 640       followed_one = insert(:user)
 641       followed_two = insert(:user)
 642       _not_followed = insert(:user)
 643
 644       {:ok, user} = User.follow(user, followed_one)
 645       {:ok, user} = User.follow(user, followed_two)
 646
 647       conn =
 648         conn
 649         |> assign(:user, user)
 650         |> get("/api/statuses/friends")
 651
 652       expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 653       result = json_response(conn, 200)
 654       assert Enum.sort(expected) == Enum.sort(result)
 655     end
 656
 657     test "it returns a given user's friends with user_id", %{conn: conn} do
 658       user = insert(:user)
 659       followed_one = insert(:user)
 660       followed_two = insert(:user)
 661       _not_followed = insert(:user)
 662
 663       {:ok, user} = User.follow(user, followed_one)
 664       {:ok, user} = User.follow(user, followed_two)
 665
 666       conn =
 667         conn
 668         |> get("/api/statuses/friends", %{"user_id" => user.id})
 669
 670       assert MapSet.equal?(
 671                MapSet.new(json_response(conn, 200)),
 672                MapSet.new(
 673                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 674                )
 675              )
 676     end
 677
 678     test "it returns a given user's friends with screen_name", %{conn: conn} do
 679       user = insert(:user)
 680       followed_one = insert(:user)
 681       followed_two = insert(:user)
 682       _not_followed = insert(:user)
 683
 684       {:ok, user} = User.follow(user, followed_one)
 685       {:ok, user} = User.follow(user, followed_two)
 686
 687       conn =
 688         conn
 689         |> get("/api/statuses/friends", %{"screen_name" => user.nickname})
 690
 691       assert MapSet.equal?(
 692                MapSet.new(json_response(conn, 200)),
 693                MapSet.new(
 694                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 695                )
 696              )
 697     end
 698   end
 699
 700   describe "GET /friends/ids" do
 701     test "it returns a user's friends", %{conn: conn} do
 702       user = insert(:user)
 703       followed_one = insert(:user)
 704       followed_two = insert(:user)
 705       _not_followed = insert(:user)
 706
 707       {:ok, user} = User.follow(user, followed_one)
 708       {:ok, user} = User.follow(user, followed_two)
 709
 710       conn =
 711         conn
 712         |> assign(:user, user)
 713         |> get("/api/friends/ids")
 714
 715       expected = [followed_one.id, followed_two.id]
 716
 717       assert MapSet.equal?(
 718                MapSet.new(Poison.decode!(json_response(conn, 200))),
 719                MapSet.new(expected)
 720              )
 721     end
 722   end
 723
 724   describe "POST /api/account/update_profile.json" do
 725     test "it updates a user's profile", %{conn: conn} do
 726       user = insert(:user)
 727
 728       conn =
 729         conn
 730         |> assign(:user, user)
 731         |> post("/api/account/update_profile.json", %{
 732           "name" => "new name",
 733           "description" => "new description"
 734         })
 735
 736       user = Repo.get!(User, user.id)
 737       assert user.name == "new name"
 738       assert user.bio == "new description"
 739
 740       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 741     end
 742   end
 743
 744   defp valid_user(_context) do
 745     user = insert(:user)
 746     [user: user]
 747   end
 748
 749   defp with_credentials(conn, username, password) do
 750     header_content = "Basic " <> Base.encode64("#{username}:#{password}")
 751     put_req_header(conn, "authorization", header_content)
 752   end
 753
 754   describe "GET /api/search.json" do
 755     test "it returns search results", %{conn: conn} do
 756       user = insert(:user)
 757       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 758
 759       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 760       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 761
 762       conn =
 763         conn
 764         |> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})
 765
 766       assert [status] = json_response(conn, 200)
 767       assert status["id"] == activity.id
 768     end
 769   end
 770
 771   describe "GET /api/statusnet/tags/timeline/:tag.json" do
 772     test "it returns the tags timeline", %{conn: conn} do
 773       user = insert(:user)
 774       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 775
 776       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
 777       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 778
 779       conn =
 780         conn
 781         |> get("/api/statusnet/tags/timeline/2hu.json")
 782
 783       assert [status] = json_response(conn, 200)
 784       assert status["id"] == activity.id
 785     end
 786   end
 787
 788   test "Convert newlines to <br> in bio", %{conn: conn} do
 789     user = insert(:user)
 790
 791     conn =
 792       conn
 793       |> assign(:user, user)
 794       |> post("/api/account/update_profile.json", %{
 795         "description" => "Hello,\r\nWorld! I\n am a test."
 796       })
 797
 798     user = Repo.get!(User, user.id)
 799     assert user.bio == "Hello,<br>World! I<br> am a test."
 800   end
 801 end