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

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