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 "locked accounts" do
1425     test "/api/v1/follow_requests works" do
1426       user = insert(:user, %{info: %User.Info{locked: true}})
1427       other_user = insert(:user)
1428
1429       {:ok, _activity} = ActivityPub.follow(other_user, user)
1430
1431       user = User.get_cached_by_id(user.id)
1432       other_user = User.get_cached_by_id(other_user.id)
1433
1434       assert User.following?(other_user, user) == false
1435
1436       conn =
1437         build_conn()
1438         |> assign(:user, user)
1439         |> get("/api/v1/follow_requests")
1440
1441       assert [relationship] = json_response(conn, 200)
1442       assert to_string(other_user.id) == relationship["id"]
1443     end
1444
1445     test "/api/v1/follow_requests/:id/authorize works" do
1446       user = insert(:user, %{info: %User.Info{locked: true}})
1447       other_user = insert(:user)
1448
1449       {:ok, _activity} = ActivityPub.follow(other_user, user)
1450
1451       user = User.get_cached_by_id(user.id)
1452       other_user = User.get_cached_by_id(other_user.id)
1453
1454       assert User.following?(other_user, user) == false
1455
1456       conn =
1457         build_conn()
1458         |> assign(:user, user)
1459         |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
1460
1461       assert relationship = json_response(conn, 200)
1462       assert to_string(other_user.id) == relationship["id"]
1463
1464       user = User.get_cached_by_id(user.id)
1465       other_user = User.get_cached_by_id(other_user.id)
1466
1467       assert User.following?(other_user, user) == true
1468     end
1469
1470     test "verify_credentials", %{conn: conn} do
1471       user = insert(:user, %{info: %User.Info{default_scope: "private"}})
1472
1473       conn =
1474         conn
1475         |> assign(:user, user)
1476         |> get("/api/v1/accounts/verify_credentials")
1477
1478       assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
1479       assert id == to_string(user.id)
1480     end
1481
1482     test "/api/v1/follow_requests/:id/reject works" do
1483       user = insert(:user, %{info: %User.Info{locked: true}})
1484       other_user = insert(:user)
1485
1486       {:ok, _activity} = ActivityPub.follow(other_user, user)
1487
1488       user = User.get_cached_by_id(user.id)
1489
1490       conn =
1491         build_conn()
1492         |> assign(:user, user)
1493         |> post("/api/v1/follow_requests/#{other_user.id}/reject")
1494
1495       assert relationship = json_response(conn, 200)
1496       assert to_string(other_user.id) == relationship["id"]
1497
1498       user = User.get_cached_by_id(user.id)
1499       other_user = User.get_cached_by_id(other_user.id)
1500
1501       assert User.following?(other_user, user) == false
1502     end
1503   end
1504
1505   test "account fetching", %{conn: conn} do
1506     user = insert(:user)
1507
1508     conn =
1509       conn
1510       |> get("/api/v1/accounts/#{user.id}")
1511
1512     assert %{"id" => id} = json_response(conn, 200)
1513     assert id == to_string(user.id)
1514
1515     conn =
1516       build_conn()
1517       |> get("/api/v1/accounts/-1")
1518
1519     assert %{"error" => "Can't find user"} = json_response(conn, 404)
1520   end
1521
1522   test "account fetching also works nickname", %{conn: conn} do
1523     user = insert(:user)
1524
1525     conn =
1526       conn
1527       |> get("/api/v1/accounts/#{user.nickname}")
1528
1529     assert %{"id" => id} = json_response(conn, 200)
1530     assert id == user.id
1531   end
1532
1533   test "media upload", %{conn: conn} do
1534     file = %Plug.Upload{
1535       content_type: "image/jpg",
1536       path: Path.absname("test/fixtures/image.jpg"),
1537       filename: "an_image.jpg"
1538     }
1539
1540     desc = "Description of the image"
1541
1542     user = insert(:user)
1543
1544     conn =
1545       conn
1546       |> assign(:user, user)
1547       |> post("/api/v1/media", %{"file" => file, "description" => desc})
1548
1549     assert media = json_response(conn, 200)
1550
1551     assert media["type"] == "image"
1552     assert media["description"] == desc
1553     assert media["id"]
1554
1555     object = Repo.get(Object, media["id"])
1556     assert object.data["actor"] == User.ap_id(user)
1557   end
1558
1559   test "mascot upload", %{conn: conn} do
1560     user = insert(:user)
1561
1562     non_image_file = %Plug.Upload{
1563       content_type: "audio/mpeg",
1564       path: Path.absname("test/fixtures/sound.mp3"),
1565       filename: "sound.mp3"
1566     }
1567
1568     conn =
1569       conn
1570       |> assign(:user, user)
1571       |> put("/api/v1/pleroma/mascot", %{"file" => non_image_file})
1572
1573     assert json_response(conn, 415)
1574
1575     file = %Plug.Upload{
1576       content_type: "image/jpg",
1577       path: Path.absname("test/fixtures/image.jpg"),
1578       filename: "an_image.jpg"
1579     }
1580
1581     conn =
1582       build_conn()
1583       |> assign(:user, user)
1584       |> put("/api/v1/pleroma/mascot", %{"file" => file})
1585
1586     assert %{"id" => _, "type" => image} = json_response(conn, 200)
1587   end
1588
1589   test "mascot retrieving", %{conn: conn} do
1590     user = insert(:user)
1591     # When user hasn't set a mascot, we should just get pleroma tan back
1592     conn =
1593       conn
1594       |> assign(:user, user)
1595       |> get("/api/v1/pleroma/mascot")
1596
1597     assert %{"url" => url} = json_response(conn, 200)
1598     assert url =~ "pleroma-fox-tan-smol"
1599
1600     # When a user sets their mascot, we should get that back
1601     file = %Plug.Upload{
1602       content_type: "image/jpg",
1603       path: Path.absname("test/fixtures/image.jpg"),
1604       filename: "an_image.jpg"
1605     }
1606
1607     conn =
1608       build_conn()
1609       |> assign(:user, user)
1610       |> put("/api/v1/pleroma/mascot", %{"file" => file})
1611
1612     assert json_response(conn, 200)
1613
1614     user = User.get_cached_by_id(user.id)
1615
1616     conn =
1617       build_conn()
1618       |> assign(:user, user)
1619       |> get("/api/v1/pleroma/mascot")
1620
1621     assert %{"url" => url, "type" => "image"} = json_response(conn, 200)
1622     assert url =~ "an_image"
1623   end
1624
1625   test "hashtag timeline", %{conn: conn} do
1626     following = insert(:user)
1627
1628     capture_log(fn ->
1629       {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
1630
1631       {:ok, [_activity]} =
1632         OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
1633
1634       nconn =
1635         conn
1636         |> get("/api/v1/timelines/tag/2hu")
1637
1638       assert [%{"id" => id}] = json_response(nconn, 200)
1639
1640       assert id == to_string(activity.id)
1641
1642       # works for different capitalization too
1643       nconn =
1644         conn
1645         |> get("/api/v1/timelines/tag/2HU")
1646
1647       assert [%{"id" => id}] = json_response(nconn, 200)
1648
1649       assert id == to_string(activity.id)
1650     end)
1651   end
1652
1653   test "multi-hashtag timeline", %{conn: conn} do
1654     user = insert(:user)
1655
1656     {:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
1657     {:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
1658     {:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})
1659
1660     any_test =
1661       conn
1662       |> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})
1663
1664     [status_none, status_test1, status_test] = json_response(any_test, 200)
1665
1666     assert to_string(activity_test.id) == status_test["id"]
1667     assert to_string(activity_test1.id) == status_test1["id"]
1668     assert to_string(activity_none.id) == status_none["id"]
1669
1670     restricted_test =
1671       conn
1672       |> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})
1673
1674     assert [status_test1] == json_response(restricted_test, 200)
1675
1676     all_test = conn |> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})
1677
1678     assert [status_none] == json_response(all_test, 200)
1679   end
1680
1681   test "getting followers", %{conn: conn} do
1682     user = insert(:user)
1683     other_user = insert(:user)
1684     {:ok, user} = User.follow(user, other_user)
1685
1686     conn =
1687       conn
1688       |> get("/api/v1/accounts/#{other_user.id}/followers")
1689
1690     assert [%{"id" => id}] = json_response(conn, 200)
1691     assert id == to_string(user.id)
1692   end
1693
1694   test "getting followers, hide_followers", %{conn: conn} do
1695     user = insert(:user)
1696     other_user = insert(:user, %{info: %{hide_followers: true}})
1697     {:ok, _user} = User.follow(user, other_user)
1698
1699     conn =
1700       conn
1701       |> get("/api/v1/accounts/#{other_user.id}/followers")
1702
1703     assert [] == json_response(conn, 200)
1704   end
1705
1706   test "getting followers, hide_followers, same user requesting", %{conn: conn} do
1707     user = insert(:user)
1708     other_user = insert(:user, %{info: %{hide_followers: true}})
1709     {:ok, _user} = User.follow(user, other_user)
1710
1711     conn =
1712       conn
1713       |> assign(:user, other_user)
1714       |> get("/api/v1/accounts/#{other_user.id}/followers")
1715
1716     refute [] == json_response(conn, 200)
1717   end
1718
1719   test "getting followers, pagination", %{conn: conn} do
1720     user = insert(:user)
1721     follower1 = insert(:user)
1722     follower2 = insert(:user)
1723     follower3 = insert(:user)
1724     {:ok, _} = User.follow(follower1, user)
1725     {:ok, _} = User.follow(follower2, user)
1726     {:ok, _} = User.follow(follower3, user)
1727
1728     conn =
1729       conn
1730       |> assign(:user, user)
1731
1732     res_conn =
1733       conn
1734       |> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1.id}")
1735
1736     assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
1737     assert id3 == follower3.id
1738     assert id2 == follower2.id
1739
1740     res_conn =
1741       conn
1742       |> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3.id}")
1743
1744     assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
1745     assert id2 == follower2.id
1746     assert id1 == follower1.id
1747
1748     res_conn =
1749       conn
1750       |> get("/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3.id}")
1751
1752     assert [%{"id" => id2}] = json_response(res_conn, 200)
1753     assert id2 == follower2.id
1754
1755     assert [link_header] = get_resp_header(res_conn, "link")
1756     assert link_header =~ ~r/min_id=#{follower2.id}/
1757     assert link_header =~ ~r/max_id=#{follower2.id}/
1758   end
1759
1760   test "getting following", %{conn: conn} do
1761     user = insert(:user)
1762     other_user = insert(:user)
1763     {:ok, user} = User.follow(user, other_user)
1764
1765     conn =
1766       conn
1767       |> get("/api/v1/accounts/#{user.id}/following")
1768
1769     assert [%{"id" => id}] = json_response(conn, 200)
1770     assert id == to_string(other_user.id)
1771   end
1772
1773   test "getting following, hide_follows", %{conn: conn} do
1774     user = insert(:user, %{info: %{hide_follows: true}})
1775     other_user = insert(:user)
1776     {:ok, user} = User.follow(user, other_user)
1777
1778     conn =
1779       conn
1780       |> get("/api/v1/accounts/#{user.id}/following")
1781
1782     assert [] == json_response(conn, 200)
1783   end
1784
1785   test "getting following, hide_follows, same user requesting", %{conn: conn} do
1786     user = insert(:user, %{info: %{hide_follows: true}})
1787     other_user = insert(:user)
1788     {:ok, user} = User.follow(user, other_user)
1789
1790     conn =
1791       conn
1792       |> assign(:user, user)
1793       |> get("/api/v1/accounts/#{user.id}/following")
1794
1795     refute [] == json_response(conn, 200)
1796   end
1797
1798   test "getting following, pagination", %{conn: conn} do
1799     user = insert(:user)
1800     following1 = insert(:user)
1801     following2 = insert(:user)
1802     following3 = insert(:user)
1803     {:ok, _} = User.follow(user, following1)
1804     {:ok, _} = User.follow(user, following2)
1805     {:ok, _} = User.follow(user, following3)
1806
1807     conn =
1808       conn
1809       |> assign(:user, user)
1810
1811     res_conn =
1812       conn
1813       |> get("/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")
1814
1815     assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
1816     assert id3 == following3.id
1817     assert id2 == following2.id
1818
1819     res_conn =
1820       conn
1821       |> get("/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")
1822
1823     assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
1824     assert id2 == following2.id
1825     assert id1 == following1.id
1826
1827     res_conn =
1828       conn
1829       |> get("/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")
1830
1831     assert [%{"id" => id2}] = json_response(res_conn, 200)
1832     assert id2 == following2.id
1833
1834     assert [link_header] = get_resp_header(res_conn, "link")
1835     assert link_header =~ ~r/min_id=#{following2.id}/
1836     assert link_header =~ ~r/max_id=#{following2.id}/
1837   end
1838
1839   test "following / unfollowing a user", %{conn: conn} do
1840     user = insert(:user)
1841     other_user = insert(:user)
1842
1843     conn =
1844       conn
1845       |> assign(:user, user)
1846       |> post("/api/v1/accounts/#{other_user.id}/follow")
1847
1848     assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1849
1850     user = User.get_cached_by_id(user.id)
1851
1852     conn =
1853       build_conn()
1854       |> assign(:user, user)
1855       |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1856
1857     assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1858
1859     user = User.get_cached_by_id(user.id)
1860
1861     conn =
1862       build_conn()
1863       |> assign(:user, user)
1864       |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1865
1866     assert %{"id" => id} = json_response(conn, 200)
1867     assert id == to_string(other_user.id)
1868   end
1869
1870   test "following without reblogs" do
1871     follower = insert(:user)
1872     followed = insert(:user)
1873     other_user = insert(:user)
1874
1875     conn =
1876       build_conn()
1877       |> assign(:user, follower)
1878       |> post("/api/v1/accounts/#{followed.id}/follow?reblogs=false")
1879
1880     assert %{"showing_reblogs" => false} = json_response(conn, 200)
1881
1882     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hey"})
1883     {:ok, reblog, _} = CommonAPI.repeat(activity.id, followed)
1884
1885     conn =
1886       build_conn()
1887       |> assign(:user, User.get_cached_by_id(follower.id))
1888       |> get("/api/v1/timelines/home")
1889
1890     assert [] == json_response(conn, 200)
1891
1892     conn =
1893       build_conn()
1894       |> assign(:user, follower)
1895       |> post("/api/v1/accounts/#{followed.id}/follow?reblogs=true")
1896
1897     assert %{"showing_reblogs" => true} = json_response(conn, 200)
1898
1899     conn =
1900       build_conn()
1901       |> assign(:user, User.get_cached_by_id(follower.id))
1902       |> get("/api/v1/timelines/home")
1903
1904     expected_activity_id = reblog.id
1905     assert [%{"id" => ^expected_activity_id}] = json_response(conn, 200)
1906   end
1907
1908   test "following / unfollowing errors" do
1909     user = insert(:user)
1910
1911     conn =
1912       build_conn()
1913       |> assign(:user, user)
1914
1915     # self follow
1916     conn_res = post(conn, "/api/v1/accounts/#{user.id}/follow")
1917     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1918
1919     # self unfollow
1920     user = User.get_cached_by_id(user.id)
1921     conn_res = post(conn, "/api/v1/accounts/#{user.id}/unfollow")
1922     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1923
1924     # self follow via uri
1925     user = User.get_cached_by_id(user.id)
1926     conn_res = post(conn, "/api/v1/follows", %{"uri" => user.nickname})
1927     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1928
1929     # follow non existing user
1930     conn_res = post(conn, "/api/v1/accounts/doesntexist/follow")
1931     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1932
1933     # follow non existing user via uri
1934     conn_res = post(conn, "/api/v1/follows", %{"uri" => "doesntexist"})
1935     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1936
1937     # unfollow non existing user
1938     conn_res = post(conn, "/api/v1/accounts/doesntexist/unfollow")
1939     assert %{"error" => "Record not found"} = json_response(conn_res, 404)
1940   end
1941
1942   test "muting / unmuting a user", %{conn: conn} do
1943     user = insert(:user)
1944     other_user = insert(:user)
1945
1946     conn =
1947       conn
1948       |> assign(:user, user)
1949       |> post("/api/v1/accounts/#{other_user.id}/mute")
1950
1951     assert %{"id" => _id, "muting" => true} = json_response(conn, 200)
1952
1953     user = User.get_cached_by_id(user.id)
1954
1955     conn =
1956       build_conn()
1957       |> assign(:user, user)
1958       |> post("/api/v1/accounts/#{other_user.id}/unmute")
1959
1960     assert %{"id" => _id, "muting" => false} = json_response(conn, 200)
1961   end
1962
1963   test "subscribing / unsubscribing to a user", %{conn: conn} do
1964     user = insert(:user)
1965     subscription_target = insert(:user)
1966
1967     conn =
1968       conn
1969       |> assign(:user, user)
1970       |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")
1971
1972     assert %{"id" => _id, "subscribing" => true} = json_response(conn, 200)
1973
1974     conn =
1975       build_conn()
1976       |> assign(:user, user)
1977       |> post("/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")
1978
1979     assert %{"id" => _id, "subscribing" => false} = json_response(conn, 200)
1980   end
1981
1982   test "getting a list of mutes", %{conn: conn} do
1983     user = insert(:user)
1984     other_user = insert(:user)
1985
1986     {:ok, user} = User.mute(user, other_user)
1987
1988     conn =
1989       conn
1990       |> assign(:user, user)
1991       |> get("/api/v1/mutes")
1992
1993     other_user_id = to_string(other_user.id)
1994     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1995   end
1996
1997   test "blocking / unblocking a user", %{conn: conn} do
1998     user = insert(:user)
1999     other_user = insert(:user)
2000
2001     conn =
2002       conn
2003       |> assign(:user, user)
2004       |> post("/api/v1/accounts/#{other_user.id}/block")
2005
2006     assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
2007
2008     user = User.get_cached_by_id(user.id)
2009
2010     conn =
2011       build_conn()
2012       |> assign(:user, user)
2013       |> post("/api/v1/accounts/#{other_user.id}/unblock")
2014
2015     assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
2016   end
2017
2018   test "getting a list of blocks", %{conn: conn} do
2019     user = insert(:user)
2020     other_user = insert(:user)
2021
2022     {:ok, user} = User.block(user, other_user)
2023
2024     conn =
2025       conn
2026       |> assign(:user, user)
2027       |> get("/api/v1/blocks")
2028
2029     other_user_id = to_string(other_user.id)
2030     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
2031   end
2032
2033   test "blocking / unblocking a domain", %{conn: conn} do
2034     user = insert(:user)
2035     other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
2036
2037     conn =
2038       conn
2039       |> assign(:user, user)
2040       |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
2041
2042     assert %{} = json_response(conn, 200)
2043     user = User.get_cached_by_ap_id(user.ap_id)
2044     assert User.blocks?(user, other_user)
2045
2046     conn =
2047       build_conn()
2048       |> assign(:user, user)
2049       |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
2050
2051     assert %{} = json_response(conn, 200)
2052     user = User.get_cached_by_ap_id(user.ap_id)
2053     refute User.blocks?(user, other_user)
2054   end
2055
2056   test "getting a list of domain blocks", %{conn: conn} do
2057     user = insert(:user)
2058
2059     {:ok, user} = User.block_domain(user, "bad.site")
2060     {:ok, user} = User.block_domain(user, "even.worse.site")
2061
2062     conn =
2063       conn
2064       |> assign(:user, user)
2065       |> get("/api/v1/domain_blocks")
2066
2067     domain_blocks = json_response(conn, 200)
2068
2069     assert "bad.site" in domain_blocks
2070     assert "even.worse.site" in domain_blocks
2071   end
2072
2073   test "unimplemented follow_requests, blocks, domain blocks" do
2074     user = insert(:user)
2075
2076     ["blocks", "domain_blocks", "follow_requests"]
2077     |> Enum.each(fn endpoint ->
2078       conn =
2079         build_conn()
2080         |> assign(:user, user)
2081         |> get("/api/v1/#{endpoint}")
2082
2083       assert [] = json_response(conn, 200)
2084     end)
2085   end
2086
2087   test "account search", %{conn: conn} do
2088     user = insert(:user)
2089     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
2090     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
2091
2092     results =
2093       conn
2094       |> assign(:user, user)
2095       |> get("/api/v1/accounts/search", %{"q" => "shp"})
2096       |> json_response(200)
2097
2098     result_ids = for result <- results, do: result["acct"]
2099
2100     assert user_two.nickname in result_ids
2101     assert user_three.nickname in result_ids
2102
2103     results =
2104       conn
2105       |> assign(:user, user)
2106       |> get("/api/v1/accounts/search", %{"q" => "2hu"})
2107       |> json_response(200)
2108
2109     result_ids = for result <- results, do: result["acct"]
2110
2111     assert user_three.nickname in result_ids
2112   end
2113
2114   test "search", %{conn: conn} do
2115     user = insert(:user)
2116     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
2117     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
2118
2119     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
2120
2121     {:ok, _activity} =
2122       CommonAPI.post(user, %{
2123         "status" => "This is about 2hu, but private",
2124         "visibility" => "private"
2125       })
2126
2127     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
2128
2129     conn =
2130       conn
2131       |> get("/api/v1/search", %{"q" => "2hu"})
2132
2133     assert results = json_response(conn, 200)
2134
2135     [account | _] = results["accounts"]
2136     assert account["id"] == to_string(user_three.id)
2137
2138     assert results["hashtags"] == []
2139
2140     [status] = results["statuses"]
2141     assert status["id"] == to_string(activity.id)
2142   end
2143
2144   test "search fetches remote statuses", %{conn: conn} do
2145     capture_log(fn ->
2146       conn =
2147         conn
2148         |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
2149
2150       assert results = json_response(conn, 200)
2151
2152       [status] = results["statuses"]
2153       assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
2154     end)
2155   end
2156
2157   test "search doesn't show statuses that it shouldn't", %{conn: conn} do
2158     {:ok, activity} =
2159       CommonAPI.post(insert(:user), %{
2160         "status" => "This is about 2hu, but private",
2161         "visibility" => "private"
2162       })
2163
2164     capture_log(fn ->
2165       conn =
2166         conn
2167         |> get("/api/v1/search", %{"q" => Object.normalize(activity).data["id"]})
2168
2169       assert results = json_response(conn, 200)
2170
2171       [] = results["statuses"]
2172     end)
2173   end
2174
2175   test "search fetches remote accounts", %{conn: conn} do
2176     conn =
2177       conn
2178       |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
2179
2180     assert results = json_response(conn, 200)
2181     [account] = results["accounts"]
2182     assert account["acct"] == "shp@social.heldscal.la"
2183   end
2184
2185   test "returns the favorites of a user", %{conn: conn} do
2186     user = insert(:user)
2187     other_user = insert(:user)
2188
2189     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
2190     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
2191
2192     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
2193
2194     first_conn =
2195       conn
2196       |> assign(:user, user)
2197       |> get("/api/v1/favourites")
2198
2199     assert [status] = json_response(first_conn, 200)
2200     assert status["id"] == to_string(activity.id)
2201
2202     assert [{"link", _link_header}] =
2203              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
2204
2205     # Honours query params
2206     {:ok, second_activity} =
2207       CommonAPI.post(other_user, %{
2208         "status" =>
2209           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
2210       })
2211
2212     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
2213
2214     last_like = status["id"]
2215
2216     second_conn =
2217       conn
2218       |> assign(:user, user)
2219       |> get("/api/v1/favourites?since_id=#{last_like}")
2220
2221     assert [second_status] = json_response(second_conn, 200)
2222     assert second_status["id"] == to_string(second_activity.id)
2223
2224     third_conn =
2225       conn
2226       |> assign(:user, user)
2227       |> get("/api/v1/favourites?limit=0")
2228
2229     assert [] = json_response(third_conn, 200)
2230   end
2231
2232   describe "getting favorites timeline of specified user" do
2233     setup do
2234       [current_user, user] = insert_pair(:user, %{info: %{hide_favorites: false}})
2235       [current_user: current_user, user: user]
2236     end
2237
2238     test "returns list of statuses favorited by specified user", %{
2239       conn: conn,
2240       current_user: current_user,
2241       user: user
2242     } do
2243       [activity | _] = insert_pair(:note_activity)
2244       CommonAPI.favorite(activity.id, user)
2245
2246       response =
2247         conn
2248         |> assign(:user, current_user)
2249         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2250         |> json_response(:ok)
2251
2252       [like] = response
2253
2254       assert length(response) == 1
2255       assert like["id"] == activity.id
2256     end
2257
2258     test "returns favorites for specified user_id when user is not logged in", %{
2259       conn: conn,
2260       user: user
2261     } do
2262       activity = insert(:note_activity)
2263       CommonAPI.favorite(activity.id, user)
2264
2265       response =
2266         conn
2267         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2268         |> json_response(:ok)
2269
2270       assert length(response) == 1
2271     end
2272
2273     test "returns favorited DM only when user is logged in and he is one of recipients", %{
2274       conn: conn,
2275       current_user: current_user,
2276       user: user
2277     } do
2278       {:ok, direct} =
2279         CommonAPI.post(current_user, %{
2280           "status" => "Hi @#{user.nickname}!",
2281           "visibility" => "direct"
2282         })
2283
2284       CommonAPI.favorite(direct.id, user)
2285
2286       response =
2287         conn
2288         |> assign(:user, current_user)
2289         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2290         |> json_response(:ok)
2291
2292       assert length(response) == 1
2293
2294       anonymous_response =
2295         conn
2296         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2297         |> json_response(:ok)
2298
2299       assert Enum.empty?(anonymous_response)
2300     end
2301
2302     test "does not return others' favorited DM when user is not one of recipients", %{
2303       conn: conn,
2304       current_user: current_user,
2305       user: user
2306     } do
2307       user_two = insert(:user)
2308
2309       {:ok, direct} =
2310         CommonAPI.post(user_two, %{
2311           "status" => "Hi @#{user.nickname}!",
2312           "visibility" => "direct"
2313         })
2314
2315       CommonAPI.favorite(direct.id, user)
2316
2317       response =
2318         conn
2319         |> assign(:user, current_user)
2320         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2321         |> json_response(:ok)
2322
2323       assert Enum.empty?(response)
2324     end
2325
2326     test "paginates favorites using since_id and max_id", %{
2327       conn: conn,
2328       current_user: current_user,
2329       user: user
2330     } do
2331       activities = insert_list(10, :note_activity)
2332
2333       Enum.each(activities, fn activity ->
2334         CommonAPI.favorite(activity.id, user)
2335       end)
2336
2337       third_activity = Enum.at(activities, 2)
2338       seventh_activity = Enum.at(activities, 6)
2339
2340       response =
2341         conn
2342         |> assign(:user, current_user)
2343         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{
2344           since_id: third_activity.id,
2345           max_id: seventh_activity.id
2346         })
2347         |> json_response(:ok)
2348
2349       assert length(response) == 3
2350       refute third_activity in response
2351       refute seventh_activity in response
2352     end
2353
2354     test "limits favorites using limit parameter", %{
2355       conn: conn,
2356       current_user: current_user,
2357       user: user
2358     } do
2359       7
2360       |> insert_list(:note_activity)
2361       |> Enum.each(fn activity ->
2362         CommonAPI.favorite(activity.id, user)
2363       end)
2364
2365       response =
2366         conn
2367         |> assign(:user, current_user)
2368         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{limit: "3"})
2369         |> json_response(:ok)
2370
2371       assert length(response) == 3
2372     end
2373
2374     test "returns empty response when user does not have any favorited statuses", %{
2375       conn: conn,
2376       current_user: current_user,
2377       user: user
2378     } do
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 "returns 404 error when specified user is not exist", %{conn: conn} do
2389       conn = get(conn, "/api/v1/pleroma/accounts/test/favourites")
2390
2391       assert json_response(conn, 404) == %{"error" => "Record not found"}
2392     end
2393
2394     test "returns 403 error when user has hidden own favorites", %{
2395       conn: conn,
2396       current_user: current_user
2397     } do
2398       user = insert(:user, %{info: %{hide_favorites: true}})
2399       activity = insert(:note_activity)
2400       CommonAPI.favorite(activity.id, user)
2401
2402       conn =
2403         conn
2404         |> assign(:user, current_user)
2405         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2406
2407       assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
2408     end
2409
2410     test "hides favorites for new users by default", %{conn: conn, current_user: current_user} do
2411       user = insert(:user)
2412       activity = insert(:note_activity)
2413       CommonAPI.favorite(activity.id, user)
2414
2415       conn =
2416         conn
2417         |> assign(:user, current_user)
2418         |> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
2419
2420       assert user.info.hide_favorites
2421       assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
2422     end
2423   end
2424
2425   describe "updating credentials" do
2426     test "updates the user's bio", %{conn: conn} do
2427       user = insert(:user)
2428       user2 = insert(:user)
2429
2430       conn =
2431         conn
2432         |> assign(:user, user)
2433         |> patch("/api/v1/accounts/update_credentials", %{
2434           "note" => "I drink #cofe with @#{user2.nickname}"
2435         })
2436
2437       assert user = json_response(conn, 200)
2438
2439       assert user["note"] ==
2440                ~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe" rel="tag">#cofe</a> with <span class="h-card"><a data-user=") <>
2441                  user2.id <>
2442                  ~s(" class="u-url mention" href=") <>
2443                  user2.ap_id <> ~s(">@<span>) <> user2.nickname <> ~s(</span></a></span>)
2444     end
2445
2446     test "updates the user's locking status", %{conn: conn} do
2447       user = insert(:user)
2448
2449       conn =
2450         conn
2451         |> assign(:user, user)
2452         |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
2453
2454       assert user = json_response(conn, 200)
2455       assert user["locked"] == true
2456     end
2457
2458     test "updates the user's default scope", %{conn: conn} do
2459       user = insert(:user)
2460
2461       conn =
2462         conn
2463         |> assign(:user, user)
2464         |> patch("/api/v1/accounts/update_credentials", %{default_scope: "cofe"})
2465
2466       assert user = json_response(conn, 200)
2467       assert user["source"]["privacy"] == "cofe"
2468     end
2469
2470     test "updates the user's hide_followers status", %{conn: conn} do
2471       user = insert(:user)
2472
2473       conn =
2474         conn
2475         |> assign(:user, user)
2476         |> patch("/api/v1/accounts/update_credentials", %{hide_followers: "true"})
2477
2478       assert user = json_response(conn, 200)
2479       assert user["pleroma"]["hide_followers"] == true
2480     end
2481
2482     test "updates the user's hide_follows status", %{conn: conn} do
2483       user = insert(:user)
2484
2485       conn =
2486         conn
2487         |> assign(:user, user)
2488         |> patch("/api/v1/accounts/update_credentials", %{hide_follows: "true"})
2489
2490       assert user = json_response(conn, 200)
2491       assert user["pleroma"]["hide_follows"] == true
2492     end
2493
2494     test "updates the user's hide_favorites status", %{conn: conn} do
2495       user = insert(:user)
2496
2497       conn =
2498         conn
2499         |> assign(:user, user)
2500         |> patch("/api/v1/accounts/update_credentials", %{hide_favorites: "true"})
2501
2502       assert user = json_response(conn, 200)
2503       assert user["pleroma"]["hide_favorites"] == true
2504     end
2505
2506     test "updates the user's show_role status", %{conn: conn} do
2507       user = insert(:user)
2508
2509       conn =
2510         conn
2511         |> assign(:user, user)
2512         |> patch("/api/v1/accounts/update_credentials", %{show_role: "false"})
2513
2514       assert user = json_response(conn, 200)
2515       assert user["source"]["pleroma"]["show_role"] == false
2516     end
2517
2518     test "updates the user's no_rich_text status", %{conn: conn} do
2519       user = insert(:user)
2520
2521       conn =
2522         conn
2523         |> assign(:user, user)
2524         |> patch("/api/v1/accounts/update_credentials", %{no_rich_text: "true"})
2525
2526       assert user = json_response(conn, 200)
2527       assert user["source"]["pleroma"]["no_rich_text"] == true
2528     end
2529
2530     test "updates the user's name", %{conn: conn} do
2531       user = insert(:user)
2532
2533       conn =
2534         conn
2535         |> assign(:user, user)
2536         |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
2537
2538       assert user = json_response(conn, 200)
2539       assert user["display_name"] == "markorepairs"
2540     end
2541
2542     test "updates the user's avatar", %{conn: conn} do
2543       user = insert(:user)
2544
2545       new_avatar = %Plug.Upload{
2546         content_type: "image/jpg",
2547         path: Path.absname("test/fixtures/image.jpg"),
2548         filename: "an_image.jpg"
2549       }
2550
2551       conn =
2552         conn
2553         |> assign(:user, user)
2554         |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
2555
2556       assert user_response = json_response(conn, 200)
2557       assert user_response["avatar"] != User.avatar_url(user)
2558     end
2559
2560     test "updates the user's banner", %{conn: conn} do
2561       user = insert(:user)
2562
2563       new_header = %Plug.Upload{
2564         content_type: "image/jpg",
2565         path: Path.absname("test/fixtures/image.jpg"),
2566         filename: "an_image.jpg"
2567       }
2568
2569       conn =
2570         conn
2571         |> assign(:user, user)
2572         |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
2573
2574       assert user_response = json_response(conn, 200)
2575       assert user_response["header"] != User.banner_url(user)
2576     end
2577
2578     test "requires 'write' permission", %{conn: conn} do
2579       token1 = insert(:oauth_token, scopes: ["read"])
2580       token2 = insert(:oauth_token, scopes: ["write", "follow"])
2581
2582       for token <- [token1, token2] do
2583         conn =
2584           conn
2585           |> put_req_header("authorization", "Bearer #{token.token}")
2586           |> patch("/api/v1/accounts/update_credentials", %{})
2587
2588         if token == token1 do
2589           assert %{"error" => "Insufficient permissions: write."} == json_response(conn, 403)
2590         else
2591           assert json_response(conn, 200)
2592         end
2593       end
2594     end
2595
2596     test "updates profile emojos", %{conn: conn} do
2597       user = insert(:user)
2598
2599       note = "*sips :blank:*"
2600       name = "I am :firefox:"
2601
2602       conn =
2603         conn
2604         |> assign(:user, user)
2605         |> patch("/api/v1/accounts/update_credentials", %{
2606           "note" => note,
2607           "display_name" => name
2608         })
2609
2610       assert json_response(conn, 200)
2611
2612       conn =
2613         conn
2614         |> get("/api/v1/accounts/#{user.id}")
2615
2616       assert user = json_response(conn, 200)
2617
2618       assert user["note"] == note
2619       assert user["display_name"] == name
2620       assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user["emojis"]
2621     end
2622   end
2623
2624   test "get instance information", %{conn: conn} do
2625     conn = get(conn, "/api/v1/instance")
2626     assert result = json_response(conn, 200)
2627
2628     email = Pleroma.Config.get([:instance, :email])
2629     # Note: not checking for "max_toot_chars" since it's optional
2630     assert %{
2631              "uri" => _,
2632              "title" => _,
2633              "description" => _,
2634              "version" => _,
2635              "email" => from_config_email,
2636              "urls" => %{
2637                "streaming_api" => _
2638              },
2639              "stats" => _,
2640              "thumbnail" => _,
2641              "languages" => _,
2642              "registrations" => _,
2643              "poll_limits" => _
2644            } = result
2645
2646     assert email == from_config_email
2647   end
2648
2649   test "get instance stats", %{conn: conn} do
2650     user = insert(:user, %{local: true})
2651
2652     user2 = insert(:user, %{local: true})
2653     {:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)
2654
2655     insert(:user, %{local: false, nickname: "u@peer1.com"})
2656     insert(:user, %{local: false, nickname: "u@peer2.com"})
2657
2658     {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
2659
2660     # Stats should count users with missing or nil `info.deactivated` value
2661     user = User.get_cached_by_id(user.id)
2662     info_change = Changeset.change(user.info, %{deactivated: nil})
2663
2664     {:ok, _user} =
2665       user
2666       |> Changeset.change()
2667       |> Changeset.put_embed(:info, info_change)
2668       |> User.update_and_set_cache()
2669
2670     Pleroma.Stats.update_stats()
2671
2672     conn = get(conn, "/api/v1/instance")
2673
2674     assert result = json_response(conn, 200)
2675
2676     stats = result["stats"]
2677
2678     assert stats
2679     assert stats["user_count"] == 1
2680     assert stats["status_count"] == 1
2681     assert stats["domain_count"] == 2
2682   end
2683
2684   test "get peers", %{conn: conn} do
2685     insert(:user, %{local: false, nickname: "u@peer1.com"})
2686     insert(:user, %{local: false, nickname: "u@peer2.com"})
2687
2688     Pleroma.Stats.update_stats()
2689
2690     conn = get(conn, "/api/v1/instance/peers")
2691
2692     assert result = json_response(conn, 200)
2693
2694     assert ["peer1.com", "peer2.com"] == Enum.sort(result)
2695   end
2696
2697   test "put settings", %{conn: conn} do
2698     user = insert(:user)
2699
2700     conn =
2701       conn
2702       |> assign(:user, user)
2703       |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
2704
2705     assert _result = json_response(conn, 200)
2706
2707     user = User.get_cached_by_ap_id(user.ap_id)
2708     assert user.info.settings == %{"programming" => "socks"}
2709   end
2710
2711   describe "pinned statuses" do
2712     setup do
2713       Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
2714
2715       user = insert(:user)
2716       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
2717
2718       [user: user, activity: activity]
2719     end
2720
2721     test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
2722       {:ok, _} = CommonAPI.pin(activity.id, user)
2723
2724       result =
2725         conn
2726         |> assign(:user, user)
2727         |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2728         |> json_response(200)
2729
2730       id_str = to_string(activity.id)
2731
2732       assert [%{"id" => ^id_str, "pinned" => true}] = result
2733     end
2734
2735     test "pin status", %{conn: conn, user: user, activity: activity} do
2736       id_str = to_string(activity.id)
2737
2738       assert %{"id" => ^id_str, "pinned" => true} =
2739                conn
2740                |> assign(:user, user)
2741                |> post("/api/v1/statuses/#{activity.id}/pin")
2742                |> json_response(200)
2743
2744       assert [%{"id" => ^id_str, "pinned" => true}] =
2745                conn
2746                |> assign(:user, user)
2747                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2748                |> json_response(200)
2749     end
2750
2751     test "unpin status", %{conn: conn, user: user, activity: activity} do
2752       {:ok, _} = CommonAPI.pin(activity.id, user)
2753
2754       id_str = to_string(activity.id)
2755       user = refresh_record(user)
2756
2757       assert %{"id" => ^id_str, "pinned" => false} =
2758                conn
2759                |> assign(:user, user)
2760                |> post("/api/v1/statuses/#{activity.id}/unpin")
2761                |> json_response(200)
2762
2763       assert [] =
2764                conn
2765                |> assign(:user, user)
2766                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
2767                |> json_response(200)
2768     end
2769
2770     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
2771       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
2772
2773       id_str_one = to_string(activity_one.id)
2774
2775       assert %{"id" => ^id_str_one, "pinned" => true} =
2776                conn
2777                |> assign(:user, user)
2778                |> post("/api/v1/statuses/#{id_str_one}/pin")
2779                |> json_response(200)
2780
2781       user = refresh_record(user)
2782
2783       assert %{"error" => "You have already pinned the maximum number of statuses"} =
2784                conn
2785                |> assign(:user, user)
2786                |> post("/api/v1/statuses/#{activity_two.id}/pin")
2787                |> json_response(400)
2788     end
2789   end
2790
2791   describe "cards" do
2792     setup do
2793       Pleroma.Config.put([:rich_media, :enabled], true)
2794
2795       on_exit(fn ->
2796         Pleroma.Config.put([:rich_media, :enabled], false)
2797       end)
2798
2799       user = insert(:user)
2800       %{user: user}
2801     end
2802
2803     test "returns rich-media card", %{conn: conn, user: user} do
2804       {:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})
2805
2806       card_data = %{
2807         "image" => "http://ia.media-imdb.com/images/rock.jpg",
2808         "provider_name" => "www.imdb.com",
2809         "provider_url" => "http://www.imdb.com",
2810         "title" => "The Rock",
2811         "type" => "link",
2812         "url" => "http://www.imdb.com/title/tt0117500/",
2813         "description" =>
2814           "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
2815         "pleroma" => %{
2816           "opengraph" => %{
2817             "image" => "http://ia.media-imdb.com/images/rock.jpg",
2818             "title" => "The Rock",
2819             "type" => "video.movie",
2820             "url" => "http://www.imdb.com/title/tt0117500/",
2821             "description" =>
2822               "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
2823           }
2824         }
2825       }
2826
2827       response =
2828         conn
2829         |> get("/api/v1/statuses/#{activity.id}/card")
2830         |> json_response(200)
2831
2832       assert response == card_data
2833
2834       # works with private posts
2835       {:ok, activity} =
2836         CommonAPI.post(user, %{"status" => "http://example.com/ogp", "visibility" => "direct"})
2837
2838       response_two =
2839         conn
2840         |> assign(:user, user)
2841         |> get("/api/v1/statuses/#{activity.id}/card")
2842         |> json_response(200)
2843
2844       assert response_two == card_data
2845     end
2846
2847     test "replaces missing description with an empty string", %{conn: conn, user: user} do
2848       {:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp-missing-data"})
2849
2850       response =
2851         conn
2852         |> get("/api/v1/statuses/#{activity.id}/card")
2853         |> json_response(:ok)
2854
2855       assert response == %{
2856                "type" => "link",
2857                "title" => "Pleroma",
2858                "description" => "",
2859                "image" => nil,
2860                "provider_name" => "pleroma.social",
2861                "provider_url" => "https://pleroma.social",
2862                "url" => "https://pleroma.social/",
2863                "pleroma" => %{
2864                  "opengraph" => %{
2865                    "title" => "Pleroma",
2866                    "type" => "website",
2867                    "url" => "https://pleroma.social/"
2868                  }
2869                }
2870              }
2871     end
2872   end
2873
2874   test "bookmarks" do
2875     user = insert(:user)
2876     for_user = insert(:user)
2877
2878     {:ok, activity1} =
2879       CommonAPI.post(user, %{
2880         "status" => "heweoo?"
2881       })
2882
2883     {:ok, activity2} =
2884       CommonAPI.post(user, %{
2885         "status" => "heweoo!"
2886       })
2887
2888     response1 =
2889       build_conn()
2890       |> assign(:user, for_user)
2891       |> post("/api/v1/statuses/#{activity1.id}/bookmark")
2892
2893     assert json_response(response1, 200)["bookmarked"] == true
2894
2895     response2 =
2896       build_conn()
2897       |> assign(:user, for_user)
2898       |> post("/api/v1/statuses/#{activity2.id}/bookmark")
2899
2900     assert json_response(response2, 200)["bookmarked"] == true
2901
2902     bookmarks =
2903       build_conn()
2904       |> assign(:user, for_user)
2905       |> get("/api/v1/bookmarks")
2906
2907     assert [json_response(response2, 200), json_response(response1, 200)] ==
2908              json_response(bookmarks, 200)
2909
2910     response1 =
2911       build_conn()
2912       |> assign(:user, for_user)
2913       |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
2914
2915     assert json_response(response1, 200)["bookmarked"] == false
2916
2917     bookmarks =
2918       build_conn()
2919       |> assign(:user, for_user)
2920       |> get("/api/v1/bookmarks")
2921
2922     assert [json_response(response2, 200)] == json_response(bookmarks, 200)
2923   end
2924
2925   describe "conversation muting" do
2926     setup do
2927       user = insert(:user)
2928       {:ok, activity} = CommonAPI.post(user, %{"status" => "HIE"})
2929
2930       [user: user, activity: activity]
2931     end
2932
2933     test "mute conversation", %{conn: conn, user: user, activity: activity} do
2934       id_str = to_string(activity.id)
2935
2936       assert %{"id" => ^id_str, "muted" => true} =
2937                conn
2938                |> assign(:user, user)
2939                |> post("/api/v1/statuses/#{activity.id}/mute")
2940                |> json_response(200)
2941     end
2942
2943     test "unmute conversation", %{conn: conn, user: user, activity: activity} do
2944       {:ok, _} = CommonAPI.add_mute(user, activity)
2945
2946       id_str = to_string(activity.id)
2947       user = refresh_record(user)
2948
2949       assert %{"id" => ^id_str, "muted" => false} =
2950                conn
2951                |> assign(:user, user)
2952                |> post("/api/v1/statuses/#{activity.id}/unmute")
2953                |> json_response(200)
2954     end
2955   end
2956
2957   describe "reports" do
2958     setup do
2959       reporter = insert(:user)
2960       target_user = insert(:user)
2961
2962       {:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})
2963
2964       [reporter: reporter, target_user: target_user, activity: activity]
2965     end
2966
2967     test "submit a basic report", %{conn: conn, reporter: reporter, target_user: target_user} do
2968       assert %{"action_taken" => false, "id" => _} =
2969                conn
2970                |> assign(:user, reporter)
2971                |> post("/api/v1/reports", %{"account_id" => target_user.id})
2972                |> json_response(200)
2973     end
2974
2975     test "submit a report with statuses and comment", %{
2976       conn: conn,
2977       reporter: reporter,
2978       target_user: target_user,
2979       activity: activity
2980     } do
2981       assert %{"action_taken" => false, "id" => _} =
2982                conn
2983                |> assign(:user, reporter)
2984                |> post("/api/v1/reports", %{
2985                  "account_id" => target_user.id,
2986                  "status_ids" => [activity.id],
2987                  "comment" => "bad status!"
2988                })
2989                |> json_response(200)
2990     end
2991
2992     test "account_id is required", %{
2993       conn: conn,
2994       reporter: reporter,
2995       activity: activity
2996     } do
2997       assert %{"error" => "Valid `account_id` required"} =
2998                conn
2999                |> assign(:user, reporter)
3000                |> post("/api/v1/reports", %{"status_ids" => [activity.id]})
3001                |> json_response(400)
3002     end
3003
3004     test "comment must be up to the size specified in the config", %{
3005       conn: conn,
3006       reporter: reporter,
3007       target_user: target_user
3008     } do
3009       max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
3010       comment = String.pad_trailing("a", max_size + 1, "a")
3011
3012       error = %{"error" => "Comment must be up to #{max_size} characters"}
3013
3014       assert ^error =
3015                conn
3016                |> assign(:user, reporter)
3017                |> post("/api/v1/reports", %{"account_id" => target_user.id, "comment" => comment})
3018                |> json_response(400)
3019     end
3020   end
3021
3022   describe "link headers" do
3023     test "preserves parameters in link headers", %{conn: conn} do
3024       user = insert(:user)
3025       other_user = insert(:user)
3026
3027       {:ok, activity1} =
3028         CommonAPI.post(other_user, %{
3029           "status" => "hi @#{user.nickname}",
3030           "visibility" => "public"
3031         })
3032
3033       {:ok, activity2} =
3034         CommonAPI.post(other_user, %{
3035           "status" => "hi @#{user.nickname}",
3036           "visibility" => "public"
3037         })
3038
3039       notification1 = Repo.get_by(Notification, activity_id: activity1.id)
3040       notification2 = Repo.get_by(Notification, activity_id: activity2.id)
3041
3042       conn =
3043         conn
3044         |> assign(:user, user)
3045         |> get("/api/v1/notifications", %{media_only: true})
3046
3047       assert [link_header] = get_resp_header(conn, "link")
3048       assert link_header =~ ~r/media_only=true/
3049       assert link_header =~ ~r/min_id=#{notification2.id}/
3050       assert link_header =~ ~r/max_id=#{notification1.id}/
3051     end
3052   end
3053
3054   test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
3055     # Need to set an old-style integer ID to reproduce the problem
3056     # (these are no longer assigned to new accounts but were preserved
3057     # for existing accounts during the migration to flakeIDs)
3058     user_one = insert(:user, %{id: 1212})
3059     user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})
3060
3061     resp_one =
3062       conn
3063       |> get("/api/v1/accounts/#{user_one.id}")
3064
3065     resp_two =
3066       conn
3067       |> get("/api/v1/accounts/#{user_two.nickname}")
3068
3069     resp_three =
3070       conn
3071       |> get("/api/v1/accounts/#{user_two.id}")
3072
3073     acc_one = json_response(resp_one, 200)
3074     acc_two = json_response(resp_two, 200)
3075     acc_three = json_response(resp_three, 200)
3076     refute acc_one == acc_two
3077     assert acc_two == acc_three
3078   end
3079
3080   describe "custom emoji" do
3081     test "with tags", %{conn: conn} do
3082       [emoji | _body] =
3083         conn
3084         |> get("/api/v1/custom_emojis")
3085         |> json_response(200)
3086
3087       assert Map.has_key?(emoji, "shortcode")
3088       assert Map.has_key?(emoji, "static_url")
3089       assert Map.has_key?(emoji, "tags")
3090       assert is_list(emoji["tags"])
3091       assert Map.has_key?(emoji, "url")
3092       assert Map.has_key?(emoji, "visible_in_picker")
3093     end
3094   end
3095
3096   describe "index/2 redirections" do
3097     setup %{conn: conn} do
3098       session_opts = [
3099         store: :cookie,
3100         key: "_test",
3101         signing_salt: "cooldude"
3102       ]
3103
3104       conn =
3105         conn
3106         |> Plug.Session.call(Plug.Session.init(session_opts))
3107         |> fetch_session()
3108
3109       test_path = "/web/statuses/test"
3110       %{conn: conn, path: test_path}
3111     end
3112
3113     test "redirects not logged-in users to the login page", %{conn: conn, path: path} do
3114       conn = get(conn, path)
3115
3116       assert conn.status == 302
3117       assert redirected_to(conn) == "/web/login"
3118     end
3119
3120     test "does not redirect logged in users to the login page", %{conn: conn, path: path} do
3121       token = insert(:oauth_token)
3122
3123       conn =
3124         conn
3125         |> assign(:user, token.user)
3126         |> put_session(:oauth_token, token.token)
3127         |> get(path)
3128
3129       assert conn.status == 200
3130     end
3131
3132     test "saves referer path to session", %{conn: conn, path: path} do
3133       conn = get(conn, path)
3134       return_to = Plug.Conn.get_session(conn, :return_to)
3135
3136       assert return_to == path
3137     end
3138
3139     test "redirects to the saved path after log in", %{conn: conn, path: path} do
3140       app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
3141       auth = insert(:oauth_authorization, app: app)
3142
3143       conn =
3144         conn
3145         |> put_session(:return_to, path)
3146         |> get("/web/login", %{code: auth.token})
3147
3148       assert conn.status == 302
3149       assert redirected_to(conn) == path
3150     end
3151
3152     test "redirects to the getting-started page when referer is not present", %{conn: conn} do
3153       app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
3154       auth = insert(:oauth_authorization, app: app)
3155
3156       conn = get(conn, "/web/login", %{code: auth.token})
3157
3158       assert conn.status == 302
3159       assert redirected_to(conn) == "/web/getting-started"
3160     end
3161   end
3162
3163   describe "scheduled activities" do
3164     test "creates a scheduled activity", %{conn: conn} do
3165       user = insert(:user)
3166       scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
3167
3168       conn =
3169         conn
3170         |> assign(:user, user)
3171         |> post("/api/v1/statuses", %{
3172           "status" => "scheduled",
3173           "scheduled_at" => scheduled_at
3174         })
3175
3176       assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
3177       assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(scheduled_at)
3178       assert [] == Repo.all(Activity)
3179     end
3180
3181     test "creates a scheduled activity with a media attachment", %{conn: conn} do
3182       user = insert(:user)
3183       scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
3184
3185       file = %Plug.Upload{
3186         content_type: "image/jpg",
3187         path: Path.absname("test/fixtures/image.jpg"),
3188         filename: "an_image.jpg"
3189       }
3190
3191       {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
3192
3193       conn =
3194         conn
3195         |> assign(:user, user)
3196         |> post("/api/v1/statuses", %{
3197           "media_ids" => [to_string(upload.id)],
3198           "status" => "scheduled",
3199           "scheduled_at" => scheduled_at
3200         })
3201
3202       assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
3203       assert %{"type" => "image"} = media_attachment
3204     end
3205
3206     test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
3207          %{conn: conn} do
3208       user = insert(:user)
3209
3210       scheduled_at =
3211         NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
3212
3213       conn =
3214         conn
3215         |> assign(:user, user)
3216         |> post("/api/v1/statuses", %{
3217           "status" => "not scheduled",
3218           "scheduled_at" => scheduled_at
3219         })
3220
3221       assert %{"content" => "not scheduled"} = json_response(conn, 200)
3222       assert [] == Repo.all(ScheduledActivity)
3223     end
3224
3225     test "returns error when daily user limit is exceeded", %{conn: conn} do
3226       user = insert(:user)
3227
3228       today =
3229         NaiveDateTime.utc_now()
3230         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
3231         |> NaiveDateTime.to_iso8601()
3232
3233       attrs = %{params: %{}, scheduled_at: today}
3234       {:ok, _} = ScheduledActivity.create(user, attrs)
3235       {:ok, _} = ScheduledActivity.create(user, attrs)
3236
3237       conn =
3238         conn
3239         |> assign(:user, user)
3240         |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
3241
3242       assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
3243     end
3244
3245     test "returns error when total user limit is exceeded", %{conn: conn} do
3246       user = insert(:user)
3247
3248       today =
3249         NaiveDateTime.utc_now()
3250         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
3251         |> NaiveDateTime.to_iso8601()
3252
3253       tomorrow =
3254         NaiveDateTime.utc_now()
3255         |> NaiveDateTime.add(:timer.hours(36), :millisecond)
3256         |> NaiveDateTime.to_iso8601()
3257
3258       attrs = %{params: %{}, scheduled_at: today}
3259       {:ok, _} = ScheduledActivity.create(user, attrs)
3260       {:ok, _} = ScheduledActivity.create(user, attrs)
3261       {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
3262
3263       conn =
3264         conn
3265         |> assign(:user, user)
3266         |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
3267
3268       assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
3269     end
3270
3271     test "shows scheduled activities", %{conn: conn} do
3272       user = insert(:user)
3273       scheduled_activity_id1 = insert(:scheduled_activity, user: user).id |> to_string()
3274       scheduled_activity_id2 = insert(:scheduled_activity, user: user).id |> to_string()
3275       scheduled_activity_id3 = insert(:scheduled_activity, user: user).id |> to_string()
3276       scheduled_activity_id4 = insert(:scheduled_activity, user: user).id |> to_string()
3277
3278       conn =
3279         conn
3280         |> assign(:user, user)
3281
3282       # min_id
3283       conn_res =
3284         conn
3285         |> get("/api/v1/scheduled_statuses?limit=2&min_id=#{scheduled_activity_id1}")
3286
3287       result = json_response(conn_res, 200)
3288       assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
3289
3290       # since_id
3291       conn_res =
3292         conn
3293         |> get("/api/v1/scheduled_statuses?limit=2&since_id=#{scheduled_activity_id1}")
3294
3295       result = json_response(conn_res, 200)
3296       assert [%{"id" => ^scheduled_activity_id4}, %{"id" => ^scheduled_activity_id3}] = result
3297
3298       # max_id
3299       conn_res =
3300         conn
3301         |> get("/api/v1/scheduled_statuses?limit=2&max_id=#{scheduled_activity_id4}")
3302
3303       result = json_response(conn_res, 200)
3304       assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
3305     end
3306
3307     test "shows a scheduled activity", %{conn: conn} do
3308       user = insert(:user)
3309       scheduled_activity = insert(:scheduled_activity, user: user)
3310
3311       res_conn =
3312         conn
3313         |> assign(:user, user)
3314         |> get("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
3315
3316       assert %{"id" => scheduled_activity_id} = json_response(res_conn, 200)
3317       assert scheduled_activity_id == scheduled_activity.id |> to_string()
3318
3319       res_conn =
3320         conn
3321         |> assign(:user, user)
3322         |> get("/api/v1/scheduled_statuses/404")
3323
3324       assert %{"error" => "Record not found"} = json_response(res_conn, 404)
3325     end
3326
3327     test "updates a scheduled activity", %{conn: conn} do
3328       user = insert(:user)
3329       scheduled_activity = insert(:scheduled_activity, user: user)
3330
3331       new_scheduled_at =
3332         NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
3333
3334       res_conn =
3335         conn
3336         |> assign(:user, user)
3337         |> put("/api/v1/scheduled_statuses/#{scheduled_activity.id}", %{
3338           scheduled_at: new_scheduled_at
3339         })
3340
3341       assert %{"scheduled_at" => expected_scheduled_at} = json_response(res_conn, 200)
3342       assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(new_scheduled_at)
3343
3344       res_conn =
3345         conn
3346         |> assign(:user, user)
3347         |> put("/api/v1/scheduled_statuses/404", %{scheduled_at: new_scheduled_at})
3348
3349       assert %{"error" => "Record not found"} = json_response(res_conn, 404)
3350     end
3351
3352     test "deletes a scheduled activity", %{conn: conn} do
3353       user = insert(:user)
3354       scheduled_activity = insert(:scheduled_activity, user: user)
3355
3356       res_conn =
3357         conn
3358         |> assign(:user, user)
3359         |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
3360
3361       assert %{} = json_response(res_conn, 200)
3362       assert nil == Repo.get(ScheduledActivity, scheduled_activity.id)
3363
3364       res_conn =
3365         conn
3366         |> assign(:user, user)
3367         |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
3368
3369       assert %{"error" => "Record not found"} = json_response(res_conn, 404)
3370     end
3371   end
3372
3373   test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
3374     user1 = insert(:user)
3375     user2 = insert(:user)
3376     user3 = insert(:user)
3377
3378     {:ok, replied_to} = TwitterAPI.create_status(user1, %{"status" => "cofe"})
3379
3380     # Reply to status from another user
3381     conn1 =
3382       conn
3383       |> assign(:user, user2)
3384       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
3385
3386     assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)
3387
3388     activity = Activity.get_by_id_with_object(id)
3389
3390     assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
3391     assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
3392
3393     # Reblog from the third user
3394     conn2 =
3395       conn
3396       |> assign(:user, user3)
3397       |> post("/api/v1/statuses/#{activity.id}/reblog")
3398
3399     assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
3400              json_response(conn2, 200)
3401
3402     assert to_string(activity.id) == id
3403
3404     # Getting third user status
3405     conn3 =
3406       conn
3407       |> assign(:user, user3)
3408       |> get("api/v1/timelines/home")
3409
3410     [reblogged_activity] = json_response(conn3, 200)
3411
3412     assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id
3413
3414     replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
3415     assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
3416   end
3417
3418   describe "create account by app" do
3419     setup do
3420       enabled = Pleroma.Config.get([:app_account_creation, :enabled])
3421       max_requests = Pleroma.Config.get([:app_account_creation, :max_requests])
3422       interval = Pleroma.Config.get([:app_account_creation, :interval])
3423
3424       Pleroma.Config.put([:app_account_creation, :enabled], true)
3425       Pleroma.Config.put([:app_account_creation, :max_requests], 5)
3426       Pleroma.Config.put([:app_account_creation, :interval], 1)
3427
3428       on_exit(fn ->
3429         Pleroma.Config.put([:app_account_creation, :enabled], enabled)
3430         Pleroma.Config.put([:app_account_creation, :max_requests], max_requests)
3431         Pleroma.Config.put([:app_account_creation, :interval], interval)
3432       end)
3433
3434       :ok
3435     end
3436
3437     test "Account registration via Application", %{conn: conn} do
3438       conn =
3439         conn
3440         |> post("/api/v1/apps", %{
3441           client_name: "client_name",
3442           redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
3443           scopes: "read, write, follow"
3444         })
3445
3446       %{
3447         "client_id" => client_id,
3448         "client_secret" => client_secret,
3449         "id" => _,
3450         "name" => "client_name",
3451         "redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
3452         "vapid_key" => _,
3453         "website" => nil
3454       } = json_response(conn, 200)
3455
3456       conn =
3457         conn
3458         |> post("/oauth/token", %{
3459           grant_type: "client_credentials",
3460           client_id: client_id,
3461           client_secret: client_secret
3462         })
3463
3464       assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
3465                json_response(conn, 200)
3466
3467       assert token
3468       token_from_db = Repo.get_by(Token, token: token)
3469       assert token_from_db
3470       assert refresh
3471       assert scope == "read write follow"
3472
3473       conn =
3474         build_conn()
3475         |> put_req_header("authorization", "Bearer " <> token)
3476         |> post("/api/v1/accounts", %{
3477           username: "lain",
3478           email: "lain@example.org",
3479           password: "PlzDontHackLain",
3480           agreement: true
3481         })
3482
3483       %{
3484         "access_token" => token,
3485         "created_at" => _created_at,
3486         "scope" => _scope,
3487         "token_type" => "Bearer"
3488       } = json_response(conn, 200)
3489
3490       token_from_db = Repo.get_by(Token, token: token)
3491       assert token_from_db
3492       token_from_db = Repo.preload(token_from_db, :user)
3493       assert token_from_db.user
3494
3495       assert token_from_db.user.info.confirmation_pending
3496     end
3497
3498     test "rate limit", %{conn: conn} do
3499       app_token = insert(:oauth_token, user: nil)
3500
3501       conn =
3502         put_req_header(conn, "authorization", "Bearer " <> app_token.token)
3503         |> Map.put(:remote_ip, {15, 15, 15, 15})
3504
3505       for i <- 1..5 do
3506         conn =
3507           conn
3508           |> post("/api/v1/accounts", %{
3509             username: "#{i}lain",
3510             email: "#{i}lain@example.org",
3511             password: "PlzDontHackLain",
3512             agreement: true
3513           })
3514
3515         %{
3516           "access_token" => token,
3517           "created_at" => _created_at,
3518           "scope" => _scope,
3519           "token_type" => "Bearer"
3520         } = json_response(conn, 200)
3521
3522         token_from_db = Repo.get_by(Token, token: token)
3523         assert token_from_db
3524         token_from_db = Repo.preload(token_from_db, :user)
3525         assert token_from_db.user
3526
3527         assert token_from_db.user.info.confirmation_pending
3528       end
3529
3530       conn =
3531         conn
3532         |> post("/api/v1/accounts", %{
3533           username: "6lain",
3534           email: "6lain@example.org",
3535           password: "PlzDontHackLain",
3536           agreement: true
3537         })
3538
3539       assert json_response(conn, 403) == %{"error" => "Rate limit exceeded."}
3540     end
3541   end
3542
3543   describe "GET /api/v1/polls/:id" do
3544     test "returns poll entity for object id", %{conn: conn} do
3545       user = insert(:user)
3546
3547       {:ok, activity} =
3548         CommonAPI.post(user, %{
3549           "status" => "Pleroma does",
3550           "poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20}
3551         })
3552
3553       object = Object.normalize(activity)
3554
3555       conn =
3556         conn
3557         |> assign(:user, user)
3558         |> get("/api/v1/polls/#{object.id}")
3559
3560       response = json_response(conn, 200)
3561       id = object.id
3562       assert %{"id" => ^id, "expired" => false, "multiple" => false} = response
3563     end
3564
3565     test "does not expose polls for private statuses", %{conn: conn} do
3566       user = insert(:user)
3567       other_user = insert(:user)
3568
3569       {:ok, activity} =
3570         CommonAPI.post(user, %{
3571           "status" => "Pleroma does",
3572           "poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20},
3573           "visibility" => "private"
3574         })
3575
3576       object = Object.normalize(activity)
3577
3578       conn =
3579         conn
3580         |> assign(:user, other_user)
3581         |> get("/api/v1/polls/#{object.id}")
3582
3583       assert json_response(conn, 404)
3584     end
3585   end
3586
3587   describe "POST /api/v1/polls/:id/votes" do
3588     test "votes are added to the poll", %{conn: conn} do
3589       user = insert(:user)
3590       other_user = insert(:user)
3591
3592       {:ok, activity} =
3593         CommonAPI.post(user, %{
3594           "status" => "A very delicious sandwich",
3595           "poll" => %{
3596             "options" => ["Lettuce", "Grilled Bacon", "Tomato"],
3597             "expires_in" => 20,
3598             "multiple" => true
3599           }
3600         })
3601
3602       object = Object.normalize(activity)
3603
3604       conn =
3605         conn
3606         |> assign(:user, other_user)
3607         |> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1, 2]})
3608
3609       assert json_response(conn, 200)
3610       object = Object.get_by_id(object.id)
3611
3612       assert Enum.all?(object.data["anyOf"], fn %{"replies" => %{"totalItems" => total_items}} ->
3613                total_items == 1
3614              end)
3615     end
3616
3617     test "author can't vote", %{conn: conn} do
3618       user = insert(:user)
3619
3620       {:ok, activity} =
3621         CommonAPI.post(user, %{
3622           "status" => "Am I cute?",
3623           "poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
3624         })
3625
3626       object = Object.normalize(activity)
3627
3628       assert conn
3629              |> assign(:user, user)
3630              |> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [1]})
3631              |> json_response(422) == %{"error" => "Poll's author can't vote"}
3632
3633       object = Object.get_by_id(object.id)
3634
3635       refute Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 1
3636     end
3637
3638     test "does not allow multiple choices on a single-choice question", %{conn: conn} do
3639       user = insert(:user)
3640       other_user = insert(:user)
3641
3642       {:ok, activity} =
3643         CommonAPI.post(user, %{
3644           "status" => "The glass is",
3645           "poll" => %{"options" => ["half empty", "half full"], "expires_in" => 20}
3646         })
3647
3648       object = Object.normalize(activity)
3649
3650       assert conn
3651              |> assign(:user, other_user)
3652              |> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1]})
3653              |> json_response(422) == %{"error" => "Too many choices"}
3654
3655       object = Object.get_by_id(object.id)
3656
3657       refute Enum.any?(object.data["oneOf"], fn %{"replies" => %{"totalItems" => total_items}} ->
3658                total_items == 1
3659              end)
3660     end
3661   end
3662 end