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