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