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-2019 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 class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
 604           user.ap_id
 605         }\">@<span>#{user.nickname}</span></a></span>"
 606
 607       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 608       assert response == expected_response
 609     end
 610
 611     test "getting a single notification", %{conn: conn} do
 612       user = insert(:user)
 613       other_user = insert(:user)
 614
 615       {:ok, activity} =
 616         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 617
 618       {:ok, [notification]} = Notification.create_notifications(activity)
 619
 620       conn =
 621         conn
 622         |> assign(:user, user)
 623         |> get("/api/v1/notifications/#{notification.id}")
 624
 625       expected_response =
 626         "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
 627           user.ap_id
 628         }\">@<span>#{user.nickname}</span></a></span>"
 629
 630       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 631       assert response == expected_response
 632     end
 633
 634     test "dismissing a single notification", %{conn: conn} do
 635       user = insert(:user)
 636       other_user = insert(:user)
 637
 638       {:ok, activity} =
 639         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 640
 641       {:ok, [notification]} = Notification.create_notifications(activity)
 642
 643       conn =
 644         conn
 645         |> assign(:user, user)
 646         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 647
 648       assert %{} = json_response(conn, 200)
 649     end
 650
 651     test "clearing all notifications", %{conn: conn} do
 652       user = insert(:user)
 653       other_user = insert(:user)
 654
 655       {:ok, activity} =
 656         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 657
 658       {:ok, [_notification]} = Notification.create_notifications(activity)
 659
 660       conn =
 661         conn
 662         |> assign(:user, user)
 663         |> post("/api/v1/notifications/clear")
 664
 665       assert %{} = json_response(conn, 200)
 666
 667       conn =
 668         build_conn()
 669         |> assign(:user, user)
 670         |> get("/api/v1/notifications")
 671
 672       assert all = json_response(conn, 200)
 673       assert all == []
 674     end
 675   end
 676
 677   describe "reblogging" do
 678     test "reblogs and returns the reblogged status", %{conn: conn} do
 679       activity = insert(:note_activity)
 680       user = insert(:user)
 681
 682       conn =
 683         conn
 684         |> assign(:user, user)
 685         |> post("/api/v1/statuses/#{activity.id}/reblog")
 686
 687       assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 688                json_response(conn, 200)
 689
 690       assert to_string(activity.id) == id
 691     end
 692   end
 693
 694   describe "unreblogging" do
 695     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 696       activity = insert(:note_activity)
 697       user = insert(:user)
 698
 699       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 700
 701       conn =
 702         conn
 703         |> assign(:user, user)
 704         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 705
 706       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 707
 708       assert to_string(activity.id) == id
 709     end
 710   end
 711
 712   describe "favoriting" do
 713     test "favs a status and returns it", %{conn: conn} do
 714       activity = insert(:note_activity)
 715       user = insert(:user)
 716
 717       conn =
 718         conn
 719         |> assign(:user, user)
 720         |> post("/api/v1/statuses/#{activity.id}/favourite")
 721
 722       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 723                json_response(conn, 200)
 724
 725       assert to_string(activity.id) == id
 726     end
 727
 728     test "returns 500 for a wrong id", %{conn: conn} do
 729       user = insert(:user)
 730
 731       resp =
 732         conn
 733         |> assign(:user, user)
 734         |> post("/api/v1/statuses/1/favourite")
 735         |> json_response(500)
 736
 737       assert resp == "Something went wrong"
 738     end
 739   end
 740
 741   describe "unfavoriting" do
 742     test "unfavorites a status and returns it", %{conn: conn} do
 743       activity = insert(:note_activity)
 744       user = insert(:user)
 745
 746       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 747
 748       conn =
 749         conn
 750         |> assign(:user, user)
 751         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 752
 753       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 754                json_response(conn, 200)
 755
 756       assert to_string(activity.id) == id
 757     end
 758   end
 759
 760   describe "user timelines" do
 761     test "gets a users statuses", %{conn: conn} do
 762       user_one = insert(:user)
 763       user_two = insert(:user)
 764       user_three = insert(:user)
 765
 766       {:ok, user_three} = User.follow(user_three, user_one)
 767
 768       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
 769
 770       {:ok, direct_activity} =
 771         CommonAPI.post(user_one, %{
 772           "status" => "Hi, @#{user_two.nickname}.",
 773           "visibility" => "direct"
 774         })
 775
 776       {:ok, private_activity} =
 777         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
 778
 779       resp =
 780         conn
 781         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 782
 783       assert [%{"id" => id}] = json_response(resp, 200)
 784       assert id == to_string(activity.id)
 785
 786       resp =
 787         conn
 788         |> assign(:user, user_two)
 789         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 790
 791       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 792       assert id_one == to_string(direct_activity.id)
 793       assert id_two == to_string(activity.id)
 794
 795       resp =
 796         conn
 797         |> assign(:user, user_three)
 798         |> get("/api/v1/accounts/#{user_one.id}/statuses")
 799
 800       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
 801       assert id_one == to_string(private_activity.id)
 802       assert id_two == to_string(activity.id)
 803     end
 804
 805     test "unimplemented pinned statuses feature", %{conn: conn} do
 806       note = insert(:note_activity)
 807       user = User.get_by_ap_id(note.data["actor"])
 808
 809       conn =
 810         conn
 811         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 812
 813       assert json_response(conn, 200) == []
 814     end
 815
 816     test "gets an users media", %{conn: conn} do
 817       note = insert(:note_activity)
 818       user = User.get_by_ap_id(note.data["actor"])
 819
 820       file = %Plug.Upload{
 821         content_type: "image/jpg",
 822         path: Path.absname("test/fixtures/image.jpg"),
 823         filename: "an_image.jpg"
 824       }
 825
 826       media =
 827         TwitterAPI.upload(file, user, "json")
 828         |> Poison.decode!()
 829
 830       {:ok, image_post} =
 831         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
 832
 833       conn =
 834         conn
 835         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
 836
 837       assert [%{"id" => id}] = json_response(conn, 200)
 838       assert id == to_string(image_post.id)
 839
 840       conn =
 841         build_conn()
 842         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
 843
 844       assert [%{"id" => id}] = json_response(conn, 200)
 845       assert id == to_string(image_post.id)
 846     end
 847
 848     test "gets a user's statuses without reblogs", %{conn: conn} do
 849       user = insert(:user)
 850       {:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
 851       {:ok, _, _} = CommonAPI.repeat(post.id, user)
 852
 853       conn =
 854         conn
 855         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})
 856
 857       assert [%{"id" => id}] = json_response(conn, 200)
 858       assert id == to_string(post.id)
 859
 860       conn =
 861         conn
 862         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})
 863
 864       assert [%{"id" => id}] = json_response(conn, 200)
 865       assert id == to_string(post.id)
 866     end
 867   end
 868
 869   describe "user relationships" do
 870     test "returns the relationships for the current user", %{conn: conn} do
 871       user = insert(:user)
 872       other_user = insert(:user)
 873       {:ok, user} = User.follow(user, other_user)
 874
 875       conn =
 876         conn
 877         |> assign(:user, user)
 878         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 879
 880       assert [relationship] = json_response(conn, 200)
 881
 882       assert to_string(other_user.id) == relationship["id"]
 883     end
 884   end
 885
 886   describe "locked accounts" do
 887     test "/api/v1/follow_requests works" do
 888       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 889       other_user = insert(:user)
 890
 891       {:ok, _activity} = ActivityPub.follow(other_user, user)
 892
 893       user = Repo.get(User, user.id)
 894       other_user = Repo.get(User, other_user.id)
 895
 896       assert User.following?(other_user, user) == false
 897
 898       conn =
 899         build_conn()
 900         |> assign(:user, user)
 901         |> get("/api/v1/follow_requests")
 902
 903       assert [relationship] = json_response(conn, 200)
 904       assert to_string(other_user.id) == relationship["id"]
 905     end
 906
 907     test "/api/v1/follow_requests/:id/authorize works" do
 908       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 909       other_user = insert(:user)
 910
 911       {:ok, _activity} = ActivityPub.follow(other_user, user)
 912
 913       user = Repo.get(User, user.id)
 914       other_user = Repo.get(User, other_user.id)
 915
 916       assert User.following?(other_user, user) == false
 917
 918       conn =
 919         build_conn()
 920         |> assign(:user, user)
 921         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
 922
 923       assert relationship = json_response(conn, 200)
 924       assert to_string(other_user.id) == relationship["id"]
 925
 926       user = Repo.get(User, user.id)
 927       other_user = Repo.get(User, other_user.id)
 928
 929       assert User.following?(other_user, user) == true
 930     end
 931
 932     test "verify_credentials", %{conn: conn} do
 933       user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
 934
 935       conn =
 936         conn
 937         |> assign(:user, user)
 938         |> get("/api/v1/accounts/verify_credentials")
 939
 940       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
 941       assert id == to_string(user.id)
 942     end
 943
 944     test "/api/v1/follow_requests/:id/reject works" do
 945       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
 946       other_user = insert(:user)
 947
 948       {:ok, _activity} = ActivityPub.follow(other_user, user)
 949
 950       conn =
 951         build_conn()
 952         |> assign(:user, user)
 953         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
 954
 955       assert relationship = json_response(conn, 200)
 956       assert to_string(other_user.id) == relationship["id"]
 957
 958       user = Repo.get(User, user.id)
 959       other_user = Repo.get(User, other_user.id)
 960
 961       assert User.following?(other_user, user) == false
 962     end
 963   end
 964
 965   test "account fetching", %{conn: conn} do
 966     user = insert(:user)
 967
 968     conn =
 969       conn
 970       |> get("/api/v1/accounts/#{user.id}")
 971
 972     assert %{"id" => id} = json_response(conn, 200)
 973     assert id == to_string(user.id)
 974
 975     conn =
 976       build_conn()
 977       |> get("/api/v1/accounts/-1")
 978
 979     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 980   end
 981
 982   test "media upload", %{conn: conn} do
 983     file = %Plug.Upload{
 984       content_type: "image/jpg",
 985       path: Path.absname("test/fixtures/image.jpg"),
 986       filename: "an_image.jpg"
 987     }
 988
 989     desc = "Description of the image"
 990
 991     user = insert(:user)
 992
 993     conn =
 994       conn
 995       |> assign(:user, user)
 996       |> post("/api/v1/media", %{"file" => file, "description" => desc})
 997
 998     assert media = json_response(conn, 200)
 999
