git.squeep.com Git - akkoma/blob - test/web/mastodon_api/mastodon_api_controller_test.exs

   1 defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
   2   use Pleroma.Web.ConnCase
   3
   4   alias Pleroma.Web.TwitterAPI.TwitterAPI
   5   alias Pleroma.{Repo, User, Activity, Notification}
   6   alias Pleroma.Web.{OStatus, CommonAPI}
   7
   8   import Pleroma.Factory
   9   import ExUnit.CaptureLog
  10
  11   test "the home timeline", %{conn: conn} do
  12     user = insert(:user)
  13     following = insert(:user)
  14
  15     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  16
  17     conn =
  18       conn
  19       |> assign(:user, user)
  20       |> get("/api/v1/timelines/home")
  21
  22     assert length(json_response(conn, 200)) == 0
  23
  24     {:ok, user} = User.follow(user, following)
  25
  26     conn =
  27       build_conn()
  28       |> assign(:user, user)
  29       |> get("/api/v1/timelines/home")
  30
  31     assert [%{"content" => "test"}] = json_response(conn, 200)
  32   end
  33
  34   test "the public timeline", %{conn: conn} do
  35     following = insert(:user)
  36
  37     capture_log(fn ->
  38       {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  39
  40       {:ok, [_activity]} =
  41         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
  42
  43       conn =
  44         conn
  45         |> get("/api/v1/timelines/public", %{"local" => "False"})
  46
  47       assert length(json_response(conn, 200)) == 2
  48
  49       conn =
  50         build_conn()
  51         |> get("/api/v1/timelines/public", %{"local" => "True"})
  52
  53       assert [%{"content" => "test"}] = json_response(conn, 200)
  54
  55       conn =
  56         build_conn()
  57         |> get("/api/v1/timelines/public", %{"local" => "1"})
  58
  59       assert [%{"content" => "test"}] = json_response(conn, 200)
  60     end)
  61   end
  62
  63   test "posting a status", %{conn: conn} do
  64     user = insert(:user)
  65
  66     idempotency_key = "Pikachu rocks!"
  67
  68     conn_one =
  69       conn
  70       |> assign(:user, user)
  71       |> put_req_header("idempotency-key", idempotency_key)
  72       |> post("/api/v1/statuses", %{
  73         "status" => "cofe",
  74         "spoiler_text" => "2hu",
  75         "sensitive" => "false"
  76       })
  77
  78     {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
  79     # Six hours
  80     assert ttl > :timer.seconds(6 * 60 * 60 - 1)
  81
  82     assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
  83              json_response(conn_one, 200)
  84
  85     assert Repo.get(Activity, id)
  86
  87     conn_two =
  88       conn
  89       |> assign(:user, user)
  90       |> put_req_header("idempotency-key", idempotency_key)
  91       |> post("/api/v1/statuses", %{
  92         "status" => "cofe",
  93         "spoiler_text" => "2hu",
  94         "sensitive" => "false"
  95       })
  96
  97     assert %{"id" => second_id} = json_response(conn_two, 200)
  98
  99     assert id == second_id
 100
 101     conn_three =
 102       conn
 103       |> assign(:user, user)
 104       |> post("/api/v1/statuses", %{
 105         "status" => "cofe",
 106         "spoiler_text" => "2hu",
 107         "sensitive" => "false"
 108       })
 109
 110     assert %{"id" => third_id} = json_response(conn_three, 200)
 111
 112     refute id == third_id
 113   end
 114
 115   test "posting a sensitive status", %{conn: conn} do
 116     user = insert(:user)
 117
 118     conn =
 119       conn
 120       |> assign(:user, user)
 121       |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
 122
 123     assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
 124     assert Repo.get(Activity, id)
 125   end
 126
 127   test "replying to a status", %{conn: conn} do
 128     user = insert(:user)
 129
 130     {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 131
 132     conn =
 133       conn
 134       |> assign(:user, user)
 135       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 136
 137     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 138
 139     activity = Repo.get(Activity, id)
 140
 141     assert activity.data["context"] == replied_to.data["context"]
 142     assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
 143   end
 144
 145   test "verify_credentials", %{conn: conn} do
 146     user = insert(:user)
 147
 148     conn =
 149       conn
 150       |> assign(:user, user)
 151       |> get("/api/v1/accounts/verify_credentials")
 152
 153     assert %{"id" => id} = json_response(conn, 200)
 154     assert id == to_string(user.id)
 155   end
 156
 157   test "get a status", %{conn: conn} do
 158     activity = insert(:note_activity)
 159
 160     conn =
 161       conn
 162       |> get("/api/v1/statuses/#{activity.id}")
 163
 164     assert %{"id" => id} = json_response(conn, 200)
 165     assert id == to_string(activity.id)
 166   end
 167
 168   describe "deleting a status" do
 169     test "when you created it", %{conn: conn} do
 170       activity = insert(:note_activity)
 171       author = User.get_by_ap_id(activity.data["actor"])
 172
 173       conn =
 174         conn
 175         |> assign(:user, author)
 176         |> delete("/api/v1/statuses/#{activity.id}")
 177
 178       assert %{} = json_response(conn, 200)
 179
 180       assert Repo.get(Activity, activity.id) == nil
 181     end
 182
 183     test "when you didn't create it", %{conn: conn} do
 184       activity = insert(:note_activity)
 185       user = insert(:user)
 186
 187       conn =
 188         conn
 189         |> assign(:user, user)
 190         |> delete("/api/v1/statuses/#{activity.id}")
 191
 192       assert %{"error" => _} = json_response(conn, 403)
 193
 194       assert Repo.get(Activity, activity.id) == activity
 195     end
 196   end
 197
 198   describe "lists" do
 199     test "creating a list", %{conn: conn} do
 200       user = insert(:user)
 201
 202       conn =
 203         conn
 204         |> assign(:user, user)
 205         |> post("/api/v1/lists", %{"title" => "cuties"})
 206
 207       assert %{"title" => title} = json_response(conn, 200)
 208       assert title == "cuties"
 209     end
 210
 211     test "adding users to a list", %{conn: conn} do
 212       user = insert(:user)
 213       other_user = insert(:user)
 214       {:ok, list} = Pleroma.List.create("name", user)
 215
 216       conn =
 217         conn
 218         |> assign(:user, user)
 219         |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 220
 221       assert %{} == json_response(conn, 200)
 222       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 223       assert following == [other_user.follower_address]
 224     end
 225
 226     test "removing users from a list", %{conn: conn} do
 227       user = insert(:user)
 228       other_user = insert(:user)
 229       third_user = insert(:user)
 230       {:ok, list} = Pleroma.List.create("name", user)
 231       {:ok, list} = Pleroma.List.follow(list, other_user)
 232       {:ok, list} = Pleroma.List.follow(list, third_user)
 233
 234       conn =
 235         conn
 236         |> assign(:user, user)
 237         |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 238
 239       assert %{} == json_response(conn, 200)
 240       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 241       assert following == [third_user.follower_address]
 242     end
 243
 244     test "listing users in a list", %{conn: conn} do
 245       user = insert(:user)
 246       other_user = insert(:user)
 247       {:ok, list} = Pleroma.List.create("name", user)
 248       {:ok, list} = Pleroma.List.follow(list, other_user)
 249
 250       conn =
 251         conn
 252         |> assign(:user, user)
 253         |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 254
 255       assert [%{"id" => id}] = json_response(conn, 200)
 256       assert id == to_string(other_user.id)
 257     end
 258
 259     test "retrieving a list", %{conn: conn} do
 260       user = insert(:user)
 261       {:ok, list} = Pleroma.List.create("name", user)
 262
 263       conn =
 264         conn
 265         |> assign(:user, user)
 266         |> get("/api/v1/lists/#{list.id}")
 267
 268       assert %{"id" => id} = json_response(conn, 200)
 269       assert id == to_string(list.id)
 270     end
 271
 272     test "renaming a list", %{conn: conn} do
 273       user = insert(:user)
 274       {:ok, list} = Pleroma.List.create("name", user)
 275
 276       conn =
 277         conn
 278         |> assign(:user, user)
 279         |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
 280
 281       assert %{"title" => name} = json_response(conn, 200)
 282       assert name == "newname"
 283     end
 284
 285     test "deleting a list", %{conn: conn} do
 286       user = insert(:user)
 287       {:ok, list} = Pleroma.List.create("name", user)
 288
 289       conn =
 290         conn
 291         |> assign(:user, user)
 292         |> delete("/api/v1/lists/#{list.id}")
 293
 294       assert %{} = json_response(conn, 200)
 295       assert is_nil(Repo.get(Pleroma.List, list.id))
 296     end
 297
 298     test "list timeline", %{conn: conn} do
 299       user = insert(:user)
 300       other_user = insert(:user)
 301       {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
 302       {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 303       {:ok, list} = Pleroma.List.create("name", user)
 304       {:ok, list} = Pleroma.List.follow(list, other_user)
 305
 306       conn =
 307         conn
 308         |> assign(:user, user)
 309         |> get("/api/v1/timelines/list/#{list.id}")
 310
 311       assert [%{"id" => id}] = json_response(conn, 200)
 312
 313       assert id == to_string(activity_two.id)
 314     end
 315   end
 316
 317   describe "notifications" do
 318     test "list of notifications", %{conn: conn} do
 319       user = insert(:user)
 320       other_user = insert(:user)
 321
 322       {:ok, activity} =
 323         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 324
 325       {:ok, [_notification]} = Notification.create_notifications(activity)
 326
 327       conn =
 328         conn
 329         |> assign(:user, user)
 330         |> get("/api/v1/notifications")
 331
 332       expected_response =
 333         "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 334
 335       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 336       assert response == expected_response
 337     end
 338
 339     test "getting a single notification", %{conn: conn} do
 340       user = insert(:user)
 341       other_user = insert(:user)
 342
 343       {:ok, activity} =
 344         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 345
 346       {:ok, [notification]} = Notification.create_notifications(activity)
 347
 348       conn =
 349         conn
 350         |> assign(:user, user)
 351         |> get("/api/v1/notifications/#{notification.id}")
 352
 353       expected_response =
 354         "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 355
 356       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 357       assert response == expected_response
 358     end
 359
 360     test "dismissing a single notification", %{conn: conn} do
 361       user = insert(:user)
 362       other_user = insert(:user)
 363
 364       {:ok, activity} =
 365         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 366
 367       {:ok, [notification]} = Notification.create_notifications(activity)
 368
 369       conn =
 370         conn
 371         |> assign(:user, user)
 372         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 373
 374       assert %{} = json_response(conn, 200)
 375     end
 376
 377     test "clearing all notifications", %{conn: conn} do
 378       user = insert(:user)
 379       other_user = insert(:user)
 380
 381       {:ok, activity} =
 382         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 383
 384       {:ok, [_notification]} = Notification.create_notifications(activity)
 385
 386       conn =
 387         conn
 388         |> assign(:user, user)
 389         |> post("/api/v1/notifications/clear")
 390
 391       assert %{} = json_response(conn, 200)
 392
 393       conn =
 394         build_conn()
 395         |> assign(:user, user)
 396         |> get("/api/v1/notifications")
 397
 398       assert all = json_response(conn, 200)
 399       assert all == []
 400     end
 401   end
 402
 403   describe "reblogging" do
 404     test "reblogs and returns the reblogged status", %{conn: conn} do
 405       activity = insert(:note_activity)
 406       user = insert(:user)
 407
 408       conn =
 409         conn
 410         |> assign(:user, user)
 411         |> post("/api/v1/statuses/#{activity.id}/reblog")
 412
 413       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 414                json_response(conn, 200)
 415
 416       assert to_string(activity.id) == id
 417     end
 418   end
 419
 420   describe "unreblogging" do
 421     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 422       activity = insert(:note_activity)
 423       user = insert(:user)
 424
 425       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 426
 427       conn =
 428         conn
 429         |> assign(:user, user)
 430         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 431
 432       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 433
 434       assert to_string(activity.id) == id
 435     end
 436   end
 437
 438   describe "favoriting" do
 439     test "favs a status and returns it", %{conn: conn} do
 440       activity = insert(:note_activity)
 441       user = insert(:user)
 442
 443       conn =
 444         conn
 445         |> assign(:user, user)
 446         |> post("/api/v1/statuses/#{activity.id}/favourite")
 447
 448       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 449                json_response(conn, 200)
 450
 451       assert to_string(activity.id) == id
 452     end
 453   end
 454
 455   describe "unfavoriting" do
 456     test "unfavorites a status and returns it", %{conn: conn} do
 457       activity = insert(:note_activity)
 458       user = insert(:user)
 459
 460       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 461
 462       conn =
 463         conn
 464         |> assign(:user, user)
 465         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 466
 467       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 468                json_response(conn, 200)
 469
 470       assert to_string(activity.id) == id
 471     end
 472   end
 473
 474   describe "user timelines" do
 475     test "gets a users statuses", %{conn: conn} do
 476       user_one = insert(:user)
 477       user_two = insert(:user)
 478       user_three = insert(:user)
 479
 480       {:ok, user_three} = User.follow(user_three, user_one)
 481
 482       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
 483
 484       {:ok, direct_activity} =
 485         CommonAPI.post(user_one, %{
 486           "status" => "Hi, @#{user_two.nickname}.",
 487           "visibility" => "direct"
 488         })
 489
 490       {:ok, private_activity} =
 491         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
 492
 493       resp =
 494         conn
 495         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 496
 497       assert [%{"id" => id}] = json_response(resp, 200)
 498       assert id == to_string(activity.id)
 499
 500       resp =
 501         conn
 502         |> assign(:user, user_two)
 503         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 504
 505       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 506       assert id_one == to_string(direct_activity.id)
 507       assert id_two == to_string(activity.id)
 508
 509       resp =
 510         conn
 511         |> assign(:user, user_three)
 512         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 513
 514       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 515       assert id_one == to_string(private_activity.id)
 516       assert id_two == to_string(activity.id)
 517     end
 518
 519     test "unimplemented pinned statuses feature", %{conn: conn} do
 520       note = insert(:note_activity)
 521       user = User.get_by_ap_id(note.data["actor"])
 522
 523       conn =
 524         conn
 525         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 526
 527       assert json_response(conn, 200) == []
 528     end
 529
 530     test "gets an users media", %{conn: conn} do
 531       note = insert(:note_activity)
 532       user = User.get_by_ap_id(note.data["actor"])
 533
 534       file = %Plug.Upload{
 535         content_type: "image/jpg",
 536         path: Path.absname("test/fixtures/image.jpg"),
 537         filename: "an_image.jpg"
 538       }
 539
 540       media =
 541         TwitterAPI.upload(file, "json")
 542         |> Poison.decode!()
 543
 544       {:ok, image_post} =
 545         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 546
 547       conn =
 548         conn
 549         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 550
 551       assert [%{"id" => id}] = json_response(conn, 200)
 552       assert id == to_string(image_post.id)
 553
 554       conn =
 555         build_conn()
 556         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 557
 558       assert [%{"id" => id}] = json_response(conn, 200)
 559       assert id == to_string(image_post.id)
 560     end
 561   end
 562
 563   describe "user relationships" do
 564     test "returns the relationships for the current user", %{conn: conn} do
 565       user = insert(:user)
 566       other_user = insert(:user)
 567       {:ok, user} = User.follow(user, other_user)
 568
 569       conn =
 570         conn
 571         |> assign(:user, user)
 572         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 573
 574       assert [relationship] = json_response(conn, 200)
 575
 576       assert to_string(other_user.id) == relationship["id"]
 577     end
 578   end
 579
 580   test "account fetching", %{conn: conn} do
 581     user = insert(:user)
 582
 583     conn =
 584       conn
 585       |> get("/api/v1/accounts/#{user.id}")
 586
 587     assert %{"id" => id} = json_response(conn, 200)
 588     assert id == to_string(user.id)
 589
 590     conn =
 591       build_conn()
 592       |> get("/api/v1/accounts/-1")
 593
 594     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 595   end
 596
 597   test "media upload", %{conn: conn} do
 598     file = %Plug.Upload{
 599       content_type: "image/jpg",
 600       path: Path.absname("test/fixtures/image.jpg"),
 601       filename: "an_image.jpg"
 602     }
 603
 604     user = insert(:user)
 605
 606     conn =
 607       conn
 608       |> assign(:user, user)
 609       |> post("/api/v1/media", %{"file" => file})
 610
 611     assert media = json_response(conn, 200)
 612
 613     assert media["type"] == "image"
 614   end
 615
 616   test "hashtag timeline", %{conn: conn} do
 617     following = insert(:user)
 618
 619     capture_log(fn ->
 620       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 621
 622       {:ok, [_activity]} =
 623         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 624
 625       conn =
 626         conn
 627         |> get("/api/v1/timelines/tag/2hu")
 628
 629       assert [%{"id" => id}] = json_response(conn, 200)
 630
 631       assert id == to_string(activity.id)
 632     end)
 633   end
 634
 635   test "getting followers", %{conn: conn} do
 636     user = insert(:user)
 637     other_user = insert(:user)
 638     {:ok, user} = User.follow(user, other_user)
 639
 640     conn =
 641       conn
 642       |> get("/api/v1/accounts/#{other_user.id}/followers")
 643
 644     assert [%{"id" => id}] = json_response(conn, 200)
 645     assert id == to_string(user.id)
 646   end
 647
 648   test "getting following", %{conn: conn} do
 649     user = insert(:user)
 650     other_user = insert(:user)
 651     {:ok, user} = User.follow(user, other_user)
 652
 653     conn =
 654       conn
 655       |> get("/api/v1/accounts/#{user.id}/following")
 656
 657     assert [%{"id" => id}] = json_response(conn, 200)
 658     assert id == to_string(other_user.id)
 659   end
 660
 661   test "following / unfollowing a user", %{conn: conn} do
 662     user = insert(:user)
 663     other_user = insert(:user)
 664
 665     conn =
 666       conn
 667       |> assign(:user, user)
 668       |> post("/api/v1/accounts/#{other_user.id}/follow")
 669
 670     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
 671
 672     user = Repo.get(User, user.id)
 673
 674     conn =
 675       build_conn()
 676       |> assign(:user, user)
 677       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
 678
 679     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
 680
 681     user = Repo.get(User, user.id)
 682
 683     conn =
 684       build_conn()
 685       |> assign(:user, user)
 686       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
 687
 688     assert %{"id" => id} = json_response(conn, 200)
 689     assert id == to_string(other_user.id)
 690   end
 691
 692   test "blocking / unblocking a user", %{conn: conn} do
 693     user = insert(:user)
 694     other_user = insert(:user)
 695
 696     conn =
 697       conn
 698       |> assign(:user, user)
 699       |> post("/api/v1/accounts/#{other_user.id}/block")
 700
 701     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
 702
 703     user = Repo.get(User, user.id)
 704
 705     conn =
 706       build_conn()
 707       |> assign(:user, user)
 708       |> post("/api/v1/accounts/#{other_user.id}/unblock")
 709
 710     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
 711   end
 712
 713   test "getting a list of blocks", %{conn: conn} do
 714     user = insert(:user)
 715     other_user = insert(:user)
 716
 717     {:ok, user} = User.block(user, other_user)
 718
 719     conn =
 720       conn
 721       |> assign(:user, user)
 722       |> get("/api/v1/blocks")
 723
 724     other_user_id = to_string(other_user.id)
 725     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
 726   end
 727
 728   test "unimplemented mute endpoints" do
 729     user = insert(:user)
 730     other_user = insert(:user)
 731
 732     ["mute", "unmute"]
 733     |> Enum.each(fn endpoint ->
 734       conn =
 735         build_conn()
 736         |> assign(:user, user)
 737         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
 738
 739       assert %{"id" => id} = json_response(conn, 200)
 740       assert id == to_string(other_user.id)
 741     end)
 742   end
 743
 744   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
 745     user = insert(:user)
 746
 747     ["blocks", "domain_blocks", "mutes", "follow_requests"]
 748     |> Enum.each(fn endpoint ->
 749       conn =
 750         build_conn()
 751         |> assign(:user, user)
 752         |> get("/api/v1/#{endpoint}")
 753
 754       assert [] = json_response(conn, 200)
 755     end)
 756   end
 757
 758   test "account search", %{conn: conn} do
 759     user = insert(:user)
 760     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 761     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 762
 763     results =
 764       conn
 765       |> assign(:user, user)
 766       |> get("/api/v1/accounts/search", %{"q" => "shp"})
 767       |> json_response(200)
 768
 769     result_ids = for result <- results, do: result["acct"]
 770
 771     assert user_two.nickname in result_ids
 772     assert user_three.nickname in result_ids
 773
 774     results =
 775       conn
 776       |> assign(:user, user)
 777       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
 778       |> json_response(200)
 779
 780     result_ids = for result <- results, do: result["acct"]
 781
 782     assert user_three.nickname in result_ids
 783   end
 784
 785   test "search", %{conn: conn} do
 786     user = insert(:user)
 787     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 788     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 789
 790     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 791
 792     {:ok, _activity} =
 793       CommonAPI.post(user, %{
 794         "status" => "This is about 2hu, but private",
 795         "visibility" => "private"
 796       })
 797
 798     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 799
 800     conn =
 801       conn
 802       |> get("/api/v1/search", %{"q" => "2hu"})
 803
 804     assert results = json_response(conn, 200)
 805
 806     [account | _] = results["accounts"]
 807     assert account["id"] == to_string(user_three.id)
 808
 809     assert results["hashtags"] == []
 810
 811     [status] = results["statuses"]
 812     assert status["id"] == to_string(activity.id)
 813   end
 814
 815   test "search fetches remote statuses", %{conn: conn} do
 816     capture_log(fn ->
 817       conn =
 818         conn
 819         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
 820
 821       assert results = json_response(conn, 200)
 822
 823       [status] = results["statuses"]
 824       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
 825     end)
 826   end
 827
 828   test "search fetches remote accounts", %{conn: conn} do
 829     conn =
 830       conn
 831       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
 832
 833     assert results = json_response(conn, 200)
 834     [account] = results["accounts"]
 835     assert account["acct"] == "shp@social.heldscal.la"
 836   end
 837
 838   test "returns the favorites of a user", %{conn: conn} do
 839     user = insert(:user)
 840     other_user = insert(:user)
 841
 842     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
 843     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
 844
 845     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 846
 847     conn =
 848       conn
 849       |> assign(:user, user)
 850       |> get("/api/v1/favourites")
 851
 852     assert [status] = json_response(conn, 200)
 853     assert status["id"] == to_string(activity.id)
 854   end
 855
 856   describe "updating credentials" do
 857     test "updates the user's bio", %{conn: conn} do
 858       user = insert(:user)
 859
 860       conn =
 861         conn
 862         |> assign(:user, user)
 863         |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
 864
 865       assert user = json_response(conn, 200)
 866       assert user["note"] == "I drink #cofe"
 867     end
 868
 869     test "updates the user's name", %{conn: conn} do
 870       user = insert(:user)
 871
 872       conn =
 873         conn
 874         |> assign(:user, user)
 875         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
 876
 877       assert user = json_response(conn, 200)
 878       assert user["display_name"] == "markorepairs"
 879     end
 880
 881     test "updates the user's avatar", %{conn: conn} do
 882       user = insert(:user)
 883
 884       new_avatar = %Plug.Upload{
 885         content_type: "image/jpg",
 886         path: Path.absname("test/fixtures/image.jpg"),
 887         filename: "an_image.jpg"
 888       }
 889
 890       conn =
 891         conn
 892         |> assign(:user, user)
 893         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
 894
 895       assert user = json_response(conn, 200)
 896       assert user["avatar"] != "https://placehold.it/48x48"
 897     end
 898
 899     test "updates the user's banner", %{conn: conn} do
 900       user = insert(:user)
 901
 902       new_header = %Plug.Upload{
 903         content_type: "image/jpg",
 904         path: Path.absname("test/fixtures/image.jpg"),
 905         filename: "an_image.jpg"
 906       }
 907
 908       conn =
 909         conn
 910         |> assign(:user, user)
 911         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
 912
 913       assert user = json_response(conn, 200)
 914       assert user["header"] != "https://placehold.it/700x335"
 915     end
 916   end
 917
 918   test "get instance information", %{conn: conn} do
 919     insert(:user, %{local: true})
 920     user = insert(:user, %{local: true})
 921     insert(:user, %{local: false})
 922
 923     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 924
 925     Pleroma.Stats.update_stats()
 926
 927     conn =
 928       conn
 929       |> get("/api/v1/instance")
 930
 931     assert result = json_response(conn, 200)
 932
 933     assert result["stats"]["user_count"] == 2
 934     assert result["stats"]["status_count"] == 1
 935   end
 936 end