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

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