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