git.squeep.com Git - akkoma/blob - test/web/mastodon_api/mastodon_api_controller_test.exs

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