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