git.squeep.com Git - akkoma/blob - test/web/mastodon_api/mastodon_api_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Web.TwitterAPI.TwitterAPI
   9   alias Pleroma.{Repo, User, Object, Activity, Notification}
  10   alias Pleroma.Web.{OStatus, CommonAPI}
  11   alias Pleroma.Web.ActivityPub.ActivityPub
  12   alias Pleroma.Web.MastodonAPI.FilterView
  13   import Pleroma.Factory
  14   import ExUnit.CaptureLog
  15   import Tesla.Mock
  16
  17   setup do
  18     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  19     :ok
  20   end
  21
  22   test "the home timeline", %{conn: conn} do
  23     user = insert(:user)
  24     following = insert(:user)
  25
  26     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  27
  28     conn =
  29       conn
  30       |> assign(:user, user)
  31       |> get("/api/v1/timelines/home")
  32
  33     assert length(json_response(conn, 200)) == 0
  34
  35     {:ok, user} = User.follow(user, following)
  36
  37     conn =
  38       build_conn()
  39       |> assign(:user, user)
  40       |> get("/api/v1/timelines/home")
  41
  42     assert [%{"content" => "test"}] = json_response(conn, 200)
  43   end
  44
  45   test "the public timeline", %{conn: conn} do
  46     following = insert(:user)
  47
  48     capture_log(fn ->
  49       {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  50
  51       {:ok, [_activity]} =
  52         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
  53
  54       conn =
  55         conn
  56         |> get("/api/v1/timelines/public", %{"local" => "False"})
  57
  58       assert length(json_response(conn, 200)) == 2
  59
  60       conn =
  61         build_conn()
  62         |> get("/api/v1/timelines/public", %{"local" => "True"})
  63
  64       assert [%{"content" => "test"}] = json_response(conn, 200)
  65
  66       conn =
  67         build_conn()
  68         |> get("/api/v1/timelines/public", %{"local" => "1"})
  69
  70       assert [%{"content" => "test"}] = json_response(conn, 200)
  71     end)
  72   end
  73
  74   test "posting a status", %{conn: conn} do
  75     user = insert(:user)
  76
  77     idempotency_key = "Pikachu rocks!"
  78
  79     conn_one =
  80       conn
  81       |> assign(:user, user)
  82       |> put_req_header("idempotency-key", idempotency_key)
  83       |> post("/api/v1/statuses", %{
  84         "status" => "cofe",
  85         "spoiler_text" => "2hu",
  86         "sensitive" => "false"
  87       })
  88
  89     {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
  90     # Six hours
  91     assert ttl > :timer.seconds(6 * 60 * 60 - 1)
  92
  93     assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
  94              json_response(conn_one, 200)
  95
  96     assert Repo.get(Activity, id)
  97
  98     conn_two =
  99       conn
 100       |> assign(:user, user)
 101       |> put_req_header("idempotency-key", idempotency_key)
 102       |> post("/api/v1/statuses", %{
 103         "status" => "cofe",
 104         "spoiler_text" => "2hu",
 105         "sensitive" => "false"
 106       })
 107
 108     assert %{"id" => second_id} = json_response(conn_two, 200)
 109
 110     assert id == second_id
 111
 112     conn_three =
 113       conn
 114       |> assign(:user, user)
 115       |> post("/api/v1/statuses", %{
 116         "status" => "cofe",
 117         "spoiler_text" => "2hu",
 118         "sensitive" => "false"
 119       })
 120
 121     assert %{"id" => third_id} = json_response(conn_three, 200)
 122
 123     refute id == third_id
 124   end
 125
 126   test "posting a sensitive status", %{conn: conn} do
 127     user = insert(:user)
 128
 129     conn =
 130       conn
 131       |> assign(:user, user)
 132       |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
 133
 134     assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
 135     assert Repo.get(Activity, id)
 136   end
 137
 138   test "posting a direct status", %{conn: conn} do
 139     user1 = insert(:user)
 140     user2 = insert(:user)
 141     content = "direct cofe @#{user2.nickname}"
 142
 143     conn =
 144       conn
 145       |> assign(:user, user1)
 146       |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
 147
 148     assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
 149     assert activity = Repo.get(Activity, id)
 150     assert activity.recipients == [user2.ap_id]
 151     assert activity.data["to"] == [user2.ap_id]
 152     assert activity.data["cc"] == []
 153   end
 154
 155   test "direct timeline", %{conn: conn} do
 156     user_one = insert(:user)
 157     user_two = insert(:user)
 158
 159     {:ok, user_two} = User.follow(user_two, user_one)
 160
 161     {:ok, direct} =
 162       CommonAPI.post(user_one, %{
 163         "status" => "Hi @#{user_two.nickname}!",
 164         "visibility" => "direct"
 165       })
 166
 167     {:ok, _follower_only} =
 168       CommonAPI.post(user_one, %{
 169         "status" => "Hi @#{user_two.nickname}!",
 170         "visibility" => "private"
 171       })
 172
 173     # Only direct should be visible here
 174     res_conn =
 175       conn
 176       |> assign(:user, user_two)
 177       |> get("api/v1/timelines/direct")
 178
 179     [status] = json_response(res_conn, 200)
 180
 181     assert %{"visibility" => "direct"} = status
 182     assert status["url"] != direct.data["id"]
 183
 184     # Both should be visible here
 185     res_conn =
 186       conn
 187       |> assign(:user, user_two)
 188       |> get("api/v1/timelines/home")
 189
 190     [_s1, _s2] = json_response(res_conn, 200)
 191
 192     # Test pagination
 193     Enum.each(1..20, fn _ ->
 194       {:ok, _} =
 195         CommonAPI.post(user_one, %{
 196           "status" => "Hi @#{user_two.nickname}!",
 197           "visibility" => "direct"
 198         })
 199     end)
 200
 201     res_conn =
 202       conn
 203       |> assign(:user, user_two)
 204       |> get("api/v1/timelines/direct")
 205
 206     statuses = json_response(res_conn, 200)
 207     assert length(statuses) == 20
 208
 209     res_conn =
 210       conn
 211       |> assign(:user, user_two)
 212       |> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})
 213
 214     [status] = json_response(res_conn, 200)
 215
 216     assert status["url"] != direct.data["id"]
 217   end
 218
 219   test "replying to a status", %{conn: conn} do
 220     user = insert(:user)
 221
 222     {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 223
 224     conn =
 225       conn
 226       |> assign(:user, user)
 227       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 228
 229     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 230
 231     activity = Repo.get(Activity, id)
 232
 233     assert activity.data["context"] == replied_to.data["context"]
 234     assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
 235   end
 236
 237   test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
 238     user = insert(:user)
 239
 240     conn =
 241       conn
 242       |> assign(:user, user)
 243       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
 244
 245     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 246
 247     activity = Repo.get(Activity, id)
 248
 249     assert activity
 250   end
 251
 252   test "verify_credentials", %{conn: conn} do
 253     user = insert(:user)
 254
 255     conn =
 256       conn
 257       |> assign(:user, user)
 258       |> get("/api/v1/accounts/verify_credentials")
 259
 260     assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
 261     assert id == to_string(user.id)
 262   end
 263
 264   test "verify_credentials default scope unlisted", %{conn: conn} do
 265     user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})
 266
 267     conn =
 268       conn
 269       |> assign(:user, user)
 270       |> get("/api/v1/accounts/verify_credentials")
 271
 272     assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
 273     assert id == to_string(user.id)
 274   end
 275
 276   test "get a status", %{conn: conn} do
 277     activity = insert(:note_activity)
 278
 279     conn =
 280       conn
 281       |> get("/api/v1/statuses/#{activity.id}")
 282
 283     assert %{"id" => id} = json_response(conn, 200)
 284     assert id == to_string(activity.id)
 285   end
 286
 287   describe "deleting a status" do
 288     test "when you created it", %{conn: conn} do
 289       activity = insert(:note_activity)
 290       author = User.get_by_ap_id(activity.data["actor"])
 291
 292       conn =
 293         conn
 294         |> assign(:user, author)
 295         |> delete("/api/v1/statuses/#{activity.id}")
 296
 297       assert %{} = json_response(conn, 200)
 298
 299       refute Repo.get(Activity, activity.id)
 300     end
 301
 302     test "when you didn't create it", %{conn: conn} do
 303       activity = insert(:note_activity)
 304       user = insert(:user)
 305
 306       conn =
 307         conn
 308         |> assign(:user, user)
 309         |> delete("/api/v1/statuses/#{activity.id}")
 310
 311       assert %{"error" => _} = json_response(conn, 403)
 312
 313       assert Repo.get(Activity, activity.id) == activity
 314     end
 315   end
 316
 317   describe "filters" do
 318     test "creating a filter", %{conn: conn} do
 319       user = insert(:user)
 320
 321       filter = %Pleroma.Filter{
 322         phrase: "knights",
 323         context: ["home"]
 324       }
 325
 326       conn =
 327         conn
 328         |> assign(:user, user)
 329         |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
 330
 331       assert response = json_response(conn, 200)
 332       assert response["phrase"] == filter.phrase
 333       assert response["context"] == filter.context
 334       assert response["id"] != nil
 335       assert response["id"] != ""
 336     end
 337
 338     test "fetching a list of filters", %{conn: conn} do
 339       user = insert(:user)
 340
 341       query_one = %Pleroma.Filter{
 342         user_id: user.id,
 343         filter_id: 1,
 344         phrase: "knights",
 345         context: ["home"]
 346       }
 347
 348       query_two = %Pleroma.Filter{
 349         user_id: user.id,
 350         filter_id: 2,
 351         phrase: "who",
 352         context: ["home"]
 353       }
 354
 355       {:ok, filter_one} = Pleroma.Filter.create(query_one)
 356       {:ok, filter_two} = Pleroma.Filter.create(query_two)
 357
 358       response =
 359         conn
 360         |> assign(:user, user)
 361         |> get("/api/v1/filters")
 362         |> json_response(200)
 363
 364       assert response ==
 365                render_json(
 366                  FilterView,
 367                  "filters.json",
 368                  filters: [filter_two, filter_one]
 369                )
 370     end
 371
 372     test "get a filter", %{conn: conn} do
 373       user = insert(:user)
 374
 375       query = %Pleroma.Filter{
 376         user_id: user.id,
 377         filter_id: 2,
 378         phrase: "knight",
 379         context: ["home"]
 380       }
 381
 382       {:ok, filter} = Pleroma.Filter.create(query)
 383
 384       conn =
 385         conn
 386         |> assign(:user, user)
 387         |> get("/api/v1/filters/#{filter.filter_id}")
 388
 389       assert response = json_response(conn, 200)
 390     end
 391
 392     test "update a filter", %{conn: conn} do
 393       user = insert(:user)
 394
 395       query = %Pleroma.Filter{
 396         user_id: user.id,
 397         filter_id: 2,
 398         phrase: "knight",
 399         context: ["home"]
 400       }
 401
 402       {:ok, _filter} = Pleroma.Filter.create(query)
 403
 404       new = %Pleroma.Filter{
 405         phrase: "nii",
 406         context: ["home"]
 407       }
 408
 409       conn =
 410         conn
 411         |> assign(:user, user)
 412         |> put("/api/v1/filters/#{query.filter_id}", %{
 413           phrase: new.phrase,
 414           context: new.context
 415         })
 416
 417       assert response = json_response(conn, 200)
 418       assert response["phrase"] == new.phrase
 419       assert response["context"] == new.context
 420     end
 421
 422     test "delete a filter", %{conn: conn} do
 423       user = insert(:user)
 424
 425       query = %Pleroma.Filter{
 426         user_id: user.id,
 427         filter_id: 2,
 428         phrase: "knight",
 429         context: ["home"]
 430       }
 431
 432       {:ok, filter} = Pleroma.Filter.create(query)
 433
 434       conn =
 435         conn
 436         |> assign(:user, user)
 437         |> delete("/api/v1/filters/#{filter.filter_id}")
 438
 439       assert response = json_response(conn, 200)
 440       assert response == %{}
 441     end
 442   end
 443
 444   describe "lists" do
 445     test "creating a list", %{conn: conn} do
 446       user = insert(:user)
 447
 448       conn =
 449         conn
 450         |> assign(:user, user)
 451         |> post("/api/v1/lists", %{"title" => "cuties"})
 452
 453       assert %{"title" => title} = json_response(conn, 200)
 454       assert title == "cuties"
 455     end
 456
 457     test "adding users to a list", %{conn: conn} do
 458       user = insert(:user)
 459       other_user = insert(:user)
 460       {:ok, list} = Pleroma.List.create("name", user)
 461
 462       conn =
 463         conn
 464         |> assign(:user, user)
 465         |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 466
 467       assert %{} == json_response(conn, 200)
 468       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 469       assert following == [other_user.follower_address]
 470     end
 471
 472     test "removing users from a list", %{conn: conn} do
 473       user = insert(:user)
 474       other_user = insert(:user)
 475       third_user = insert(:user)
 476       {:ok, list} = Pleroma.List.create("name", user)
 477       {:ok, list} = Pleroma.List.follow(list, other_user)
 478       {:ok, list} = Pleroma.List.follow(list, third_user)
 479
 480       conn =
 481         conn
 482         |> assign(:user, user)
 483         |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 484
 485       assert %{} == json_response(conn, 200)
 486       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 487       assert following == [third_user.follower_address]
 488     end
 489
 490     test "listing users in a list", %{conn: conn} do
 491       user = insert(:user)
 492       other_user = insert(:user)
 493       {:ok, list} = Pleroma.List.create("name", user)
 494       {:ok, list} = Pleroma.List.follow(list, other_user)
 495
 496       conn =
 497         conn
 498         |> assign(:user, user)
 499         |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 500
 501       assert [%{"id" => id}] = json_response(conn, 200)
 502       assert id == to_string(other_user.id)
 503     end
 504
 505     test "retrieving a list", %{conn: conn} do
 506       user = insert(:user)
 507       {:ok, list} = Pleroma.List.create("name", user)
 508
 509       conn =
 510         conn
 511         |> assign(:user, user)
 512         |> get("/api/v1/lists/#{list.id}")
 513
 514       assert %{"id" => id} = json_response(conn, 200)
 515       assert id == to_string(list.id)
 516     end
 517
 518     test "renaming a list", %{conn: conn} do
 519       user = insert(:user)
 520       {:ok, list} = Pleroma.List.create("name", user)
 521
 522       conn =
 523         conn
 524         |> assign(:user, user)
 525         |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
 526
 527       assert %{"title" => name} = json_response(conn, 200)
 528       assert name == "newname"
 529     end
 530
 531     test "deleting a list", %{conn: conn} do
 532       user = insert(:user)
 533       {:ok, list} = Pleroma.List.create("name", user)
 534
 535       conn =
 536         conn
 537         |> assign(:user, user)
 538         |> delete("/api/v1/lists/#{list.id}")
 539
 540       assert %{} = json_response(conn, 200)
 541       assert is_nil(Repo.get(Pleroma.List, list.id))
 542     end
 543
 544     test "list timeline", %{conn: conn} do
 545       user = insert(:user)
 546       other_user = insert(:user)
 547       {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
 548       {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 549       {:ok, list} = Pleroma.List.create("name", user)
 550       {:ok, list} = Pleroma.List.follow(list, other_user)
 551
 552       conn =
 553         conn
 554         |> assign(:user, user)
 555         |> get("/api/v1/timelines/list/#{list.id}")
 556
 557       assert [%{"id" => id}] = json_response(conn, 200)
 558
 559       assert id == to_string(activity_two.id)
 560     end
 561
 562     test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
 563       user = insert(:user)
 564       other_user = insert(:user)
 565       {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 566
 567       {:ok, _activity_two} =
 568         TwitterAPI.create_status(other_user, %{
 569           "status" => "Marisa is cute.",
 570           "visibility" => "private"
 571         })
 572
 573       {:ok, list} = Pleroma.List.create("name", user)
 574       {:ok, list} = Pleroma.List.follow(list, other_user)
 575
 576       conn =
 577         conn
 578         |> assign(:user, user)
 579         |> get("/api/v1/timelines/list/#{list.id}")
 580
 581       assert [%{"id" => id}] = json_response(conn, 200)
 582
 583       assert id == to_string(activity_one.id)
 584     end
 585   end
 586
 587   describe "notifications" do
 588     test "list of notifications", %{conn: conn} do
 589       user = insert(:user)
 590       other_user = insert(:user)
 591
 592       {:ok, activity} =
 593         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 594
 595       {:ok, [_notification]} = Notification.create_notifications(activity)
 596
 597       conn =
 598         conn
 599         |> assign(:user, user)
 600         |> get("/api/v1/notifications")
 601
 602       expected_response =
 603         "hi <span><a data-user=\"#{user.id}\" href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 604
 605       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 606       assert response == expected_response
 607     end
 608
 609     test "getting a single notification", %{conn: conn} do
 610       user = insert(:user)
 611       other_user = insert(:user)
 612
 613       {:ok, activity} =
 614         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 615
 616       {:ok, [notification]} = Notification.create_notifications(activity)
 617
 618       conn =
 619         conn
 620         |> assign(:user, user)
 621         |> get("/api/v1/notifications/#{notification.id}")
 622
 623       expected_response =
 624         "hi <span><a data-user=\"#{user.id}\" href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
 625
 626       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 627       assert response == expected_response
 628     end
 629
 630     test "dismissing a single notification", %{conn: conn} do
 631       user = insert(:user)
 632       other_user = insert(:user)
 633
 634       {:ok, activity} =
 635         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 636
 637       {:ok, [notification]} = Notification.create_notifications(activity)
 638
 639       conn =
 640         conn
 641         |> assign(:user, user)
 642         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 643
 644       assert %{} = json_response(conn, 200)
 645     end
 646
 647     test "clearing all notifications", %{conn: conn} do
 648       user = insert(:user)
 649       other_user = insert(:user)
 650
 651       {:ok, activity} =
 652         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 653
 654       {:ok, [_notification]} = Notification.create_notifications(activity)
 655
 656       conn =
 657         conn
 658         |> assign(:user, user)
 659         |> post("/api/v1/notifications/clear")
 660
 661       assert %{} = json_response(conn, 200)
 662
 663       conn =
 664         build_conn()
 665         |> assign(:user, user)
 666         |> get("/api/v1/notifications")
 667
 668       assert all = json_response(conn, 200)
 669       assert all == []
 670     end
 671   end
 672
 673   describe "reblogging" do
 674     test "reblogs and returns the reblogged status", %{conn: conn} do
 675       activity = insert(:note_activity)
 676       user = insert(:user)
 677
 678       conn =
 679         conn
 680         |> assign(:user, user)
 681         |> post("/api/v1/statuses/#{activity.id}/reblog")
 682
 683       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 684                json_response(conn, 200)
 685
 686       assert to_string(activity.id) == id
 687     end
 688   end
 689
 690   describe "unreblogging" do
 691     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 692       activity = insert(:note_activity)
 693       user = insert(:user)
 694
 695       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 696
 697       conn =
 698         conn
 699         |> assign(:user, user)
 700         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 701
 702       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 703
 704       assert to_string(activity.id) == id
 705     end
 706   end
 707
 708   describe "favoriting" do
 709     test "favs a status and returns it", %{conn: conn} do
 710       activity = insert(:note_activity)
 711       user = insert(:user)
 712
 713       conn =
 714         conn
 715         |> assign(:user, user)
 716         |> post("/api/v1/statuses/#{activity.id}/favourite")
 717
 718       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 719                json_response(conn, 200)
 720
 721       assert to_string(activity.id) == id
 722     end
 723
 724     test "returns 500 for a wrong id", %{conn: conn} do
 725       user = insert(:user)
 726
 727       resp =
 728         conn
 729         |> assign(:user, user)
 730         |> post("/api/v1/statuses/1/favourite")
 731         |> json_response(500)
 732
 733       assert resp == "Something went wrong"
 734     end
 735   end
 736
 737   describe "unfavoriting" do
 738     test "unfavorites a status and returns it", %{conn: conn} do
 739       activity = insert(:note_activity)
 740       user = insert(:user)
 741
 742       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 743
 744       conn =
 745         conn
 746         |> assign(:user, user)
 747         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 748
 749       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 750                json_response(conn, 200)
 751
 752       assert to_string(activity.id) == id
 753     end
 754   end
 755
 756   describe "user timelines" do
 757     test "gets a users statuses", %{conn: conn} do
 758       user_one = insert(:user)
 759       user_two = insert(:user)
 760       user_three = insert(:user)
 761
 762       {:ok, user_three} = User.follow(user_three, user_one)
 763
 764       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
 765
 766       {:ok, direct_activity} =
 767         CommonAPI.post(user_one, %{
 768           "status" => "Hi, @#{user_two.nickname}.",
 769           "visibility" => "direct"
 770         })
 771
 772       {:ok, private_activity} =
 773         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
 774
 775       resp =
 776         conn
 777         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 778
 779       assert [%{"id" => id}] = json_response(resp, 200)
 780       assert id == to_string(activity.id)
 781
 782       resp =
 783         conn
 784         |> assign(:user, user_two)
 785         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 786
 787       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 788       assert id_one == to_string(direct_activity.id)
 789       assert id_two == to_string(activity.id)
 790
 791       resp =
 792         conn
 793         |> assign(:user, user_three)
 794         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 795
 796       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 797       assert id_one == to_string(private_activity.id)
 798       assert id_two == to_string(activity.id)
 799     end
 800
 801     test "unimplemented pinned statuses feature", %{conn: conn} do
 802       note = insert(:note_activity)
 803       user = User.get_by_ap_id(note.data["actor"])
 804
 805       conn =
 806         conn
 807         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 808
 809       assert json_response(conn, 200) == []
 810     end
 811
 812     test "gets an users media", %{conn: conn} do
 813       note = insert(:note_activity)
 814       user = User.get_by_ap_id(note.data["actor"])
 815
 816       file = %Plug.Upload{
 817         content_type: "image/jpg",
 818         path: Path.absname("test/fixtures/image.jpg"),
 819         filename: "an_image.jpg"
 820       }
 821
 822       media =
 823         TwitterAPI.upload(file, user, "json")
 824         |> Poison.decode!()
 825
 826       {:ok, image_post} =
 827         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 828
 829       conn =
 830         conn
 831         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 832
 833       assert [%{"id" => id}] = json_response(conn, 200)
 834       assert id == to_string(image_post.id)
 835
 836       conn =
 837         build_conn()
 838         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 839
 840       assert [%{"id" => id}] = json_response(conn, 200)
 841       assert id == to_string(image_post.id)
 842     end
 843
 844     test "gets a user's statuses without reblogs", %{conn: conn} do
 845       user = insert(:user)
 846       {:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
 847       {:ok, _, _} = CommonAPI.repeat(post.id, user)
 848
 849       conn =
 850         conn
 851         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})
 852
 853       assert [%{"id" => id}] = json_response(conn, 200)
 854       assert id == to_string(post.id)
 855
 856       conn =
 857         conn
 858         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})
 859
 860       assert [%{"id" => id}] = json_response(conn, 200)
 861       assert id == to_string(post.id)
 862     end
 863   end
 864
 865   describe "user relationships" do
 866     test "returns the relationships for the current user", %{conn: conn} do
 867       user = insert(:user)
 868       other_user = insert(:user)
 869       {:ok, user} = User.follow(user, other_user)
 870
 871       conn =
 872         conn
 873         |> assign(:user, user)
 874         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 875
 876       assert [relationship] = json_response(conn, 200)
 877
 878       assert to_string(other_user.id) == relationship["id"]
 879     end
 880   end
 881
 882   describe "locked accounts" do
 883     test "/api/v1/follow_requests works" do
 884       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 885       other_user = insert(:user)
 886
 887       {:ok, _activity} = ActivityPub.follow(other_user, user)
 888
 889       user = Repo.get(User, user.id)
 890       other_user = Repo.get(User, other_user.id)
 891
 892       assert User.following?(other_user, user) == false
 893
 894       conn =
 895         build_conn()
 896         |> assign(:user, user)
 897         |> get("/api/v1/follow_requests")
 898
 899       assert [relationship] = json_response(conn, 200)
 900       assert to_string(other_user.id) == relationship["id"]
 901     end
 902
 903     test "/api/v1/follow_requests/:id/authorize works" do
 904       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 905       other_user = insert(:user)
 906
 907       {:ok, _activity} = ActivityPub.follow(other_user, user)
 908
 909       user = Repo.get(User, user.id)
 910       other_user = Repo.get(User, other_user.id)
 911
 912       assert User.following?(other_user, user) == false
 913
 914       conn =
 915         build_conn()
 916         |> assign(:user, user)
 917         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
 918
 919       assert relationship = json_response(conn, 200)
 920       assert to_string(other_user.id) == relationship["id"]
 921
 922       user = Repo.get(User, user.id)
 923       other_user = Repo.get(User, other_user.id)
 924
 925       assert User.following?(other_user, user) == true
 926     end
 927
 928     test "verify_credentials", %{conn: conn} do
 929       user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
 930
 931       conn =
 932         conn
 933         |> assign(:user, user)
 934         |> get("/api/v1/accounts/verify_credentials")
 935
 936       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
 937       assert id == to_string(user.id)
 938     end
 939
 940     test "/api/v1/follow_requests/:id/reject works" do
 941       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 942       other_user = insert(:user)
 943
 944       {:ok, _activity} = ActivityPub.follow(other_user, user)
 945
 946       conn =
 947         build_conn()
 948         |> assign(:user, user)
 949         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
 950
 951       assert relationship = json_response(conn, 200)
 952       assert to_string(other_user.id) == relationship["id"]
 953
 954       user = Repo.get(User, user.id)
 955       other_user = Repo.get(User, other_user.id)
 956
 957       assert User.following?(other_user, user) == false
 958     end
 959   end
 960
 961   test "account fetching", %{conn: conn} do
 962     user = insert(:user)
 963
 964     conn =
 965       conn
 966       |> get("/api/v1/accounts/#{user.id}")
 967
 968     assert %{"id" => id} = json_response(conn, 200)
 969     assert id == to_string(user.id)
 970
 971     conn =
 972       build_conn()
 973       |> get("/api/v1/accounts/-1")
 974
 975     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 976   end
 977
 978   test "media upload", %{conn: conn} do
 979     file = %Plug.Upload{
 980       content_type: "image/jpg",
 981       path: Path.absname("test/fixtures/image.jpg"),
 982       filename: "an_image.jpg"
 983     }
 984
 985     desc = "Description of the image"
 986
 987     user = insert(:user)
 988
 989     conn =
 990       conn
 991       |> assign(:user, user)
 992       |> post("/api/v1/media", %{"file" => file, "description" => desc})
 993
 994     assert media = json_response(conn, 200)
 995
 996     assert media["type"] == "image"
 997     assert media["description"] == desc
 998     assert media["id"]
 999
