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       {:ok, object} = Object.context_mapping("2hu") |> Repo.insert()
 168
 169       conn =
 170         conn
 171         |> get("/api/statusnet/conversation/#{object.id}.json")
 172
 173       response = json_response(conn, 200)
 174
 175       assert length(response) == 2
 176     end
 177   end
 178
 179   describe "GET /statuses/friends_timeline.json" do
 180     setup [:valid_user]
 181
 182     test "without valid credentials", %{conn: conn} do
 183       conn = get(conn, "/api/statuses/friends_timeline.json")
 184       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 185     end
 186
 187     test "with credentials", %{conn: conn, user: current_user} do
 188       user = insert(:user)
 189
 190       activities =
 191         ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
 192
 193       returned_activities =
 194         ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
 195
 196       other_user = insert(:user)
 197       ActivityBuilder.insert_list(10, %{}, %{user: other_user})
 198       since_id = List.last(activities).id
 199
 200       current_user =
 201         Ecto.Changeset.change(current_user, following: [User.ap_followers(user)])
 202         |> Repo.update!()
 203
 204       conn =
 205         conn
 206         |> with_credentials(current_user.nickname, "test")
 207         |> get("/api/statuses/friends_timeline.json", %{since_id: since_id})
 208
 209       response = json_response(conn, 200)
 210
 211       assert length(response) == 10
 212
 213       assert response ==
 214                Enum.map(returned_activities, fn activity ->
 215                  ActivityRepresenter.to_map(activity, %{
 216                    user: User.get_cached_by_ap_id(activity.data["actor"]),
 217                    for: current_user
 218                  })
 219                end)
 220     end
 221   end
 222
 223   describe "GET /statuses/mentions.json" do
 224     setup [:valid_user]
 225
 226     test "without valid credentials", %{conn: conn} do
 227       conn = get(conn, "/api/statuses/mentions.json")
 228       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 229     end
 230
 231     test "with credentials", %{conn: conn, user: current_user} do
 232       {:ok, activity} =
 233         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})
 234
 235       conn =
 236         conn
 237         |> with_credentials(current_user.nickname, "test")
 238         |> get("/api/statuses/mentions.json")
 239
 240       response = json_response(conn, 200)
 241
 242       assert length(response) == 1
 243
 244       assert Enum.at(response, 0) ==
 245                ActivityRepresenter.to_map(activity, %{
 246                  user: current_user,
 247                  mentioned: [current_user]
 248                })
 249     end
 250   end
 251
 252   describe "GET /statuses/user_timeline.json" do
 253     setup [:valid_user]
 254
 255     test "without any params", %{conn: conn} do
 256       conn = get(conn, "/api/statuses/user_timeline.json")
 257
 258       assert json_response(conn, 400) == %{
 259                "error" => "You need to specify screen_name or user_id",
 260                "request" => "/api/statuses/user_timeline.json"
 261              }
 262     end
 263
 264     test "with user_id", %{conn: conn} do
 265       user = insert(:user)
 266       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 267
 268       conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
 269       response = json_response(conn, 200)
 270       assert length(response) == 1
 271       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 272     end
 273
 274     test "with screen_name", %{conn: conn} do
 275       user = insert(:user)
 276       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 277
 278       conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 279       response = json_response(conn, 200)
 280       assert length(response) == 1
 281       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 282     end
 283
 284     test "with credentials", %{conn: conn, user: current_user} do
 285       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
 286
 287       conn =
 288         conn
 289         |> with_credentials(current_user.nickname, "test")
 290         |> get("/api/statuses/user_timeline.json")
 291
 292       response = json_response(conn, 200)
 293
 294       assert length(response) == 1
 295       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
 296     end
 297
 298     test "with credentials with user_id", %{conn: conn, user: current_user} do
 299       user = insert(:user)
 300       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 301
 302       conn =
 303         conn
 304         |> with_credentials(current_user.nickname, "test")
 305         |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
 306
 307       response = json_response(conn, 200)
 308
 309       assert length(response) == 1
 310       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 311     end
 312
 313     test "with credentials screen_name", %{conn: conn, user: current_user} do
 314       user = insert(:user)
 315       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 316
 317       conn =
 318         conn
 319         |> with_credentials(current_user.nickname, "test")
 320         |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 321
 322       response = json_response(conn, 200)
 323
 324       assert length(response) == 1
 325       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 326     end
 327   end
 328
 329   describe "POST /friendships/create.json" do
 330     setup [:valid_user]
 331
 332     test "without valid credentials", %{conn: conn} do
 333       conn = post(conn, "/api/friendships/create.json")
 334       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 335     end
 336
 337     test "with credentials", %{conn: conn, user: current_user} do
 338       followed = insert(:user)
 339
 340       conn =
 341         conn
 342         |> with_credentials(current_user.nickname, "test")
 343         |> post("/api/friendships/create.json", %{user_id: followed.id})
 344
 345       current_user = Repo.get(User, current_user.id)
 346       assert User.ap_followers(followed) in current_user.following
 347
 348       assert json_response(conn, 200) ==
 349                UserView.render("show.json", %{user: followed, for: current_user})
 350     end
 351   end
 352
 353   describe "POST /friendships/destroy.json" do
 354     setup [:valid_user]
 355
 356     test "without valid credentials", %{conn: conn} do
 357       conn = post(conn, "/api/friendships/destroy.json")
 358       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 359     end
 360
 361     test "with credentials", %{conn: conn, user: current_user} do
 362       followed = insert(:user)
 363
 364       {:ok, current_user} = User.follow(current_user, followed)
 365       assert User.ap_followers(followed) in current_user.following
 366       ActivityPub.follow(current_user, followed)
 367
 368       conn =
 369         conn
 370         |> with_credentials(current_user.nickname, "test")
 371         |> post("/api/friendships/destroy.json", %{user_id: followed.id})
 372
 373       current_user = Repo.get(User, current_user.id)
 374       assert current_user.following == [current_user.ap_id]
 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 /blocks/create.json" do
 382     setup [:valid_user]
 383
 384     test "without valid credentials", %{conn: conn} do
 385       conn = post(conn, "/api/blocks/create.json")
 386       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 387     end
 388
 389     test "with credentials", %{conn: conn, user: current_user} do
 390       blocked = insert(:user)
 391
 392       conn =
 393         conn
 394         |> with_credentials(current_user.nickname, "test")
 395         |> post("/api/blocks/create.json", %{user_id: blocked.id})
 396
 397       current_user = Repo.get(User, current_user.id)
 398       assert User.blocks?(current_user, blocked)
 399
 400       assert json_response(conn, 200) ==
 401                UserView.render("show.json", %{user: blocked, for: current_user})
 402     end
 403   end
 404
 405   describe "POST /blocks/destroy.json" do
 406     setup [:valid_user]
 407
 408     test "without valid credentials", %{conn: conn} do
 409       conn = post(conn, "/api/blocks/destroy.json")
 410       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 411     end
 412
 413     test "with credentials", %{conn: conn, user: current_user} do
 414       blocked = insert(:user)
 415
 416       {:ok, current_user} = User.block(current_user, blocked)
 417       assert User.blocks?(current_user, blocked)
 418
 419       conn =
 420         conn
 421         |> with_credentials(current_user.nickname, "test")
 422         |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
 423
 424       current_user = Repo.get(User, current_user.id)
 425       assert current_user.info["blocks"] == []
 426
 427       assert json_response(conn, 200) ==
 428                UserView.render("show.json", %{user: blocked, for: current_user})
 429     end
 430   end
 431
 432   describe "GET /help/test.json" do
 433     test "returns \"ok\"", %{conn: conn} do
 434       conn = get(conn, "/api/help/test.json")
 435       assert json_response(conn, 200) == "ok"
 436     end
 437   end
 438
 439   describe "POST /api/qvitter/update_avatar.json" do
 440     setup [:valid_user]
 441
 442     test "without valid credentials", %{conn: conn} do
 443       conn = post(conn, "/api/qvitter/update_avatar.json")
 444       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 445     end
 446
 447     test "with credentials", %{conn: conn, user: current_user} do
 448       avatar_image = File.read!("test/fixtures/avatar_data_uri")
 449
 450       conn =
 451         conn
 452         |> with_credentials(current_user.nickname, "test")
 453         |> post("/api/qvitter/update_avatar.json", %{img: avatar_image})
 454
 455       current_user = Repo.get(User, current_user.id)
 456       assert is_map(current_user.avatar)
 457
 458       assert json_response(conn, 200) ==
 459                UserView.render("show.json", %{user: current_user, for: current_user})
 460     end
 461   end
 462
 463   describe "POST /api/favorites/create/:id" do
 464     setup [:valid_user]
 465
 466     test "without valid credentials", %{conn: conn} do
 467       note_activity = insert(:note_activity)
 468       conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
 469       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 470     end
 471
 472     test "with credentials", %{conn: conn, user: current_user} do
 473       note_activity = insert(:note_activity)
 474
 475       conn =
 476         conn
 477         |> with_credentials(current_user.nickname, "test")
 478         |> post("/api/favorites/create/#{note_activity.id}.json")
 479
 480       assert json_response(conn, 200)
 481     end
 482   end
 483
 484   describe "POST /api/favorites/destroy/:id" do
 485     setup [:valid_user]
 486
 487     test "without valid credentials", %{conn: conn} do
 488       note_activity = insert(:note_activity)
 489       conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
 490       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 491     end
 492
 493     test "with credentials", %{conn: conn, user: current_user} do
 494       note_activity = insert(:note_activity)
 495       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 496       ActivityPub.like(current_user, object)
 497
 498       conn =
 499         conn
 500         |> with_credentials(current_user.nickname, "test")
 501         |> post("/api/favorites/destroy/#{note_activity.id}.json")
 502
 503       assert json_response(conn, 200)
 504     end
 505   end
 506
 507   describe "POST /api/statuses/retweet/:id" do
 508     setup [:valid_user]
 509
 510     test "without valid credentials", %{conn: conn} do
 511       note_activity = insert(:note_activity)
 512       conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
 513       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 514     end
 515
 516     test "with credentials", %{conn: conn, user: current_user} do
 517       note_activity = insert(:note_activity)
 518
 519       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 520
 521       response =
 522         conn
 523         |> with_credentials(current_user.nickname, "test")
 524         |> post(request_path)
 525
 526       activity = Repo.get(Activity, note_activity.id)
 527       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 528
 529       assert json_response(response, 200) ==
 530                ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 531     end
 532   end
 533
 534   describe "POST /api/account/register" do
 535     test "it creates a new user", %{conn: conn} do
 536       data = %{
 537         "nickname" => "lain",
 538         "email" => "lain@wired.jp",
 539         "fullname" => "lain iwakura",
 540         "bio" => "close the world.",
 541         "password" => "bear",
 542         "confirm" => "bear"
 543       }
 544
 545       conn =
 546         conn
 547         |> post("/api/account/register", data)
 548
 549       user = json_response(conn, 200)
 550
 551       fetched_user = Repo.get_by(User, nickname: "lain")
 552       assert user == UserView.render("show.json", %{user: fetched_user})
 553     end
 554
 555     test "it returns errors on a problem", %{conn: conn} do
 556       data = %{
 557         "email" => "lain@wired.jp",
 558         "fullname" => "lain iwakura",
 559         "bio" => "close the world.",
 560         "password" => "bear",
 561         "confirm" => "bear"
 562       }
 563
 564       conn =
 565         conn
 566         |> post("/api/account/register", data)
 567
 568       errors = json_response(conn, 400)
 569
 570       assert is_binary(errors["error"])
 571     end
 572   end
 573
 574   describe "GET /api/externalprofile/show" do
 575     test "it returns the user", %{conn: conn} do
 576       user = insert(:user)
 577       other_user = insert(:user)
 578
 579       conn =
 580         conn
 581         |> assign(:user, user)
 582         |> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})
 583
 584       assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
 585     end
 586   end
 587
 588   describe "GET /api/statuses/followers" do
 589     test "it returns a user's followers", %{conn: conn} do
 590       user = insert(:user)
 591       follower_one = insert(:user)
 592       follower_two = insert(:user)
 593       _not_follower = insert(:user)
 594
 595       {:ok, follower_one} = User.follow(follower_one, user)
 596       {:ok, follower_two} = User.follow(follower_two, user)
 597
 598       conn =
 599         conn
 600         |> assign(:user, user)
 601         |> get("/api/statuses/followers")
 602
 603       assert json_response(conn, 200) ==
 604                UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
 605     end
 606   end
 607
 608   describe "GET /api/statuses/friends" do
 609     test "it returns the logged in user's friends", %{conn: conn} do
 610       user = insert(:user)
 611       followed_one = insert(:user)
 612       followed_two = insert(:user)
 613       _not_followed = insert(:user)
 614
 615       {:ok, user} = User.follow(user, followed_one)
 616       {:ok, user} = User.follow(user, followed_two)
 617
 618       conn =
 619         conn
 620         |> assign(:user, user)
 621         |> get("/api/statuses/friends")
 622
 623       assert MapSet.equal?(
 624                MapSet.new(json_response(conn, 200)),
 625                MapSet.new(
 626                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 627                )
 628              )
 629     end
 630
 631     test "it returns a given user's friends with user_id", %{conn: conn} do
 632       user = insert(:user)
 633       followed_one = insert(:user)
 634       followed_two = insert(:user)
 635       _not_followed = insert(:user)
 636
 637       {:ok, user} = User.follow(user, followed_one)
 638       {:ok, user} = User.follow(user, followed_two)
 639
 640       conn =
 641         conn
 642         |> get("/api/statuses/friends", %{"user_id" => user.id})
 643
 644       assert MapSet.equal?(
 645                MapSet.new(json_response(conn, 200)),
 646                MapSet.new(
 647                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 648                )
 649              )
 650     end
 651
 652     test "it returns a given user's friends with screen_name", %{conn: conn} do
 653       user = insert(:user)
 654       followed_one = insert(:user)
 655       followed_two = insert(:user)
 656       _not_followed = insert(:user)
 657
 658       {:ok, user} = User.follow(user, followed_one)
 659       {:ok, user} = User.follow(user, followed_two)
 660
 661       conn =
 662         conn
 663         |> get("/api/statuses/friends", %{"screen_name" => user.nickname})
 664
 665       assert MapSet.equal?(
 666                MapSet.new(json_response(conn, 200)),
 667                MapSet.new(
 668                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 669                )
 670              )
 671     end
 672   end
 673
 674   describe "GET /friends/ids" do
 675     test "it returns a user's friends", %{conn: conn} do
 676       user = insert(:user)
 677       followed_one = insert(:user)
 678       followed_two = insert(:user)
 679       _not_followed = insert(:user)
 680
 681       {:ok, user} = User.follow(user, followed_one)
 682       {:ok, user} = User.follow(user, followed_two)
 683
 684       conn =
 685         conn
 686         |> assign(:user, user)
 687         |> get("/api/friends/ids")
 688
 689       expected = [followed_one.id, followed_two.id]
 690
 691       assert MapSet.equal?(
 692                MapSet.new(Poison.decode!(json_response(conn, 200))),
 693                MapSet.new(expected)
 694              )
 695     end
 696   end
 697
 698   describe "POST /api/account/update_profile.json" do
 699     test "it updates a user's profile", %{conn: conn} do
 700       user = insert(:user)
 701
 702       conn =
 703         conn
 704         |> assign(:user, user)
 705         |> post("/api/account/update_profile.json", %{
 706           "name" => "new name",
 707           "description" => "new description"
 708         })
 709
 710       user = Repo.get!(User, user.id)
 711       assert user.name == "new name"
 712       assert user.bio == "new description"
 713
 714       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 715     end
 716   end
 717
 718   defp valid_user(_context) do
 719     user = insert(:user)
 720     [user: user]
 721   end
 722
 723   defp with_credentials(conn, username, password) do
 724     header_content = "Basic " <> Base.encode64("#{username}:#{password}")
 725     put_req_header(conn, "authorization", header_content)
 726   end
 727
 728   describe "GET /api/search.json" do
 729     test "it returns search results", %{conn: conn} do
 730       user = insert(:user)
 731       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 732
 733       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 734       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 735
 736       conn =
 737         conn
 738         |> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})
 739
 740       assert [status] = json_response(conn, 200)
 741       assert status["id"] == activity.id
 742     end
 743   end
 744
 745   describe "GET /api/statusnet/tags/timeline/:tag.json" do
 746     test "it returns the tags timeline", %{conn: conn} do
 747       user = insert(:user)
 748       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 749
 750       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
 751       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 752
 753       conn =
 754         conn
 755         |> get("/api/statusnet/tags/timeline/2hu.json")
 756
 757       assert [status] = json_response(conn, 200)
 758       assert status["id"] == activity.id
 759     end
 760   end
 761 end