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       nconn =
 948         conn
 949         |> get("/api/v1/timelines/tag/2hu")
 950
 951       assert [%{"id" => id}] = json_response(nconn, 200)
 952
 953       assert id == to_string(activity.id)
 954
 955       # works for different capitalization too
 956       nconn =
 957         conn
 958         |> get("/api/v1/timelines/tag/2HU")
 959
 960       assert [%{"id" => id}] = json_response(nconn, 200)
 961
 962       assert id == to_string(activity.id)
 963     end)
 964   end
 965
 966   test "getting followers", %{conn: conn} do
 967     user = insert(:user)
 968     other_user = insert(:user)
 969     {:ok, user} = User.follow(user, other_user)
 970
 971     conn =
 972       conn
 973       |> get("/api/v1/accounts/#{other_user.id}/followers")
 974
 975     assert [%{"id" => id}] = json_response(conn, 200)
 976     assert id == to_string(user.id)
 977   end
 978
 979   test "getting following", %{conn: conn} do
 980     user = insert(:user)
 981     other_user = insert(:user)
 982     {:ok, user} = User.follow(user, other_user)
 983
 984     conn =
 985       conn
 986       |> get("/api/v1/accounts/#{user.id}/following")
 987
 988     assert [%{"id" => id}] = json_response(conn, 200)
 989     assert id == to_string(other_user.id)
 990   end
 991
 992   test "following / unfollowing a user", %{conn: conn} do
 993     user = insert(:user)
 994     other_user = insert(:user)
 995
 996     conn =
 997       conn
 998       |> assign(:user, user)
 999       |> post("/api/v1/accounts/#{other_user.id}/follow")
