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
 509     test "returns 500 for a wrong id", %{conn: conn} do
 510       user = insert(:user)
 511
 512       resp =
 513         conn
 514         |> assign(:user, user)
 515         |> post("/api/v1/statuses/1/favourite")
 516         |> json_response(500)
 517
 518       assert resp == "Something went wrong"
 519     end
 520   end
 521
 522   describe "unfavoriting" do
 523     test "unfavorites a status and returns it", %{conn: conn} do
 524       activity = insert(:note_activity)
 525       user = insert(:user)
 526
 527       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 528
 529       conn =
 530         conn
 531         |> assign(:user, user)
 532         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 533
 534       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 535                json_response(conn, 200)
 536
 537       assert to_string(activity.id) == id
 538     end
 539   end
 540
 541   describe "user timelines" do
 542     test "gets a users statuses", %{conn: conn} do
 543       user_one = insert(:user)
 544       user_two = insert(:user)
 545       user_three = insert(:user)
 546
 547       {:ok, user_three} = User.follow(user_three, user_one)
 548
 549       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
 550
 551       {:ok, direct_activity} =
 552         CommonAPI.post(user_one, %{
 553           "status" => "Hi, @#{user_two.nickname}.",
 554           "visibility" => "direct"
 555         })
 556
 557       {:ok, private_activity} =
 558         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
 559
 560       resp =
 561         conn
 562         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 563
 564       assert [%{"id" => id}] = json_response(resp, 200)
 565       assert id == to_string(activity.id)
 566
 567       resp =
 568         conn
 569         |> assign(:user, user_two)
 570         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 571
 572       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 573       assert id_one == to_string(direct_activity.id)
 574       assert id_two == to_string(activity.id)
 575
 576       resp =
 577         conn
 578         |> assign(:user, user_three)
 579         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 580
 581       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 582       assert id_one == to_string(private_activity.id)
 583       assert id_two == to_string(activity.id)
 584     end
 585
 586     test "unimplemented pinned statuses feature", %{conn: conn} do
 587       note = insert(:note_activity)
 588       user = User.get_by_ap_id(note.data["actor"])
 589
 590       conn =
 591         conn
 592         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 593
 594       assert json_response(conn, 200) == []
 595     end
 596
 597     test "gets an users media", %{conn: conn} do
 598       note = insert(:note_activity)
 599       user = User.get_by_ap_id(note.data["actor"])
 600
 601       file = %Plug.Upload{
 602         content_type: "image/jpg",
 603         path: Path.absname("test/fixtures/image.jpg"),
 604         filename: "an_image.jpg"
 605       }
 606
 607       media =
 608         TwitterAPI.upload(file, "json")
 609         |> Poison.decode!()
 610
 611       {:ok, image_post} =
 612         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 613
 614       conn =
 615         conn
 616         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 617
 618       assert [%{"id" => id}] = json_response(conn, 200)
 619       assert id == to_string(image_post.id)
 620
 621       conn =
 622         build_conn()
 623         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 624
 625       assert [%{"id" => id}] = json_response(conn, 200)
 626       assert id == to_string(image_post.id)
 627     end
 628   end
 629
 630   describe "user relationships" do
 631     test "returns the relationships for the current user", %{conn: conn} do
 632       user = insert(:user)
 633       other_user = insert(:user)
 634       {:ok, user} = User.follow(user, other_user)
 635
 636       conn =
 637         conn
 638         |> assign(:user, user)
 639         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 640
 641       assert [relationship] = json_response(conn, 200)
 642
 643       assert to_string(other_user.id) == relationship["id"]
 644     end
 645   end
 646
 647   test "account fetching", %{conn: conn} do
 648     user = insert(:user)
 649
 650     conn =
 651       conn
 652       |> get("/api/v1/accounts/#{user.id}")
 653
 654     assert %{"id" => id} = json_response(conn, 200)
 655     assert id == to_string(user.id)
 656
 657     conn =
 658       build_conn()
 659       |> get("/api/v1/accounts/-1")
 660
 661     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 662   end
 663
 664   test "media upload", %{conn: conn} do
 665     file = %Plug.Upload{
 666       content_type: "image/jpg",
 667       path: Path.absname("test/fixtures/image.jpg"),
 668       filename: "an_image.jpg"
 669     }
 670
 671     user = insert(:user)
 672
 673     conn =
 674       conn
 675       |> assign(:user, user)
 676       |> post("/api/v1/media", %{"file" => file})
 677
 678     assert media = json_response(conn, 200)
 679
 680     assert media["type"] == "image"
 681   end
 682
 683   test "hashtag timeline", %{conn: conn} do
 684     following = insert(:user)
 685
 686     capture_log(fn ->
 687       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 688
 689       {:ok, [_activity]} =
 690         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 691
 692       conn =
 693         conn
 694         |> get("/api/v1/timelines/tag/2hu")
 695
 696       assert [%{"id" => id}] = json_response(conn, 200)
 697
 698       assert id == to_string(activity.id)
 699     end)
 700   end
 701
 702   test "getting followers", %{conn: conn} do
 703     user = insert(:user)
 704     other_user = insert(:user)
 705     {:ok, user} = User.follow(user, other_user)
 706
 707     conn =
 708       conn
 709       |> get("/api/v1/accounts/#{other_user.id}/followers")
 710
 711     assert [%{"id" => id}] = json_response(conn, 200)
 712     assert id == to_string(user.id)
 713   end
 714
 715   test "getting following", %{conn: conn} do
 716     user = insert(:user)
 717     other_user = insert(:user)
 718     {:ok, user} = User.follow(user, other_user)
 719
 720     conn =
 721       conn
 722       |> get("/api/v1/accounts/#{user.id}/following")
 723
 724     assert [%{"id" => id}] = json_response(conn, 200)
 725     assert id == to_string(other_user.id)
 726   end
 727
 728   test "following / unfollowing a user", %{conn: conn} do
 729     user = insert(:user)
 730     other_user = insert(:user)
 731
 732     conn =
 733       conn
 734       |> assign(:user, user)
 735       |> post("/api/v1/accounts/#{other_user.id}/follow")
 736
 737     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
 738
 739     user = Repo.get(User, user.id)
 740
 741     conn =
 742       build_conn()
 743       |> assign(:user, user)
 744       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
 745
 746     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
 747
 748     user = Repo.get(User, user.id)
 749
 750     conn =
 751       build_conn()
 752       |> assign(:user, user)
 753       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
 754
 755     assert %{"id" => id} = json_response(conn, 200)
 756     assert id == to_string(other_user.id)
 757   end
 758
 759   test "blocking / unblocking a user", %{conn: conn} do
 760     user = insert(:user)
 761     other_user = insert(:user)
 762
 763     conn =
 764       conn
 765       |> assign(:user, user)
 766       |> post("/api/v1/accounts/#{other_user.id}/block")
 767
 768     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
 769
 770     user = Repo.get(User, user.id)
 771
 772     conn =
 773       build_conn()
 774       |> assign(:user, user)
 775       |> post("/api/v1/accounts/#{other_user.id}/unblock")
 776
 777     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
 778   end
 779
 780   test "getting a list of blocks", %{conn: conn} do
 781     user = insert(:user)
 782     other_user = insert(:user)
 783
 784     {:ok, user} = User.block(user, other_user)
 785
 786     conn =
 787       conn
 788       |> assign(:user, user)
 789       |> get("/api/v1/blocks")
 790
 791     other_user_id = to_string(other_user.id)
 792     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
 793   end
 794
 795   test "unimplemented mute endpoints" do
 796     user = insert(:user)
 797     other_user = insert(:user)
 798
 799     ["mute", "unmute"]
 800     |> Enum.each(fn endpoint ->
 801       conn =
 802         build_conn()
 803         |> assign(:user, user)
 804         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
 805
 806       assert %{"id" => id} = json_response(conn, 200)
 807       assert id == to_string(other_user.id)
 808     end)
 809   end
 810
 811   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
 812     user = insert(:user)
 813
 814     ["blocks", "domain_blocks", "mutes", "follow_requests"]
 815     |> Enum.each(fn endpoint ->
 816       conn =
 817         build_conn()
 818         |> assign(:user, user)
 819         |> get("/api/v1/#{endpoint}")
 820
 821       assert [] = json_response(conn, 200)
 822     end)
 823   end
 824
 825   test "account search", %{conn: conn} do
 826     user = insert(:user)
 827     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 828     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 829
 830     results =
 831       conn
 832       |> assign(:user, user)
 833       |> get("/api/v1/accounts/search", %{"q" => "shp"})
 834       |> json_response(200)
 835
 836     result_ids = for result <- results, do: result["acct"]
 837
 838     assert user_two.nickname in result_ids
 839     assert user_three.nickname in result_ids
 840
 841     results =
 842       conn
 843       |> assign(:user, user)
 844       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
 845       |> json_response(200)
 846
 847     result_ids = for result <- results, do: result["acct"]
 848
 849     assert user_three.nickname in result_ids
 850   end
 851
 852   test "search", %{conn: conn} do
 853     user = insert(:user)
 854     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 855     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 856
 857     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 858
 859     {:ok, _activity} =
 860       CommonAPI.post(user, %{
 861         "status" => "This is about 2hu, but private",
 862         "visibility" => "private"
 863       })
 864
 865     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 866
 867     conn =
 868       conn
 869       |> get("/api/v1/search", %{"q" => "2hu"})
 870
 871     assert results = json_response(conn, 200)
 872
 873     [account | _] = results["accounts"]
 874     assert account["id"] == to_string(user_three.id)
 875
 876     assert results["hashtags"] == []
 877
 878     [status] = results["statuses"]
 879     assert status["id"] == to_string(activity.id)
 880   end
 881
 882   test "search fetches remote statuses", %{conn: conn} do
 883     capture_log(fn ->
 884       conn =
 885         conn
 886         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
 887
 888       assert results = json_response(conn, 200)
 889
 890       [status] = results["statuses"]
 891       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
 892     end)
 893   end
 894
 895   test "search fetches remote accounts", %{conn: conn} do
 896     conn =
 897       conn
 898       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
 899
 900     assert results = json_response(conn, 200)
 901     [account] = results["accounts"]
 902     assert account["acct"] == "shp@social.heldscal.la"
 903   end
 904
 905   test "returns the favorites of a user", %{conn: conn} do
 906     user = insert(:user)
 907     other_user = insert(:user)
 908
 909     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
 910     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
 911
 912     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 913
 914     conn =
 915       conn
 916       |> assign(:user, user)
 917       |> get("/api/v1/favourites")
 918
 919     assert [status] = json_response(conn, 200)
 920     assert status["id"] == to_string(activity.id)
 921   end
 922
 923   describe "updating credentials" do
 924     test "updates the user's bio", %{conn: conn} do
 925       user = insert(:user)
 926
 927       conn =
 928         conn
 929         |> assign(:user, user)
 930         |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
 931
 932       assert user = json_response(conn, 200)
 933       assert user["note"] == "I drink #cofe"
 934     end
 935
 936     test "updates the user's name", %{conn: conn} do
 937       user = insert(:user)
 938
 939       conn =
 940         conn
 941         |> assign(:user, user)
 942         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
 943
 944       assert user = json_response(conn, 200)
 945       assert user["display_name"] == "markorepairs"
 946     end
 947
 948     test "updates the user's avatar", %{conn: conn} do
 949       user = insert(:user)
 950
 951       new_avatar = %Plug.Upload{
 952         content_type: "image/jpg",
 953         path: Path.absname("test/fixtures/image.jpg"),
 954         filename: "an_image.jpg"
 955       }
 956
 957       conn =
 958         conn
 959         |> assign(:user, user)
 960         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
 961
 962       assert user = json_response(conn, 200)
 963       assert user["avatar"] != "https://placehold.it/48x48"
 964     end
 965
 966     test "updates the user's banner", %{conn: conn} do
 967       user = insert(:user)
 968
 969       new_header = %Plug.Upload{
 970         content_type: "image/jpg",
 971         path: Path.absname("test/fixtures/image.jpg"),
 972         filename: "an_image.jpg"
 973       }
 974
 975       conn =
 976         conn
 977         |> assign(:user, user)
 978         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
 979
 980       assert user = json_response(conn, 200)
 981       assert user["header"] != "https://placehold.it/700x335"
 982     end
 983   end
 984
 985   test "get instance information", %{conn: conn} do
 986     insert(:user, %{local: true})
 987     user = insert(:user, %{local: true})
 988     insert(:user, %{local: false})
 989
 990     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 991
 992     Pleroma.Stats.update_stats()
 993
 994     conn =
 995       conn
 996       |> get("/api/v1/instance")
 997
 998     assert result = json_response(conn, 200)
 999
1000     assert result["stats"]["user_count"] == 2
1001     assert result["stats"]["status_count"] == 1
1002   end
1003 end