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       assert Repo.get(Activity, activity.id) == nil
 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   end
 844
 845   describe "user relationships" do
 846     test "returns the relationships for the current user", %{conn: conn} do
 847       user = insert(:user)
 848       other_user = insert(:user)
 849       {:ok, user} = User.follow(user, other_user)
 850
 851       conn =
 852         conn
 853         |> assign(:user, user)
 854         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 855
 856       assert [relationship] = json_response(conn, 200)
 857
 858       assert to_string(other_user.id) == relationship["id"]
 859     end
 860   end
 861
 862   describe "locked accounts" do
 863     test "/api/v1/follow_requests works" do
 864       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 865       other_user = insert(:user)
 866
 867       {:ok, _activity} = ActivityPub.follow(other_user, user)
 868
 869       user = Repo.get(User, user.id)
 870       other_user = Repo.get(User, other_user.id)
 871
 872       assert User.following?(other_user, user) == false
 873
 874       conn =
 875         build_conn()
 876         |> assign(:user, user)
 877         |> get("/api/v1/follow_requests")
 878
 879       assert [relationship] = json_response(conn, 200)
 880       assert to_string(other_user.id) == relationship["id"]
 881     end
 882
 883     test "/api/v1/follow_requests/:id/authorize 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         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
 898
 899       assert relationship = json_response(conn, 200)
 900       assert to_string(other_user.id) == relationship["id"]
 901
 902       user = Repo.get(User, user.id)
 903       other_user = Repo.get(User, other_user.id)
 904
 905       assert User.following?(other_user, user) == true
 906     end
 907
 908     test "verify_credentials", %{conn: conn} do
 909       user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
 910
 911       conn =
 912         conn
 913         |> assign(:user, user)
 914         |> get("/api/v1/accounts/verify_credentials")
 915
 916       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
 917       assert id == to_string(user.id)
 918     end
 919
 920     test "/api/v1/follow_requests/:id/reject works" do
 921       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 922       other_user = insert(:user)
 923
 924       {:ok, _activity} = ActivityPub.follow(other_user, user)
 925
 926       conn =
 927         build_conn()
 928         |> assign(:user, user)
 929         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
 930
 931       assert relationship = json_response(conn, 200)
 932       assert to_string(other_user.id) == relationship["id"]
 933
 934       user = Repo.get(User, user.id)
 935       other_user = Repo.get(User, other_user.id)
 936
 937       assert User.following?(other_user, user) == false
 938     end
 939   end
 940
 941   test "account fetching", %{conn: conn} do
 942     user = insert(:user)
 943
 944     conn =
 945       conn
 946       |> get("/api/v1/accounts/#{user.id}")
 947
 948     assert %{"id" => id} = json_response(conn, 200)
 949     assert id == to_string(user.id)
 950
 951     conn =
 952       build_conn()
 953       |> get("/api/v1/accounts/-1")
 954
 955     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 956   end
 957
 958   test "media upload", %{conn: conn} do
 959     file = %Plug.Upload{
 960       content_type: "image/jpg",
 961       path: Path.absname("test/fixtures/image.jpg"),
 962       filename: "an_image.jpg"
 963     }
 964
 965     desc = "Description of the image"
 966
 967     user = insert(:user)
 968
 969     conn =
 970       conn
 971       |> assign(:user, user)
 972       |> post("/api/v1/media", %{"file" => file, "description" => desc})
 973
 974     assert media = json_response(conn, 200)
 975
 976     assert media["type"] == "image"
 977     assert media["description"] == desc
 978     assert media["id"]
 979
 980     object = Repo.get(Object, media["id"])
 981     assert object.data["actor"] == User.ap_id(user)
 982   end
 983
 984   test "hashtag timeline", %{conn: conn} do
 985     following = insert(:user)
 986
 987     capture_log(fn ->
 988       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 989
 990       {:ok, [_activity]} =
 991         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 992
 993       nconn =
 994         conn
 995         |> get("/api/v1/timelines/tag/2hu")
 996
 997       assert [%{"id" => id}] = json_response(nconn, 200)
 998
 999       assert id == to_string(activity.id)
1000
1001       # works for different capitalization too
1002       nconn =
1003         conn
1004         |> get("/api/v1/timelines/tag/2HU")
1005
1006       assert [%{"id" => id}] = json_response(nconn, 200)
1007
1008       assert id == to_string(activity.id)
1009     end)
1010   end
1011
1012   test "getting followers", %{conn: conn} do
1013     user = insert(:user)
1014     other_user = insert(:user)
1015     {:ok, user} = User.follow(user, other_user)
1016
1017     conn =
1018       conn
1019       |> get("/api/v1/accounts/#{other_user.id}/followers")
1020
1021     assert [%{"id" => id}] = json_response(conn, 200)
1022     assert id == to_string(user.id)
1023   end
1024
1025   test "getting followers, hide_network", %{conn: conn} do
1026     user = insert(:user)
1027     other_user = insert(:user, %{info: %{hide_network: true}})
1028     {:ok, _user} = User.follow(user, other_user)
1029
1030     conn =
1031       conn
1032       |> get("/api/v1/accounts/#{other_user.id}/followers")
1033
1034     assert [] == json_response(conn, 200)
1035   end
1036
1037   test "getting followers, hide_network, same user requesting", %{conn: conn} do
1038     user = insert(:user)
1039     other_user = insert(:user, %{info: %{hide_network: true}})
1040     {:ok, _user} = User.follow(user, other_user)
1041
1042     conn =
1043       conn
1044       |> assign(:user, other_user)
1045       |> get("/api/v1/accounts/#{other_user.id}/followers")
1046
1047     refute [] == json_response(conn, 200)
1048   end
1049
1050   test "getting following", %{conn: conn} do
1051     user = insert(:user)
1052     other_user = insert(:user)
1053     {:ok, user} = User.follow(user, other_user)
1054
1055     conn =
1056       conn
1057       |> get("/api/v1/accounts/#{user.id}/following")
1058
1059     assert [%{"id" => id}] = json_response(conn, 200)
1060     assert id == to_string(other_user.id)
1061   end
1062
1063   test "getting following, hide_network", %{conn: conn} do
1064     user = insert(:user, %{info: %{hide_network: true}})
1065     other_user = insert(:user)
1066     {:ok, user} = User.follow(user, other_user)
1067
1068     conn =
1069       conn
1070       |> get("/api/v1/accounts/#{user.id}/following")
1071
1072     assert [] == json_response(conn, 200)
1073   end
1074
1075   test "getting following, hide_network, same user requesting", %{conn: conn} do
1076     user = insert(:user, %{info: %{hide_network: true}})
1077     other_user = insert(:user)
1078     {:ok, user} = User.follow(user, other_user)
1079
1080     conn =
1081       conn
1082       |> assign(:user, user)
1083       |> get("/api/v1/accounts/#{user.id}/following")
1084
1085     refute [] == json_response(conn, 200)
1086   end
1087
1088   test "following / unfollowing a user", %{conn: conn} do
1089     user = insert(:user)
1090     other_user = insert(:user)
1091
1092     conn =
1093       conn
1094       |> assign(:user, user)
1095       |> post("/api/v1/accounts/#{other_user.id}/follow")
1096
1097     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1098
1099     user = Repo.get(User, user.id)
1100
1101     conn =
1102       build_conn()
1103       |> assign(:user, user)
1104       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1105
1106     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1107
1108     user = Repo.get(User, user.id)
1109
1110     conn =
1111       build_conn()
1112       |> assign(:user, user)
1113       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1114
1115     assert %{"id" => id} = json_response(conn, 200)
1116     assert id == to_string(other_user.id)
1117   end
1118
1119   test "blocking / unblocking a user", %{conn: conn} do
1120     user = insert(:user)
1121     other_user = insert(:user)
1122
1123     conn =
1124       conn
1125       |> assign(:user, user)
1126       |> post("/api/v1/accounts/#{other_user.id}/block")
1127
1128     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1129
1130     user = Repo.get(User, user.id)
1131
1132     conn =
1133       build_conn()
1134       |> assign(:user, user)
1135       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1136
1137     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1138   end
1139
1140   test "getting a list of blocks", %{conn: conn} do
1141     user = insert(:user)
1142     other_user = insert(:user)
1143
1144     {:ok, user} = User.block(user, other_user)
1145
1146     conn =
1147       conn
1148       |> assign(:user, user)
1149       |> get("/api/v1/blocks")
1150
1151     other_user_id = to_string(other_user.id)
1152     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1153   end
1154
1155   test "blocking / unblocking a domain", %{conn: conn} do
1156     user = insert(:user)
1157     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1158
1159     conn =
1160       conn
1161       |> assign(:user, user)
1162       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1163
1164     assert %{} = json_response(conn, 200)
1165     user = User.get_cached_by_ap_id(user.ap_id)
1166     assert User.blocks?(user, other_user)
1167
1168     conn =
1169       build_conn()
1170       |> assign(:user, user)
1171       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1172
1173     assert %{} = json_response(conn, 200)
1174     user = User.get_cached_by_ap_id(user.ap_id)
1175     refute User.blocks?(user, other_user)
1176   end
1177
1178   test "getting a list of domain blocks", %{conn: conn} do
1179     user = insert(:user)
1180
1181     {:ok, user} = User.block_domain(user, "bad.site")
1182     {:ok, user} = User.block_domain(user, "even.worse.site")
1183
1184     conn =
1185       conn
1186       |> assign(:user, user)
1187       |> get("/api/v1/domain_blocks")
1188
1189     domain_blocks = json_response(conn, 200)
1190
1191     assert "bad.site" in domain_blocks
1192     assert "even.worse.site" in domain_blocks
1193   end
1194
1195   test "unimplemented mute endpoints" do
1196     user = insert(:user)
1197     other_user = insert(:user)
1198
1199     ["mute", "unmute"]
1200     |> Enum.each(fn endpoint ->
1201       conn =
1202         build_conn()
1203         |> assign(:user, user)
1204         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1205
1206       assert %{"id" => id} = json_response(conn, 200)
1207       assert id == to_string(other_user.id)
1208     end)
1209   end
1210
1211   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1212     user = insert(:user)
1213
1214     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1215     |> Enum.each(fn endpoint ->
1216       conn =
1217         build_conn()
1218         |> assign(:user, user)
1219         |> get("/api/v1/#{endpoint}")
1220
1221       assert [] = json_response(conn, 200)
1222     end)
1223   end
1224
1225   test "account search", %{conn: conn} do
1226     user = insert(:user)
1227     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1228     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1229
1230     results =
1231       conn
1232       |> assign(:user, user)
1233       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1234       |> json_response(200)
1235
1236     result_ids = for result <- results, do: result["acct"]
1237
1238     assert user_two.nickname in result_ids
1239     assert user_three.nickname in result_ids
1240
1241     results =
1242       conn
1243       |> assign(:user, user)
1244       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1245       |> json_response(200)
1246
1247     result_ids = for result <- results, do: result["acct"]
1248
1249     assert user_three.nickname in result_ids
1250   end
1251
1252   test "search", %{conn: conn} do
1253     user = insert(:user)
1254     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1255     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1256
1257     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1258
1259     {:ok, _activity} =
1260       CommonAPI.post(user, %{
1261         "status" => "This is about 2hu, but private",
1262         "visibility" => "private"
1263       })
1264
1265     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1266
1267     conn =
1268       conn
1269       |> get("/api/v1/search", %{"q" => "2hu"})
1270
1271     assert results = json_response(conn, 200)
1272
1273     [account | _] = results["accounts"]
1274     assert account["id"] == to_string(user_three.id)
1275
1276     assert results["hashtags"] == []
1277
1278     [status] = results["statuses"]
1279     assert status["id"] == to_string(activity.id)
1280   end
1281
1282   test "search fetches remote statuses", %{conn: conn} do
1283     capture_log(fn ->
1284       conn =
1285         conn
1286         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1287
1288       assert results = json_response(conn, 200)
1289
1290       [status] = results["statuses"]
1291       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1292     end)
1293   end
1294
1295   test "search fetches remote accounts", %{conn: conn} do
1296     conn =
1297       conn
1298       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1299
1300     assert results = json_response(conn, 200)
1301     [account] = results["accounts"]
1302     assert account["acct"] == "shp@social.heldscal.la"
1303   end
1304
1305   test "returns the favorites of a user", %{conn: conn} do
1306     user = insert(:user)
1307     other_user = insert(:user)
1308
1309     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1310     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1311
1312     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1313
1314     conn =
1315       conn
1316       |> assign(:user, user)
1317       |> get("/api/v1/favourites")
1318
1319     assert [status] = json_response(conn, 200)
1320     assert status["id"] == to_string(activity.id)
1321   end
1322
1323   describe "updating credentials" do
1324     test "updates the user's bio", %{conn: conn} do
1325       user = insert(:user)
1326       user2 = insert(:user)
1327
1328       conn =
1329         conn
1330         |> assign(:user, user)
1331         |> patch("/api/v1/accounts/update_credentials", %{
1332           "note" => "I drink #cofe with @#{user2.nickname}"
1333         })
1334
1335       assert user = json_response(conn, 200)
1336
1337       assert user["note"] ==
1338                "I drink <a data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span><a data-user=\"#{
1339                  user2.id
1340                }\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
1341     end
1342
1343     test "updates the user's locking status", %{conn: conn} do
1344       user = insert(:user)
1345
1346       conn =
1347         conn
1348         |> assign(:user, user)
1349         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1350
1351       assert user = json_response(conn, 200)
1352       assert user["locked"] == true
1353     end
1354
1355     test "updates the user's name", %{conn: conn} do
1356       user = insert(:user)
1357
1358       conn =
1359         conn
1360         |> assign(:user, user)
1361         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1362
1363       assert user = json_response(conn, 200)
1364       assert user["display_name"] == "markorepairs"
1365     end
1366
1367     test "updates the user's avatar", %{conn: conn} do
1368       user = insert(:user)
1369
1370       new_avatar = %Plug.Upload{
1371         content_type: "image/jpg",
1372         path: Path.absname("test/fixtures/image.jpg"),
1373         filename: "an_image.jpg"
1374       }
1375
1376       conn =
1377         conn
1378         |> assign(:user, user)
1379         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1380
1381       assert user_response = json_response(conn, 200)
1382       assert user_response["avatar"] != User.avatar_url(user)
1383     end
1384
1385     test "updates the user's banner", %{conn: conn} do
1386       user = insert(:user)
1387
1388       new_header = %Plug.Upload{
1389         content_type: "image/jpg",
1390         path: Path.absname("test/fixtures/image.jpg"),
1391         filename: "an_image.jpg"
1392       }
1393
1394       conn =
1395         conn
1396         |> assign(:user, user)
1397         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1398
1399       assert user_response = json_response(conn, 200)
1400       assert user_response["header"] != User.banner_url(user)
1401     end
1402   end
1403
1404   test "get instance information", %{conn: conn} do
1405     insert(:user, %{local: true})
1406     user = insert(:user, %{local: true})
1407     insert(:user, %{local: false})
1408
1409     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1410
1411     Pleroma.Stats.update_stats()
1412
1413     conn =
1414       conn
1415       |> get("/api/v1/instance")
1416
1417     assert result = json_response(conn, 200)
1418
1419     assert result["stats"]["user_count"] == 2
1420     assert result["stats"]["status_count"] == 1
1421   end
1422
1423   test "put settings", %{conn: conn} do
1424     user = insert(:user)
1425
1426     conn =
1427       conn
1428       |> assign(:user, user)
1429       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
1430
1431     assert result = json_response(conn, 200)
1432
1433     user = User.get_cached_by_ap_id(user.ap_id)
1434     assert user.info.settings == %{"programming" => "socks"}
1435   end
1436 end