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 "account search", %{conn: conn} do
2138     user = insert(:user)
2139     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
2140     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
2141
2142     results =
2143       conn
2144       |> assign(:user, user)
2145       |> get("/api/v1/accounts/search", %{"q" => "shp"})
2146       |> json_response(200)
2147
2148     result_ids = for result <- results, do: result["acct"]
2149
2150     assert user_two.nickname in result_ids
2151     assert user_three.nickname in result_ids
2152
2153     results =
2154       conn
2155       |> assign(:user, user)
2156       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
2157       |> json_response(200)
2158
2159     result_ids = for result <- results, do: result["acct"]
2160
2161     assert user_three.nickname in result_ids
2162   end
2163
2164   test "search", %{conn: conn} do
2165     user = insert(:user)
2166     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
2167     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
2168
2169     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
2170
2171     {:ok, _activity} =
2172       CommonAPI.post(user, %{
2173         "status" => "This is about 2hu, but private",
2174         "visibility" => "private"
2175       })
2176
2177     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
2178
2179     conn =
2180       conn
2181       |> get("/api/v1/search", %{"q" => "2hu"})
2182
2183     assert results = json_response(conn, 200)
2184
2185     [account | _] = results["accounts"]
2186     assert account["id"] == to_string(user_three.id)
2187
2188     assert results["hashtags"] == []
2189
2190     [status] = results["statuses"]
2191     assert status["id"] == to_string(activity.id)
2192   end
2193
2194   test "search fetches remote statuses", %{conn: conn} do
2195     capture_log(fn ->
2196       conn =
2197         conn
2198         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
2199
2200       assert results = json_response(conn, 200)
2201
2202       [status] = results["statuses"]
2203       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
2204     end)
2205   end
2206
2207   test "search doesn't show statuses that it shouldn't", %{conn: conn} do
2208     {:ok, activity} =
2209       CommonAPI.post(insert(:user), %{
2210         "status" => "This is about 2hu, but private",
2211         "visibility" => "private"
2212       })
2213
2214     capture_log(fn ->
2215       conn =
2216         conn
2217         |> get("/api/v1/search", %{"q" => Object.normalize(activity).data["id"]})
2218
2219       assert results = json_response(conn, 200)
2220
2221       [] = results["statuses"]
2222     end)
2223   end
2224
2225   test "search fetches remote accounts", %{conn: conn} do
2226     user = insert(:user)
2227
2228     conn =
2229       conn
2230       |> assign(:user, user)
2231       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
2232
2233     assert results = json_response(conn, 200)
2234     [account] = results["accounts"]
2235     assert account["acct"] == "shp@social.heldscal.la"
2236   end
2237
2238   test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
2239     conn =
2240       conn
2241       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "false"})
2242
2243     assert results = json_response(conn, 200)
2244     assert [] == results["accounts"]
2245   end
2246
2247   test "returns the favorites of a user", %{conn: conn} do
2248     user = insert(:user)
2249     other_user = insert(:user)
2250
2251     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
2252     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
2253
2254     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
2255
2256     first_conn =
2257       conn
2258       |> assign(:user, user)
2259       |> get("/api/v1/favourites")
2260
2261     assert [status] = json_response(first_conn, 200)
2262     assert status["id"] == to_string(activity.id)
2263
2264     assert [{"link", _link_header}] =
2265              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
2266
2267     # Honours query params
2268     {:ok, second_activity} =
2269       CommonAPI.post(other_user, %{
2270         "status" =>
2271           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
2272       })
2273
2274     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
2275
2276     last_like = status["id"]
2277
2278     second_conn =
2279       conn
2280       |> assign(:user, user)
2281       |> get("/api/v1/favourites?since_id=#{last_like}")
2282
2283     assert [second_status] = json_response(second_conn, 200)
2284     assert second_status["id"] == to_string(second_activity.id)
2285
2286     third_conn =
2287       conn
2288       |> assign(:user, user)
2289       |> get("/api/v1/favourites?limit=0")
2290
2291     assert [] = json_response(third_conn, 200)
2292   end
2293
2294   describe "getting favorites timeline of specified user" do
2295     setup do
2296       [current_user, user] = insert_pair(:user, %{info: %{hide_favorites: false}})
2297       [current_user: current_user, user: user]
2298     end
2299
2300     test "returns list of statuses favorited by specified user", %{
2301       conn: conn,
2302       current_user: current_user,
2303       user: user
2304     } do
2305       [activity | _] = insert_pair(:note_activity)
2306       CommonAPI.favorite(activity.id, user)
2307
2308       response =
2309         conn
2310         |> assign(:user, current_user)
2311         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2312         |> json_response(:ok)
2313
2314       [like] = response
2315
2316       assert length(response) == 1
2317       assert like["id"] == activity.id
2318     end
2319
2320     test "returns favorites for specified user_id when user is not logged in", %{
2321       conn: conn,
2322       user: user
2323     } do
2324       activity = insert(:note_activity)
2325       CommonAPI.favorite(activity.id, user)
2326
2327       response =
2328         conn
2329         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2330         |> json_response(:ok)
2331
2332       assert length(response) == 1
2333     end
2334
2335     test "returns favorited DM only when user is logged in and he is one of recipients", %{
2336       conn: conn,
2337       current_user: current_user,
2338       user: user
2339     } do
2340       {:ok, direct} =
2341         CommonAPI.post(current_user, %{
2342           "status" => "Hi @#{user.nickname}!",
2343           "visibility" => "direct"
2344         })
2345
2346       CommonAPI.favorite(direct.id, user)
2347
2348       response =
2349         conn
2350         |> assign(:user, current_user)
2351         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2352         |> json_response(:ok)
2353
2354       assert length(response) == 1
2355
2356       anonymous_response =
2357         conn
2358         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2359         |> json_response(:ok)
2360
2361       assert Enum.empty?(anonymous_response)
2362     end
2363
2364     test "does not return others' favorited DM when user is not one of recipients", %{
2365       conn: conn,
2366       current_user: current_user,
2367       user: user
2368     } do
2369       user_two = insert(:user)
2370
2371       {:ok, direct} =
2372         CommonAPI.post(user_two, %{
2373           "status" => "Hi @#{user.nickname}!",
2374           "visibility" => "direct"
2375         })
2376
2377       CommonAPI.favorite(direct.id, user)
2378
2379       response =
2380         conn
2381         |> assign(:user, current_user)
2382         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2383         |> json_response(:ok)
2384
2385       assert Enum.empty?(response)
2386     end
2387
2388     test "paginates favorites using since_id and max_id", %{
2389       conn: conn,
2390       current_user: current_user,
2391       user: user
2392     } do
2393       activities = insert_list(10, :note_activity)
2394
2395       Enum.each(activities, fn activity ->
2396         CommonAPI.favorite(activity.id, user)
2397       end)
2398
2399       third_activity = Enum.at(activities, 2)
2400       seventh_activity = Enum.at(activities, 6)
2401
2402       response =
2403         conn
2404         |> assign(:user, current_user)
2405         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{
2406           since_id: third_activity.id,
2407           max_id: seventh_activity.id
2408         })
2409         |> json_response(:ok)
2410
2411       assert length(response) == 3
2412       refute third_activity in response
2413       refute seventh_activity in response
2414     end
2415
2416     test "limits favorites using limit parameter", %{
2417       conn: conn,
2418       current_user: current_user,
2419       user: user
2420     } do
2421       7
2422       |> insert_list(:note_activity)
2423       |> Enum.each(fn activity ->
2424         CommonAPI.favorite(activity.id, user)
2425       end)
2426
2427       response =
2428         conn
2429         |> assign(:user, current_user)
2430         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{limit: "3"})
2431         |> json_response(:ok)
2432
2433       assert length(response) == 3
2434     end
2435
2436     test "returns empty response when user does not have any favorited statuses", %{
2437       conn: conn,
2438       current_user: current_user,
2439       user: user
2440     } do
2441       response =
2442         conn
2443         |> assign(:user, current_user)
2444         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2445         |> json_response(:ok)
2446
2447       assert Enum.empty?(response)
2448     end
2449
2450     test "returns 404 error when specified user is not exist", %{conn: conn} do
2451       conn = get(conn, "/api/v1/pleroma/accounts/test/favourites")
2452
2453       assert json_response(conn, 404) == %{"error" => "Record not found"}
2454     end
2455
2456     test "returns 403 error when user has hidden own favorites", %{
2457       conn: conn,
2458       current_user: current_user
2459     } do
2460       user = insert(:user, %{info: %{hide_favorites: true}})
2461       activity = insert(:note_activity)
2462       CommonAPI.favorite(activity.id, user)
2463
2464       conn =
2465         conn
2466         |> assign(:user, current_user)
2467         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2468
2469       assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
2470     end
2471
2472     test "hides favorites for new users by default", %{conn: conn, current_user: current_user} do
2473       user = insert(:user)
2474       activity = insert(:note_activity)
2475       CommonAPI.favorite(activity.id, user)
2476
2477       conn =
2478         conn
2479         |> assign(:user, current_user)
2480         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2481
2482       assert user.info.hide_favorites
2483       assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
2484     end
2485   end
2486
2487   test "get instance information", %{conn: conn} do
2488     conn = get(conn, "/api/v1/instance")
2489     assert result = json_response(conn, 200)
2490
2491     email = Pleroma.Config.get([:instance, :email])
2492     # Note: not checking for "max_toot_chars" since it's optional
2493     assert %{
2494              "uri" => _,
2495              "title" => _,
2496              "description" => _,
2497              "version" => _,
2498              "email" => from_config_email,
2499              "urls" => %{
2500                "streaming_api" => _
2501              },
2502              "stats" => _,
2503              "thumbnail" => _,
2504              "languages" => _,
2505              "registrations" => _,
2506              "poll_limits" => _
2507            } = result
2508
2509     assert email == from_config_email
2510   end
2511
2512   test "get instance stats", %{conn: conn} do
2513     user = insert(:user, %{local: true})
2514
2515     user2 = insert(:user, %{local: true})
2516     {:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)
2517
2518     insert(:user, %{local: false, nickname: "u@peer1.com"})
2519     insert(:user, %{local: false, nickname: "u@peer2.com"})
2520
2521     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
2522
2523     # Stats should count users with missing or nil `info.deactivated` value
2524     user = User.get_cached_by_id(user.id)
2525     info_change = Changeset.change(user.info, %{deactivated: nil})
2526
2527     {:ok, _user} =
2528       user
2529       |> Changeset.change()
2530       |> Changeset.put_embed(:info, info_change)
2531       |> User.update_and_set_cache()
2532
2533     Pleroma.Stats.update_stats()
2534
2535     conn = get(conn, "/api/v1/instance")
2536
2537     assert result = json_response(conn, 200)
2538
2539     stats = result["stats"]
2540
2541     assert stats
2542     assert stats["user_count"] == 1
2543     assert stats["status_count"] == 1
2544     assert stats["domain_count"] == 2
2545   end
2546
2547   test "get peers", %{conn: conn} do
2548     insert(:user, %{local: false, nickname: "u@peer1.com"})
2549     insert(:user, %{local: false, nickname: "u@peer2.com"})
2550
2551     Pleroma.Stats.update_stats()
2552
2553     conn = get(conn, "/api/v1/instance/peers")
2554
2555     assert result = json_response(conn, 200)
2556
2557     assert ["peer1.com", "peer2.com"] == Enum.sort(result)
2558   end
2559
2560   test "put settings", %{conn: conn} do
2561     user = insert(:user)
2562
2563     conn =
2564       conn
2565       |> assign(:user, user)
2566       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
2567
2568     assert _result = json_response(conn, 200)
2569
2570     user = User.get_cached_by_ap_id(user.ap_id)
2571     assert user.info.settings == %{"programming" => "socks"}
2572   end
2573
2574   describe "pinned statuses" do
2575     setup do
2576       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
2577
2578       user = insert(:user)
2579       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
2580
2581       [user: user, activity: activity]
2582     end
2583
2584     test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
2585       {:ok, _} = CommonAPI.pin(activity.id, user)
2586
2587       result =
2588         conn
2589         |> assign(:user, user)
2590         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2591         |> json_response(200)
2592
2593       id_str = to_string(activity.id)
2594
2595       assert [%{"id" => ^id_str, "pinned" => true}] = result
2596     end
2597
2598     test "pin status", %{conn: conn, user: user, activity: activity} do
2599       id_str = to_string(activity.id)
2600
2601       assert %{"id" => ^id_str, "pinned" => true} =
2602                conn
2603                |> assign(:user, user)
2604                |> post("/api/v1/statuses/#{activity.id}/pin")
2605                |> json_response(200)
2606
2607       assert [%{"id" => ^id_str, "pinned" => true}] =
2608                conn
2609                |> assign(:user, user)
2610                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2611                |> json_response(200)
2612     end
2613
2614     test "unpin status", %{conn: conn, user: user, activity: activity} do
2615       {:ok, _} = CommonAPI.pin(activity.id, user)
2616
2617       id_str = to_string(activity.id)
2618       user = refresh_record(user)
2619
2620       assert %{"id" => ^id_str, "pinned" => false} =
2621                conn
2622                |> assign(:user, user)
2623                |> post("/api/v1/statuses/#{activity.id}/unpin")
2624                |> json_response(200)
2625
2626       assert [] =
2627                conn
2628                |> assign(:user, user)
2629                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2630                |> json_response(200)
2631     end
2632
2633     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
2634       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
2635
2636       id_str_one = to_string(activity_one.id)
2637
2638       assert %{"id" => ^id_str_one, "pinned" => true} =
2639                conn
2640                |> assign(:user, user)
2641                |> post("/api/v1/statuses/#{id_str_one}/pin")
2642                |> json_response(200)
2643
2644       user = refresh_record(user)
2645
2646       assert %{"error" => "You have already pinned the maximum number of statuses"} =
2647                conn
2648                |> assign(:user, user)
2649                |> post("/api/v1/statuses/#{activity_two.id}/pin")
2650                |> json_response(400)
2651     end
2652   end
2653
2654   describe "cards" do
2655     setup do
2656       Pleroma.Config.put([:rich_media, :enabled], true)
2657
2658       on_exit(fn ->
2659         Pleroma.Config.put([:rich_media, :enabled], false)
2660       end)
2661
2662       user = insert(:user)
2663       %{user: user}
2664     end
2665
2666     test "returns rich-media card", %{conn: conn, user: user} do
2667       {:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})
2668
2669       card_data = %{
2670         "image" => "http://ia.media-imdb.com/images/rock.jpg",
2671         "provider_name" => "www.imdb.com",
2672         "provider_url" => "http://www.imdb.com",
2673         "title" => "The Rock",
2674         "type" => "link",
2675         "url" => "http://www.imdb.com/title/tt0117500/",
2676         "description" =>
2677           "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
2678         "pleroma" => %{
2679           "opengraph" => %{
2680             "image" => "http://ia.media-imdb.com/images/rock.jpg",
2681             "title" => "The Rock",
2682             "type" => "video.movie",
2683             "url" => "http://www.imdb.com/title/tt0117500/",
2684             "description" =>
2685               "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
2686           }
2687         }
2688       }
2689
2690       response =
2691         conn
2692         |> get("/api/v1/statuses/#{activity.id}/card")
2693         |> json_response(200)
2694
2695       assert response == card_data
2696
2697       # works with private posts
2698       {:ok, activity} =
2699         CommonAPI.post(user, %{"status" => "http://example.com/ogp", "visibility" => "direct"})
2700
2701       response_two =
2702         conn
2703         |> assign(:user, user)
2704         |> get("/api/v1/statuses/#{activity.id}/card")
2705         |> json_response(200)
2706
2707       assert response_two == card_data
2708     end
2709
2710     test "replaces missing description with an empty string", %{conn: conn, user: user} do
2711       {:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp-missing-data"})
2712
2713       response =
2714         conn
2715         |> get("/api/v1/statuses/#{activity.id}/card")
2716         |> json_response(:ok)
2717
2718       assert response == %{
2719                "type" => "link",
2720                "title" => "Pleroma",
2721                "description" => "",
2722                "image" => nil,
2723                "provider_name" => "pleroma.social",
2724                "provider_url" => "https://pleroma.social",
2725                "url" => "https://pleroma.social/",
2726                "pleroma" => %{
2727                  "opengraph" => %{
2728                    "title" => "Pleroma",
2729                    "type" => "website",
2730                    "url" => "https://pleroma.social/"
2731                  }
2732                }
2733              }
2734     end
2735   end
2736
2737   test "bookmarks" do
2738     user = insert(:user)
2739     for_user = insert(:user)
2740
2741     {:ok, activity1} =
2742       CommonAPI.post(user, %{
2743         "status" => "heweoo?"
2744       })
2745
2746     {:ok, activity2} =
2747       CommonAPI.post(user, %{
2748         "status" => "heweoo!"
2749       })
2750
2751     response1 =
2752       build_conn()
2753       |> assign(:user, for_user)
2754       |> post("/api/v1/statuses/#{activity1.id}/bookmark")
2755
2756     assert json_response(response1, 200)["bookmarked"] == true
2757
2758     response2 =
2759       build_conn()
2760       |> assign(:user, for_user)
2761       |> post("/api/v1/statuses/#{activity2.id}/bookmark")
2762
2763     assert json_response(response2, 200)["bookmarked"] == true
2764
2765     bookmarks =
2766       build_conn()
2767       |> assign(:user, for_user)
2768       |> get("/api/v1/bookmarks")
2769
2770     assert [json_response(response2, 200), json_response(response1, 200)] ==
2771              json_response(bookmarks, 200)
2772
2773     response1 =
2774       build_conn()
2775       |> assign(:user, for_user)
2776       |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
2777
2778     assert json_response(response1, 200)["bookmarked"] == false
2779
2780     bookmarks =
2781       build_conn()
2782       |> assign(:user, for_user)
2783       |> get("/api/v1/bookmarks")
2784
2785     assert [json_response(response2, 200)] == json_response(bookmarks, 200)
2786   end
2787
2788   describe "conversation muting" do
2789     setup do
2790       user = insert(:user)
2791       {:ok, activity} = CommonAPI.post(user, %{"status" => "HIE"})
2792
2793       [user: user, activity: activity]
2794     end
2795
2796     test "mute conversation", %{conn: conn, user: user, activity: activity} do
2797       id_str = to_string(activity.id)
2798
2799       assert %{"id" => ^id_str, "muted" => true} =
2800                conn
2801                |> assign(:user, user)
2802                |> post("/api/v1/statuses/#{activity.id}/mute")
2803                |> json_response(200)
2804     end
2805
2806     test "unmute conversation", %{conn: conn, user: user, activity: activity} do
2807       {:ok, _} = CommonAPI.add_mute(user, activity)
2808
2809       id_str = to_string(activity.id)
2810       user = refresh_record(user)
2811
2812       assert %{"id" => ^id_str, "muted" => false} =
2813                conn
2814                |> assign(:user, user)
2815                |> post("/api/v1/statuses/#{activity.id}/unmute")
2816                |> json_response(200)
2817     end
2818   end
2819
2820   describe "reports" do
2821     setup do
2822       reporter = insert(:user)
2823       target_user = insert(:user)
2824
2825       {:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})
2826
2827       [reporter: reporter, target_user: target_user, activity: activity]
2828     end
2829
2830     test "submit a basic report", %{conn: conn, reporter: reporter, target_user: target_user} do
2831       assert %{"action_taken" => false, "id" => _} =
2832                conn
2833                |> assign(:user, reporter)
2834                |> post("/api/v1/reports", %{"account_id" => target_user.id})
2835                |> json_response(200)
2836     end
2837
2838     test "submit a report with statuses and comment", %{
2839       conn: conn,
2840       reporter: reporter,
2841       target_user: target_user,
2842       activity: activity
2843     } do
2844       assert %{"action_taken" => false, "id" => _} =
2845                conn
2846                |> assign(:user, reporter)
2847                |> post("/api/v1/reports", %{
2848                  "account_id" => target_user.id,
2849                  "status_ids" => [activity.id],
2850                  "comment" => "bad status!"
2851                })
2852                |> json_response(200)
2853     end
2854
2855     test "account_id is required", %{
2856       conn: conn,
2857       reporter: reporter,
2858       activity: activity
2859     } do
2860       assert %{"error" => "Valid `account_id` required"} =
2861                conn
2862                |> assign(:user, reporter)
2863                |> post("/api/v1/reports", %{"status_ids" => [activity.id]})
2864                |> json_response(400)
2865     end
2866
2867     test "comment must be up to the size specified in the config", %{
2868       conn: conn,
2869       reporter: reporter,
2870       target_user: target_user
2871     } do
2872       max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
2873       comment = String.pad_trailing("a", max_size + 1, "a")
2874
2875       error = %{"error" => "Comment must be up to #{max_size} characters"}
2876
2877       assert ^error =
2878                conn
2879                |> assign(:user, reporter)
2880                |> post("/api/v1/reports", %{"account_id" => target_user.id, "comment" => comment})
2881                |> json_response(400)
2882     end
2883   end
2884
2885   describe "link headers" do
2886     test "preserves parameters in link headers", %{conn: conn} do
2887       user = insert(:user)
2888       other_user = insert(:user)
2889
2890       {:ok, activity1} =
2891         CommonAPI.post(other_user, %{
2892           "status" => "hi @#{user.nickname}",
2893           "visibility" => "public"
2894         })
2895
2896       {:ok, activity2} =
2897         CommonAPI.post(other_user, %{
2898           "status" => "hi @#{user.nickname}",
2899           "visibility" => "public"
2900         })
2901
2902       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
2903       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
2904
2905       conn =
2906         conn
2907         |> assign(:user, user)
2908         |> get("/api/v1/notifications", %{media_only: true})
2909
2910       assert [link_header] = get_resp_header(conn, "link")
2911       assert link_header =~ ~r/media_only=true/
2912       assert link_header =~ ~r/min_id=#{notification2.id}/
2913       assert link_header =~ ~r/max_id=#{notification1.id}/
2914     end
2915   end
2916
2917   test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
2918     # Need to set an old-style integer ID to reproduce the problem
2919     # (these are no longer assigned to new accounts but were preserved
2920     # for existing accounts during the migration to flakeIDs)
2921     user_one = insert(:user, %{id: 1212})
2922     user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})
2923
2924     resp_one =
2925       conn
2926       |> get("/api/v1/accounts/#{user_one.id}")
2927
2928     resp_two =
2929       conn
2930       |> get("/api/v1/accounts/#{user_two.nickname}")
2931
2932     resp_three =
2933       conn
2934       |> get("/api/v1/accounts/#{user_two.id}")
2935
2936     acc_one = json_response(resp_one, 200)
2937     acc_two = json_response(resp_two, 200)
2938     acc_three = json_response(resp_three, 200)
2939     refute acc_one == acc_two
2940     assert acc_two == acc_three
2941   end
2942
2943   describe "custom emoji" do
2944     test "with tags", %{conn: conn} do
2945       [emoji | _body] =
2946         conn
2947         |> get("/api/v1/custom_emojis")
2948         |> json_response(200)
2949
2950       assert Map.has_key?(emoji, "shortcode")
2951       assert Map.has_key?(emoji, "static_url")
2952       assert Map.has_key?(emoji, "tags")
2953       assert is_list(emoji["tags"])
2954       assert Map.has_key?(emoji, "url")
2955       assert Map.has_key?(emoji, "visible_in_picker")
2956     end
2957   end
2958
2959   describe "index/2 redirections" do
2960     setup %{conn: conn} do
2961       session_opts = [
2962         store: :cookie,
2963         key: "_test",
2964         signing_salt: "cooldude"
2965       ]
2966
2967       conn =
2968         conn
2969         |> Plug.Session.call(Plug.Session.init(session_opts))
2970         |> fetch_session()
2971
2972       test_path = "/web/statuses/test"
2973       %{conn: conn, path: test_path}
2974     end
2975
2976     test "redirects not logged-in users to the login page", %{conn: conn, path: path} do
2977       conn = get(conn, path)
2978
2979       assert conn.status == 302
2980       assert redirected_to(conn) == "/web/login"
2981     end
2982
2983     test "does not redirect logged in users to the login page", %{conn: conn, path: path} do
2984       token = insert(:oauth_token)
2985
2986       conn =
2987         conn
2988         |> assign(:user, token.user)
2989         |> put_session(:oauth_token, token.token)
2990         |> get(path)
2991
2992       assert conn.status == 200
2993     end
2994
2995     test "saves referer path to session", %{conn: conn, path: path} do
2996       conn = get(conn, path)
2997       return_to = Plug.Conn.get_session(conn, :return_to)
2998
2999       assert return_to == path
3000     end
3001
3002     test "redirects to the saved path after log in", %{conn: conn, path: path} do
3003       app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
3004       auth = insert(:oauth_authorization, app: app)
3005
3006       conn =
3007         conn
3008         |> put_session(:return_to, path)
3009         |> get("/web/login", %{code: auth.token})
3010
3011       assert conn.status == 302
3012       assert redirected_to(conn) == path
3013     end
3014
3015     test "redirects to the getting-started page when referer is not present", %{conn: conn} do
3016       app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
3017       auth = insert(:oauth_authorization, app: app)
3018
3019       conn = get(conn, "/web/login", %{code: auth.token})
3020
3021       assert conn.status == 302
3022       assert redirected_to(conn) == "/web/getting-started"
3023     end
3024   end
3025
3026   describe "scheduled activities" do
3027     test "creates a scheduled activity", %{conn: conn} do
3028       user = insert(:user)
3029       scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
3030
3031       conn =
3032         conn
3033         |> assign(:user, user)
3034         |> post("/api/v1/statuses", %{
3035           "status" => "scheduled",
3036           "scheduled_at" => scheduled_at
3037         })
3038
3039       assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
3040       assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(scheduled_at)
3041       assert [] == Repo.all(Activity)
3042     end
3043
3044     test "creates a scheduled activity with a media attachment", %{conn: conn} do
3045       user = insert(:user)
3046       scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
3047
3048       file = %Plug.Upload{
3049         content_type: "image/jpg",
3050         path: Path.absname("test/fixtures/image.jpg"),
3051         filename: "an_image.jpg"
3052       }
3053
3054       {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
3055
3056       conn =
3057         conn
3058         |> assign(:user, user)
3059         |> post("/api/v1/statuses", %{
3060           "media_ids" => [to_string(upload.id)],
3061           "status" => "scheduled",
3062           "scheduled_at" => scheduled_at
3063         })
3064
3065       assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
3066       assert %{"type" => "image"} = media_attachment
3067     end
3068
3069     test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
3070          %{conn: conn} do
3071       user = insert(:user)
3072
3073       scheduled_at =
3074         NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
3075
3076       conn =
3077         conn
3078         |> assign(:user, user)
3079         |> post("/api/v1/statuses", %{
3080           "status" => "not scheduled",
3081           "scheduled_at" => scheduled_at
3082         })
3083
3084       assert %{"content" => "not scheduled"} = json_response(conn, 200)
3085       assert [] == Repo.all(ScheduledActivity)
3086     end
3087
3088     test "returns error when daily user limit is exceeded", %{conn: conn} do
3089       user = insert(:user)
3090
3091       today =
3092         NaiveDateTime.utc_now()
3093         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
3094         |> NaiveDateTime.to_iso8601()
3095
3096       attrs = %{params: %{}, scheduled_at: today}
3097       {:ok, _} = ScheduledActivity.create(user, attrs)
3098       {:ok, _} = ScheduledActivity.create(user, attrs)
3099
3100       conn =
3101         conn
3102         |> assign(:user, user)
3103         |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
3104
3105       assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
3106     end
3107
3108     test "returns error when total user limit is exceeded", %{conn: conn} do
3109       user = insert(:user)
3110
3111       today =
3112         NaiveDateTime.utc_now()
3113         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
3114         |> NaiveDateTime.to_iso8601()
3115
3116       tomorrow =
3117         NaiveDateTime.utc_now()
3118         |> NaiveDateTime.add(:timer.hours(36), :millisecond)
3119         |> NaiveDateTime.to_iso8601()
3120
3121       attrs = %{params: %{}, scheduled_at: today}
3122       {:ok, _} = ScheduledActivity.create(user, attrs)
3123       {:ok, _} = ScheduledActivity.create(user, attrs)
3124       {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
3125
3126       conn =
3127         conn
3128         |> assign(:user, user)
3129         |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
3130
3131       assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
3132     end
3133
3134     test "shows scheduled activities", %{conn: conn} do
3135       user = insert(:user)
3136       scheduled_activity_id1 = insert(:scheduled_activity, user: user).id |> to_string()
3137       scheduled_activity_id2 = insert(:scheduled_activity, user: user).id |> to_string()
3138       scheduled_activity_id3 = insert(:scheduled_activity, user: user).id |> to_string()
3139       scheduled_activity_id4 = insert(:scheduled_activity, user: user).id |> to_string()
3140
3141       conn =
3142         conn
3143         |> assign(:user, user)
3144
3145       # min_id
3146       conn_res =
3147         conn
3148         |> get("/api/v1/scheduled_statuses?limit=2&min_id=#{scheduled_activity_id1}")
3149
3150       result = json_response(conn_res, 200)
3151       assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
3152
3153       # since_id
3154       conn_res =
3155         conn
3156         |> get("/api/v1/scheduled_statuses?limit=2&since_id=#{scheduled_activity_id1}")
3157
3158       result = json_response(conn_res, 200)
3159       assert [%{"id" => ^scheduled_activity_id4}, %{"id" => ^scheduled_activity_id3}] = result
3160
3161       # max_id
3162       conn_res =
3163         conn
3164         |> get("/api/v1/scheduled_statuses?limit=2&max_id=#{scheduled_activity_id4}")
3165
3166       result = json_response(conn_res, 200)
3167       assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
3168     end
3169
3170     test "shows a scheduled activity", %{conn: conn} do
3171       user = insert(:user)
3172       scheduled_activity = insert(:scheduled_activity, user: user)
3173
3174       res_conn =
3175         conn
3176         |> assign(:user, user)
3177         |> get("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
3178
3179       assert %{"id" => scheduled_activity_id} = json_response(res_conn, 200)
3180       assert scheduled_activity_id == scheduled_activity.id |> to_string()
3181
3182       res_conn =
3183         conn
3184         |> assign(:user, user)
3185         |> get("/api/v1/scheduled_statuses/404")
3186
3187       assert %{"error" => "Record not found"} = json_response(res_conn, 404)
3188     end
3189
3190     test "updates a scheduled activity", %{conn: conn} do
3191       user = insert(:user)
3192       scheduled_activity = insert(:scheduled_activity, user: user)
3193
3194       new_scheduled_at =
3195         NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
3196
3197       res_conn =
3198         conn
3199         |> assign(:user, user)
3200         |> put("/api/v1/scheduled_statuses/#{scheduled_activity.id}", %{
3201           scheduled_at: new_scheduled_at
3202         })
3203
3204       assert %{"scheduled_at" => expected_scheduled_at} = json_response(res_conn, 200)
3205       assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(new_scheduled_at)
3206
3207       res_conn =
3208         conn
3209         |> assign(:user, user)
3210         |> put("/api/v1/scheduled_statuses/404", %{scheduled_at: new_scheduled_at})
3211
3212       assert %{"error" => "Record not found"} = json_response(res_conn, 404)
3213     end
3214
3215     test "deletes a scheduled activity", %{conn: conn} do
3216       user = insert(:user)
3217       scheduled_activity = insert(:scheduled_activity, user: user)
3218
3219       res_conn =
3220         conn
3221         |> assign(:user, user)
3222         |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
3223
3224       assert %{} = json_response(res_conn, 200)
3225       assert nil == Repo.get(ScheduledActivity, scheduled_activity.id)
3226
3227       res_conn =
3228         conn
3229         |> assign(:user, user)
3230         |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
3231
3232       assert %{"error" => "Record not found"} = json_response(res_conn, 404)
3233     end
3234   end
3235
3236   test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
3237     user1 = insert(:user)
3238     user2 = insert(:user)
3239     user3 = insert(:user)
3240
3241     {:ok, replied_to} = TwitterAPI.create_status(user1, %{"status" => "cofe"})
3242
3243     # Reply to status from another user
3244     conn1 =
3245       conn
3246       |> assign(:user, user2)
3247       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
3248
3249     assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)
3250
3251     activity = Activity.get_by_id_with_object(id)
3252
3253     assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
3254     assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
3255
3256     # Reblog from the third user
3257     conn2 =
3258       conn
3259       |> assign(:user, user3)
3260       |> post("/api/v1/statuses/#{activity.id}/reblog")
3261
3262     assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
3263              json_response(conn2, 200)
3264
3265     assert to_string(activity.id) == id
3266
3267     # Getting third user status
3268     conn3 =
3269       conn
3270       |> assign(:user, user3)
3271       |> get("api/v1/timelines/home")
3272
3273     [reblogged_activity] = json_response(conn3, 200)
3274
3275     assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id
3276
3277     replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
3278     assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
3279   end
3280
3281   describe "create account by app" do
3282     test "Account registration via Application", %{conn: conn} do
3283       conn =
3284         conn
3285         |> post("/api/v1/apps", %{
3286           client_name: "client_name",
3287           redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
3288           scopes: "read, write, follow"
3289         })
3290
3291       %{
3292         "client_id" => client_id,
3293         "client_secret" => client_secret,
3294         "id" => _,
3295         "name" => "client_name",
3296         "redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
3297         "vapid_key" => _,
3298         "website" => nil
3299       } = json_response(conn, 200)
3300
3301       conn =
3302         conn
3303         |> post("/oauth/token", %{
3304           grant_type: "client_credentials",
3305           client_id: client_id,
3306           client_secret: client_secret
3307         })
3308
3309       assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
3310                json_response(conn, 200)
3311
3312       assert token
3313       token_from_db = Repo.get_by(Token, token: token)
3314       assert token_from_db
3315       assert refresh
3316       assert scope == "read write follow"
3317
3318       conn =
3319         build_conn()
3320         |> put_req_header("authorization", "Bearer " <> token)
3321         |> post("/api/v1/accounts", %{
3322           username: "lain",
3323           email: "lain@example.org",
3324           password: "PlzDontHackLain",
3325           agreement: true
3326         })
3327
3328       %{
3329         "access_token" => token,
3330         "created_at" => _created_at,
3331         "scope" => _scope,
3332         "token_type" => "Bearer"
3333       } = json_response(conn, 200)
3334
3335       token_from_db = Repo.get_by(Token, token: token)
3336       assert token_from_db
3337       token_from_db = Repo.preload(token_from_db, :user)
3338       assert token_from_db.user
3339
3340       assert token_from_db.user.info.confirmation_pending
3341     end
3342
3343     test "rate limit", %{conn: conn} do
3344       app_token = insert(:oauth_token, user: nil)
3345
3346       conn =
3347         put_req_header(conn, "authorization", "Bearer " <> app_token.token)
3348         |> Map.put(:remote_ip, {15, 15, 15, 15})
3349
3350       for i <- 1..5 do
3351         conn =
3352           conn
3353           |> post("/api/v1/accounts", %{
3354             username: "#{i}lain",
3355             email: "#{i}lain@example.org",
3356             password: "PlzDontHackLain",
3357             agreement: true
3358           })
3359
3360         %{
3361           "access_token" => token,
3362           "created_at" => _created_at,
3363           "scope" => _scope,
3364           "token_type" => "Bearer"
3365         } = json_response(conn, 200)
3366
3367         token_from_db = Repo.get_by(Token, token: token)
3368         assert token_from_db
3369         token_from_db = Repo.preload(token_from_db, :user)
3370         assert token_from_db.user
3371
3372         assert token_from_db.user.info.confirmation_pending
3373       end
3374
3375       conn =
3376         conn
3377         |> post("/api/v1/accounts", %{
3378           username: "6lain",
3379           email: "6lain@example.org",
3380           password: "PlzDontHackLain",
3381           agreement: true
3382         })
3383
3384       assert json_response(conn, :too_many_requests) == %{"error" => "Throttled"}
3385     end
3386   end
3387
3388   describe "GET /api/v1/polls/:id" do
3389     test "returns poll entity for object id", %{conn: conn} do
3390       user = insert(:user)
3391
3392       {:ok, activity} =
3393         CommonAPI.post(user, %{
3394           "status" => "Pleroma does",
3395           "poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20}
3396         })
3397
3398       object = Object.normalize(activity)
3399
3400       conn =
3401         conn
3402         |> assign(:user, user)
3403         |> get("/api/v1/polls/#{object.id}")
3404
3405       response = json_response(conn, 200)
3406       id = object.id
3407       assert %{"id" => ^id, "expired" => false, "multiple" => false} = response
3408     end
3409
3410     test "does not expose polls for private statuses", %{conn: conn} do
3411       user = insert(:user)
3412       other_user = insert(:user)
3413
3414       {:ok, activity} =
3415         CommonAPI.post(user, %{
3416           "status" => "Pleroma does",
3417           "poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20},
3418           "visibility" => "private"
3419         })
3420
3421       object = Object.normalize(activity)
3422
3423       conn =
3424         conn
3425         |> assign(:user, other_user)
3426         |> get("/api/v1/polls/#{object.id}")
3427
3428       assert json_response(conn, 404)
3429     end
3430   end
3431
3432   describe "POST /api/v1/polls/:id/votes" do
3433     test "votes are added to the poll", %{conn: conn} do
3434       user = insert(:user)
3435       other_user = insert(:user)
3436
3437       {:ok, activity} =
3438         CommonAPI.post(user, %{
3439           "status" => "A very delicious sandwich",
3440           "poll" => %{
3441             "options" => ["Lettuce", "Grilled Bacon", "Tomato"],
3442             "expires_in" => 20,
3443             "multiple" => true
3444           }
3445         })
3446
3447       object = Object.normalize(activity)
3448
3449       conn =
3450         conn
3451         |> assign(:user, other_user)
3452         |> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1, 2]})
3453
3454       assert json_response(conn, 200)
3455       object = Object.get_by_id(object.id)
3456
3457       assert Enum.all?(object.data["anyOf"], fn %{"replies" => %{"totalItems" => total_items}} ->
3458                total_items == 1
3459              end)
3460     end
3461
3462     test "author can't vote", %{conn: conn} do
3463       user = insert(:user)
3464
3465       {:ok, activity} =
3466         CommonAPI.post(user, %{
3467           "status" => "Am I cute?",
3468           "poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
3469         })
3470
3471       object = Object.normalize(activity)
3472
3473       assert conn
3474              |> assign(:user, user)
3475              |> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [1]})
3476              |> json_response(422) == %{"error" => "Poll's author can't vote"}
3477
3478       object = Object.get_by_id(object.id)
3479
3480       refute Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 1
3481     end
3482
3483     test "does not allow multiple choices on a single-choice question", %{conn: conn} do
3484       user = insert(:user)
3485       other_user = insert(:user)
3486
3487       {:ok, activity} =
3488         CommonAPI.post(user, %{
3489           "status" => "The glass is",
3490           "poll" => %{"options" => ["half empty", "half full"], "expires_in" => 20}
3491         })
3492
3493       object = Object.normalize(activity)
3494
3495       assert conn
3496              |> assign(:user, other_user)
3497              |> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1]})
3498              |> json_response(422) == %{"error" => "Too many choices"}
3499
3500       object = Object.get_by_id(object.id)
3501
3502       refute Enum.any?(object.data["oneOf"], fn %{"replies" => %{"totalItems" => total_items}} ->
3503                total_items == 1
3504              end)
3505     end
3506   end
3507 end