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