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