1000     object = Repo.get(Object, media["id"])
1001     assert object.data["actor"] == User.ap_id(user)
1002   end
1003
1004   test "hashtag timeline", %{conn: conn} do
1005     following = insert(:user)
1006
1007     capture_log(fn ->
1008       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
1009
1010       {:ok, [_activity]} =
1011         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
1012
1013       nconn =
1014         conn
1015         |> get("/api/v1/timelines/tag/2hu")
1016
1017       assert [%{"id" => id}] = json_response(nconn, 200)
1018
1019       assert id == to_string(activity.id)
1020
1021       # works for different capitalization too
1022       nconn =
1023         conn
1024         |> get("/api/v1/timelines/tag/2HU")
1025
1026       assert [%{"id" => id}] = json_response(nconn, 200)
1027
1028       assert id == to_string(activity.id)
1029     end)
1030   end
1031
1032   test "getting followers", %{conn: conn} do
1033     user = insert(:user)
1034     other_user = insert(:user)
1035     {:ok, user} = User.follow(user, other_user)
1036
1037     conn =
1038       conn
1039       |> get("/api/v1/accounts/#{other_user.id}/followers")
1040
1041     assert [%{"id" => id}] = json_response(conn, 200)
1042     assert id == to_string(user.id)
1043   end
1044
1045   test "getting followers, hide_network", %{conn: conn} do
1046     user = insert(:user)
1047     other_user = insert(:user, %{info: %{hide_network: true}})
1048     {:ok, _user} = User.follow(user, other_user)
1049
1050     conn =
1051       conn
1052       |> get("/api/v1/accounts/#{other_user.id}/followers")
1053
1054     assert [] == json_response(conn, 200)
1055   end
1056
1057   test "getting followers, hide_network, same user requesting", %{conn: conn} do
1058     user = insert(:user)
1059     other_user = insert(:user, %{info: %{hide_network: true}})
1060     {:ok, _user} = User.follow(user, other_user)
1061
1062     conn =
1063       conn
1064       |> assign(:user, other_user)
1065       |> get("/api/v1/accounts/#{other_user.id}/followers")
1066
1067     refute [] == json_response(conn, 200)
1068   end
1069
1070   test "getting following", %{conn: conn} do
1071     user = insert(:user)
1072     other_user = insert(:user)
1073     {:ok, user} = User.follow(user, other_user)
1074
1075     conn =
1076       conn
1077       |> get("/api/v1/accounts/#{user.id}/following")
1078
1079     assert [%{"id" => id}] = json_response(conn, 200)
1080     assert id == to_string(other_user.id)
1081   end
1082
1083   test "getting following, hide_network", %{conn: conn} do
1084     user = insert(:user, %{info: %{hide_network: true}})
1085     other_user = insert(:user)
1086     {:ok, user} = User.follow(user, other_user)
1087
1088     conn =
1089       conn
1090       |> get("/api/v1/accounts/#{user.id}/following")
1091
1092     assert [] == json_response(conn, 200)
1093   end
1094
1095   test "getting following, hide_network, same user requesting", %{conn: conn} do
1096     user = insert(:user, %{info: %{hide_network: true}})
1097     other_user = insert(:user)
1098     {:ok, user} = User.follow(user, other_user)
1099
1100     conn =
1101       conn
1102       |> assign(:user, user)
1103       |> get("/api/v1/accounts/#{user.id}/following")
1104
1105     refute [] == json_response(conn, 200)
1106   end
1107
1108   test "following / unfollowing a user", %{conn: conn} do
1109     user = insert(:user)
1110     other_user = insert(:user)
1111
1112     conn =
1113       conn
1114       |> assign(:user, user)
1115       |> post("/api/v1/accounts/#{other_user.id}/follow")
1116
1117     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1118
1119     user = Repo.get(User, user.id)
1120
1121     conn =
1122       build_conn()
1123       |> assign(:user, user)
1124       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1125
1126     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1127
1128     user = Repo.get(User, user.id)
1129
1130     conn =
1131       build_conn()
1132       |> assign(:user, user)
1133       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1134
1135     assert %{"id" => id} = json_response(conn, 200)
1136     assert id == to_string(other_user.id)
1137   end
1138
1139   test "blocking / unblocking a user", %{conn: conn} do
1140     user = insert(:user)
1141     other_user = insert(:user)
1142
1143     conn =
1144       conn
1145       |> assign(:user, user)
1146       |> post("/api/v1/accounts/#{other_user.id}/block")
1147
1148     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1149
1150     user = Repo.get(User, user.id)
1151
1152     conn =
1153       build_conn()
1154       |> assign(:user, user)
1155       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1156
1157     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1158   end
1159
1160   test "getting a list of blocks", %{conn: conn} do
1161     user = insert(:user)
1162     other_user = insert(:user)
1163
1164     {:ok, user} = User.block(user, other_user)
1165
1166     conn =
1167       conn
1168       |> assign(:user, user)
1169       |> get("/api/v1/blocks")
1170
1171     other_user_id = to_string(other_user.id)
1172     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1173   end
1174
1175   test "blocking / unblocking a domain", %{conn: conn} do
1176     user = insert(:user)
1177     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1178
1179     conn =
1180       conn
1181       |> assign(:user, user)
1182       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1183
1184     assert %{} = json_response(conn, 200)
1185     user = User.get_cached_by_ap_id(user.ap_id)
1186     assert User.blocks?(user, other_user)
1187
1188     conn =
1189       build_conn()
1190       |> assign(:user, user)
1191       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1192
1193     assert %{} = json_response(conn, 200)
1194     user = User.get_cached_by_ap_id(user.ap_id)
1195     refute User.blocks?(user, other_user)
1196   end
1197
1198   test "getting a list of domain blocks", %{conn: conn} do
1199     user = insert(:user)
1200
1201     {:ok, user} = User.block_domain(user, "bad.site")
1202     {:ok, user} = User.block_domain(user, "even.worse.site")
1203
1204     conn =
1205       conn
1206       |> assign(:user, user)
1207       |> get("/api/v1/domain_blocks")
1208
1209     domain_blocks = json_response(conn, 200)
1210
1211     assert "bad.site" in domain_blocks
1212     assert "even.worse.site" in domain_blocks
1213   end
1214
1215   test "unimplemented mute endpoints" do
1216     user = insert(:user)
1217     other_user = insert(:user)
1218
1219     ["mute", "unmute"]
1220     |> Enum.each(fn endpoint ->
1221       conn =
1222         build_conn()
1223         |> assign(:user, user)
1224         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1225
1226       assert %{"id" => id} = json_response(conn, 200)
1227       assert id == to_string(other_user.id)
1228     end)
1229   end
1230
1231   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1232     user = insert(:user)
1233
1234     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1235     |> Enum.each(fn endpoint ->
1236       conn =
1237         build_conn()
1238         |> assign(:user, user)
1239         |> get("/api/v1/#{endpoint}")
1240
1241       assert [] = json_response(conn, 200)
1242     end)
1243   end
1244
1245   test "account search", %{conn: conn} do
1246     user = insert(:user)
1247     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1248     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1249
1250     results =
1251       conn
1252       |> assign(:user, user)
1253       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1254       |> json_response(200)
1255
1256     result_ids = for result <- results, do: result["acct"]
1257
1258     assert user_two.nickname in result_ids
1259     assert user_three.nickname in result_ids
1260
1261     results =
1262       conn
1263       |> assign(:user, user)
1264       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1265       |> json_response(200)
1266
1267     result_ids = for result <- results, do: result["acct"]
1268
1269     assert user_three.nickname in result_ids
1270   end
1271
1272   test "search", %{conn: conn} do
1273     user = insert(:user)
1274     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1275     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1276
1277     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1278
1279     {:ok, _activity} =
1280       CommonAPI.post(user, %{
1281         "status" => "This is about 2hu, but private",
1282         "visibility" => "private"
1283       })
1284
1285     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1286
1287     conn =
1288       conn
1289       |> get("/api/v1/search", %{"q" => "2hu"})
1290
1291     assert results = json_response(conn, 200)
1292
1293     [account | _] = results["accounts"]
1294     assert account["id"] == to_string(user_three.id)
1295
1296     assert results["hashtags"] == []
1297
1298     [status] = results["statuses"]
1299     assert status["id"] == to_string(activity.id)
1300   end
1301
1302   test "search fetches remote statuses", %{conn: conn} do
1303     capture_log(fn ->
1304       conn =
1305         conn
1306         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1307
1308       assert results = json_response(conn, 200)
1309
1310       [status] = results["statuses"]
1311       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1312     end)
1313   end
1314
1315   test "search doesn't show statuses that it shouldn't", %{conn: conn} do
1316     {:ok, activity} =
1317       CommonAPI.post(insert(:user), %{
1318         "status" => "This is about 2hu, but private",
1319         "visibility" => "private"
1320       })
1321
1322     capture_log(fn ->
1323       conn =
1324         conn
1325         |> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})
1326
1327       assert results = json_response(conn, 200)
1328
1329       [] = results["statuses"]
1330     end)
1331   end
1332
1333   test "search fetches remote accounts", %{conn: conn} do
1334     conn =
1335       conn
1336       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1337
1338     assert results = json_response(conn, 200)
1339     [account] = results["accounts"]
1340     assert account["acct"] == "shp@social.heldscal.la"
1341   end
1342
1343   test "returns the favorites of a user", %{conn: conn} do
1344     user = insert(:user)
1345     other_user = insert(:user)
1346
1347     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1348     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1349
1350     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1351
1352     conn =
1353       conn
1354       |> assign(:user, user)
1355       |> get("/api/v1/favourites")
1356
1357     assert [status] = json_response(conn, 200)
1358     assert status["id"] == to_string(activity.id)
1359   end
1360
1361   describe "updating credentials" do
1362     test "updates the user's bio", %{conn: conn} do
1363       user = insert(:user)
1364       user2 = insert(:user)
1365
1366       conn =
1367         conn
1368         |> assign(:user, user)
1369         |> patch("/api/v1/accounts/update_credentials", %{
1370           "note" => "I drink #cofe with @#{user2.nickname}"
1371         })
1372
1373       assert user = json_response(conn, 200)
1374
1375       assert user["note"] ==
1376                "I drink <a data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span><a data-user=\"#{
1377                  user2.id
1378                }\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
1379     end
1380
1381     test "updates the user's locking status", %{conn: conn} do
1382       user = insert(:user)
1383
1384       conn =
1385         conn
1386         |> assign(:user, user)
1387         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1388
1389       assert user = json_response(conn, 200)
1390       assert user["locked"] == true
1391     end
1392
1393     test "updates the user's name", %{conn: conn} do
1394       user = insert(:user)
1395
1396       conn =
1397         conn
1398         |> assign(:user, user)
1399         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1400
1401       assert user = json_response(conn, 200)
1402       assert user["display_name"] == "markorepairs"
1403     end
1404
1405     test "updates the user's avatar", %{conn: conn} do
1406       user = insert(:user)
1407
1408       new_avatar = %Plug.Upload{
1409         content_type: "image/jpg",
1410         path: Path.absname("test/fixtures/image.jpg"),
1411         filename: "an_image.jpg"
1412       }
1413
1414       conn =
1415         conn
1416         |> assign(:user, user)
1417         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1418
1419       assert user_response = json_response(conn, 200)
1420       assert user_response["avatar"] != User.avatar_url(user)
1421     end
1422
1423     test "updates the user's banner", %{conn: conn} do
1424       user = insert(:user)
1425
1426       new_header = %Plug.Upload{
1427         content_type: "image/jpg",
1428         path: Path.absname("test/fixtures/image.jpg"),
1429         filename: "an_image.jpg"
1430       }
1431
1432       conn =
1433         conn
1434         |> assign(:user, user)
1435         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1436
1437       assert user_response = json_response(conn, 200)
1438       assert user_response["header"] != User.banner_url(user)
1439     end
1440   end
1441
1442   test "get instance information", %{conn: conn} do
1443     insert(:user, %{local: true})
1444     user = insert(:user, %{local: true})
1445     insert(:user, %{local: false})
1446
1447     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1448
1449     Pleroma.Stats.update_stats()
1450
1451     conn =
1452       conn
1453       |> get("/api/v1/instance")
1454
1455     assert result = json_response(conn, 200)
1456
1457     assert result["stats"]["user_count"] == 2
1458     assert result["stats"]["status_count"] == 1
1459   end
1460
1461   test "put settings", %{conn: conn} do
1462     user = insert(:user)
1463
1464     conn =
1465       conn
1466       |> assign(:user, user)
1467       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
1468
1469     assert result = json_response(conn, 200)
1470
1471     user = User.get_cached_by_ap_id(user.ap_id)
1472     assert user.info.settings == %{"programming" => "socks"}
1473   end
1474 end