1000     assert media["type"] == "image"
1001     assert media["description"] == desc
1002     assert media["id"]
1003
1004     object = Repo.get(Object, media["id"])
1005     assert object.data["actor"] == User.ap_id(user)
1006   end
1007
1008   test "hashtag timeline", %{conn: conn} do
1009     following = insert(:user)
1010
1011     capture_log(fn ->
1012       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
1013
1014       {:ok, [_activity]} =
1015         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
1016
1017       nconn =
1018         conn
1019         |> get("/api/v1/timelines/tag/2hu")
1020
1021       assert [%{"id" => id}] = json_response(nconn, 200)
1022
1023       assert id == to_string(activity.id)
1024
1025       # works for different capitalization too
1026       nconn =
1027         conn
1028         |> get("/api/v1/timelines/tag/2HU")
1029
1030       assert [%{"id" => id}] = json_response(nconn, 200)
1031
1032       assert id == to_string(activity.id)
1033     end)
1034   end
1035
1036   test "getting followers", %{conn: conn} do
1037     user = insert(:user)
1038     other_user = insert(:user)
1039     {:ok, user} = User.follow(user, other_user)
1040
1041     conn =
1042       conn
1043       |> get("/api/v1/accounts/#{other_user.id}/followers")
1044
1045     assert [%{"id" => id}] = json_response(conn, 200)
1046     assert id == to_string(user.id)
1047   end
1048
1049   test "getting followers, hide_network", %{conn: conn} do
1050     user = insert(:user)
1051     other_user = insert(:user, %{info: %{hide_network: true}})
1052     {:ok, _user} = User.follow(user, other_user)
1053
1054     conn =
1055       conn
1056       |> get("/api/v1/accounts/#{other_user.id}/followers")
1057
1058     assert [] == json_response(conn, 200)
1059   end
1060
1061   test "getting followers, hide_network, same user requesting", %{conn: conn} do
1062     user = insert(:user)
1063     other_user = insert(:user, %{info: %{hide_network: true}})
1064     {:ok, _user} = User.follow(user, other_user)
1065
1066     conn =
1067       conn
1068       |> assign(:user, other_user)
1069       |> get("/api/v1/accounts/#{other_user.id}/followers")
1070
1071     refute [] == json_response(conn, 200)
1072   end
1073
1074   test "getting following", %{conn: conn} do
1075     user = insert(:user)
1076     other_user = insert(:user)
1077     {:ok, user} = User.follow(user, other_user)
1078
1079     conn =
1080       conn
1081       |> get("/api/v1/accounts/#{user.id}/following")
1082
1083     assert [%{"id" => id}] = json_response(conn, 200)
1084     assert id == to_string(other_user.id)
1085   end
1086
1087   test "getting following, hide_network", %{conn: conn} do
1088     user = insert(:user, %{info: %{hide_network: true}})
1089     other_user = insert(:user)
1090     {:ok, user} = User.follow(user, other_user)
1091
1092     conn =
1093       conn
1094       |> get("/api/v1/accounts/#{user.id}/following")
1095
1096     assert [] == json_response(conn, 200)
1097   end
1098
1099   test "getting following, hide_network, same user requesting", %{conn: conn} do
1100     user = insert(:user, %{info: %{hide_network: true}})
1101     other_user = insert(:user)
1102     {:ok, user} = User.follow(user, other_user)
1103
1104     conn =
1105       conn
1106       |> assign(:user, user)
1107       |> get("/api/v1/accounts/#{user.id}/following")
1108
1109     refute [] == json_response(conn, 200)
1110   end
1111
1112   test "following / unfollowing a user", %{conn: conn} do
1113     user = insert(:user)
1114     other_user = insert(:user)
1115
1116     conn =
1117       conn
1118       |> assign(:user, user)
1119       |> post("/api/v1/accounts/#{other_user.id}/follow")
1120
1121     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1122
1123     user = Repo.get(User, user.id)
1124
1125     conn =
1126       build_conn()
1127       |> assign(:user, user)
1128       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1129
1130     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1131
1132     user = Repo.get(User, user.id)
1133
1134     conn =
1135       build_conn()
1136       |> assign(:user, user)
1137       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1138
1139     assert %{"id" => id} = json_response(conn, 200)
1140     assert id == to_string(other_user.id)
1141   end
1142
1143   test "blocking / unblocking a user", %{conn: conn} do
1144     user = insert(:user)
1145     other_user = insert(:user)
1146
1147     conn =
1148       conn
1149       |> assign(:user, user)
1150       |> post("/api/v1/accounts/#{other_user.id}/block")
1151
1152     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1153
1154     user = Repo.get(User, user.id)
1155
1156     conn =
1157       build_conn()
1158       |> assign(:user, user)
1159       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1160
1161     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1162   end
1163
1164   test "getting a list of blocks", %{conn: conn} do
1165     user = insert(:user)
1166     other_user = insert(:user)
1167
1168     {:ok, user} = User.block(user, other_user)
1169
1170     conn =
1171       conn
1172       |> assign(:user, user)
1173       |> get("/api/v1/blocks")
1174
1175     other_user_id = to_string(other_user.id)
1176     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1177   end
1178
1179   test "blocking / unblocking a domain", %{conn: conn} do
1180     user = insert(:user)
1181     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1182
1183     conn =
1184       conn
1185       |> assign(:user, user)
1186       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1187
1188     assert %{} = json_response(conn, 200)
1189     user = User.get_cached_by_ap_id(user.ap_id)
1190     assert User.blocks?(user, other_user)
1191
1192     conn =
1193       build_conn()
1194       |> assign(:user, user)
1195       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1196
1197     assert %{} = json_response(conn, 200)
1198     user = User.get_cached_by_ap_id(user.ap_id)
1199     refute User.blocks?(user, other_user)
1200   end
1201
1202   test "getting a list of domain blocks", %{conn: conn} do
1203     user = insert(:user)
1204
1205     {:ok, user} = User.block_domain(user, "bad.site")
1206     {:ok, user} = User.block_domain(user, "even.worse.site")
1207
1208     conn =
1209       conn
1210       |> assign(:user, user)
1211       |> get("/api/v1/domain_blocks")
1212
1213     domain_blocks = json_response(conn, 200)
1214
1215     assert "bad.site" in domain_blocks
1216     assert "even.worse.site" in domain_blocks
1217   end
1218
1219   test "unimplemented mute endpoints" do
1220     user = insert(:user)
1221     other_user = insert(:user)
1222
1223     ["mute", "unmute"]
1224     |> Enum.each(fn endpoint ->
1225       conn =
1226         build_conn()
1227         |> assign(:user, user)
1228         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1229
1230       assert %{"id" => id} = json_response(conn, 200)
1231       assert id == to_string(other_user.id)
1232     end)
1233   end
1234
1235   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1236     user = insert(:user)
1237
1238     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1239     |> Enum.each(fn endpoint ->
1240       conn =
1241         build_conn()
1242         |> assign(:user, user)
1243         |> get("/api/v1/#{endpoint}")
1244
1245       assert [] = json_response(conn, 200)
1246     end)
1247   end
1248
1249   test "account search", %{conn: conn} do
1250     user = insert(:user)
1251     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1252     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1253
1254     results =
1255       conn
1256       |> assign(:user, user)
1257       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1258       |> json_response(200)
1259
1260     result_ids = for result <- results, do: result["acct"]
1261
1262     assert user_two.nickname in result_ids
1263     assert user_three.nickname in result_ids
1264
1265     results =
1266       conn
1267       |> assign(:user, user)
1268       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1269       |> json_response(200)
1270
1271     result_ids = for result <- results, do: result["acct"]
1272
1273     assert user_three.nickname in result_ids
1274   end
1275
1276   test "search", %{conn: conn} do
1277     user = insert(:user)
1278     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1279     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1280
1281     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1282
1283     {:ok, _activity} =
1284       CommonAPI.post(user, %{
1285         "status" => "This is about 2hu, but private",
1286         "visibility" => "private"
1287       })
1288
1289     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1290
1291     conn =
1292       conn
1293       |> get("/api/v1/search", %{"q" => "2hu"})
1294
1295     assert results = json_response(conn, 200)
1296
1297     [account | _] = results["accounts"]
1298     assert account["id"] == to_string(user_three.id)
1299
1300     assert results["hashtags"] == []
1301
1302     [status] = results["statuses"]
1303     assert status["id"] == to_string(activity.id)
1304   end
1305
1306   test "search fetches remote statuses", %{conn: conn} do
1307     capture_log(fn ->
1308       conn =
1309         conn
1310         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1311
1312       assert results = json_response(conn, 200)
1313
1314       [status] = results["statuses"]
1315       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1316     end)
1317   end
1318
1319   test "search doesn't show statuses that it shouldn't", %{conn: conn} do
1320     {:ok, activity} =
1321       CommonAPI.post(insert(:user), %{
1322         "status" => "This is about 2hu, but private",
1323         "visibility" => "private"
1324       })
1325
1326     capture_log(fn ->
1327       conn =
1328         conn
1329         |> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})
1330
1331       assert results = json_response(conn, 200)
1332
1333       [] = results["statuses"]
1334     end)
1335   end
1336
1337   test "search fetches remote accounts", %{conn: conn} do
1338     conn =
1339       conn
1340       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1341
1342     assert results = json_response(conn, 200)
1343     [account] = results["accounts"]
1344     assert account["acct"] == "shp@social.heldscal.la"
1345   end
1346
1347   test "returns the favorites of a user", %{conn: conn} do
1348     user = insert(:user)
1349     other_user = insert(:user)
1350
1351     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1352     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1353
1354     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1355
1356     first_conn =
1357       conn
1358       |> assign(:user, user)
1359       |> get("/api/v1/favourites")
1360
1361     assert [status] = json_response(first_conn, 200)
1362     assert status["id"] == to_string(activity.id)
1363
1364     assert [{"link", _link_header}] =
1365              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1366
1367     # Honours query params
1368     {:ok, second_activity} =
1369       CommonAPI.post(other_user, %{
1370         "status" =>
1371           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1372       })
1373
1374     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
1375
1376     last_like = status["id"]
1377
1378     second_conn =
1379       conn
1380       |> assign(:user, user)
1381       |> get("/api/v1/favourites?since_id=#{last_like}")
1382
1383     assert [second_status] = json_response(second_conn, 200)
1384     assert second_status["id"] == to_string(second_activity.id)
1385
1386     third_conn =
1387       conn
1388       |> assign(:user, user)
1389       |> get("/api/v1/favourites?limit=0")
1390
1391     assert [] = json_response(third_conn, 200)
1392   end
1393
1394   describe "updating credentials" do
1395     test "updates the user's bio", %{conn: conn} do
1396       user = insert(:user)
1397       user2 = insert(:user)
1398
1399       conn =
1400         conn
1401         |> assign(:user, user)
1402         |> patch("/api/v1/accounts/update_credentials", %{
1403           "note" => "I drink #cofe with @#{user2.nickname}"
1404         })
1405
1406       assert user = json_response(conn, 200)
1407
1408       assert user["note"] ==
1409                "I drink <a class=\"hashtag\" data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span class=\"h-card\"><a data-user=\"#{
1410                  user2.id
1411                }\" class=\"u-url mention\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
1412     end
1413
1414     test "updates the user's locking status", %{conn: conn} do
1415       user = insert(:user)
1416
1417       conn =
1418         conn
1419         |> assign(:user, user)
1420         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1421
1422       assert user = json_response(conn, 200)
1423       assert user["locked"] == true
1424     end
1425
1426     test "updates the user's name", %{conn: conn} do
1427       user = insert(:user)
1428
1429       conn =
1430         conn
1431         |> assign(:user, user)
1432         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1433
1434       assert user = json_response(conn, 200)
1435       assert user["display_name"] == "markorepairs"
1436     end
1437
1438     test "updates the user's avatar", %{conn: conn} do
1439       user = insert(:user)
1440
1441       new_avatar = %Plug.Upload{
1442         content_type: "image/jpg",
1443         path: Path.absname("test/fixtures/image.jpg"),
1444         filename: "an_image.jpg"
1445       }
1446
1447       conn =
1448         conn
1449         |> assign(:user, user)
1450         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1451
1452       assert user_response = json_response(conn, 200)
1453       assert user_response["avatar"] != User.avatar_url(user)
1454     end
1455
1456     test "updates the user's banner", %{conn: conn} do
1457       user = insert(:user)
1458
1459       new_header = %Plug.Upload{
1460         content_type: "image/jpg",
1461         path: Path.absname("test/fixtures/image.jpg"),
1462         filename: "an_image.jpg"
1463       }
1464
1465       conn =
1466         conn
1467         |> assign(:user, user)
1468         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1469
1470       assert user_response = json_response(conn, 200)
1471       assert user_response["header"] != User.banner_url(user)
1472     end
1473   end
1474
1475   test "get instance information", %{conn: conn} do
1476     insert(:user, %{local: true})
1477     user = insert(:user, %{local: true})
1478     insert(:user, %{local: false, nickname: "u@peer1.com"})
1479     insert(:user, %{local: false, nickname: "u@peer2.com"})
1480
1481     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1482
1483     Pleroma.Stats.update_stats()
1484
1485     conn = get(conn, "/api/v1/instance")
1486
1487     assert result = json_response(conn, 200)
1488
1489     stats = result["stats"]
1490
1491     assert stats
1492     assert stats["user_count"] == 2
1493     assert stats["status_count"] == 1
1494     assert stats["domain_count"] == 2
1495   end
1496
1497   test "get peers", %{conn: conn} do
1498     insert(:user, %{local: false, nickname: "u@peer1.com"})
1499     insert(:user, %{local: false, nickname: "u@peer2.com"})
1500
1501     Pleroma.Stats.update_stats()
1502
1503     conn = get(conn, "/api/v1/instance/peers")
1504
1505     assert result = json_response(conn, 200)
1506
1507     assert ["peer1.com", "peer2.com"] == Enum.sort(result)
1508   end
1509
1510   test "put settings", %{conn: conn} do
1511     user = insert(:user)
1512
1513     conn =
1514       conn
1515       |> assign(:user, user)
1516       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
1517
1518     assert _result = json_response(conn, 200)
1519
1520     user = User.get_cached_by_ap_id(user.ap_id)
1521     assert user.info.settings == %{"programming" => "socks"}
1522   end
1523
1524   describe "pinned statuses" do
1525     setup do
1526       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
1527
1528       user = insert(:user)
1529       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
1530
1531       [user: user, activity: activity]
1532     end
1533
1534     test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
1535       {:ok, _} = CommonAPI.pin(activity.id, user)
1536
1537       result =
1538         conn
1539         |> assign(:user, user)
1540         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1541         |> json_response(200)
1542
1543       id_str = to_string(activity.id)
1544
1545       assert [%{"id" => ^id_str, "pinned" => true}] = result
1546     end
1547
1548     test "pin status", %{conn: conn, user: user, activity: activity} do
1549       id_str = to_string(activity.id)
1550
1551       assert %{"id" => ^id_str, "pinned" => true} =
1552                conn
1553                |> assign(:user, user)
1554                |> post("/api/v1/statuses/#{activity.id}/pin")
1555                |> json_response(200)
1556
1557       assert [%{"id" => ^id_str, "pinned" => true}] =
1558                conn
1559                |> assign(:user, user)
1560                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1561                |> json_response(200)
1562     end
1563
1564     test "unpin status", %{conn: conn, user: user, activity: activity} do
1565       {:ok, _} = CommonAPI.pin(activity.id, user)
1566
1567       id_str = to_string(activity.id)
1568       user = refresh_record(user)
1569
1570       assert %{"id" => ^id_str, "pinned" => false} =
1571                conn
1572                |> assign(:user, user)
1573                |> post("/api/v1/statuses/#{activity.id}/unpin")
1574                |> json_response(200)
1575
1576       assert [] =
1577                conn
1578                |> assign(:user, user)
1579                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1580                |> json_response(200)
1581     end
1582
1583     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
1584       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1585
1586       id_str_one = to_string(activity_one.id)
1587
1588       assert %{"id" => ^id_str_one, "pinned" => true} =
1589                conn
1590                |> assign(:user, user)
1591                |> post("/api/v1/statuses/#{id_str_one}/pin")
1592                |> json_response(200)
1593
1594       user = refresh_record(user)
1595
1596       assert %{"error" => "You have already pinned the maximum number of statuses"} =
1597                conn
1598                |> assign(:user, user)
1599                |> post("/api/v1/statuses/#{activity_two.id}/pin")
1600                |> json_response(400)
1601     end
1602   end
1603 end