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