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       other_user = insert(:user)
 261
 262       {:ok, activity} =
 263         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
 264
 265       conn =
 266         conn
 267         |> with_credentials(current_user.nickname, "test")
 268         |> get("/api/qvitter/statuses/notifications.json")
 269
 270       response = json_response(conn, 200)
 271
 272       assert length(response) == 1
 273
 274       assert response ==
 275                NotificationView.render("notification.json", %{
 276                  notifications: Notification.for_user(current_user),
 277                  for: current_user
 278                })
 279     end
 280   end
 281
 282   describe "GET /statuses/user_timeline.json" do
 283     setup [:valid_user]
 284
 285     test "without any params", %{conn: conn} do
 286       conn = get(conn, "/api/statuses/user_timeline.json")
 287
 288       assert json_response(conn, 400) == %{
 289                "error" => "You need to specify screen_name or user_id",
 290                "request" => "/api/statuses/user_timeline.json"
 291              }
 292     end
 293
 294     test "with user_id", %{conn: conn} do
 295       user = insert(:user)
 296       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 297
 298       conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
 299       response = json_response(conn, 200)
 300       assert length(response) == 1
 301       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 302     end
 303
 304     test "with screen_name", %{conn: conn} do
 305       user = insert(:user)
 306       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 307
 308       conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 309       response = json_response(conn, 200)
 310       assert length(response) == 1
 311       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 312     end
 313
 314     test "with credentials", %{conn: conn, user: current_user} do
 315       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
 316
 317       conn =
 318         conn
 319         |> with_credentials(current_user.nickname, "test")
 320         |> get("/api/statuses/user_timeline.json")
 321
 322       response = json_response(conn, 200)
 323
 324       assert length(response) == 1
 325       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
 326     end
 327
 328     test "with credentials with user_id", %{conn: conn, user: current_user} do
 329       user = insert(:user)
 330       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 331
 332       conn =
 333         conn
 334         |> with_credentials(current_user.nickname, "test")
 335         |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
 336
 337       response = json_response(conn, 200)
 338
 339       assert length(response) == 1
 340       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 341     end
 342
 343     test "with credentials screen_name", %{conn: conn, user: current_user} do
 344       user = insert(:user)
 345       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 346
 347       conn =
 348         conn
 349         |> with_credentials(current_user.nickname, "test")
 350         |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 351
 352       response = json_response(conn, 200)
 353
 354       assert length(response) == 1
 355       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 356     end
 357   end
 358
 359   describe "POST /friendships/create.json" do
 360     setup [:valid_user]
 361
 362     test "without valid credentials", %{conn: conn} do
 363       conn = post(conn, "/api/friendships/create.json")
 364       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 365     end
 366
 367     test "with credentials", %{conn: conn, user: current_user} do
 368       followed = insert(:user)
 369
 370       conn =
 371         conn
 372         |> with_credentials(current_user.nickname, "test")
 373         |> post("/api/friendships/create.json", %{user_id: followed.id})
 374
 375       current_user = Repo.get(User, current_user.id)
 376       assert User.ap_followers(followed) in current_user.following
 377
 378       assert json_response(conn, 200) ==
 379                UserView.render("show.json", %{user: followed, for: current_user})
 380     end
 381   end
 382
 383   describe "POST /friendships/destroy.json" do
 384     setup [:valid_user]
 385
 386     test "without valid credentials", %{conn: conn} do
 387       conn = post(conn, "/api/friendships/destroy.json")
 388       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 389     end
 390
 391     test "with credentials", %{conn: conn, user: current_user} do
 392       followed = insert(:user)
 393
 394       {:ok, current_user} = User.follow(current_user, followed)
 395       assert User.ap_followers(followed) in current_user.following
 396       ActivityPub.follow(current_user, followed)
 397
 398       conn =
 399         conn
 400         |> with_credentials(current_user.nickname, "test")
 401         |> post("/api/friendships/destroy.json", %{user_id: followed.id})
 402
 403       current_user = Repo.get(User, current_user.id)
 404       assert current_user.following == [current_user.ap_id]
 405
 406       assert json_response(conn, 200) ==
 407                UserView.render("show.json", %{user: followed, for: current_user})
 408     end
 409   end
 410
 411   describe "POST /blocks/create.json" do
 412     setup [:valid_user]
 413
 414     test "without valid credentials", %{conn: conn} do
 415       conn = post(conn, "/api/blocks/create.json")
 416       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 417     end
 418
 419     test "with credentials", %{conn: conn, user: current_user} do
 420       blocked = insert(:user)
 421
 422       conn =
 423         conn
 424         |> with_credentials(current_user.nickname, "test")
 425         |> post("/api/blocks/create.json", %{user_id: blocked.id})
 426
 427       current_user = Repo.get(User, current_user.id)
 428       assert User.blocks?(current_user, blocked)
 429
 430       assert json_response(conn, 200) ==
 431                UserView.render("show.json", %{user: blocked, for: current_user})
 432     end
 433   end
 434
 435   describe "POST /blocks/destroy.json" do
 436     setup [:valid_user]
 437
 438     test "without valid credentials", %{conn: conn} do
 439       conn = post(conn, "/api/blocks/destroy.json")
 440       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 441     end
 442
 443     test "with credentials", %{conn: conn, user: current_user} do
 444       blocked = insert(:user)
 445
 446       {:ok, current_user} = User.block(current_user, blocked)
 447       assert User.blocks?(current_user, blocked)
 448
 449       conn =
 450         conn
 451         |> with_credentials(current_user.nickname, "test")
 452         |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
 453
 454       current_user = Repo.get(User, current_user.id)
 455       assert current_user.info["blocks"] == []
 456
 457       assert json_response(conn, 200) ==
 458                UserView.render("show.json", %{user: blocked, for: current_user})
 459     end
 460   end
 461
 462   describe "GET /help/test.json" do
 463     test "returns \"ok\"", %{conn: conn} do
 464       conn = get(conn, "/api/help/test.json")
 465       assert json_response(conn, 200) == "ok"
 466     end
 467   end
 468
 469   describe "POST /api/qvitter/update_avatar.json" do
 470     setup [:valid_user]
 471
 472     test "without valid credentials", %{conn: conn} do
 473       conn = post(conn, "/api/qvitter/update_avatar.json")
 474       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 475     end
 476
 477     test "with credentials", %{conn: conn, user: current_user} do
 478       avatar_image = File.read!("test/fixtures/avatar_data_uri")
 479
 480       conn =
 481         conn
 482         |> with_credentials(current_user.nickname, "test")
 483         |> post("/api/qvitter/update_avatar.json", %{img: avatar_image})
 484
 485       current_user = Repo.get(User, current_user.id)
 486       assert is_map(current_user.avatar)
 487
 488       assert json_response(conn, 200) ==
 489                UserView.render("show.json", %{user: current_user, for: current_user})
 490     end
 491   end
 492
 493   describe "POST /api/favorites/create/:id" do
 494     setup [:valid_user]
 495
 496     test "without valid credentials", %{conn: conn} do
 497       note_activity = insert(:note_activity)
 498       conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
 499       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 500     end
 501
 502     test "with credentials", %{conn: conn, user: current_user} do
 503       note_activity = insert(:note_activity)
 504
 505       conn =
 506         conn
 507         |> with_credentials(current_user.nickname, "test")
 508         |> post("/api/favorites/create/#{note_activity.id}.json")
 509
 510       assert json_response(conn, 200)
 511     end
 512   end
 513
 514   describe "POST /api/favorites/destroy/: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/destroy/#{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       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 526       ActivityPub.like(current_user, object)
 527
 528       conn =
 529         conn
 530         |> with_credentials(current_user.nickname, "test")
 531         |> post("/api/favorites/destroy/#{note_activity.id}.json")
 532
 533       assert json_response(conn, 200)
 534     end
 535   end
 536
 537   describe "POST /api/statuses/retweet/:id" do
 538     setup [:valid_user]
 539
 540     test "without valid credentials", %{conn: conn} do
 541       note_activity = insert(:note_activity)
 542       conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
 543       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 544     end
 545
 546     test "with credentials", %{conn: conn, user: current_user} do
 547       note_activity = insert(:note_activity)
 548
 549       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 550
 551       response =
 552         conn
 553         |> with_credentials(current_user.nickname, "test")
 554         |> post(request_path)
 555
 556       activity = Repo.get(Activity, note_activity.id)
 557       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 558
 559       assert json_response(response, 200) ==
 560                ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 561     end
 562   end
 563
 564   describe "POST /api/account/register" do
 565     test "it creates a new user", %{conn: conn} do
 566       data = %{
 567         "nickname" => "lain",
 568         "email" => "lain@wired.jp",
 569         "fullname" => "lain iwakura",
 570         "bio" => "close the world.",
 571         "password" => "bear",
 572         "confirm" => "bear"
 573       }
 574
 575       conn =
 576         conn
 577         |> post("/api/account/register", data)
 578
 579       user = json_response(conn, 200)
 580
 581       fetched_user = Repo.get_by(User, nickname: "lain")
 582       assert user == UserView.render("show.json", %{user: fetched_user})
 583     end
 584
 585     test "it returns errors on a problem", %{conn: conn} do
 586       data = %{
 587         "email" => "lain@wired.jp",
 588         "fullname" => "lain iwakura",
 589         "bio" => "close the world.",
 590         "password" => "bear",
 591         "confirm" => "bear"
 592       }
 593
 594       conn =
 595         conn
 596         |> post("/api/account/register", data)
 597
 598       errors = json_response(conn, 400)
 599
 600       assert is_binary(errors["error"])
 601     end
 602   end
 603
 604   describe "GET /api/externalprofile/show" do
 605     test "it returns the user", %{conn: conn} do
 606       user = insert(:user)
 607       other_user = insert(:user)
 608
 609       conn =
 610         conn
 611         |> assign(:user, user)
 612         |> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})
 613
 614       assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
 615     end
 616   end
 617
 618   describe "GET /api/statuses/followers" do
 619     test "it returns a user's followers", %{conn: conn} do
 620       user = insert(:user)
 621       follower_one = insert(:user)
 622       follower_two = insert(:user)
 623       _not_follower = insert(:user)
 624
 625       {:ok, follower_one} = User.follow(follower_one, user)
 626       {:ok, follower_two} = User.follow(follower_two, user)
 627
 628       conn =
 629         conn
 630         |> assign(:user, user)
 631         |> get("/api/statuses/followers")
 632
 633       expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
 634       result = json_response(conn, 200)
 635       assert Enum.sort(expected) == Enum.sort(result)
 636     end
 637   end
 638
 639   describe "GET /api/statuses/friends" do
 640     test "it returns the logged in user's friends", %{conn: conn} do
 641       user = insert(:user)
 642       followed_one = insert(:user)
 643       followed_two = insert(:user)
 644       _not_followed = insert(:user)
 645
 646       {:ok, user} = User.follow(user, followed_one)
 647       {:ok, user} = User.follow(user, followed_two)
 648
 649       conn =
 650         conn
 651         |> assign(:user, user)
 652         |> get("/api/statuses/friends")
 653
 654       expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 655       result = json_response(conn, 200)
 656       assert Enum.sort(expected) == Enum.sort(result)
 657     end
 658
 659     test "it returns a given user's friends with user_id", %{conn: conn} do
 660       user = insert(:user)
 661       followed_one = insert(:user)
 662       followed_two = insert(:user)
 663       _not_followed = insert(:user)
 664
 665       {:ok, user} = User.follow(user, followed_one)
 666       {:ok, user} = User.follow(user, followed_two)
 667
 668       conn =
 669         conn
 670         |> get("/api/statuses/friends", %{"user_id" => user.id})
 671
 672       assert MapSet.equal?(
 673                MapSet.new(json_response(conn, 200)),
 674                MapSet.new(
 675                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 676                )
 677              )
 678     end
 679
 680     test "it returns a given user's friends with screen_name", %{conn: conn} do
 681       user = insert(:user)
 682       followed_one = insert(:user)
 683       followed_two = insert(:user)
 684       _not_followed = insert(:user)
 685
 686       {:ok, user} = User.follow(user, followed_one)
 687       {:ok, user} = User.follow(user, followed_two)
 688
 689       conn =
 690         conn
 691         |> get("/api/statuses/friends", %{"screen_name" => user.nickname})
 692
 693       assert MapSet.equal?(
 694                MapSet.new(json_response(conn, 200)),
 695                MapSet.new(
 696                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 697                )
 698              )
 699     end
 700   end
 701
 702   describe "GET /friends/ids" do
 703     test "it returns a user's friends", %{conn: conn} do
 704       user = insert(:user)
 705       followed_one = insert(:user)
 706       followed_two = insert(:user)
 707       _not_followed = insert(:user)
 708
 709       {:ok, user} = User.follow(user, followed_one)
 710       {:ok, user} = User.follow(user, followed_two)
 711
 712       conn =
 713         conn
 714         |> assign(:user, user)
 715         |> get("/api/friends/ids")
 716
 717       expected = [followed_one.id, followed_two.id]
 718
 719       assert MapSet.equal?(
 720                MapSet.new(Poison.decode!(json_response(conn, 200))),
 721                MapSet.new(expected)
 722              )
 723     end
 724   end
 725
 726   describe "POST /api/account/update_profile.json" do
 727     test "it updates a user's profile", %{conn: conn} do
 728       user = insert(:user)
 729
 730       conn =
 731         conn
 732         |> assign(:user, user)
 733         |> post("/api/account/update_profile.json", %{
 734           "name" => "new name",
 735           "description" => "new description"
 736         })
 737
 738       user = Repo.get!(User, user.id)
 739       assert user.name == "new name"
 740       assert user.bio == "new description"
 741
 742       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 743     end
 744   end
 745
 746   defp valid_user(_context) do
 747     user = insert(:user)
 748     [user: user]
 749   end
 750
 751   defp with_credentials(conn, username, password) do
 752     header_content = "Basic " <> Base.encode64("#{username}:#{password}")
 753     put_req_header(conn, "authorization", header_content)
 754   end
 755
 756   describe "GET /api/search.json" do
 757     test "it returns search results", %{conn: conn} do
 758       user = insert(:user)
 759       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 760
 761       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 762       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 763
 764       conn =
 765         conn
 766         |> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})
 767
 768       assert [status] = json_response(conn, 200)
 769       assert status["id"] == activity.id
 770     end
 771   end
 772
 773   describe "GET /api/statusnet/tags/timeline/:tag.json" do
 774     test "it returns the tags timeline", %{conn: conn} do
 775       user = insert(:user)
 776       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 777
 778       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
 779       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 780
 781       conn =
 782         conn
 783         |> get("/api/statusnet/tags/timeline/2hu.json")
 784
 785       assert [status] = json_response(conn, 200)
 786       assert status["id"] == activity.id
 787     end
 788   end
 789
 790   test "Convert newlines to <br> in bio", %{conn: conn} do
 791     user = insert(:user)
 792
 793     conn =
 794       conn
 795       |> assign(:user, user)
 796       |> post("/api/account/update_profile.json", %{
 797         "description" => "Hello,\r\nWorld! I\n am a test."
 798       })
 799
 800     user = Repo.get!(User, user.id)
 801     assert user.bio == "Hello,<br>World! I<br> am a test."
 802   end
 803 end