1000
1001     assert %{"id" => _id, "following" => true} = 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/accounts/#{other_user.id}/unfollow")
1009
1010     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1011
1012     user = Repo.get(User, user.id)
1013
1014     conn =
1015       build_conn()
1016       |> assign(:user, user)
1017       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1018
1019     assert %{"id" => id} = json_response(conn, 200)
1020     assert id == to_string(other_user.id)
1021   end
1022
1023   test "blocking / unblocking a user", %{conn: conn} do
1024     user = insert(:user)
1025     other_user = insert(:user)
1026
1027     conn =
1028       conn
1029       |> assign(:user, user)
1030       |> post("/api/v1/accounts/#{other_user.id}/block")
1031
1032     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1033
1034     user = Repo.get(User, user.id)
1035
1036     conn =
1037       build_conn()
1038       |> assign(:user, user)
1039       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1040
1041     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1042   end
1043
1044   test "getting a list of blocks", %{conn: conn} do
1045     user = insert(:user)
1046     other_user = insert(:user)
1047
1048     {:ok, user} = User.block(user, other_user)
1049
1050     conn =
1051       conn
1052       |> assign(:user, user)
1053       |> get("/api/v1/blocks")
1054
1055     other_user_id = to_string(other_user.id)
1056     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1057   end
1058
1059   test "blocking / unblocking a domain", %{conn: conn} do
1060     user = insert(:user)
1061     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1062
1063     conn =
1064       conn
1065       |> assign(:user, user)
1066       |> post("/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     assert User.blocks?(user, other_user)
1071
1072     conn =
1073       build_conn()
1074       |> assign(:user, user)
1075       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1076
1077     assert %{} = json_response(conn, 200)
1078     user = User.get_cached_by_ap_id(user.ap_id)
1079     refute User.blocks?(user, other_user)
1080   end
1081
1082   test "getting a list of domain blocks" do
1083     user = insert(:user)
1084
1085     {:ok, user} = User.block_domain(user, "bad.site")
1086     {:ok, user} = User.block_domain(user, "even.worse.site")
1087
1088     conn =
1089       conn
1090       |> assign(:user, user)
1091       |> get("/api/v1/domain_blocks")
1092
1093     domain_blocks = json_response(conn, 200)
1094
1095     assert "bad.site" in domain_blocks
1096     assert "even.worse.site" in domain_blocks
1097   end
1098
1099   test "unimplemented mute endpoints" do
1100     user = insert(:user)
1101     other_user = insert(:user)
1102
1103     ["mute", "unmute"]
1104     |> Enum.each(fn endpoint ->
1105       conn =
1106         build_conn()
1107         |> assign(:user, user)
1108         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1109
1110       assert %{"id" => id} = json_response(conn, 200)
1111       assert id == to_string(other_user.id)
1112     end)
1113   end
1114
1115   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1116     user = insert(:user)
1117
1118     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1119     |> Enum.each(fn endpoint ->
1120       conn =
1121         build_conn()
1122         |> assign(:user, user)
1123         |> get("/api/v1/#{endpoint}")
1124
1125       assert [] = json_response(conn, 200)
1126     end)
1127   end
1128
1129   test "account search", %{conn: conn} do
1130     user = insert(:user)
1131     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1132     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1133
1134     results =
1135       conn
1136       |> assign(:user, user)
1137       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1138       |> json_response(200)
1139
1140     result_ids = for result <- results, do: result["acct"]
1141
1142     assert user_two.nickname in result_ids
1143     assert user_three.nickname in result_ids
1144
1145     results =
1146       conn
1147       |> assign(:user, user)
1148       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1149       |> json_response(200)
1150
1151     result_ids = for result <- results, do: result["acct"]
1152
1153     assert user_three.nickname in result_ids
1154   end
1155
1156   test "search", %{conn: conn} do
1157     user = insert(:user)
1158     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1159     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1160
1161     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1162
1163     {:ok, _activity} =
1164       CommonAPI.post(user, %{
1165         "status" => "This is about 2hu, but private",
1166         "visibility" => "private"
1167       })
1168
1169     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1170
1171     conn =
1172       conn
1173       |> get("/api/v1/search", %{"q" => "2hu"})
1174
1175     assert results = json_response(conn, 200)
1176
1177     [account | _] = results["accounts"]
1178     assert account["id"] == to_string(user_three.id)
1179
1180     assert results["hashtags"] == []
1181
1182     [status] = results["statuses"]
1183     assert status["id"] == to_string(activity.id)
1184   end
1185
1186   test "search fetches remote statuses", %{conn: conn} do
1187     capture_log(fn ->
1188       conn =
1189         conn
1190         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1191
1192       assert results = json_response(conn, 200)
1193
1194       [status] = results["statuses"]
1195       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1196     end)
1197   end
1198
1199   test "search fetches remote accounts", %{conn: conn} do
1200     conn =
1201       conn
1202       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1203
1204     assert results = json_response(conn, 200)
1205     [account] = results["accounts"]
1206     assert account["acct"] == "shp@social.heldscal.la"
1207   end
1208
1209   test "returns the favorites of a user", %{conn: conn} do
1210     user = insert(:user)
1211     other_user = insert(:user)
1212
1213     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1214     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1215
1216     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1217
1218     conn =
1219       conn
1220       |> assign(:user, user)
1221       |> get("/api/v1/favourites")
1222
1223     assert [status] = json_response(conn, 200)
1224     assert status["id"] == to_string(activity.id)
1225   end
1226
1227   describe "updating credentials" do
1228     test "updates the user's bio", %{conn: conn} do
1229       user = insert(:user)
1230
1231       conn =
1232         conn
1233         |> assign(:user, user)
1234         |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
1235
1236       assert user = json_response(conn, 200)
1237       assert user["note"] == "I drink #cofe"
1238     end
1239
1240     test "updates the user's name", %{conn: conn} do
1241       user = insert(:user)
1242
1243       conn =
1244         conn
1245         |> assign(:user, user)
1246         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1247
1248       assert user = json_response(conn, 200)
1249       assert user["display_name"] == "markorepairs"
1250     end
1251
1252     test "updates the user's avatar", %{conn: conn} do
1253       user = insert(:user)
1254
1255       new_avatar = %Plug.Upload{
1256         content_type: "image/jpg",
1257         path: Path.absname("test/fixtures/image.jpg"),
1258         filename: "an_image.jpg"
1259       }
1260
1261       conn =
1262         conn
1263         |> assign(:user, user)
1264         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1265
1266       assert user = json_response(conn, 200)
1267       assert user["avatar"] != "https://placehold.it/48x48"
1268     end
1269
1270     test "updates the user's banner", %{conn: conn} do
1271       user = insert(:user)
1272
1273       new_header = %Plug.Upload{
1274         content_type: "image/jpg",
1275         path: Path.absname("test/fixtures/image.jpg"),
1276         filename: "an_image.jpg"
1277       }
1278
1279       conn =
1280         conn
1281         |> assign(:user, user)
1282         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1283
1284       assert user = json_response(conn, 200)
1285       assert user["header"] != "https://placehold.it/700x335"
1286     end
1287   end
1288
1289   test "get instance information", %{conn: conn} do
1290     insert(:user, %{local: true})
1291     user = insert(:user, %{local: true})
1292     insert(:user, %{local: false})
1293
1294     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1295
1296     Pleroma.Stats.update_stats()
1297
1298     conn =
1299       conn
1300       |> get("/api/v1/instance")
1301
1302     assert result = json_response(conn, 200)
1303
1304     assert result["stats"]["user_count"] == 2
1305     assert result["stats"]["status_count"] == 1
1306   end
1307 end