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 Ecto.Changeset
   9   alias Pleroma.Activity
  10   alias Pleroma.Notification
  11   alias Pleroma.Object
  12   alias Pleroma.Repo
  13   alias Pleroma.ScheduledActivity
  14   alias Pleroma.User
  15   alias Pleroma.Web.ActivityPub.ActivityPub
  16   alias Pleroma.Web.CommonAPI
  17   alias Pleroma.Web.MastodonAPI.FilterView
  18   alias Pleroma.Web.OAuth.App
  19   alias Pleroma.Web.OStatus
  20   alias Pleroma.Web.Push
  21   alias Pleroma.Web.TwitterAPI.TwitterAPI
  22   import Pleroma.Factory
  23   import ExUnit.CaptureLog
  24   import Tesla.Mock
  25
  26   setup do
  27     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  28     :ok
  29   end
  30
  31   test "the home timeline", %{conn: conn} do
  32     user = insert(:user)
  33     following = insert(:user)
  34
  35     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  36
  37     conn =
  38       conn
  39       |> assign(:user, user)
  40       |> get("/api/v1/timelines/home")
  41
  42     assert Enum.empty?(json_response(conn, 200))
  43
  44     {:ok, user} = User.follow(user, following)
  45
  46     conn =
  47       build_conn()
  48       |> assign(:user, user)
  49       |> get("/api/v1/timelines/home")
  50
  51     assert [%{"content" => "test"}] = json_response(conn, 200)
  52   end
  53
  54   test "the public timeline", %{conn: conn} do
  55     following = insert(:user)
  56
  57     capture_log(fn ->
  58       {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  59
  60       {:ok, [_activity]} =
  61         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
  62
  63       conn =
  64         conn
  65         |> get("/api/v1/timelines/public", %{"local" => "False"})
  66
  67       assert length(json_response(conn, 200)) == 2
  68
  69       conn =
  70         build_conn()
  71         |> get("/api/v1/timelines/public", %{"local" => "True"})
  72
  73       assert [%{"content" => "test"}] = json_response(conn, 200)
  74
  75       conn =
  76         build_conn()
  77         |> get("/api/v1/timelines/public", %{"local" => "1"})
  78
  79       assert [%{"content" => "test"}] = json_response(conn, 200)
  80     end)
  81   end
  82
  83   test "posting a status", %{conn: conn} do
  84     user = insert(:user)
  85
  86     idempotency_key = "Pikachu rocks!"
  87
  88     conn_one =
  89       conn
  90       |> assign(:user, user)
  91       |> put_req_header("idempotency-key", idempotency_key)
  92       |> post("/api/v1/statuses", %{
  93         "status" => "cofe",
  94         "spoiler_text" => "2hu",
  95         "sensitive" => "false"
  96       })
  97
  98     {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
  99     # Six hours
 100     assert ttl > :timer.seconds(6 * 60 * 60 - 1)
 101
 102     assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
 103              json_response(conn_one, 200)
 104
 105     assert Activity.get_by_id(id)
 106
 107     conn_two =
 108       conn
 109       |> assign(:user, user)
 110       |> put_req_header("idempotency-key", idempotency_key)
 111       |> post("/api/v1/statuses", %{
 112         "status" => "cofe",
 113         "spoiler_text" => "2hu",
 114         "sensitive" => "false"
 115       })
 116
 117     assert %{"id" => second_id} = json_response(conn_two, 200)
 118
 119     assert id == second_id
 120
 121     conn_three =
 122       conn
 123       |> assign(:user, user)
 124       |> post("/api/v1/statuses", %{
 125         "status" => "cofe",
 126         "spoiler_text" => "2hu",
 127         "sensitive" => "false"
 128       })
 129
 130     assert %{"id" => third_id} = json_response(conn_three, 200)
 131
 132     refute id == third_id
 133   end
 134
 135   test "posting a sensitive status", %{conn: conn} do
 136     user = insert(:user)
 137
 138     conn =
 139       conn
 140       |> assign(:user, user)
 141       |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
 142
 143     assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
 144     assert Activity.get_by_id(id)
 145   end
 146
 147   test "posting a fake status", %{conn: conn} do
 148     user = insert(:user)
 149
 150     real_conn =
 151       conn
 152       |> assign(:user, user)
 153       |> post("/api/v1/statuses", %{
 154         "status" =>
 155           "\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it"
 156       })
 157
 158     real_status = json_response(real_conn, 200)
 159
 160     assert real_status
 161     assert Object.get_by_ap_id(real_status["uri"])
 162
 163     real_status =
 164       real_status
 165       |> Map.put("id", nil)
 166       |> Map.put("url", nil)
 167       |> Map.put("uri", nil)
 168       |> Map.put("created_at", nil)
 169       |> Kernel.put_in(["pleroma", "conversation_id"], nil)
 170
 171     fake_conn =
 172       conn
 173       |> assign(:user, user)
 174       |> post("/api/v1/statuses", %{
 175         "status" =>
 176           "\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it",
 177         "preview" => true
 178       })
 179
 180     fake_status = json_response(fake_conn, 200)
 181
 182     assert fake_status
 183     refute Object.get_by_ap_id(fake_status["uri"])
 184
 185     fake_status =
 186       fake_status
 187       |> Map.put("id", nil)
 188       |> Map.put("url", nil)
 189       |> Map.put("uri", nil)
 190       |> Map.put("created_at", nil)
 191       |> Kernel.put_in(["pleroma", "conversation_id"], nil)
 192
 193     assert real_status == fake_status
 194   end
 195
 196   test "posting a status with OGP link preview", %{conn: conn} do
 197     Pleroma.Config.put([:rich_media, :enabled], true)
 198     user = insert(:user)
 199
 200     conn =
 201       conn
 202       |> assign(:user, user)
 203       |> post("/api/v1/statuses", %{
 204         "status" => "http://example.com/ogp"
 205       })
 206
 207     assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
 208     assert Activity.get_by_id(id)
 209     Pleroma.Config.put([:rich_media, :enabled], false)
 210   end
 211
 212   test "posting a direct status", %{conn: conn} do
 213     user1 = insert(:user)
 214     user2 = insert(:user)
 215     content = "direct cofe @#{user2.nickname}"
 216
 217     conn =
 218       conn
 219       |> assign(:user, user1)
 220       |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
 221
 222     assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
 223     assert activity = Activity.get_by_id(id)
 224     assert activity.recipients == [user2.ap_id, user1.ap_id]
 225     assert activity.data["to"] == [user2.ap_id]
 226     assert activity.data["cc"] == []
 227   end
 228
 229   test "direct timeline", %{conn: conn} do
 230     user_one = insert(:user)
 231     user_two = insert(:user)
 232
 233     {:ok, user_two} = User.follow(user_two, user_one)
 234
 235     {:ok, direct} =
 236       CommonAPI.post(user_one, %{
 237         "status" => "Hi @#{user_two.nickname}!",
 238         "visibility" => "direct"
 239       })
 240
 241     {:ok, _follower_only} =
 242       CommonAPI.post(user_one, %{
 243         "status" => "Hi @#{user_two.nickname}!",
 244         "visibility" => "private"
 245       })
 246
 247     # Only direct should be visible here
 248     res_conn =
 249       conn
 250       |> assign(:user, user_two)
 251       |> get("api/v1/timelines/direct")
 252
 253     [status] = json_response(res_conn, 200)
 254
 255     assert %{"visibility" => "direct"} = status
 256     assert status["url"] != direct.data["id"]
 257
 258     # User should be able to see his own direct message
 259     res_conn =
 260       build_conn()
 261       |> assign(:user, user_one)
 262       |> get("api/v1/timelines/direct")
 263
 264     [status] = json_response(res_conn, 200)
 265
 266     assert %{"visibility" => "direct"} = status
 267
 268     # Both should be visible here
 269     res_conn =
 270       conn
 271       |> assign(:user, user_two)
 272       |> get("api/v1/timelines/home")
 273
 274     [_s1, _s2] = json_response(res_conn, 200)
 275
 276     # Test pagination
 277     Enum.each(1..20, fn _ ->
 278       {:ok, _} =
 279         CommonAPI.post(user_one, %{
 280           "status" => "Hi @#{user_two.nickname}!",
 281           "visibility" => "direct"
 282         })
 283     end)
 284
 285     res_conn =
 286       conn
 287       |> assign(:user, user_two)
 288       |> get("api/v1/timelines/direct")
 289
 290     statuses = json_response(res_conn, 200)
 291     assert length(statuses) == 20
 292
 293     res_conn =
 294       conn
 295       |> assign(:user, user_two)
 296       |> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})
 297
 298     [status] = json_response(res_conn, 200)
 299
 300     assert status["url"] != direct.data["id"]
 301   end
 302
 303   test "doesn't include DMs from blocked users", %{conn: conn} do
 304     blocker = insert(:user)
 305     blocked = insert(:user)
 306     user = insert(:user)
 307     {:ok, blocker} = User.block(blocker, blocked)
 308
 309     {:ok, _blocked_direct} =
 310       CommonAPI.post(blocked, %{
 311         "status" => "Hi @#{blocker.nickname}!",
 312         "visibility" => "direct"
 313       })
 314
 315     {:ok, direct} =
 316       CommonAPI.post(user, %{
 317         "status" => "Hi @#{blocker.nickname}!",
 318         "visibility" => "direct"
 319       })
 320
 321     res_conn =
 322       conn
 323       |> assign(:user, user)
 324       |> get("api/v1/timelines/direct")
 325
 326     [status] = json_response(res_conn, 200)
 327     assert status["id"] == direct.id
 328   end
 329
 330   test "replying to a status", %{conn: conn} do
 331     user = insert(:user)
 332
 333     {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
 334
 335     conn =
 336       conn
 337       |> assign(:user, user)
 338       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 339
 340     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 341
 342     activity = Activity.get_by_id(id)
 343
 344     assert activity.data["context"] == replied_to.data["context"]
 345     assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
 346   end
 347
 348   test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
 349     user = insert(:user)
 350
 351     conn =
 352       conn
 353       |> assign(:user, user)
 354       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
 355
 356     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 357
 358     activity = Activity.get_by_id(id)
 359
 360     assert activity
 361   end
 362
 363   test "verify_credentials", %{conn: conn} do
 364     user = insert(:user)
 365
 366     conn =
 367       conn
 368       |> assign(:user, user)
 369       |> get("/api/v1/accounts/verify_credentials")
 370
 371     assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
 372     assert id == to_string(user.id)
 373   end
 374
 375   test "verify_credentials default scope unlisted", %{conn: conn} do
 376     user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})
 377
 378     conn =
 379       conn
 380       |> assign(:user, user)
 381       |> get("/api/v1/accounts/verify_credentials")
 382
 383     assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
 384     assert id == to_string(user.id)
 385   end
 386
 387   test "apps/verify_credentials", %{conn: conn} do
 388     token = insert(:oauth_token)
 389
 390     conn =
 391       conn
 392       |> assign(:user, token.user)
 393       |> assign(:token, token)
 394       |> get("/api/v1/apps/verify_credentials")
 395
 396     app = Repo.preload(token, :app).app
 397
 398     expected = %{
 399       "name" => app.client_name,
 400       "website" => app.website,
 401       "vapid_key" => Push.vapid_config() |> Keyword.get(:public_key)
 402     }
 403
 404     assert expected == json_response(conn, 200)
 405   end
 406
 407   test "creates an oauth app", %{conn: conn} do
 408     user = insert(:user)
 409     app_attrs = build(:oauth_app)
 410
 411     conn =
 412       conn
 413       |> assign(:user, user)
 414       |> post("/api/v1/apps", %{
 415         client_name: app_attrs.client_name,
 416         redirect_uris: app_attrs.redirect_uris
 417       })
 418
 419     [app] = Repo.all(App)
 420
 421     expected = %{
 422       "name" => app.client_name,
 423       "website" => app.website,
 424       "client_id" => app.client_id,
 425       "client_secret" => app.client_secret,
 426       "id" => app.id |> to_string(),
 427       "redirect_uri" => app.redirect_uris,
 428       "vapid_key" => Push.vapid_config() |> Keyword.get(:public_key)
 429     }
 430
 431     assert expected == json_response(conn, 200)
 432   end
 433
 434   test "get a status", %{conn: conn} do
 435     activity = insert(:note_activity)
 436
 437     conn =
 438       conn
 439       |> get("/api/v1/statuses/#{activity.id}")
 440
 441     assert %{"id" => id} = json_response(conn, 200)
 442     assert id == to_string(activity.id)
 443   end
 444
 445   describe "deleting a status" do
 446     test "when you created it", %{conn: conn} do
 447       activity = insert(:note_activity)
 448       author = User.get_by_ap_id(activity.data["actor"])
 449
 450       conn =
 451         conn
 452         |> assign(:user, author)
 453         |> delete("/api/v1/statuses/#{activity.id}")
 454
 455       assert %{} = json_response(conn, 200)
 456
 457       refute Activity.get_by_id(activity.id)
 458     end
 459
 460     test "when you didn't create it", %{conn: conn} do
 461       activity = insert(:note_activity)
 462       user = insert(:user)
 463
 464       conn =
 465         conn
 466         |> assign(:user, user)
 467         |> delete("/api/v1/statuses/#{activity.id}")
 468
 469       assert %{"error" => _} = json_response(conn, 403)
 470
 471       assert Activity.get_by_id(activity.id) == activity
 472     end
 473
 474     test "when you're an admin or moderator", %{conn: conn} do
 475       activity1 = insert(:note_activity)
 476       activity2 = insert(:note_activity)
 477       admin = insert(:user, info: %{is_admin: true})
 478       moderator = insert(:user, info: %{is_moderator: true})
 479
 480       res_conn =
 481         conn
 482         |> assign(:user, admin)
 483         |> delete("/api/v1/statuses/#{activity1.id}")
 484
 485       assert %{} = json_response(res_conn, 200)
 486
 487       res_conn =
 488         conn
 489         |> assign(:user, moderator)
 490         |> delete("/api/v1/statuses/#{activity2.id}")
 491
 492       assert %{} = json_response(res_conn, 200)
 493
 494       refute Activity.get_by_id(activity1.id)
 495       refute Activity.get_by_id(activity2.id)
 496     end
 497   end
 498
 499   describe "filters" do
 500     test "creating a filter", %{conn: conn} do
 501       user = insert(:user)
 502
 503       filter = %Pleroma.Filter{
 504         phrase: "knights",
 505         context: ["home"]
 506       }
 507
 508       conn =
 509         conn
 510         |> assign(:user, user)
 511         |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
 512
 513       assert response = json_response(conn, 200)
 514       assert response["phrase"] == filter.phrase
 515       assert response["context"] == filter.context
 516       assert response["id"] != nil
 517       assert response["id"] != ""
 518     end
 519
 520     test "fetching a list of filters", %{conn: conn} do
 521       user = insert(:user)
 522
 523       query_one = %Pleroma.Filter{
 524         user_id: user.id,
 525         filter_id: 1,
 526         phrase: "knights",
 527         context: ["home"]
 528       }
 529
 530       query_two = %Pleroma.Filter{
 531         user_id: user.id,
 532         filter_id: 2,
 533         phrase: "who",
 534         context: ["home"]
 535       }
 536
 537       {:ok, filter_one} = Pleroma.Filter.create(query_one)
 538       {:ok, filter_two} = Pleroma.Filter.create(query_two)
 539
 540       response =
 541         conn
 542         |> assign(:user, user)
 543         |> get("/api/v1/filters")
 544         |> json_response(200)
 545
 546       assert response ==
 547                render_json(
 548                  FilterView,
 549                  "filters.json",
 550                  filters: [filter_two, filter_one]
 551                )
 552     end
 553
 554     test "get a filter", %{conn: conn} do
 555       user = insert(:user)
 556
 557       query = %Pleroma.Filter{
 558         user_id: user.id,
 559         filter_id: 2,
 560         phrase: "knight",
 561         context: ["home"]
 562       }
 563
 564       {:ok, filter} = Pleroma.Filter.create(query)
 565
 566       conn =
 567         conn
 568         |> assign(:user, user)
 569         |> get("/api/v1/filters/#{filter.filter_id}")
 570
 571       assert _response = json_response(conn, 200)
 572     end
 573
 574     test "update a filter", %{conn: conn} do
 575       user = insert(:user)
 576
 577       query = %Pleroma.Filter{
 578         user_id: user.id,
 579         filter_id: 2,
 580         phrase: "knight",
 581         context: ["home"]
 582       }
 583
 584       {:ok, _filter} = Pleroma.Filter.create(query)
 585
 586       new = %Pleroma.Filter{
 587         phrase: "nii",
 588         context: ["home"]
 589       }
 590
 591       conn =
 592         conn
 593         |> assign(:user, user)
 594         |> put("/api/v1/filters/#{query.filter_id}", %{
 595           phrase: new.phrase,
 596           context: new.context
 597         })
 598
 599       assert response = json_response(conn, 200)
 600       assert response["phrase"] == new.phrase
 601       assert response["context"] == new.context
 602     end
 603
 604     test "delete a filter", %{conn: conn} do
 605       user = insert(:user)
 606
 607       query = %Pleroma.Filter{
 608         user_id: user.id,
 609         filter_id: 2,
 610         phrase: "knight",
 611         context: ["home"]
 612       }
 613
 614       {:ok, filter} = Pleroma.Filter.create(query)
 615
 616       conn =
 617         conn
 618         |> assign(:user, user)
 619         |> delete("/api/v1/filters/#{filter.filter_id}")
 620
 621       assert response = json_response(conn, 200)
 622       assert response == %{}
 623     end
 624   end
 625
 626   describe "lists" do
 627     test "creating a list", %{conn: conn} do
 628       user = insert(:user)
 629
 630       conn =
 631         conn
 632         |> assign(:user, user)
 633         |> post("/api/v1/lists", %{"title" => "cuties"})
 634
 635       assert %{"title" => title} = json_response(conn, 200)
 636       assert title == "cuties"
 637     end
 638
 639     test "adding users to a list", %{conn: conn} do
 640       user = insert(:user)
 641       other_user = insert(:user)
 642       {:ok, list} = Pleroma.List.create("name", user)
 643
 644       conn =
 645         conn
 646         |> assign(:user, user)
 647         |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 648
 649       assert %{} == json_response(conn, 200)
 650       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 651       assert following == [other_user.follower_address]
 652     end
 653
 654     test "removing users from a list", %{conn: conn} do
 655       user = insert(:user)
 656       other_user = insert(:user)
 657       third_user = insert(:user)
 658       {:ok, list} = Pleroma.List.create("name", user)
 659       {:ok, list} = Pleroma.List.follow(list, other_user)
 660       {:ok, list} = Pleroma.List.follow(list, third_user)
 661
 662       conn =
 663         conn
 664         |> assign(:user, user)
 665         |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 666
 667       assert %{} == json_response(conn, 200)
 668       %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
 669       assert following == [third_user.follower_address]
 670     end
 671
 672     test "listing users in a list", %{conn: conn} do
 673       user = insert(:user)
 674       other_user = insert(:user)
 675       {:ok, list} = Pleroma.List.create("name", user)
 676       {:ok, list} = Pleroma.List.follow(list, other_user)
 677
 678       conn =
 679         conn
 680         |> assign(:user, user)
 681         |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
 682
 683       assert [%{"id" => id}] = json_response(conn, 200)
 684       assert id == to_string(other_user.id)
 685     end
 686
 687     test "retrieving a list", %{conn: conn} do
 688       user = insert(:user)
 689       {:ok, list} = Pleroma.List.create("name", user)
 690
 691       conn =
 692         conn
 693         |> assign(:user, user)
 694         |> get("/api/v1/lists/#{list.id}")
 695
 696       assert %{"id" => id} = json_response(conn, 200)
 697       assert id == to_string(list.id)
 698     end
 699
 700     test "renaming a list", %{conn: conn} do
 701       user = insert(:user)
 702       {:ok, list} = Pleroma.List.create("name", user)
 703
 704       conn =
 705         conn
 706         |> assign(:user, user)
 707         |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
 708
 709       assert %{"title" => name} = json_response(conn, 200)
 710       assert name == "newname"
 711     end
 712
 713     test "deleting a list", %{conn: conn} do
 714       user = insert(:user)
 715       {:ok, list} = Pleroma.List.create("name", user)
 716
 717       conn =
 718         conn
 719         |> assign(:user, user)
 720         |> delete("/api/v1/lists/#{list.id}")
 721
 722       assert %{} = json_response(conn, 200)
 723       assert is_nil(Repo.get(Pleroma.List, list.id))
 724     end
 725
 726     test "list timeline", %{conn: conn} do
 727       user = insert(:user)
 728       other_user = insert(:user)
 729       {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
 730       {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 731       {:ok, list} = Pleroma.List.create("name", user)
 732       {:ok, list} = Pleroma.List.follow(list, other_user)
 733
 734       conn =
 735         conn
 736         |> assign(:user, user)
 737         |> get("/api/v1/timelines/list/#{list.id}")
 738
 739       assert [%{"id" => id}] = json_response(conn, 200)
 740
 741       assert id == to_string(activity_two.id)
 742     end
 743
 744     test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
 745       user = insert(:user)
 746       other_user = insert(:user)
 747       {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
 748
 749       {:ok, _activity_two} =
 750         TwitterAPI.create_status(other_user, %{
 751           "status" => "Marisa is cute.",
 752           "visibility" => "private"
 753         })
 754
 755       {:ok, list} = Pleroma.List.create("name", user)
 756       {:ok, list} = Pleroma.List.follow(list, other_user)
 757
 758       conn =
 759         conn
 760         |> assign(:user, user)
 761         |> get("/api/v1/timelines/list/#{list.id}")
 762
 763       assert [%{"id" => id}] = json_response(conn, 200)
 764
 765       assert id == to_string(activity_one.id)
 766     end
 767   end
 768
 769   describe "notifications" do
 770     test "list of notifications", %{conn: conn} do
 771       user = insert(:user)
 772       other_user = insert(:user)
 773
 774       {:ok, activity} =
 775         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 776
 777       {:ok, [_notification]} = Notification.create_notifications(activity)
 778
 779       conn =
 780         conn
 781         |> assign(:user, user)
 782         |> get("/api/v1/notifications")
 783
 784       expected_response =
 785         "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
 786           user.ap_id
 787         }\">@<span>#{user.nickname}</span></a></span>"
 788
 789       assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
 790       assert response == expected_response
 791     end
 792
 793     test "getting a single notification", %{conn: conn} do
 794       user = insert(:user)
 795       other_user = insert(:user)
 796
 797       {:ok, activity} =
 798         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 799
 800       {:ok, [notification]} = Notification.create_notifications(activity)
 801
 802       conn =
 803         conn
 804         |> assign(:user, user)
 805         |> get("/api/v1/notifications/#{notification.id}")
 806
 807       expected_response =
 808         "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
 809           user.ap_id
 810         }\">@<span>#{user.nickname}</span></a></span>"
 811
 812       assert %{"status" => %{"content" => response}} = json_response(conn, 200)
 813       assert response == expected_response
 814     end
 815
 816     test "dismissing a single notification", %{conn: conn} do
 817       user = insert(:user)
 818       other_user = insert(:user)
 819
 820       {:ok, activity} =
 821         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 822
 823       {:ok, [notification]} = Notification.create_notifications(activity)
 824
 825       conn =
 826         conn
 827         |> assign(:user, user)
 828         |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
 829
 830       assert %{} = json_response(conn, 200)
 831     end
 832
 833     test "clearing all notifications", %{conn: conn} do
 834       user = insert(:user)
 835       other_user = insert(:user)
 836
 837       {:ok, activity} =
 838         TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
 839
 840       {:ok, [_notification]} = Notification.create_notifications(activity)
 841
 842       conn =
 843         conn
 844         |> assign(:user, user)
 845         |> post("/api/v1/notifications/clear")
 846
 847       assert %{} = json_response(conn, 200)
 848
 849       conn =
 850         build_conn()
 851         |> assign(:user, user)
 852         |> get("/api/v1/notifications")
 853
 854       assert all = json_response(conn, 200)
 855       assert all == []
 856     end
 857
 858     test "paginates notifications using min_id, since_id, max_id, and limit", %{conn: conn} do
 859       user = insert(:user)
 860       other_user = insert(:user)
 861
 862       {:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 863       {:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 864       {:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 865       {:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 866
 867       notification1_id = Repo.get_by(Notification, activity_id: activity1.id).id |> to_string()
 868       notification2_id = Repo.get_by(Notification, activity_id: activity2.id).id |> to_string()
 869       notification3_id = Repo.get_by(Notification, activity_id: activity3.id).id |> to_string()
 870       notification4_id = Repo.get_by(Notification, activity_id: activity4.id).id |> to_string()
 871
 872       conn =
 873         conn
 874         |> assign(:user, user)
 875
 876       # min_id
 877       conn_res =
 878         conn
 879         |> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
 880
 881       result = json_response(conn_res, 200)
 882       assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 883
 884       # since_id
 885       conn_res =
 886         conn
 887         |> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
 888
 889       result = json_response(conn_res, 200)
 890       assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 891
 892       # max_id
 893       conn_res =
 894         conn
 895         |> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
 896
 897       result = json_response(conn_res, 200)
 898       assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
 899     end
 900
 901     test "filters notifications using exclude_types", %{conn: conn} do
 902       user = insert(:user)
 903       other_user = insert(:user)
 904
 905       {:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
 906       {:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
 907       {:ok, favorite_activity, _} = CommonAPI.favorite(create_activity.id, other_user)
 908       {:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
 909       {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
 910
 911       mention_notification_id =
 912         Repo.get_by(Notification, activity_id: mention_activity.id).id |> to_string()
 913
 914       favorite_notification_id =
 915         Repo.get_by(Notification, activity_id: favorite_activity.id).id |> to_string()
 916
 917       reblog_notification_id =
 918         Repo.get_by(Notification, activity_id: reblog_activity.id).id |> to_string()
 919
 920       follow_notification_id =
 921         Repo.get_by(Notification, activity_id: follow_activity.id).id |> to_string()
 922
 923       conn =
 924         conn
 925         |> assign(:user, user)
 926
 927       conn_res =
 928         get(conn, "/api/v1/notifications", %{exclude_types: ["mention", "favourite", "reblog"]})
 929
 930       assert [%{"id" => ^follow_notification_id}] = json_response(conn_res, 200)
 931
 932       conn_res =
 933         get(conn, "/api/v1/notifications", %{exclude_types: ["favourite", "reblog", "follow"]})
 934
 935       assert [%{"id" => ^mention_notification_id}] = json_response(conn_res, 200)
 936
 937       conn_res =
 938         get(conn, "/api/v1/notifications", %{exclude_types: ["reblog", "follow", "mention"]})
 939
 940       assert [%{"id" => ^favorite_notification_id}] = json_response(conn_res, 200)
 941
 942       conn_res =
 943         get(conn, "/api/v1/notifications", %{exclude_types: ["follow", "mention", "favourite"]})
 944
 945       assert [%{"id" => ^reblog_notification_id}] = json_response(conn_res, 200)
 946     end
 947
 948     test "destroy multiple", %{conn: conn} do
 949       user = insert(:user)
 950       other_user = insert(:user)
 951
 952       {:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 953       {:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
 954       {:ok, activity3} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
 955       {:ok, activity4} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
 956
 957       notification1_id = Repo.get_by(Notification, activity_id: activity1.id).id |> to_string()
 958       notification2_id = Repo.get_by(Notification, activity_id: activity2.id).id |> to_string()
 959       notification3_id = Repo.get_by(Notification, activity_id: activity3.id).id |> to_string()
 960       notification4_id = Repo.get_by(Notification, activity_id: activity4.id).id |> to_string()
 961
 962       conn =
 963         conn
 964         |> assign(:user, user)
 965
 966       conn_res =
 967         conn
 968         |> get("/api/v1/notifications")
 969
 970       result = json_response(conn_res, 200)
 971       assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result
 972
 973       conn2 =
 974         conn
 975         |> assign(:user, other_user)
 976
 977       conn_res =
 978         conn2
 979         |> get("/api/v1/notifications")
 980
 981       result = json_response(conn_res, 200)
 982       assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 983
 984       conn_destroy =
 985         conn
 986         |> delete("/api/v1/notifications/destroy_multiple", %{
 987           "ids" => [notification1_id, notification2_id]
 988         })
 989
 990       assert json_response(conn_destroy, 200) == %{}
 991
 992       conn_res =
 993         conn2
 994         |> get("/api/v1/notifications")
 995
 996       result = json_response(conn_res, 200)
 997       assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
 998     end
 999   end
1000
1001   describe "reblogging" do
1002     test "reblogs and returns the reblogged status", %{conn: conn} do
1003       activity = insert(:note_activity)
1004       user = insert(:user)
1005
1006       conn =
1007         conn
1008         |> assign(:user, user)
1009         |> post("/api/v1/statuses/#{activity.id}/reblog")
1010
1011       assert %{
1012                "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
1013                "reblogged" => true
1014              } = json_response(conn, 200)
1015
1016       assert to_string(activity.id) == id
1017     end
1018
1019     test "reblogged status for another user", %{conn: conn} do
1020       activity = insert(:note_activity)
1021       user1 = insert(:user)
1022       user2 = insert(:user)
1023       user3 = insert(:user)
1024       {:ok, reblog_activity1, _object} = CommonAPI.repeat(activity.id, user1)
1025       {:ok, _, _object} = CommonAPI.repeat(activity.id, user2)
1026
1027       conn_res =
1028         conn
1029         |> assign(:user, user3)
1030         |> get("/api/v1/statuses/#{reblog_activity1.id}")
1031
1032       assert %{
1033                "reblog" => %{"id" => id, "reblogged" => false, "reblogs_count" => 2},
1034                "reblogged" => false
1035              } = json_response(conn_res, 200)
1036
1037       conn_res =
1038         conn
1039         |> assign(:user, user2)
1040         |> get("/api/v1/statuses/#{reblog_activity1.id}")
1041
1042       assert %{
1043                "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
1044                "reblogged" => true
1045              } = json_response(conn_res, 200)
1046
1047       assert to_string(activity.id) == id
1048     end
1049   end
1050
1051   describe "unreblogging" do
1052     test "unreblogs and returns the unreblogged status", %{conn: conn} do
1053       activity = insert(:note_activity)
1054       user = insert(:user)
1055
1056       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
1057
1058       conn =
1059         conn
1060         |> assign(:user, user)
1061         |> post("/api/v1/statuses/#{activity.id}/unreblog")
1062
1063       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
1064
1065       assert to_string(activity.id) == id
1066     end
1067   end
1068
1069   describe "favoriting" do
1070     test "favs a status and returns it", %{conn: conn} do
1071       activity = insert(:note_activity)
1072       user = insert(:user)
1073
1074       conn =
1075         conn
1076         |> assign(:user, user)
1077         |> post("/api/v1/statuses/#{activity.id}/favourite")
1078
1079       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
1080                json_response(conn, 200)
1081
1082       assert to_string(activity.id) == id
1083     end
1084
1085     test "returns 500 for a wrong id", %{conn: conn} do
1086       user = insert(:user)
1087
1088       resp =
1089         conn
1090         |> assign(:user, user)
1091         |> post("/api/v1/statuses/1/favourite")
1092         |> json_response(500)
1093
1094       assert resp == "Something went wrong"
1095     end
1096   end
1097
1098   describe "unfavoriting" do
1099     test "unfavorites a status and returns it", %{conn: conn} do
1100       activity = insert(:note_activity)
1101       user = insert(:user)
1102
1103       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1104
1105       conn =
1106         conn
1107         |> assign(:user, user)
1108         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
1109
1110       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
1111                json_response(conn, 200)
1112
1113       assert to_string(activity.id) == id
1114     end
1115   end
1116
1117   describe "user timelines" do
1118     test "gets a users statuses", %{conn: conn} do
1119       user_one = insert(:user)
1120       user_two = insert(:user)
1121       user_three = insert(:user)
1122
1123       {:ok, user_three} = User.follow(user_three, user_one)
1124
1125       {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
1126
1127       {:ok, direct_activity} =
1128         CommonAPI.post(user_one, %{
1129           "status" => "Hi, @#{user_two.nickname}.",
1130           "visibility" => "direct"
1131         })
1132
1133       {:ok, private_activity} =
1134         CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
1135
1136       resp =
1137         conn
1138         |> get("/api/v1/accounts/#{user_one.id}/statuses")
1139
1140       assert [%{"id" => id}] = json_response(resp, 200)
1141       assert id == to_string(activity.id)
1142
1143       resp =
1144         conn
1145         |> assign(:user, user_two)
1146         |> get("/api/v1/accounts/#{user_one.id}/statuses")
1147
1148       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
1149       assert id_one == to_string(direct_activity.id)
1150       assert id_two == to_string(activity.id)
1151
1152       resp =
1153         conn
1154         |> assign(:user, user_three)
1155         |> get("/api/v1/accounts/#{user_one.id}/statuses")
1156
1157       assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
1158       assert id_one == to_string(private_activity.id)
1159       assert id_two == to_string(activity.id)
1160     end
1161
1162     test "unimplemented pinned statuses feature", %{conn: conn} do
1163       note = insert(:note_activity)
1164       user = User.get_by_ap_id(note.data["actor"])
1165
1166       conn =
1167         conn
1168         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1169
1170       assert json_response(conn, 200) == []
1171     end
1172
1173     test "gets an users media", %{conn: conn} do
1174       note = insert(:note_activity)
1175       user = User.get_by_ap_id(note.data["actor"])
1176
1177       file = %Plug.Upload{
1178         content_type: "image/jpg",
1179         path: Path.absname("test/fixtures/image.jpg"),
1180         filename: "an_image.jpg"
1181       }
1182
1183       media =
1184         TwitterAPI.upload(file, user, "json")
1185         |> Poison.decode!()
1186
1187       {:ok, image_post} =
1188         TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
1189
1190       conn =
1191         conn
1192         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
1193
1194       assert [%{"id" => id}] = json_response(conn, 200)
1195       assert id == to_string(image_post.id)
1196
1197       conn =
1198         build_conn()
1199         |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
1200
1201       assert [%{"id" => id}] = json_response(conn, 200)
1202       assert id == to_string(image_post.id)
1203     end
1204
1205     test "gets a user's statuses without reblogs", %{conn: conn} do
1206       user = insert(:user)
1207       {:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
1208       {:ok, _, _} = CommonAPI.repeat(post.id, user)
1209
1210       conn =
1211         conn
1212         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})
1213
1214       assert [%{"id" => id}] = json_response(conn, 200)
1215       assert id == to_string(post.id)
1216
1217       conn =
1218         conn
1219         |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})
1220
1221       assert [%{"id" => id}] = json_response(conn, 200)
1222       assert id == to_string(post.id)
1223     end
1224   end
1225
1226   describe "user relationships" do
1227     test "returns the relationships for the current user", %{conn: conn} do
1228       user = insert(:user)
1229       other_user = insert(:user)
1230       {:ok, user} = User.follow(user, other_user)
1231
1232       conn =
1233         conn
1234         |> assign(:user, user)
1235         |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
1236
1237       assert [relationship] = json_response(conn, 200)
1238
1239       assert to_string(other_user.id) == relationship["id"]
1240     end
1241   end
1242
1243   describe "locked accounts" do
1244     test "/api/v1/follow_requests works" do
1245       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
1246       other_user = insert(:user)
1247
1248       {:ok, _activity} = ActivityPub.follow(other_user, user)
1249
1250       user = User.get_by_id(user.id)
1251       other_user = User.get_by_id(other_user.id)
1252
1253       assert User.following?(other_user, user) == false
1254
1255       conn =
1256         build_conn()
1257         |> assign(:user, user)
1258         |> get("/api/v1/follow_requests")
1259
1260       assert [relationship] = json_response(conn, 200)
1261       assert to_string(other_user.id) == relationship["id"]
1262     end
1263
1264     test "/api/v1/follow_requests/:id/authorize works" do
1265       user = insert(:user, %{info: %User.Info{locked: true}})
1266       other_user = insert(:user)
1267
1268       {:ok, _activity} = ActivityPub.follow(other_user, user)
1269
1270       user = User.get_by_id(user.id)
1271       other_user = User.get_by_id(other_user.id)
1272
1273       assert User.following?(other_user, user) == false
1274
1275       conn =
1276         build_conn()
1277         |> assign(:user, user)
1278         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
1279
1280       assert relationship = json_response(conn, 200)
1281       assert to_string(other_user.id) == relationship["id"]
1282
1283       user = User.get_by_id(user.id)
1284       other_user = User.get_by_id(other_user.id)
1285
1286       assert User.following?(other_user, user) == true
1287     end
1288
1289     test "verify_credentials", %{conn: conn} do
1290       user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
1291
1292       conn =
1293         conn
1294         |> assign(:user, user)
1295         |> get("/api/v1/accounts/verify_credentials")
1296
1297       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
1298       assert id == to_string(user.id)
1299     end
1300
1301     test "/api/v1/follow_requests/:id/reject works" do
1302       user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
1303       other_user = insert(:user)
1304
1305       {:ok, _activity} = ActivityPub.follow(other_user, user)
1306
1307       user = User.get_by_id(user.id)
1308
1309       conn =
1310         build_conn()
1311         |> assign(:user, user)
1312         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
1313
1314       assert relationship = json_response(conn, 200)
1315       assert to_string(other_user.id) == relationship["id"]
1316
1317       user = User.get_by_id(user.id)
1318       other_user = User.get_by_id(other_user.id)
1319
1320       assert User.following?(other_user, user) == false
1321     end
1322   end
1323
1324   test "account fetching", %{conn: conn} do
1325     user = insert(:user)
1326
1327     conn =
1328       conn
1329       |> get("/api/v1/accounts/#{user.id}")
1330
1331     assert %{"id" => id} = json_response(conn, 200)
1332     assert id == to_string(user.id)
1333
1334     conn =
1335       build_conn()
1336       |> get("/api/v1/accounts/-1")
1337
1338     assert %{"error" => "Can't find user"} = json_response(conn, 404)
1339   end
1340
1341   test "account fetching also works nickname", %{conn: conn} do
1342     user = insert(:user)
1343
1344     conn =
1345       conn
1346       |> get("/api/v1/accounts/#{user.nickname}")
1347
1348     assert %{"id" => id} = json_response(conn, 200)
1349     assert id == user.id
1350   end
1351
1352   test "media upload", %{conn: conn} do
1353     file = %Plug.Upload{
1354       content_type: "image/jpg",
1355       path: Path.absname("test/fixtures/image.jpg"),
1356       filename: "an_image.jpg"
1357     }
1358
1359     desc = "Description of the image"
1360
1361     user = insert(:user)
1362
1363     conn =
1364       conn
1365       |> assign(:user, user)
1366       |> post("/api/v1/media", %{"file" => file, "description" => desc})
1367
1368     assert media = json_response(conn, 200)
1369
1370     assert media["type"] == "image"
1371     assert media["description"] == desc
1372     assert media["id"]
1373
1374     object = Repo.get(Object, media["id"])
1375     assert object.data["actor"] == User.ap_id(user)
1376   end
1377
1378   test "hashtag timeline", %{conn: conn} do
1379     following = insert(:user)
1380
1381     capture_log(fn ->
1382       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
1383
1384       {:ok, [_activity]} =
1385         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
1386
1387       nconn =
1388         conn
1389         |> get("/api/v1/timelines/tag/2hu")
1390
1391       assert [%{"id" => id}] = json_response(nconn, 200)
1392
1393       assert id == to_string(activity.id)
1394
1395       # works for different capitalization too
1396       nconn =
1397         conn
1398         |> get("/api/v1/timelines/tag/2HU")
1399
1400       assert [%{"id" => id}] = json_response(nconn, 200)
1401
1402       assert id == to_string(activity.id)
1403     end)
1404   end
1405
1406   test "multi-hashtag timeline", %{conn: conn} do
1407     user = insert(:user)
1408
1409     {:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
1410     {:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
1411     {:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})
1412
1413     any_test =
1414       conn
1415       |> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})
1416
1417     [status_none, status_test1, status_test] = json_response(any_test, 200)
1418
1419     assert to_string(activity_test.id) == status_test["id"]
1420     assert to_string(activity_test1.id) == status_test1["id"]
1421     assert to_string(activity_none.id) == status_none["id"]
1422
1423     restricted_test =
1424       conn
1425       |> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})
1426
1427     assert [status_test1] == json_response(restricted_test, 200)
1428
1429     all_test = conn |> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})
1430
1431     assert [status_none] == json_response(all_test, 200)
1432   end
1433
1434   test "getting followers", %{conn: conn} do
1435     user = insert(:user)
1436     other_user = insert(:user)
1437     {:ok, user} = User.follow(user, other_user)
1438
1439     conn =
1440       conn
1441       |> get("/api/v1/accounts/#{other_user.id}/followers")
1442
1443     assert [%{"id" => id}] = json_response(conn, 200)
1444     assert id == to_string(user.id)
1445   end
1446
1447   test "getting followers, hide_followers", %{conn: conn} do
1448     user = insert(:user)
1449     other_user = insert(:user, %{info: %{hide_followers: true}})
1450     {:ok, _user} = User.follow(user, other_user)
1451
1452     conn =
1453       conn
1454       |> get("/api/v1/accounts/#{other_user.id}/followers")
1455
1456     assert [] == json_response(conn, 200)
1457   end
1458
1459   test "getting followers, hide_followers, same user requesting", %{conn: conn} do
1460     user = insert(:user)
1461     other_user = insert(:user, %{info: %{hide_followers: true}})
1462     {:ok, _user} = User.follow(user, other_user)
1463
1464     conn =
1465       conn
1466       |> assign(:user, other_user)
1467       |> get("/api/v1/accounts/#{other_user.id}/followers")
1468
1469     refute [] == json_response(conn, 200)
1470   end
1471
1472   test "getting followers, pagination", %{conn: conn} do
1473     user = insert(:user)
1474     follower1 = insert(:user)
1475     follower2 = insert(:user)
1476     follower3 = insert(:user)
1477     {:ok, _} = User.follow(follower1, user)
1478     {:ok, _} = User.follow(follower2, user)
1479     {:ok, _} = User.follow(follower3, user)
1480
1481     conn =
1482       conn
1483       |> assign(:user, user)
1484
1485     res_conn =
1486       conn
1487       |> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1.id}")
1488
1489     assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
1490     assert id3 == follower3.id
1491     assert id2 == follower2.id
1492
1493     res_conn =
1494       conn
1495       |> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3.id}")
1496
1497     assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
1498     assert id2 == follower2.id
1499     assert id1 == follower1.id
1500
1501     res_conn =
1502       conn
1503       |> get("/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3.id}")
1504
1505     assert [%{"id" => id2}] = json_response(res_conn, 200)
1506     assert id2 == follower2.id
1507
1508     assert [link_header] = get_resp_header(res_conn, "link")
1509     assert link_header =~ ~r/min_id=#{follower2.id}/
1510     assert link_header =~ ~r/max_id=#{follower2.id}/
1511   end
1512
1513   test "getting following", %{conn: conn} do
1514     user = insert(:user)
1515     other_user = insert(:user)
1516     {:ok, user} = User.follow(user, other_user)
1517
1518     conn =
1519       conn
1520       |> get("/api/v1/accounts/#{user.id}/following")
1521
1522     assert [%{"id" => id}] = json_response(conn, 200)
1523     assert id == to_string(other_user.id)
1524   end
1525
1526   test "getting following, hide_follows", %{conn: conn} do
1527     user = insert(:user, %{info: %{hide_follows: true}})
1528     other_user = insert(:user)
1529     {:ok, user} = User.follow(user, other_user)
1530
1531     conn =
1532       conn
1533       |> get("/api/v1/accounts/#{user.id}/following")
1534
1535     assert [] == json_response(conn, 200)
1536   end
1537
1538   test "getting following, hide_follows, same user requesting", %{conn: conn} do
1539     user = insert(:user, %{info: %{hide_follows: true}})
1540     other_user = insert(:user)
1541     {:ok, user} = User.follow(user, other_user)
1542
1543     conn =
1544       conn
1545       |> assign(:user, user)
1546       |> get("/api/v1/accounts/#{user.id}/following")
1547
1548     refute [] == json_response(conn, 200)
1549   end
1550
1551   test "getting following, pagination", %{conn: conn} do
1552     user = insert(:user)
1553     following1 = insert(:user)
1554     following2 = insert(:user)
1555     following3 = insert(:user)
1556     {:ok, _} = User.follow(user, following1)
1557     {:ok, _} = User.follow(user, following2)
1558     {:ok, _} = User.follow(user, following3)
1559
1560     conn =
1561       conn
1562       |> assign(:user, user)
1563
1564     res_conn =
1565       conn
1566       |> get("/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")
1567
1568     assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
1569     assert id3 == following3.id
1570     assert id2 == following2.id
1571
1572     res_conn =
1573       conn
1574       |> get("/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")
1575
1576     assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
1577     assert id2 == following2.id
1578     assert id1 == following1.id
1579
1580     res_conn =
1581       conn
1582       |> get("/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")
1583
1584     assert [%{"id" => id2}] = json_response(res_conn, 200)
1585     assert id2 == following2.id
1586
1587     assert [link_header] = get_resp_header(res_conn, "link")
1588     assert link_header =~ ~r/min_id=#{following2.id}/
1589     assert link_header =~ ~r/max_id=#{following2.id}/
1590   end
1591
1592   test "following / unfollowing a user", %{conn: conn} do
1593     user = insert(:user)
1594     other_user = insert(:user)
1595
1596     conn =
1597       conn
1598       |> assign(:user, user)
1599       |> post("/api/v1/accounts/#{other_user.id}/follow")
1600
1601     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1602
1603     user = User.get_by_id(user.id)
1604
1605     conn =
1606       build_conn()
1607       |> assign(:user, user)
1608       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1609
1610     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1611
1612     user = User.get_by_id(user.id)
1613
1614     conn =
1615       build_conn()
1616       |> assign(:user, user)
1617       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1618
1619     assert %{"id" => id} = json_response(conn, 200)
1620     assert id == to_string(other_user.id)
1621   end
1622
1623   test "following / unfollowing errors" do
1624     user = insert(:user)
1625
1626     conn =
1627       build_conn()
1628       |> assign(:user, user)
1629
1630     # self follow
1631     conn_res = post(conn, "/api/v1/accounts/#{user.id}/follow")
1632     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1633
1634     # self unfollow
1635     user = User.get_cached_by_id(user.id)
1636     conn_res = post(conn, "/api/v1/accounts/#{user.id}/unfollow")
1637     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1638
1639     # self follow via uri
1640     user = User.get_cached_by_id(user.id)
1641     conn_res = post(conn, "/api/v1/follows", %{"uri" => user.nickname})
1642     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1643
1644     # follow non existing user
1645     conn_res = post(conn, "/api/v1/accounts/doesntexist/follow")
1646     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1647
1648     # follow non existing user via uri
1649     conn_res = post(conn, "/api/v1/follows", %{"uri" => "doesntexist"})
1650     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1651
1652     # unfollow non existing user
1653     conn_res = post(conn, "/api/v1/accounts/doesntexist/unfollow")
1654     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1655   end
1656
1657   test "muting / unmuting a user", %{conn: conn} do
1658     user = insert(:user)
1659     other_user = insert(:user)
1660
1661     conn =
1662       conn
1663       |> assign(:user, user)
1664       |> post("/api/v1/accounts/#{other_user.id}/mute")
1665
1666     assert %{"id" => _id, "muting" => true} = json_response(conn, 200)
1667
1668     user = User.get_by_id(user.id)
1669
1670     conn =
1671       build_conn()
1672       |> assign(:user, user)
1673       |> post("/api/v1/accounts/#{other_user.id}/unmute")
1674
1675     assert %{"id" => _id, "muting" => false} = json_response(conn, 200)
1676   end
1677
1678   test "subscribing / unsubscribing to a user", %{conn: conn} do
1679     user = insert(:user)
1680     subscription_target = insert(:user)
1681
1682     conn =
1683       conn
1684       |> assign(:user, user)
1685       |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")
1686
1687     assert %{"id" => _id, "subscribing" => true} = json_response(conn, 200)
1688
1689     conn =
1690       build_conn()
1691       |> assign(:user, user)
1692       |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")
1693
1694     assert %{"id" => _id, "subscribing" => false} = json_response(conn, 200)
1695   end
1696
1697   test "getting a list of mutes", %{conn: conn} do
1698     user = insert(:user)
1699     other_user = insert(:user)
1700
1701     {:ok, user} = User.mute(user, other_user)
1702
1703     conn =
1704       conn
1705       |> assign(:user, user)
1706       |> get("/api/v1/mutes")
1707
1708     other_user_id = to_string(other_user.id)
1709     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1710   end
1711
1712   test "blocking / unblocking a user", %{conn: conn} do
1713     user = insert(:user)
1714     other_user = insert(:user)
1715
1716     conn =
1717       conn
1718       |> assign(:user, user)
1719       |> post("/api/v1/accounts/#{other_user.id}/block")
1720
1721     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1722
1723     user = User.get_by_id(user.id)
1724
1725     conn =
1726       build_conn()
1727       |> assign(:user, user)
1728       |> post("/api/v1/accounts/#{other_user.id}/unblock")
1729
1730     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1731   end
1732
1733   test "getting a list of blocks", %{conn: conn} do
1734     user = insert(:user)
1735     other_user = insert(:user)
1736
1737     {:ok, user} = User.block(user, other_user)
1738
1739     conn =
1740       conn
1741       |> assign(:user, user)
1742       |> get("/api/v1/blocks")
1743
1744     other_user_id = to_string(other_user.id)
1745     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1746   end
1747
1748   test "blocking / unblocking a domain", %{conn: conn} do
1749     user = insert(:user)
1750     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1751
1752     conn =
1753       conn
1754       |> assign(:user, user)
1755       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1756
1757     assert %{} = json_response(conn, 200)
1758     user = User.get_cached_by_ap_id(user.ap_id)
1759     assert User.blocks?(user, other_user)
1760
1761     conn =
1762       build_conn()
1763       |> assign(:user, user)
1764       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1765
1766     assert %{} = json_response(conn, 200)
1767     user = User.get_cached_by_ap_id(user.ap_id)
1768     refute User.blocks?(user, other_user)
1769   end
1770
1771   test "getting a list of domain blocks", %{conn: conn} do
1772     user = insert(:user)
1773
1774     {:ok, user} = User.block_domain(user, "bad.site")
1775     {:ok, user} = User.block_domain(user, "even.worse.site")
1776
1777     conn =
1778       conn
1779       |> assign(:user, user)
1780       |> get("/api/v1/domain_blocks")
1781
1782     domain_blocks = json_response(conn, 200)
1783
1784     assert "bad.site" in domain_blocks
1785     assert "even.worse.site" in domain_blocks
1786   end
1787
1788   test "unimplemented follow_requests, blocks, domain blocks" do
1789     user = insert(:user)
1790
1791     ["blocks", "domain_blocks", "follow_requests"]
1792     |> Enum.each(fn endpoint ->
1793       conn =
1794         build_conn()
1795         |> assign(:user, user)
1796         |> get("/api/v1/#{endpoint}")
1797
1798       assert [] = json_response(conn, 200)
1799     end)
1800   end
1801
1802   test "account search", %{conn: conn} do
1803     user = insert(:user)
1804     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1805     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1806
1807     results =
1808       conn
1809       |> assign(:user, user)
1810       |> get("/api/v1/accounts/search", %{"q" => "shp"})
1811       |> json_response(200)
1812
1813     result_ids = for result <- results, do: result["acct"]
1814
1815     assert user_two.nickname in result_ids
1816     assert user_three.nickname in result_ids
1817
1818     results =
1819       conn
1820       |> assign(:user, user)
1821       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1822       |> json_response(200)
1823
1824     result_ids = for result <- results, do: result["acct"]
1825
1826     assert user_three.nickname in result_ids
1827   end
1828
1829   test "search", %{conn: conn} do
1830     user = insert(:user)
1831     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1832     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1833
1834     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1835
1836     {:ok, _activity} =
1837       CommonAPI.post(user, %{
1838         "status" => "This is about 2hu, but private",
1839         "visibility" => "private"
1840       })
1841
1842     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1843
1844     conn =
1845       conn
1846       |> get("/api/v1/search", %{"q" => "2hu"})
1847
1848     assert results = json_response(conn, 200)
1849
1850     [account | _] = results["accounts"]
1851     assert account["id"] == to_string(user_three.id)
1852
1853     assert results["hashtags"] == []
1854
1855     [status] = results["statuses"]
1856     assert status["id"] == to_string(activity.id)
1857   end
1858
1859   test "search fetches remote statuses", %{conn: conn} do
1860     capture_log(fn ->
1861       conn =
1862         conn
1863         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1864
1865       assert results = json_response(conn, 200)
1866
1867       [status] = results["statuses"]
1868       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1869     end)
1870   end
1871
1872   test "search doesn't show statuses that it shouldn't", %{conn: conn} do
1873     {:ok, activity} =
1874       CommonAPI.post(insert(:user), %{
1875         "status" => "This is about 2hu, but private",
1876         "visibility" => "private"
1877       })
1878
1879     capture_log(fn ->
1880       conn =
1881         conn
1882         |> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})
1883
1884       assert results = json_response(conn, 200)
1885
1886       [] = results["statuses"]
1887     end)
1888   end
1889
1890   test "search fetches remote accounts", %{conn: conn} do
1891     conn =
1892       conn
1893       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1894
1895     assert results = json_response(conn, 200)
1896     [account] = results["accounts"]
1897     assert account["acct"] == "shp@social.heldscal.la"
1898   end
1899
1900   test "returns the favorites of a user", %{conn: conn} do
1901     user = insert(:user)
1902     other_user = insert(:user)
1903
1904     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1905     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1906
1907     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1908
1909     first_conn =
1910       conn
1911       |> assign(:user, user)
1912       |> get("/api/v1/favourites")
1913
1914     assert [status] = json_response(first_conn, 200)
1915     assert status["id"] == to_string(activity.id)
1916
1917     assert [{"link", _link_header}] =
1918              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1919
1920     # Honours query params
1921     {:ok, second_activity} =
1922       CommonAPI.post(other_user, %{
1923         "status" =>
1924           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1925       })
1926
1927     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
1928
1929     last_like = status["id"]
1930
1931     second_conn =
1932       conn
1933       |> assign(:user, user)
1934       |> get("/api/v1/favourites?since_id=#{last_like}")
1935
1936     assert [second_status] = json_response(second_conn, 200)
1937     assert second_status["id"] == to_string(second_activity.id)
1938
1939     third_conn =
1940       conn
1941       |> assign(:user, user)
1942       |> get("/api/v1/favourites?limit=0")
1943
1944     assert [] = json_response(third_conn, 200)
1945   end
1946
1947   describe "updating credentials" do
1948     test "updates the user's bio", %{conn: conn} do
1949       user = insert(:user)
1950       user2 = insert(:user)
1951
1952       conn =
1953         conn
1954         |> assign(:user, user)
1955         |> patch("/api/v1/accounts/update_credentials", %{
1956           "note" => "I drink #cofe with @#{user2.nickname}"
1957         })
1958
1959       assert user = json_response(conn, 200)
1960
1961       assert user["note"] ==
1962                ~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe" rel="tag">#cofe</a> with <span class="h-card"><a data-user=") <>
1963                  user2.id <>
1964                  ~s(" class="u-url mention" href=") <>
1965                  user2.ap_id <> ~s(">@<span>) <> user2.nickname <> ~s(</span></a></span>)
1966     end
1967
1968     test "updates the user's locking status", %{conn: conn} do
1969       user = insert(:user)
1970
1971       conn =
1972         conn
1973         |> assign(:user, user)
1974         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1975
1976       assert user = json_response(conn, 200)
1977       assert user["locked"] == true
1978     end
1979
1980     test "updates the user's name", %{conn: conn} do
1981       user = insert(:user)
1982
1983       conn =
1984         conn
1985         |> assign(:user, user)
1986         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1987
1988       assert user = json_response(conn, 200)
1989       assert user["display_name"] == "markorepairs"
1990     end
1991
1992     test "updates the user's avatar", %{conn: conn} do
1993       user = insert(:user)
1994
1995       new_avatar = %Plug.Upload{
1996         content_type: "image/jpg",
1997         path: Path.absname("test/fixtures/image.jpg"),
1998         filename: "an_image.jpg"
1999       }
2000
2001       conn =
2002         conn
2003         |> assign(:user, user)
2004         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
2005
2006       assert user_response = json_response(conn, 200)
2007       assert user_response["avatar"] != User.avatar_url(user)
2008     end
2009
2010     test "updates the user's banner", %{conn: conn} do
2011       user = insert(:user)
2012
2013       new_header = %Plug.Upload{
2014         content_type: "image/jpg",
2015         path: Path.absname("test/fixtures/image.jpg"),
2016         filename: "an_image.jpg"
2017       }
2018
2019       conn =
2020         conn
2021         |> assign(:user, user)
2022         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
2023
2024       assert user_response = json_response(conn, 200)
2025       assert user_response["header"] != User.banner_url(user)
2026     end
2027
2028     test "requires 'write' permission", %{conn: conn} do
2029       token1 = insert(:oauth_token, scopes: ["read"])
2030       token2 = insert(:oauth_token, scopes: ["write", "follow"])
2031
2032       for token <- [token1, token2] do
2033         conn =
2034           conn
2035           |> put_req_header("authorization", "Bearer #{token.token}")
2036           |> patch("/api/v1/accounts/update_credentials", %{})
2037
2038         if token == token1 do
2039           assert %{"error" => "Insufficient permissions: write."} == json_response(conn, 403)
2040         else
2041           assert json_response(conn, 200)
2042         end
2043       end
2044     end
2045   end
2046
2047   test "get instance information", %{conn: conn} do
2048     conn = get(conn, "/api/v1/instance")
2049     assert result = json_response(conn, 200)
2050
2051     email = Pleroma.Config.get([:instance, :email])
2052     # Note: not checking for "max_toot_chars" since it's optional
2053     assert %{
2054              "uri" => _,
2055              "title" => _,
2056              "description" => _,
2057              "version" => _,
2058              "email" => from_config_email,
2059              "urls" => %{
2060                "streaming_api" => _
2061              },
2062              "stats" => _,
2063              "thumbnail" => _,
2064              "languages" => _,
2065              "registrations" => _
2066            } = result
2067
2068     assert email == from_config_email
2069   end
2070
2071   test "get instance stats", %{conn: conn} do
2072     user = insert(:user, %{local: true})
2073
2074     user2 = insert(:user, %{local: true})
2075     {:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)
2076
2077     insert(:user, %{local: false, nickname: "u@peer1.com"})
2078     insert(:user, %{local: false, nickname: "u@peer2.com"})
2079
2080     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
2081
2082     # Stats should count users with missing or nil `info.deactivated` value
2083     user = User.get_by_id(user.id)
2084     info_change = Changeset.change(user.info, %{deactivated: nil})
2085
2086     {:ok, _user} =
2087       user
2088       |> Changeset.change()
2089       |> Changeset.put_embed(:info, info_change)
2090       |> User.update_and_set_cache()
2091
2092     Pleroma.Stats.update_stats()
2093
2094     conn = get(conn, "/api/v1/instance")
2095
2096     assert result = json_response(conn, 200)
2097
2098     stats = result["stats"]
2099
2100     assert stats
2101     assert stats["user_count"] == 1
2102     assert stats["status_count"] == 1
2103     assert stats["domain_count"] == 2
2104   end
2105
2106   test "get peers", %{conn: conn} do
2107     insert(:user, %{local: false, nickname: "u@peer1.com"})
2108     insert(:user, %{local: false, nickname: "u@peer2.com"})
2109
2110     Pleroma.Stats.update_stats()
2111
2112     conn = get(conn, "/api/v1/instance/peers")
2113
2114     assert result = json_response(conn, 200)
2115
2116     assert ["peer1.com", "peer2.com"] == Enum.sort(result)
2117   end
2118
2119   test "put settings", %{conn: conn} do
2120     user = insert(:user)
2121
2122     conn =
2123       conn
2124       |> assign(:user, user)
2125       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
2126
2127     assert _result = json_response(conn, 200)
2128
2129     user = User.get_cached_by_ap_id(user.ap_id)
2130     assert user.info.settings == %{"programming" => "socks"}
2131   end
2132
2133   describe "pinned statuses" do
2134     setup do
2135       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
2136
2137       user = insert(:user)
2138       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
2139
2140       [user: user, activity: activity]
2141     end
2142
2143     test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
2144       {:ok, _} = CommonAPI.pin(activity.id, user)
2145
2146       result =
2147         conn
2148         |> assign(:user, user)
2149         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2150         |> json_response(200)
2151
2152       id_str = to_string(activity.id)
2153
2154       assert [%{"id" => ^id_str, "pinned" => true}] = result
2155     end
2156
2157     test "pin status", %{conn: conn, user: user, activity: activity} do
2158       id_str = to_string(activity.id)
2159
2160       assert %{"id" => ^id_str, "pinned" => true} =
2161                conn
2162                |> assign(:user, user)
2163                |> post("/api/v1/statuses/#{activity.id}/pin")
2164                |> json_response(200)
2165
2166       assert [%{"id" => ^id_str, "pinned" => true}] =
2167                conn
2168                |> assign(:user, user)
2169                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2170                |> json_response(200)
2171     end
2172
2173     test "unpin status", %{conn: conn, user: user, activity: activity} do
2174       {:ok, _} = CommonAPI.pin(activity.id, user)
2175
2176       id_str = to_string(activity.id)
2177       user = refresh_record(user)
2178
2179       assert %{"id" => ^id_str, "pinned" => false} =
2180                conn
2181                |> assign(:user, user)
2182                |> post("/api/v1/statuses/#{activity.id}/unpin")
2183                |> json_response(200)
2184
2185       assert [] =
2186                conn
2187                |> assign(:user, user)
2188                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2189                |> json_response(200)
2190     end
2191
2192     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
2193       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
2194
2195       id_str_one = to_string(activity_one.id)
2196
2197       assert %{"id" => ^id_str_one, "pinned" => true} =
2198                conn
2199                |> assign(:user, user)
2200                |> post("/api/v1/statuses/#{id_str_one}/pin")
2201                |> json_response(200)
2202
2203       user = refresh_record(user)
2204
2205       assert %{"error" => "You have already pinned the maximum number of statuses"} =
2206                conn
2207                |> assign(:user, user)
2208                |> post("/api/v1/statuses/#{activity_two.id}/pin")
2209                |> json_response(400)
2210     end
2211
2212     test "Status rich-media Card", %{conn: conn, user: user} do
2213       Pleroma.Config.put([:rich_media, :enabled], true)
2214       {:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})
2215
2216       response =
2217         conn
2218         |> get("/api/v1/statuses/#{activity.id}/card")
2219         |> json_response(200)
2220
2221       assert response == %{
2222                "image" => "http://ia.media-imdb.com/images/rock.jpg",
2223                "provider_name" => "www.imdb.com",
2224                "provider_url" => "http://www.imdb.com",
2225                "title" => "The Rock",
2226                "type" => "link",
2227                "url" => "http://www.imdb.com/title/tt0117500/",
2228                "description" => nil,
2229                "pleroma" => %{
2230                  "opengraph" => %{
2231                    "image" => "http://ia.media-imdb.com/images/rock.jpg",
2232                    "title" => "The Rock",
2233                    "type" => "video.movie",
2234                    "url" => "http://www.imdb.com/title/tt0117500/"
2235                  }
2236                }
2237              }
2238
2239       # works with private posts
2240       {:ok, activity} =
2241         CommonAPI.post(user, %{"status" => "http://example.com/ogp", "visibility" => "direct"})
2242
2243       response_two =
2244         conn
2245         |> assign(:user, user)
2246         |> get("/api/v1/statuses/#{activity.id}/card")
2247         |> json_response(200)
2248
2249       assert response_two == response
2250
2251       Pleroma.Config.put([:rich_media, :enabled], false)
2252     end
2253   end
2254
2255   test "bookmarks" do
2256     user = insert(:user)
2257     for_user = insert(:user)
2258
2259     {:ok, activity1} =
2260       CommonAPI.post(user, %{
2261         "status" => "heweoo?"
2262       })
2263
2264     {:ok, activity2} =
2265       CommonAPI.post(user, %{
2266         "status" => "heweoo!"
2267       })
2268
2269     response1 =
2270       build_conn()
2271       |> assign(:user, for_user)
2272       |> post("/api/v1/statuses/#{activity1.id}/bookmark")
2273
2274     assert json_response(response1, 200)["bookmarked"] == true
2275
2276     response2 =
2277       build_conn()
2278       |> assign(:user, for_user)
2279       |> post("/api/v1/statuses/#{activity2.id}/bookmark")
2280
2281     assert json_response(response2, 200)["bookmarked"] == true
2282
2283     bookmarks =
2284       build_conn()
2285       |> assign(:user, for_user)
2286       |> get("/api/v1/bookmarks")
2287
2288     assert [json_response(response2, 200), json_response(response1, 200)] ==
2289              json_response(bookmarks, 200)
2290
2291     response1 =
2292       build_conn()
2293       |> assign(:user, for_user)
2294       |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
2295
2296     assert json_response(response1, 200)["bookmarked"] == false
2297
2298     bookmarks =
2299       build_conn()
2300       |> assign(:user, for_user)
2301       |> get("/api/v1/bookmarks")
2302
2303     assert [json_response(response2, 200)] == json_response(bookmarks, 200)
2304   end
2305
2306   describe "conversation muting" do
2307     setup do
2308       user = insert(:user)
2309       {:ok, activity} = CommonAPI.post(user, %{"status" => "HIE"})
2310
2311       [user: user, activity: activity]
2312     end
2313
2314     test "mute conversation", %{conn: conn, user: user, activity: activity} do
2315       id_str = to_string(activity.id)
2316
2317       assert %{"id" => ^id_str, "muted" => true} =
2318                conn
2319                |> assign(:user, user)
2320                |> post("/api/v1/statuses/#{activity.id}/mute")
2321                |> json_response(200)
2322     end
2323
2324     test "unmute conversation", %{conn: conn, user: user, activity: activity} do
2325       {:ok, _} = CommonAPI.add_mute(user, activity)
2326
2327       id_str = to_string(activity.id)
2328       user = refresh_record(user)
2329
2330       assert %{"id" => ^id_str, "muted" => false} =
2331                conn
2332                |> assign(:user, user)
2333                |> post("/api/v1/statuses/#{activity.id}/unmute")
2334                |> json_response(200)
2335     end
2336   end
2337
2338   test "flavours switching (Pleroma Extension)", %{conn: conn} do
2339     user = insert(:user)
2340
2341     get_old_flavour =
2342       conn
2343       |> assign(:user, user)
2344       |> get("/api/v1/pleroma/flavour")
2345
2346     assert "glitch" == json_response(get_old_flavour, 200)
2347
2348     set_flavour =
2349       conn
2350       |> assign(:user, user)
2351       |> post("/api/v1/pleroma/flavour/vanilla")
2352
2353     assert "vanilla" == json_response(set_flavour, 200)
2354
2355     get_new_flavour =
2356       conn
2357       |> assign(:user, user)
2358       |> post("/api/v1/pleroma/flavour/vanilla")
2359
2360     assert json_response(set_flavour, 200) == json_response(get_new_flavour, 200)
2361   end
2362
2363   describe "reports" do
2364     setup do
2365       reporter = insert(:user)
2366       target_user = insert(:user)
2367
2368       {:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})
2369
2370       [reporter: reporter, target_user: target_user, activity: activity]
2371     end
2372
2373     test "submit a basic report", %{conn: conn, reporter: reporter, target_user: target_user} do
2374       assert %{"action_taken" => false, "id" => _} =
2375                conn
2376                |> assign(:user, reporter)
2377                |> post("/api/v1/reports", %{"account_id" => target_user.id})
2378                |> json_response(200)
2379     end
2380
2381     test "submit a report with statuses and comment", %{
2382       conn: conn,
2383       reporter: reporter,
2384       target_user: target_user,
2385       activity: activity
2386     } do
2387       assert %{"action_taken" => false, "id" => _} =
2388                conn
2389                |> assign(:user, reporter)
2390                |> post("/api/v1/reports", %{
2391                  "account_id" => target_user.id,
2392                  "status_ids" => [activity.id],
2393                  "comment" => "bad status!"
2394                })
2395                |> json_response(200)
2396     end
2397
2398     test "account_id is required", %{
2399       conn: conn,
2400       reporter: reporter,
2401       activity: activity
2402     } do
2403       assert %{"error" => "Valid `account_id` required"} =
2404                conn
2405                |> assign(:user, reporter)
2406                |> post("/api/v1/reports", %{"status_ids" => [activity.id]})
2407                |> json_response(400)
2408     end
2409
2410     test "comment must be up to the size specified in the config", %{
2411       conn: conn,
2412       reporter: reporter,
2413       target_user: target_user
2414     } do
2415       max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
2416       comment = String.pad_trailing("a", max_size + 1, "a")
2417
2418       error = %{"error" => "Comment must be up to #{max_size} characters"}
2419
2420       assert ^error =
2421                conn
2422                |> assign(:user, reporter)
2423                |> post("/api/v1/reports", %{"account_id" => target_user.id, "comment" => comment})
2424                |> json_response(400)
2425     end
2426   end
2427
2428   describe "link headers" do
2429     test "preserves parameters in link headers", %{conn: conn} do
2430       user = insert(:user)
2431       other_user = insert(:user)
2432
2433       {:ok, activity1} =
2434         CommonAPI.post(other_user, %{
2435           "status" => "hi @#{user.nickname}",
2436           "visibility" => "public"
2437         })
2438
2439       {:ok, activity2} =
2440         CommonAPI.post(other_user, %{
2441           "status" => "hi @#{user.nickname}",
2442           "visibility" => "public"
2443         })
2444
2445       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
2446       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
2447
2448       conn =
2449         conn
2450         |> assign(:user, user)
2451         |> get("/api/v1/notifications", %{media_only: true})
2452
2453       assert [link_header] = get_resp_header(conn, "link")
2454       assert link_header =~ ~r/media_only=true/
2455       assert link_header =~ ~r/min_id=#{notification2.id}/
2456       assert link_header =~ ~r/max_id=#{notification1.id}/
2457     end
2458   end
2459
2460   test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
2461     # Need to set an old-style integer ID to reproduce the problem
2462     # (these are no longer assigned to new accounts but were preserved
2463     # for existing accounts during the migration to flakeIDs)
2464     user_one = insert(:user, %{id: 1212})
2465     user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})
2466
2467     resp_one =
2468       conn
2469       |> get("/api/v1/accounts/#{user_one.id}")
2470
2471     resp_two =
2472       conn
2473       |> get("/api/v1/accounts/#{user_two.nickname}")
2474
2475     resp_three =
2476       conn
2477       |> get("/api/v1/accounts/#{user_two.id}")
2478
2479     acc_one = json_response(resp_one, 200)
2480     acc_two = json_response(resp_two, 200)
2481     acc_three = json_response(resp_three, 200)
2482     refute acc_one == acc_two
2483     assert acc_two == acc_three
2484   end
2485
2486   describe "custom emoji" do
2487     test "with tags", %{conn: conn} do
2488       [emoji | _body] =
2489         conn
2490         |> get("/api/v1/custom_emojis")
2491         |> json_response(200)
2492
2493       assert Map.has_key?(emoji, "shortcode")
2494       assert Map.has_key?(emoji, "static_url")
2495       assert Map.has_key?(emoji, "tags")
2496       assert is_list(emoji["tags"])
2497       assert Map.has_key?(emoji, "url")
2498       assert Map.has_key?(emoji, "visible_in_picker")
2499     end
2500   end
2501
2502   describe "index/2 redirections" do
2503     setup %{conn: conn} do
2504       session_opts = [
2505         store: :cookie,
2506         key: "_test",
2507         signing_salt: "cooldude"
2508       ]
2509
2510       conn =
2511         conn
2512         |> Plug.Session.call(Plug.Session.init(session_opts))
2513         |> fetch_session()
2514
2515       test_path = "/web/statuses/test"
2516       %{conn: conn, path: test_path}
2517     end
2518
2519     test "redirects not logged-in users to the login page", %{conn: conn, path: path} do
2520       conn = get(conn, path)
2521
2522       assert conn.status == 302
2523       assert redirected_to(conn) == "/web/login"
2524     end
2525
2526     test "does not redirect logged in users to the login page", %{conn: conn, path: path} do
2527       token = insert(:oauth_token)
2528
2529       conn =
2530         conn
2531         |> assign(:user, token.user)
2532         |> put_session(:oauth_token, token.token)
2533         |> get(path)
2534
2535       assert conn.status == 200
2536     end
2537
2538     test "saves referer path to session", %{conn: conn, path: path} do
2539       conn = get(conn, path)
2540       return_to = Plug.Conn.get_session(conn, :return_to)
2541
2542       assert return_to == path
2543     end
2544
2545     test "redirects to the saved path after log in", %{conn: conn, path: path} do
2546       app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
2547       auth = insert(:oauth_authorization, app: app)
2548
2549       conn =
2550         conn
2551         |> put_session(:return_to, path)
2552         |> get("/web/login", %{code: auth.token})
2553
2554       assert conn.status == 302
2555       assert redirected_to(conn) == path
2556     end
2557
2558     test "redirects to the getting-started page when referer is not present", %{conn: conn} do
2559       app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
2560       auth = insert(:oauth_authorization, app: app)
2561
2562       conn = get(conn, "/web/login", %{code: auth.token})
2563
2564       assert conn.status == 302
2565       assert redirected_to(conn) == "/web/getting-started"
2566     end
2567   end
2568
2569   describe "scheduled activities" do
2570     test "creates a scheduled activity", %{conn: conn} do
2571       user = insert(:user)
2572       scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
2573
2574       conn =
2575         conn
2576         |> assign(:user, user)
2577         |> post("/api/v1/statuses", %{
2578           "status" => "scheduled",
2579           "scheduled_at" => scheduled_at
2580         })
2581
2582       assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
2583       assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(scheduled_at)
2584       assert [] == Repo.all(Activity)
2585     end
2586
2587     test "creates a scheduled activity with a media attachment", %{conn: conn} do
2588       user = insert(:user)
2589       scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
2590
2591       file = %Plug.Upload{
2592         content_type: "image/jpg",
2593         path: Path.absname("test/fixtures/image.jpg"),
2594         filename: "an_image.jpg"
2595       }
2596
2597       {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
2598
2599       conn =
2600         conn
2601         |> assign(:user, user)
2602         |> post("/api/v1/statuses", %{
2603           "media_ids" => [to_string(upload.id)],
2604           "status" => "scheduled",
2605           "scheduled_at" => scheduled_at
2606         })
2607
2608       assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
2609       assert %{"type" => "image"} = media_attachment
2610     end
2611
2612     test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
2613          %{conn: conn} do
2614       user = insert(:user)
2615
2616       scheduled_at =
2617         NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
2618
2619       conn =
2620         conn
2621         |> assign(:user, user)
2622         |> post("/api/v1/statuses", %{
2623           "status" => "not scheduled",
2624           "scheduled_at" => scheduled_at
2625         })
2626
2627       assert %{"content" => "not scheduled"} = json_response(conn, 200)
2628       assert [] == Repo.all(ScheduledActivity)
2629     end
2630
2631     test "returns error when daily user limit is exceeded", %{conn: conn} do
2632       user = insert(:user)
2633
2634       today =
2635         NaiveDateTime.utc_now()
2636         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
2637         |> NaiveDateTime.to_iso8601()
2638
2639       attrs = %{params: %{}, scheduled_at: today}
2640       {:ok, _} = ScheduledActivity.create(user, attrs)
2641       {:ok, _} = ScheduledActivity.create(user, attrs)
2642
2643       conn =
2644         conn
2645         |> assign(:user, user)
2646         |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
2647
2648       assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
2649     end
2650
2651     test "returns error when total user limit is exceeded", %{conn: conn} do
2652       user = insert(:user)
2653
2654       today =
2655         NaiveDateTime.utc_now()
2656         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
2657         |> NaiveDateTime.to_iso8601()
2658
2659       tomorrow =
2660         NaiveDateTime.utc_now()
2661         |> NaiveDateTime.add(:timer.hours(36), :millisecond)
2662         |> NaiveDateTime.to_iso8601()
2663
2664       attrs = %{params: %{}, scheduled_at: today}
2665       {:ok, _} = ScheduledActivity.create(user, attrs)
2666       {:ok, _} = ScheduledActivity.create(user, attrs)
2667       {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
2668
2669       conn =
2670         conn
2671         |> assign(:user, user)
2672         |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
2673
2674       assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
2675     end
2676
2677     test "shows scheduled activities", %{conn: conn} do
2678       user = insert(:user)
2679       scheduled_activity_id1 = insert(:scheduled_activity, user: user).id |> to_string()
2680       scheduled_activity_id2 = insert(:scheduled_activity, user: user).id |> to_string()
2681       scheduled_activity_id3 = insert(:scheduled_activity, user: user).id |> to_string()
2682       scheduled_activity_id4 = insert(:scheduled_activity, user: user).id |> to_string()
2683
2684       conn =
2685         conn
2686         |> assign(:user, user)
2687
2688       # min_id
2689       conn_res =
2690         conn
2691         |> get("/api/v1/scheduled_statuses?limit=2&min_id=#{scheduled_activity_id1}")
2692
2693       result = json_response(conn_res, 200)
2694       assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
2695
2696       # since_id
2697       conn_res =
2698         conn
2699         |> get("/api/v1/scheduled_statuses?limit=2&since_id=#{scheduled_activity_id1}")
2700
2701       result = json_response(conn_res, 200)
2702       assert [%{"id" => ^scheduled_activity_id4}, %{"id" => ^scheduled_activity_id3}] = result
2703
2704       # max_id
2705       conn_res =
2706         conn
2707         |> get("/api/v1/scheduled_statuses?limit=2&max_id=#{scheduled_activity_id4}")
2708
2709       result = json_response(conn_res, 200)
2710       assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
2711     end
2712
2713     test "shows a scheduled activity", %{conn: conn} do
2714       user = insert(:user)
2715       scheduled_activity = insert(:scheduled_activity, user: user)
2716
2717       res_conn =
2718         conn
2719         |> assign(:user, user)
2720         |> get("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
2721
2722       assert %{"id" => scheduled_activity_id} = json_response(res_conn, 200)
2723       assert scheduled_activity_id == scheduled_activity.id |> to_string()
2724
2725       res_conn =
2726         conn
2727         |> assign(:user, user)
2728         |> get("/api/v1/scheduled_statuses/404")
2729
2730       assert %{"error" => "Record not found"} = json_response(res_conn, 404)
2731     end
2732
2733     test "updates a scheduled activity", %{conn: conn} do
2734       user = insert(:user)
2735       scheduled_activity = insert(:scheduled_activity, user: user)
2736
2737       new_scheduled_at =
2738         NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
2739
2740       res_conn =
2741         conn
2742         |> assign(:user, user)
2743         |> put("/api/v1/scheduled_statuses/#{scheduled_activity.id}", %{
2744           scheduled_at: new_scheduled_at
2745         })
2746
2747       assert %{"scheduled_at" => expected_scheduled_at} = json_response(res_conn, 200)
2748       assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(new_scheduled_at)
2749
2750       res_conn =
2751         conn
2752         |> assign(:user, user)
2753         |> put("/api/v1/scheduled_statuses/404", %{scheduled_at: new_scheduled_at})
2754
2755       assert %{"error" => "Record not found"} = json_response(res_conn, 404)
2756     end
2757
2758     test "deletes a scheduled activity", %{conn: conn} do
2759       user = insert(:user)
2760       scheduled_activity = insert(:scheduled_activity, user: user)
2761
2762       res_conn =
2763         conn
2764         |> assign(:user, user)
2765         |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
2766
2767       assert %{} = json_response(res_conn, 200)
2768       assert nil == Repo.get(ScheduledActivity, scheduled_activity.id)
2769
2770       res_conn =
2771         conn
2772         |> assign(:user, user)
2773         |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
2774
2775       assert %{"error" => "Record not found"} = json_response(res_conn, 404)
2776     end
2777   end
2778
2779   test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
2780     user1 = insert(:user)
2781     user2 = insert(:user)
2782     user3 = insert(:user)
2783
2784     {:ok, replied_to} = TwitterAPI.create_status(user1, %{"status" => "cofe"})
2785
2786     # Reply to status from another user
2787     conn1 =
2788       conn
2789       |> assign(:user, user2)
2790       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
2791
2792     assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)
2793
2794     activity = Activity.get_by_id(id)
2795
2796     assert activity.data["object"]["inReplyTo"] == replied_to.data["object"]["id"]
2797     assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
2798
2799     # Reblog from the third user
2800     conn2 =
2801       conn
2802       |> assign(:user, user3)
2803       |> post("/api/v1/statuses/#{activity.id}/reblog")
2804
2805     assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
2806              json_response(conn2, 200)
2807
2808     assert to_string(activity.id) == id
2809
2810     # Getting third user status
2811     conn3 =
2812       conn
2813       |> assign(:user, user3)
2814       |> get("api/v1/timelines/home")
2815
2816     [reblogged_activity] = json_response(conn3, 200)
2817
2818     assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id
2819
2820     replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
2821     assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
2822   end
2823 end