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