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 "multi-hashtag timeline", %{conn: conn} do
1048     user = insert(:user)
1049
1050     {:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
1051     {:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test1"})
1052     {:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})
1053
1054     all_test =
1055       conn
1056       |> get("/api/v1/timelines/tag/test", %{"all" => ["test1"]})
1057
1058     assert [status_none, status_test1, status_test] = json_response(all_test, 200)
1059
1060     assert to_string(activity_test.id) == status_test["id"]
1061     assert to_string(activity_test1.id) == status_test1["id"]
1062     assert to_string(activity_none.id) == status_none["id"]
1063
1064     restricted_test =
1065       conn
1066       |> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})
1067
1068     assert [status_test1, status_test] == json_response(restricted_test, 200)
1069   end
1070
1071   test "getting followers", %{conn: conn} do
1072     user = insert(:user)
1073     other_user = insert(:user)
1074     {:ok, user} = User.follow(user, other_user)
1075
1076     conn =
1077       conn
1078       |> get("/api/v1/accounts/#{other_user.id}/followers")
1079
1080     assert [%{"id" => id}] = json_response(conn, 200)
1081     assert id == to_string(user.id)
1082   end
1083
1084   test "getting followers, hide_network", %{conn: conn} do
1085     user = insert(:user)
1086     other_user = insert(:user, %{info: %{hide_network: true}})
1087     {:ok, _user} = User.follow(user, other_user)
1088
1089     conn =
1090       conn
1091       |> get("/api/v1/accounts/#{other_user.id}/followers")
1092
1093     assert [] == json_response(conn, 200)
1094   end
1095
1096   test "getting followers, hide_network, same user requesting", %{conn: conn} do
1097     user = insert(:user)
1098     other_user = insert(:user, %{info: %{hide_network: true}})
1099     {:ok, _user} = User.follow(user, other_user)
1100
1101     conn =
1102       conn
1103       |> assign(:user, other_user)
1104       |> get("/api/v1/accounts/#{other_user.id}/followers")
1105
1106     refute [] == json_response(conn, 200)
1107   end
1108
1109   test "getting following", %{conn: conn} do
1110     user = insert(:user)
1111     other_user = insert(:user)
1112     {:ok, user} = User.follow(user, other_user)
1113
1114     conn =
1115       conn
1116       |> get("/api/v1/accounts/#{user.id}/following")
1117
1118     assert [%{"id" => id}] = json_response(conn, 200)
1119     assert id == to_string(other_user.id)
1120   end
1121
1122   test "getting following, hide_network", %{conn: conn} do
1123     user = insert(:user, %{info: %{hide_network: true}})
1124     other_user = insert(:user)
1125     {:ok, user} = User.follow(user, other_user)
1126
1127     conn =
1128       conn
1129       |> get("/api/v1/accounts/#{user.id}/following")
1130
1131     assert [] == json_response(conn, 200)
1132   end
1133
1134   test "getting following, hide_network, same user requesting", %{conn: conn} do
1135     user = insert(:user, %{info: %{hide_network: true}})
1136     other_user = insert(:user)
1137     {:ok, user} = User.follow(user, other_user)
1138
1139     conn =
1140       conn
1141       |> assign(:user, user)
1142       |> get("/api/v1/accounts/#{user.id}/following")
1143
1144     refute [] == json_response(conn, 200)
1145   end
1146
1147   test "following / unfollowing a user", %{conn: conn} do
1148     user = insert(:user)
1149     other_user = insert(:user)
1150
1151     conn =
1152       conn
1153       |> assign(:user, user)
1154       |> post("/api/v1/accounts/#{other_user.id}/follow")
1155
1156     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1157
1158     user = Repo.get(User, user.id)
1159
1160     conn =
1161       build_conn()
1162       |> assign(:user, user)
1163       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1164
1165     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1166
1167     user = Repo.get(User, user.id)
1168
1169     conn =
1170       build_conn()
1171       |> assign(:user, user)
1172       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1173
1174     assert %{"id" => id} = json_response(conn, 200)
1175     assert id == to_string(other_user.id)
1176   end
1177
1178   test "blocking / unblocking a user", %{conn: conn} do
1179     user = insert(:user)
1180     other_user = insert(:user)
1181
1182     conn =
1183       conn
1184       |> assign(:user, user)
1185       |> post("/api/v1/accounts/#{other_user.id}/block")
1186
1187     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1188
1189     user = Repo.get(User, user.id)
1190
1191     conn =
1192       build_conn()
1193       |> assign(:user, user)
1194       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1195
1196     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1197   end
1198
1199   test "getting a list of blocks", %{conn: conn} do
1200     user = insert(:user)
1201     other_user = insert(:user)
1202
1203     {:ok, user} = User.block(user, other_user)
1204
1205     conn =
1206       conn
1207       |> assign(:user, user)
1208       |> get("/api/v1/blocks")
1209
1210     other_user_id = to_string(other_user.id)
1211     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1212   end
1213
1214   test "blocking / unblocking a domain", %{conn: conn} do
1215     user = insert(:user)
1216     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1217
1218     conn =
1219       conn
1220       |> assign(:user, user)
1221       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1222
1223     assert %{} = json_response(conn, 200)
1224     user = User.get_cached_by_ap_id(user.ap_id)
1225     assert User.blocks?(user, other_user)
1226
1227     conn =
1228       build_conn()
1229       |> assign(:user, user)
1230       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1231
1232     assert %{} = json_response(conn, 200)
1233     user = User.get_cached_by_ap_id(user.ap_id)
1234     refute User.blocks?(user, other_user)
1235   end
1236
1237   test "getting a list of domain blocks", %{conn: conn} do
1238     user = insert(:user)
1239
1240     {:ok, user} = User.block_domain(user, "bad.site")
1241     {:ok, user} = User.block_domain(user, "even.worse.site")
1242
1243     conn =
1244       conn
1245       |> assign(:user, user)
1246       |> get("/api/v1/domain_blocks")
1247
1248     domain_blocks = json_response(conn, 200)
1249
1250     assert "bad.site" in domain_blocks
1251     assert "even.worse.site" in domain_blocks
1252   end
1253
1254   test "unimplemented mute endpoints" do
1255     user = insert(:user)
1256     other_user = insert(:user)
1257
1258     ["mute", "unmute"]
1259     |> Enum.each(fn endpoint ->
1260       conn =
1261         build_conn()
1262         |> assign(:user, user)
1263         |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1264
1265       assert %{"id" => id} = json_response(conn, 200)
1266       assert id == to_string(other_user.id)
1267     end)
1268   end
1269
1270   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1271     user = insert(:user)
1272
1273     ["blocks", "domain_blocks", "mutes", "follow_requests"]
1274     |> Enum.each(fn endpoint ->
1275       conn =
1276         build_conn()
1277         |> assign(:user, user)
1278         |> get("/api/v1/#{endpoint}")
1279
1280       assert [] = json_response(conn, 200)
1281     end)
1282   end
1283
1284   test "account search", %{conn: conn} do
1285     user = insert(:user)
1286     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1287     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1288
1289     results =
1290       conn
1291       |> assign(:user, user)
1292       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1293       |> json_response(200)
1294
1295     result_ids = for result <- results, do: result["acct"]
1296
1297     assert user_two.nickname in result_ids
1298     assert user_three.nickname in result_ids
1299
1300     results =
1301       conn
1302       |> assign(:user, user)
1303       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1304       |> json_response(200)
1305
1306     result_ids = for result <- results, do: result["acct"]
1307
1308     assert user_three.nickname in result_ids
1309   end
1310
1311   test "search", %{conn: conn} do
1312     user = insert(:user)
1313     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1314     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1315
1316     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1317
1318     {:ok, _activity} =
1319       CommonAPI.post(user, %{
1320         "status" => "This is about 2hu, but private",
1321         "visibility" => "private"
1322       })
1323
1324     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1325
1326     conn =
1327       conn
1328       |> get("/api/v1/search", %{"q" => "2hu"})
1329
1330     assert results = json_response(conn, 200)
1331
1332     [account | _] = results["accounts"]
1333     assert account["id"] == to_string(user_three.id)
1334
1335     assert results["hashtags"] == []
1336
1337     [status] = results["statuses"]
1338     assert status["id"] == to_string(activity.id)
1339   end
1340
1341   test "search fetches remote statuses", %{conn: conn} do
1342     capture_log(fn ->
1343       conn =
1344         conn
1345         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1346
1347       assert results = json_response(conn, 200)
1348
1349       [status] = results["statuses"]
1350       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1351     end)
1352   end
1353
1354   test "search doesn't show statuses that it shouldn't", %{conn: conn} do
1355     {:ok, activity} =
1356       CommonAPI.post(insert(:user), %{
1357         "status" => "This is about 2hu, but private",
1358         "visibility" => "private"
1359       })
1360
1361     capture_log(fn ->
1362       conn =
1363         conn
1364         |> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})
1365
1366       assert results = json_response(conn, 200)
1367
1368       [] = results["statuses"]
1369     end)
1370   end
1371
1372   test "search fetches remote accounts", %{conn: conn} do
1373     conn =
1374       conn
1375       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1376
1377     assert results = json_response(conn, 200)
1378     [account] = results["accounts"]
1379     assert account["acct"] == "shp@social.heldscal.la"
1380   end
1381
1382   test "returns the favorites of a user", %{conn: conn} do
1383     user = insert(:user)
1384     other_user = insert(:user)
1385
1386     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1387     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1388
1389     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1390
1391     first_conn =
1392       conn
1393       |> assign(:user, user)
1394       |> get("/api/v1/favourites")
1395
1396     assert [status] = json_response(first_conn, 200)
1397     assert status["id"] == to_string(activity.id)
1398
1399     assert [{"link", _link_header}] =
1400              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1401
1402     # Honours query params
1403     {:ok, second_activity} =
1404       CommonAPI.post(other_user, %{
1405         "status" =>
1406           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1407       })
1408
1409     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
1410
1411     last_like = status["id"]
1412
1413     second_conn =
1414       conn
1415       |> assign(:user, user)
1416       |> get("/api/v1/favourites?since_id=#{last_like}")
1417
1418     assert [second_status] = json_response(second_conn, 200)
1419     assert second_status["id"] == to_string(second_activity.id)
1420
1421     third_conn =
1422       conn
1423       |> assign(:user, user)
1424       |> get("/api/v1/favourites?limit=0")
1425
1426     assert [] = json_response(third_conn, 200)
1427   end
1428
1429   describe "updating credentials" do
1430     test "updates the user's bio", %{conn: conn} do
1431       user = insert(:user)
1432       user2 = insert(:user)
1433
1434       conn =
1435         conn
1436         |> assign(:user, user)
1437         |> patch("/api/v1/accounts/update_credentials", %{
1438           "note" => "I drink #cofe with @#{user2.nickname}"
1439         })
1440
1441       assert user = json_response(conn, 200)
1442
1443       assert user["note"] ==
1444                "I drink <a class=\"hashtag\" data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span class=\"h-card\"><a data-user=\"#{
1445                  user2.id
1446                }\" class=\"u-url mention\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
1447     end
1448
1449     test "updates the user's locking status", %{conn: conn} do
1450       user = insert(:user)
1451
1452       conn =
1453         conn
1454         |> assign(:user, user)
1455         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1456
1457       assert user = json_response(conn, 200)
1458       assert user["locked"] == true
1459     end
1460
1461     test "updates the user's name", %{conn: conn} do
1462       user = insert(:user)
1463
1464       conn =
1465         conn
1466         |> assign(:user, user)
1467         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1468
1469       assert user = json_response(conn, 200)
1470       assert user["display_name"] == "markorepairs"
1471     end
1472
1473     test "updates the user's avatar", %{conn: conn} do
1474       user = insert(:user)
1475
1476       new_avatar = %Plug.Upload{
1477         content_type: "image/jpg",
1478         path: Path.absname("test/fixtures/image.jpg"),
1479         filename: "an_image.jpg"
1480       }
1481
1482       conn =
1483         conn
1484         |> assign(:user, user)
1485         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1486
1487       assert user_response = json_response(conn, 200)
1488       assert user_response["avatar"] != User.avatar_url(user)
1489     end
1490
1491     test "updates the user's banner", %{conn: conn} do
1492       user = insert(:user)
1493
1494       new_header = %Plug.Upload{
1495         content_type: "image/jpg",
1496         path: Path.absname("test/fixtures/image.jpg"),
1497         filename: "an_image.jpg"
1498       }
1499
1500       conn =
1501         conn
1502         |> assign(:user, user)
1503         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1504
1505       assert user_response = json_response(conn, 200)
1506       assert user_response["header"] != User.banner_url(user)
1507     end
1508   end
1509
1510   test "get instance information", %{conn: conn} do
1511     user = insert(:user, %{local: true})
1512
1513     user2 = insert(:user, %{local: true})
1514     {:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)
1515
1516     insert(:user, %{local: false, nickname: "u@peer1.com"})
1517     insert(:user, %{local: false, nickname: "u@peer2.com"})
1518
1519     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1520
1521     # Stats should count users with missing or nil `info.deactivated` value
1522     user = Repo.get(User, user.id)
1523     info_change = Changeset.change(user.info, %{deactivated: nil})
1524
1525     {:ok, _user} =
1526       user
1527       |> Changeset.change()
1528       |> Changeset.put_embed(:info, info_change)
1529       |> User.update_and_set_cache()
1530
1531     Pleroma.Stats.update_stats()
1532
1533     conn = get(conn, "/api/v1/instance")
1534
1535     assert result = json_response(conn, 200)
1536
1537     stats = result["stats"]
1538
1539     assert stats
1540     assert stats["user_count"] == 1
1541     assert stats["status_count"] == 1
1542     assert stats["domain_count"] == 2
1543   end
1544
1545   test "get peers", %{conn: conn} do
1546     insert(:user, %{local: false, nickname: "u@peer1.com"})
1547     insert(:user, %{local: false, nickname: "u@peer2.com"})
1548
1549     Pleroma.Stats.update_stats()
1550
1551     conn = get(conn, "/api/v1/instance/peers")
1552
1553     assert result = json_response(conn, 200)
1554
1555     assert ["peer1.com", "peer2.com"] == Enum.sort(result)
1556   end
1557
1558   test "put settings", %{conn: conn} do
1559     user = insert(:user)
1560
1561     conn =
1562       conn
1563       |> assign(:user, user)
1564       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
1565
1566     assert _result = json_response(conn, 200)
1567
1568     user = User.get_cached_by_ap_id(user.ap_id)
1569     assert user.info.settings == %{"programming" => "socks"}
1570   end
1571
1572   describe "pinned statuses" do
1573     setup do
1574       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
1575
1576       user = insert(:user)
1577       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
1578
1579       [user: user, activity: activity]
1580     end
1581
1582     test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
1583       {:ok, _} = CommonAPI.pin(activity.id, user)
1584
1585       result =
1586         conn
1587         |> assign(:user, user)
1588         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1589         |> json_response(200)
1590
1591       id_str = to_string(activity.id)
1592
1593       assert [%{"id" => ^id_str, "pinned" => true}] = result
1594     end
1595
1596     test "pin status", %{conn: conn, user: user, activity: activity} do
1597       id_str = to_string(activity.id)
1598
1599       assert %{"id" => ^id_str, "pinned" => true} =
1600                conn
1601                |> assign(:user, user)
1602                |> post("/api/v1/statuses/#{activity.id}/pin")
1603                |> json_response(200)
1604
1605       assert [%{"id" => ^id_str, "pinned" => true}] =
1606                conn
1607                |> assign(:user, user)
1608                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1609                |> json_response(200)
1610     end
1611
1612     test "unpin status", %{conn: conn, user: user, activity: activity} do
1613       {:ok, _} = CommonAPI.pin(activity.id, user)
1614
1615       id_str = to_string(activity.id)
1616       user = refresh_record(user)
1617
1618       assert %{"id" => ^id_str, "pinned" => false} =
1619                conn
1620                |> assign(:user, user)
1621                |> post("/api/v1/statuses/#{activity.id}/unpin")
1622                |> json_response(200)
1623
1624       assert [] =
1625                conn
1626                |> assign(:user, user)
1627                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1628                |> json_response(200)
1629     end
1630
1631     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
1632       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1633
1634       id_str_one = to_string(activity_one.id)
1635
1636       assert %{"id" => ^id_str_one, "pinned" => true} =
1637                conn
1638                |> assign(:user, user)
1639                |> post("/api/v1/statuses/#{id_str_one}/pin")
1640                |> json_response(200)
1641
1642       user = refresh_record(user)
1643
1644       assert %{"error" => "You have already pinned the maximum number of statuses"} =
1645                conn
1646                |> assign(:user, user)
1647                |> post("/api/v1/statuses/#{activity_two.id}/pin")
1648                |> json_response(400)
1649     end
1650   end
1651 end