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 "filters" do
 267     test "creating a filter", %{conn: conn} do
 268       user = insert(:user)
 269
 270       filter = %Pleroma.Filter{
 271         phrase: "knights",
 272         context: ["home"]
 273       }
 274
 275       conn =
 276         conn
 277         |> assign(:user, user)
 278         |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
 279
 280       assert response = json_response(conn, 200)
 281       assert response["phrase"] == filter.phrase
 282       assert response["context"] == filter.context
 283     end
 284
 285     test "fetching a list of filters", %{conn: conn} do
 286       user = insert(:user)
 287
 288       query_one = %Pleroma.Filter{
 289         user_id: user.id,
 290         filter_id: 1,
 291         phrase: "knights",
 292         context: ["home"]
 293       }
 294
 295       query_two = %Pleroma.Filter{
 296         user_id: user.id,
 297         filter_id: 2,
 298         phrase: "who",
 299         context: ["home"]
 300       }
 301
 302       {:ok, filter_one} = Pleroma.Filter.create(query_one)
 303       {:ok, filter_two} = Pleroma.Filter.create(query_two)
 304
 305       conn =
 306         conn
 307         |> assign(:user, user)
 308         |> get("/api/v1/filters")
 309
 310       assert response = json_response(conn, 200)
 311     end
 312
 313     test "get a filter", %{conn: conn} do
 314       user = insert(:user)
 315
 316       query = %Pleroma.Filter{
 317         user_id: user.id,
 318         filter_id: 2,
 319         phrase: "knight",
 320         context: ["home"]
 321       }
 322
 323       {:ok, filter} = Pleroma.Filter.create(query)
 324
 325       conn =
 326         conn
 327         |> assign(:user, user)
 328         |> get("/api/v1/filters/#{filter.filter_id}")
 329
 330       assert response = json_response(conn, 200)
 331     end
 332
 333     test "update a filter", %{conn: conn} do
 334       user = insert(:user)
 335
 336       query = %Pleroma.Filter{
 337         user_id: user.id,
 338         filter_id: 2,
 339         phrase: "knight",
 340         context: ["home"]
 341       }
 342
 343       {:ok, filter} = Pleroma.Filter.create(query)
 344
 345       new = %Pleroma.Filter{
 346         phrase: "nii",
 347         context: ["home"]
 348       }
 349
 350       conn =
 351         conn
 352         |> assign(:user, user)
 353         |> put("/api/v1/filters/#{query.filter_id}", %{
 354           phrase: new.phrase,
 355           context: new.context
 356         })
 357
 358       assert response = json_response(conn, 200)
 359       assert response["phrase"] == new.phrase
 360       assert response["context"] == new.context
 361     end
 362
 363     test "delete a filter", %{conn: conn} do
 364       user = insert(:user)
 365
 366       query = %Pleroma.Filter{
 367         user_id: user.id,
 368         filter_id: 2,
 369         phrase: "knight",
 370         context: ["home"]
 371       }
 372
 373       {:ok, filter} = Pleroma.Filter.create(query)
 374
 375       conn =
 376         conn
 377         |> assign(:user, user)
 378         |> delete("/api/v1/filters/#{filter.filter_id}")
 379
 380       assert response = json_response(conn, 200)
 381       assert response == %{}
 382     end
 383   end
 384
 385   describe "lists" do
 386     test "creating a list", %{conn: conn} do
 387       user = insert(:user)
 388
 389       conn =
 390         conn
 391         |> assign(:user, user)
 392         |> post("/api/v1/lists", %{"title" => "cuties"})
 393
 394       assert %{"title" => title} = json_response(conn, 200)
 395       assert title == "cuties"
 396     end
 397
 398     test "adding users to a list", %{conn: conn} do
 399       user = insert(:user)
 400       other_user = insert(:user)
 401       {:ok, list} = Pleroma.List.create("name", user)
 402
 403       conn =
 404         conn
 405         |> assign(:user, user)
 406         |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 407
 408       assert %{} == json_response(conn, 200)
 409       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 410       assert following == [other_user.follower_address]
 411     end
 412
 413     test "removing users from a list", %{conn: conn} do
 414       user = insert(:user)
 415       other_user = insert(:user)
 416       third_user = insert(:user)
 417       {:ok, list} = Pleroma.List.create("name", user)
 418       {:ok, list} = Pleroma.List.follow(list, other_user)
 419       {:ok, list} = Pleroma.List.follow(list, third_user)
 420
 421       conn =
 422         conn
 423         |> assign(:user, user)
 424         |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 425
 426       assert %{} == json_response(conn, 200)
 427       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 428       assert following == [third_user.follower_address]
 429     end
 430
 431     test "listing users in a list", %{conn: conn} do
 432       user = insert(:user)
 433       other_user = insert(:user)
 434       {:ok, list} = Pleroma.List.create("name", user)
 435       {:ok, list} = Pleroma.List.follow(list, other_user)
 436
 437       conn =
 438         conn
 439         |> assign(:user, user)
 440         |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 441
 442       assert [%{"id" => id}] = json_response(conn, 200)
 443       assert id == to_string(other_user.id)
 444     end
 445
 446     test "retrieving a list", %{conn: conn} do
 447       user = insert(:user)
 448       {:ok, list} = Pleroma.List.create("name", user)
 449
 450       conn =
 451         conn
 452         |> assign(:user, user)
 453         |> get("/api/v1/lists/#{list.id}")
 454
 455       assert %{"id" => id} = json_response(conn, 200)
 456       assert id == to_string(list.id)
 457     end
 458
 459     test "renaming a list", %{conn: conn} do
 460       user = insert(:user)
 461       {:ok, list} = Pleroma.List.create("name", user)
 462
 463       conn =
 464         conn
 465         |> assign(:user, user)
 466         |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
 467
 468       assert %{"title" => name} = json_response(conn, 200)
 469       assert name == "newname"
 470     end
 471
 472     test "deleting a list", %{conn: conn} do
 473       user = insert(:user)
 474       {:ok, list} = Pleroma.List.create("name", user)
 475
 476       conn =
 477         conn
 478         |> assign(:user, user)
 479         |> delete("/api/v1/lists/#{list.id}")
 480
 481       assert %{} = json_response(conn, 200)
 482       assert is_nil(Repo.get(Pleroma.List, list.id))
 483     end
 484
 485     test "list timeline", %{conn: conn} do
 486       user = insert(:user)
 487       other_user = insert(:user)
 488       {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
 489       {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 490       {:ok, list} = Pleroma.List.create("name", user)
 491       {:ok, list} = Pleroma.List.follow(list, other_user)
 492
 493       conn =
 494         conn
 495         |> assign(:user, user)
 496         |> get("/api/v1/timelines/list/#{list.id}")
 497
 498       assert [%{"id" => id}] = json_response(conn, 200)
 499
 500       assert id == to_string(activity_two.id)
 501     end
 502
 503     test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
 504       user = insert(:user)
 505       other_user = insert(:user)
 506       {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 507
 508       {:ok, activity_two} =
 509         TwitterAPI.create_status(other_user, %{
 510           "status" => "Marisa is cute.",
 511           "visibility" => "private"
 512         })
 513
 514       {:ok, list} = Pleroma.List.create("name", user)
 515       {:ok, list} = Pleroma.List.follow(list, other_user)
 516
 517       conn =
 518         conn
 519         |> assign(:user, user)
 520         |> get("/api/v1/timelines/list/#{list.id}")
 521
 522       assert [%{"id" => id}] = json_response(conn, 200)
 523
 524       assert id == to_string(activity_one.id)
 525     end
 526   end
 527
 528   describe "notifications" do
 529     test "list of notifications", %{conn: conn} do
 530       user = insert(:user)
 531       other_user = insert(:user)
 532
 533       {:ok, activity} =
 534         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 535
 536       {:ok, [_notification]} = Notification.create_notifications(activity)
 537
 538       conn =
 539         conn
 540         |> assign(:user, user)
 541         |> get("/api/v1/notifications")
 542
 543       expected_response =
 544         "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 545
 546       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 547       assert response == expected_response
 548     end
 549
 550     test "getting a single notification", %{conn: conn} do
 551       user = insert(:user)
 552       other_user = insert(:user)
 553
 554       {:ok, activity} =
 555         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 556
 557       {:ok, [notification]} = Notification.create_notifications(activity)
 558
 559       conn =
 560         conn
 561         |> assign(:user, user)
 562         |> get("/api/v1/notifications/#{notification.id}")
 563
 564       expected_response =
 565         "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 566
 567       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 568       assert response == expected_response
 569     end
 570
 571     test "dismissing a single notification", %{conn: conn} do
 572       user = insert(:user)
 573       other_user = insert(:user)
 574
 575       {:ok, activity} =
 576         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 577
 578       {:ok, [notification]} = Notification.create_notifications(activity)
 579
 580       conn =
 581         conn
 582         |> assign(:user, user)
 583         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 584
 585       assert %{} = json_response(conn, 200)
 586     end
 587
 588     test "clearing all notifications", %{conn: conn} do
 589       user = insert(:user)
 590       other_user = insert(:user)
 591
 592       {:ok, activity} =
 593         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 594
 595       {:ok, [_notification]} = Notification.create_notifications(activity)
 596
 597       conn =
 598         conn
 599         |> assign(:user, user)
 600         |> post("/api/v1/notifications/clear")
 601
 602       assert %{} = json_response(conn, 200)
 603
 604       conn =
 605         build_conn()
 606         |> assign(:user, user)
 607         |> get("/api/v1/notifications")
 608
 609       assert all = json_response(conn, 200)
 610       assert all == []
 611     end
 612   end
 613
 614   describe "reblogging" do
 615     test "reblogs and returns the reblogged status", %{conn: conn} do
 616       activity = insert(:note_activity)
 617       user = insert(:user)
 618
 619       conn =
 620         conn
 621         |> assign(:user, user)
 622         |> post("/api/v1/statuses/#{activity.id}/reblog")
 623
 624       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 625                json_response(conn, 200)
 626
 627       assert to_string(activity.id) == id
 628     end
 629   end
 630
 631   describe "unreblogging" do
 632     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 633       activity = insert(:note_activity)
 634       user = insert(:user)
 635
 636       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 637
 638       conn =
 639         conn
 640         |> assign(:user, user)
 641         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 642
 643       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 644
 645       assert to_string(activity.id) == id
 646     end
 647   end
 648
 649   describe "favoriting" do
 650     test "favs a status and returns it", %{conn: conn} do
 651       activity = insert(:note_activity)
 652       user = insert(:user)
 653
 654       conn =
 655         conn
 656         |> assign(:user, user)
 657         |> post("/api/v1/statuses/#{activity.id}/favourite")
 658
 659       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 660                json_response(conn, 200)
 661
 662       assert to_string(activity.id) == id
 663     end
 664
 665     test "returns 500 for a wrong id", %{conn: conn} do
 666       user = insert(:user)
 667
 668       resp =
 669         conn
 670         |> assign(:user, user)
 671         |> post("/api/v1/statuses/1/favourite")
 672         |> json_response(500)
 673
 674       assert resp == "Something went wrong"
 675     end
 676   end
 677
 678   describe "unfavoriting" do
 679     test "unfavorites a status and returns it", %{conn: conn} do
 680       activity = insert(:note_activity)
 681       user = insert(:user)
 682
 683       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 684
 685       conn =
 686         conn
 687         |> assign(:user, user)
 688         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 689
 690       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 691                json_response(conn, 200)
 692
 693       assert to_string(activity.id) == id
 694     end
 695   end
 696
 697   describe "user timelines" do
 698     test "gets a users statuses", %{conn: conn} do
 699       user_one = insert(:user)
 700       user_two = insert(:user)
 701       user_three = insert(:user)
 702
 703       {:ok, user_three} = User.follow(user_three, user_one)
 704
 705       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
 706
 707       {:ok, direct_activity} =
 708         CommonAPI.post(user_one, %{
 709           "status" => "Hi, @#{user_two.nickname}.",
 710           "visibility" => "direct"
 711         })
 712
 713       {:ok, private_activity} =
 714         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
 715
 716       resp =
 717         conn
 718         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 719
 720       assert [%{"id" => id}] = json_response(resp, 200)
 721       assert id == to_string(activity.id)
 722
 723       resp =
 724         conn
 725         |> assign(:user, user_two)
 726         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 727
 728       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 729       assert id_one == to_string(direct_activity.id)
 730       assert id_two == to_string(activity.id)
 731
 732       resp =
 733         conn
 734         |> assign(:user, user_three)
 735         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 736
 737       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 738       assert id_one == to_string(private_activity.id)
 739       assert id_two == to_string(activity.id)
 740     end
 741
 742     test "unimplemented pinned statuses feature", %{conn: conn} do
 743       note = insert(:note_activity)
 744       user = User.get_by_ap_id(note.data["actor"])
 745
 746       conn =
 747         conn
 748         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 749
 750       assert json_response(conn, 200) == []
 751     end
 752
 753     test "gets an users media", %{conn: conn} do
 754       note = insert(:note_activity)
 755       user = User.get_by_ap_id(note.data["actor"])
 756
 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       media =
 764         TwitterAPI.upload(file, "json")
 765         |> Poison.decode!()
 766
 767       {:ok, image_post} =
 768         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 769
 770       conn =
 771         conn
 772         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 773
 774       assert [%{"id" => id}] = json_response(conn, 200)
 775       assert id == to_string(image_post.id)
 776
 777       conn =
 778         build_conn()
 779         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 780
 781       assert [%{"id" => id}] = json_response(conn, 200)
 782       assert id == to_string(image_post.id)
 783     end
 784   end
 785
 786   describe "user relationships" do
 787     test "returns the relationships for the current user", %{conn: conn} do
 788       user = insert(:user)
 789       other_user = insert(:user)
 790       {:ok, user} = User.follow(user, other_user)
 791
 792       conn =
 793         conn
 794         |> assign(:user, user)
 795         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 796
 797       assert [relationship] = json_response(conn, 200)
 798
 799       assert to_string(other_user.id) == relationship["id"]
 800     end
 801   end
 802
 803   describe "locked accounts" do
 804     test "/api/v1/follow_requests works" do
 805       user = insert(:user, %{info: %{"locked" => true}})
 806       other_user = insert(:user)
 807
 808       {:ok, activity} = ActivityPub.follow(other_user, user)
 809
 810       user = Repo.get(User, user.id)
 811       other_user = Repo.get(User, other_user.id)
 812
 813       assert User.following?(other_user, user) == false
 814
 815       conn =
 816         build_conn()
 817         |> assign(:user, user)
 818         |> get("/api/v1/follow_requests")
 819
 820       assert [relationship] = json_response(conn, 200)
 821       assert to_string(other_user.id) == relationship["id"]
 822     end
 823
 824     test "/api/v1/follow_requests/:id/authorize works" do
 825       user = insert(:user, %{info: %{"locked" => true}})
 826       other_user = insert(:user)
 827
 828       {:ok, activity} = ActivityPub.follow(other_user, user)
 829
 830       user = Repo.get(User, user.id)
 831       other_user = Repo.get(User, other_user.id)
 832
 833       assert User.following?(other_user, user) == false
 834
 835       conn =
 836         build_conn()
 837         |> assign(:user, user)
 838         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
 839
 840       assert relationship = json_response(conn, 200)
 841       assert to_string(other_user.id) == relationship["id"]
 842
 843       user = Repo.get(User, user.id)
 844       other_user = Repo.get(User, other_user.id)
 845
 846       assert User.following?(other_user, user) == true
 847     end
 848
 849     test "verify_credentials", %{conn: conn} do
 850       user = insert(:user, %{info: %{"default_scope" => "private"}})
 851
 852       conn =
 853         conn
 854         |> assign(:user, user)
 855         |> get("/api/v1/accounts/verify_credentials")
 856
 857       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
 858       assert id == to_string(user.id)
 859     end
 860
 861     test "/api/v1/follow_requests/:id/reject works" do
 862       user = insert(:user, %{info: %{"locked" => true}})
 863       other_user = insert(:user)
 864
 865       {:ok, activity} = ActivityPub.follow(other_user, user)
 866
 867       conn =
 868         build_conn()
 869         |> assign(:user, user)
 870         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
 871
 872       assert relationship = json_response(conn, 200)
 873       assert to_string(other_user.id) == relationship["id"]
 874
 875       user = Repo.get(User, user.id)
 876       other_user = Repo.get(User, other_user.id)
 877
 878       assert User.following?(other_user, user) == false
 879     end
 880   end
 881
 882   test "account fetching", %{conn: conn} do
 883     user = insert(:user)
 884
 885     conn =
 886       conn
 887       |> get("/api/v1/accounts/#{user.id}")
 888
 889     assert %{"id" => id} = json_response(conn, 200)
 890     assert id == to_string(user.id)
 891
 892     conn =
 893       build_conn()
 894       |> get("/api/v1/accounts/-1")
 895
 896     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 897   end
 898
 899   test "media upload", %{conn: conn} do
 900     file = %Plug.Upload{
 901       content_type: "image/jpg",
 902       path: Path.absname("test/fixtures/image.jpg"),
 903       filename: "an_image.jpg"
 904     }
 905
 906     desc = "Description of the image"
 907
 908     user = insert(:user)
 909
 910     conn =
 911       conn
 912       |> assign(:user, user)
 913       |> post("/api/v1/media", %{"file" => file, "description" => desc})
 914
 915     assert media = json_response(conn, 200)
 916
 917     assert media["type"] == "image"
 918     assert media["description"] == desc
 919   end
 920
 921   test "hashtag timeline", %{conn: conn} do
 922     following = insert(:user)
 923
 924     capture_log(fn ->
 925       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 926
 927       {:ok, [_activity]} =
 928         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 929
 930       conn =
 931         conn
 932         |> get("/api/v1/timelines/tag/2hu")
 933
 934       assert [%{"id" => id}] = json_response(conn, 200)
 935
 936       assert id == to_string(activity.id)
 937     end)
 938   end
 939
 940   test "getting followers", %{conn: conn} do
 941     user = insert(:user)
 942     other_user = insert(:user)
 943     {:ok, user} = User.follow(user, other_user)
 944
 945     conn =
 946       conn
 947       |> get("/api/v1/accounts/#{other_user.id}/followers")
 948
 949     assert [%{"id" => id}] = json_response(conn, 200)
 950     assert id == to_string(user.id)
 951   end
 952
 953   test "getting following", %{conn: conn} do
 954     user = insert(:user)
 955     other_user = insert(:user)
 956     {:ok, user} = User.follow(user, other_user)
 957
 958     conn =
 959       conn
 960       |> get("/api/v1/accounts/#{user.id}/following")
 961
 962     assert [%{"id" => id}] = json_response(conn, 200)
 963     assert id == to_string(other_user.id)
 964   end
 965
 966   test "following / unfollowing a user", %{conn: conn} do
 967     user = insert(:user)
 968     other_user = insert(:user)
 969
 970     conn =
 971       conn
 972       |> assign(:user, user)
 973       |> post("/api/v1/accounts/#{other_user.id}/follow")
 974
 975     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
 976
 977     user = Repo.get(User, user.id)
 978
 979     conn =
 980       build_conn()
 981       |> assign(:user, user)
 982       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
 983
 984     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
 985
 986     user = Repo.get(User, user.id)
 987
 988     conn =
 989       build_conn()
 990       |> assign(:user, user)
 991       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
 992
 993     assert %{"id" => id} = json_response(conn, 200)
 994     assert id == to_string(other_user.id)
 995   end
 996
 997   test "blocking / unblocking a user", %{conn: conn} do
 998     user = insert(:user)
 999     other_user = insert(:user)
1000
1001     conn =
1002       conn
1003       |> assign(:user, user)
1004       |> post("/api/v1/accounts/#{other_user.id}/block")
1005
1006     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1007
1008     user = Repo.get(User, user.id)
1009
1010     conn =
1011       build_conn()
1012       |> assign(:user, user)
1013       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1014
1015     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1016   end
1017
1018   test "getting a list of blocks", %{conn: conn} do
1019     user = insert(:user)
1020     other_user = insert(:user)
1021
1022     {:ok, user} = User.block(user, other_user)
1023
1024     conn =
1025       conn
1026       |> assign(:user, user)
1027       |> get("/api/v1/blocks")
1028
1029     other_user_id = to_string(other_user.id)
1030     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1031   end
1032
1033   test "blocking / unblocking a domain", %{conn: conn} do
1034     user = insert(:user)
1035     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1036
1037     conn =
1038       conn
1039       |> assign(:user, user)
1040       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1041
1042     assert %{} = json_response(conn, 200)
1043     user = User.get_cached_by_ap_id(user.ap_id)
1044     assert User.blocks?(user, other_user)
1045
1046     conn =
1047       build_conn()
1048       |> assign(:user, user)
1049       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1050
1051     assert %{} = json_response(conn, 200)
1052     user = User.get_cached_by_ap_id(user.ap_id)
1053     refute User.blocks?(user, other_user)
1054   end
1055
1056   test "getting a list of domain blocks" do
1057     user = insert(:user)
1058
1059     {:ok, user} = User.block_domain(user, "bad.site")
1060     {:ok, user} = User.block_domain(user, "even.worse.site")
1061
1062     conn =
1063       conn
1064       |> assign(:user, user)
1065       |> get("/api/v1/domain_blocks")
1066
1067     domain_blocks = json_response(conn, 200)
1068
1069     assert "bad.site" in domain_blocks
1070     assert "even.worse.site" in domain_blocks
1071   end
1072
1073   test "unimplemented mute endpoints" do
1074     user = insert(:user)
1075     other_user = insert(:user)
1076
1077     ["mute", "unmute"]
1078     |> Enum.each(fn endpoint ->
1079       conn =
1080         build_conn()
1081         |> assign(:user, user)
1082         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1083
1084       assert %{"id" => id} = json_response(conn, 200)
1085       assert id == to_string(other_user.id)
1086     end)
1087   end
1088
1089   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1090     user = insert(:user)
1091
1092     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1093     |> Enum.each(fn endpoint ->
1094       conn =
1095         build_conn()
1096         |> assign(:user, user)
1097         |> get("/api/v1/#{endpoint}")
1098
1099       assert [] = json_response(conn, 200)
1100     end)
1101   end
1102
1103   test "account search", %{conn: conn} do
1104     user = insert(:user)
1105     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1106     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1107
1108     results =
1109       conn
1110       |> assign(:user, user)
1111       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1112       |> json_response(200)
1113
1114     result_ids = for result <- results, do: result["acct"]
1115
1116     assert user_two.nickname in result_ids
1117     assert user_three.nickname in result_ids
1118
1119     results =
1120       conn
1121       |> assign(:user, user)
1122       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1123       |> json_response(200)
1124
1125     result_ids = for result <- results, do: result["acct"]
1126
1127     assert user_three.nickname in result_ids
1128   end
1129
1130   test "search", %{conn: conn} do
1131     user = insert(:user)
1132     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1133     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1134
1135     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1136
1137     {:ok, _activity} =
1138       CommonAPI.post(user, %{
1139         "status" => "This is about 2hu, but private",
1140         "visibility" => "private"
1141       })
1142
1143     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1144
1145     conn =
1146       conn
1147       |> get("/api/v1/search", %{"q" => "2hu"})
1148
1149     assert results = json_response(conn, 200)
1150
1151     [account | _] = results["accounts"]
1152     assert account["id"] == to_string(user_three.id)
1153
1154     assert results["hashtags"] == []
1155
1156     [status] = results["statuses"]
1157     assert status["id"] == to_string(activity.id)
1158   end
1159
1160   test "search fetches remote statuses", %{conn: conn} do
1161     capture_log(fn ->
1162       conn =
1163         conn
1164         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1165
1166       assert results = json_response(conn, 200)
1167
1168       [status] = results["statuses"]
1169       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1170     end)
1171   end
1172
1173   test "search fetches remote accounts", %{conn: conn} do
1174     conn =
1175       conn
1176       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1177
1178     assert results = json_response(conn, 200)
1179     [account] = results["accounts"]
1180     assert account["acct"] == "shp@social.heldscal.la"
1181   end
1182
1183   test "returns the favorites of a user", %{conn: conn} do
1184     user = insert(:user)
1185     other_user = insert(:user)
1186
1187     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1188     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1189
1190     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1191
1192     conn =
1193       conn
1194       |> assign(:user, user)
1195       |> get("/api/v1/favourites")
1196
1197     assert [status] = json_response(conn, 200)
1198     assert status["id"] == to_string(activity.id)
1199   end
1200
1201   describe "updating credentials" do
1202     test "updates the user's bio", %{conn: conn} do
1203       user = insert(:user)
1204
1205       conn =
1206         conn
1207         |> assign(:user, user)
1208         |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
1209
1210       assert user = json_response(conn, 200)
1211       assert user["note"] == "I drink #cofe"
1212     end
1213
1214     test "updates the user's name", %{conn: conn} do
1215       user = insert(:user)
1216
1217       conn =
1218         conn
1219         |> assign(:user, user)
1220         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1221
1222       assert user = json_response(conn, 200)
1223       assert user["display_name"] == "markorepairs"
1224     end
1225
1226     test "updates the user's avatar", %{conn: conn} do
1227       user = insert(:user)
1228
1229       new_avatar = %Plug.Upload{
1230         content_type: "image/jpg",
1231         path: Path.absname("test/fixtures/image.jpg"),
1232         filename: "an_image.jpg"
1233       }
1234
1235       conn =
1236         conn
1237         |> assign(:user, user)
1238         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1239
1240       assert user = json_response(conn, 200)
1241       assert user["avatar"] != "https://placehold.it/48x48"
1242     end
1243
1244     test "updates the user's banner", %{conn: conn} do
1245       user = insert(:user)
1246
1247       new_header = %Plug.Upload{
1248         content_type: "image/jpg",
1249         path: Path.absname("test/fixtures/image.jpg"),
1250         filename: "an_image.jpg"
1251       }
1252
1253       conn =
1254         conn
1255         |> assign(:user, user)
1256         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1257
1258       assert user = json_response(conn, 200)
1259       assert user["header"] != "https://placehold.it/700x335"
1260     end
1261   end
1262
1263   test "get instance information", %{conn: conn} do
1264     insert(:user, %{local: true})
1265     user = insert(:user, %{local: true})
1266     insert(:user, %{local: false})
1267
1268     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1269
1270     Pleroma.Stats.update_stats()
1271
1272     conn =
1273       conn
1274       |> get("/api/v1/instance")
1275
1276     assert result = json_response(conn, 200)
1277
1278     assert result["stats"]["user_count"] == 2
1279     assert result["stats"]["status_count"] == 1
1280   end
1281 end