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