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