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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.ActivityExpiration
  10   alias Pleroma.Config
  11   alias Pleroma.Conversation.Participation
  12   alias Pleroma.Object
  13   alias Pleroma.Repo
  14   alias Pleroma.ScheduledActivity
  15   alias Pleroma.Tests.ObanHelpers
  16   alias Pleroma.User
  17   alias Pleroma.Web.ActivityPub.ActivityPub
  18   alias Pleroma.Web.CommonAPI
  19
  20   import Pleroma.Factory
  21
  22   setup do: clear_config([:instance, :federating])
  23   setup do: clear_config([:instance, :allow_relay])
  24   setup do: clear_config([:rich_media, :enabled])
  25
  26   describe "posting statuses" do
  27     setup do: oauth_access(["write:statuses"])
  28
  29     test "posting a status does not increment reblog_count when relaying", %{conn: conn} do
  30       Pleroma.Config.put([:instance, :federating], true)
  31       Pleroma.Config.get([:instance, :allow_relay], true)
  32
  33       response =
  34         conn
  35         |> post("api/v1/statuses", %{
  36           "content_type" => "text/plain",
  37           "source" => "Pleroma FE",
  38           "status" => "Hello world",
  39           "visibility" => "public"
  40         })
  41         |> json_response(200)
  42
  43       assert response["reblogs_count"] == 0
  44       ObanHelpers.perform_all()
  45
  46       response =
  47         conn
  48         |> get("api/v1/statuses/#{response["id"]}", %{})
  49         |> json_response(200)
  50
  51       assert response["reblogs_count"] == 0
  52     end
  53
  54     test "posting a status", %{conn: conn} do
  55       idempotency_key = "Pikachu rocks!"
  56
  57       conn_one =
  58         conn
  59         |> put_req_header("idempotency-key", idempotency_key)
  60         |> post("/api/v1/statuses", %{
  61           "status" => "cofe",
  62           "spoiler_text" => "2hu",
  63           "sensitive" => "false"
  64         })
  65
  66       {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
  67       # Six hours
  68       assert ttl > :timer.seconds(6 * 60 * 60 - 1)
  69
  70       assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
  71                json_response(conn_one, 200)
  72
  73       assert Activity.get_by_id(id)
  74
  75       conn_two =
  76         conn
  77         |> put_req_header("idempotency-key", idempotency_key)
  78         |> post("/api/v1/statuses", %{
  79           "status" => "cofe",
  80           "spoiler_text" => "2hu",
  81           "sensitive" => "false"
  82         })
  83
  84       assert %{"id" => second_id} = json_response(conn_two, 200)
  85       assert id == second_id
  86
  87       conn_three =
  88         conn
  89         |> post("/api/v1/statuses", %{
  90           "status" => "cofe",
  91           "spoiler_text" => "2hu",
  92           "sensitive" => "false"
  93         })
  94
  95       assert %{"id" => third_id} = json_response(conn_three, 200)
  96       refute id == third_id
  97
  98       # An activity that will expire:
  99       # 2 hours
 100       expires_in = 120 * 60
 101
 102       conn_four =
 103         conn
 104         |> post("api/v1/statuses", %{
 105           "status" => "oolong",
 106           "expires_in" => expires_in
 107         })
 108
 109       assert fourth_response = %{"id" => fourth_id} = json_response(conn_four, 200)
 110       assert activity = Activity.get_by_id(fourth_id)
 111       assert expiration = ActivityExpiration.get_by_activity_id(fourth_id)
 112
 113       estimated_expires_at =
 114         NaiveDateTime.utc_now()
 115         |> NaiveDateTime.add(expires_in)
 116         |> NaiveDateTime.truncate(:second)
 117
 118       # This assert will fail if the test takes longer than a minute. I sure hope it never does:
 119       assert abs(NaiveDateTime.diff(expiration.scheduled_at, estimated_expires_at, :second)) < 60
 120
 121       assert fourth_response["pleroma"]["expires_at"] ==
 122                NaiveDateTime.to_iso8601(expiration.scheduled_at)
 123     end
 124
 125     test "it fails to create a status if `expires_in` is less or equal than an hour", %{
 126       conn: conn
 127     } do
 128       # 1 hour
 129       expires_in = 60 * 60
 130
 131       assert %{"error" => "Expiry date is too soon"} =
 132                conn
 133                |> post("api/v1/statuses", %{
 134                  "status" => "oolong",
 135                  "expires_in" => expires_in
 136                })
 137                |> json_response(422)
 138
 139       # 30 minutes
 140       expires_in = 30 * 60
 141
 142       assert %{"error" => "Expiry date is too soon"} =
 143                conn
 144                |> post("api/v1/statuses", %{
 145                  "status" => "oolong",
 146                  "expires_in" => expires_in
 147                })
 148                |> json_response(422)
 149     end
 150
 151     test "posting an undefined status with an attachment", %{user: user, conn: conn} do
 152       file = %Plug.Upload{
 153         content_type: "image/jpg",
 154         path: Path.absname("test/fixtures/image.jpg"),
 155         filename: "an_image.jpg"
 156       }
 157
 158       {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
 159
 160       conn =
 161         post(conn, "/api/v1/statuses", %{
 162           "media_ids" => [to_string(upload.id)]
 163         })
 164
 165       assert json_response(conn, 200)
 166     end
 167
 168     test "replying to a status", %{user: user, conn: conn} do
 169       {:ok, replied_to} = CommonAPI.post(user, %{"status" => "cofe"})
 170
 171       conn =
 172         conn
 173         |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 174
 175       assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 176
 177       activity = Activity.get_by_id(id)
 178
 179       assert activity.data["context"] == replied_to.data["context"]
 180       assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
 181     end
 182
 183     test "replying to a direct message with visibility other than direct", %{
 184       user: user,
 185       conn: conn
 186     } do
 187       {:ok, replied_to} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})
 188
 189       Enum.each(["public", "private", "unlisted"], fn visibility ->
 190         conn =
 191           conn
 192           |> post("/api/v1/statuses", %{
 193             "status" => "@#{user.nickname} hey",
 194             "in_reply_to_id" => replied_to.id,
 195             "visibility" => visibility
 196           })
 197
 198         assert json_response(conn, 422) == %{"error" => "The message visibility must be direct"}
 199       end)
 200     end
 201
 202     test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
 203       conn = post(conn, "/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
 204
 205       assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 206       assert Activity.get_by_id(id)
 207     end
 208
 209     test "posting a sensitive status", %{conn: conn} do
 210       conn = post(conn, "/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
 211
 212       assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
 213       assert Activity.get_by_id(id)
 214     end
 215
 216     test "posting a fake status", %{conn: conn} do
 217       real_conn =
 218         post(conn, "/api/v1/statuses", %{
 219           "status" =>
 220             "\"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"
 221         })
 222
 223       real_status = json_response(real_conn, 200)
 224
 225       assert real_status
 226       assert Object.get_by_ap_id(real_status["uri"])
 227
 228       real_status =
 229         real_status
 230         |> Map.put("id", nil)
 231         |> Map.put("url", nil)
 232         |> Map.put("uri", nil)
 233         |> Map.put("created_at", nil)
 234         |> Kernel.put_in(["pleroma", "conversation_id"], nil)
 235
 236       fake_conn =
 237         post(conn, "/api/v1/statuses", %{
 238           "status" =>
 239             "\"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",
 240           "preview" => true
 241         })
 242
 243       fake_status = json_response(fake_conn, 200)
 244
 245       assert fake_status
 246       refute Object.get_by_ap_id(fake_status["uri"])
 247
 248       fake_status =
 249         fake_status
 250         |> Map.put("id", nil)
 251         |> Map.put("url", nil)
 252         |> Map.put("uri", nil)
 253         |> Map.put("created_at", nil)
 254         |> Kernel.put_in(["pleroma", "conversation_id"], nil)
 255
 256       assert real_status == fake_status
 257     end
 258
 259     test "posting a status with OGP link preview", %{conn: conn} do
 260       Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
 261       Config.put([:rich_media, :enabled], true)
 262
 263       conn =
 264         post(conn, "/api/v1/statuses", %{
 265           "status" => "https://example.com/ogp"
 266         })
 267
 268       assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
 269       assert Activity.get_by_id(id)
 270     end
 271
 272     test "posting a direct status", %{conn: conn} do
 273       user2 = insert(:user)
 274       content = "direct cofe @#{user2.nickname}"
 275
 276       conn = post(conn, "api/v1/statuses", %{"status" => content, "visibility" => "direct"})
 277
 278       assert %{"id" => id} = response = json_response(conn, 200)
 279       assert response["visibility"] == "direct"
 280       assert response["pleroma"]["direct_conversation_id"]
 281       assert activity = Activity.get_by_id(id)
 282       assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
 283       assert activity.data["to"] == [user2.ap_id]
 284       assert activity.data["cc"] == []
 285     end
 286   end
 287
 288   describe "posting scheduled statuses" do
 289     setup do: oauth_access(["write:statuses"])
 290
 291     test "creates a scheduled activity", %{conn: conn} do
 292       scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
 293
 294       conn =
 295         post(conn, "/api/v1/statuses", %{
 296           "status" => "scheduled",
 297           "scheduled_at" => scheduled_at
 298         })
 299
 300       assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
 301       assert expected_scheduled_at == CommonAPI.Utils.to_masto_date(scheduled_at)
 302       assert [] == Repo.all(Activity)
 303     end
 304
 305     test "creates a scheduled activity with a media attachment", %{user: user, conn: conn} do
 306       scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
 307
 308       file = %Plug.Upload{
 309         content_type: "image/jpg",
 310         path: Path.absname("test/fixtures/image.jpg"),
 311         filename: "an_image.jpg"
 312       }
 313
 314       {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
 315
 316       conn =
 317         post(conn, "/api/v1/statuses", %{
 318           "media_ids" => [to_string(upload.id)],
 319           "status" => "scheduled",
 320           "scheduled_at" => scheduled_at
 321         })
 322
 323       assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
 324       assert %{"type" => "image"} = media_attachment
 325     end
 326
 327     test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
 328          %{conn: conn} do
 329       scheduled_at =
 330         NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
 331
 332       conn =
 333         post(conn, "/api/v1/statuses", %{
 334           "status" => "not scheduled",
 335           "scheduled_at" => scheduled_at
 336         })
 337
 338       assert %{"content" => "not scheduled"} = json_response(conn, 200)
 339       assert [] == Repo.all(ScheduledActivity)
 340     end
 341
 342     test "returns error when daily user limit is exceeded", %{user: user, conn: conn} do
 343       today =
 344         NaiveDateTime.utc_now()
 345         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
 346         |> NaiveDateTime.to_iso8601()
 347
 348       attrs = %{params: %{}, scheduled_at: today}
 349       {:ok, _} = ScheduledActivity.create(user, attrs)
 350       {:ok, _} = ScheduledActivity.create(user, attrs)
 351
 352       conn = post(conn, "/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
 353
 354       assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
 355     end
 356
 357     test "returns error when total user limit is exceeded", %{user: user, conn: conn} do
 358       today =
 359         NaiveDateTime.utc_now()
 360         |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
 361         |> NaiveDateTime.to_iso8601()
 362
 363       tomorrow =
 364         NaiveDateTime.utc_now()
 365         |> NaiveDateTime.add(:timer.hours(36), :millisecond)
 366         |> NaiveDateTime.to_iso8601()
 367
 368       attrs = %{params: %{}, scheduled_at: today}
 369       {:ok, _} = ScheduledActivity.create(user, attrs)
 370       {:ok, _} = ScheduledActivity.create(user, attrs)
 371       {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
 372
 373       conn =
 374         post(conn, "/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
 375
 376       assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
 377     end
 378   end
 379
 380   describe "posting polls" do
 381     setup do: oauth_access(["write:statuses"])
 382
 383     test "posting a poll", %{conn: conn} do
 384       time = NaiveDateTime.utc_now()
 385
 386       conn =
 387         post(conn, "/api/v1/statuses", %{
 388           "status" => "Who is the #bestgrill?",
 389           "poll" => %{"options" => ["Rei", "Asuka", "Misato"], "expires_in" => 420}
 390         })
 391
 392       response = json_response(conn, 200)
 393
 394       assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
 395                title in ["Rei", "Asuka", "Misato"]
 396              end)
 397
 398       assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
 399       refute response["poll"]["expred"]
 400
 401       question = Object.get_by_id(response["poll"]["id"])
 402
 403       # closed contains utc timezone
 404       assert question.data["closed"] =~ "Z"
 405     end
 406
 407     test "option limit is enforced", %{conn: conn} do
 408       limit = Config.get([:instance, :poll_limits, :max_options])
 409
 410       conn =
 411         post(conn, "/api/v1/statuses", %{
 412           "status" => "desu~",
 413           "poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
 414         })
 415
 416       %{"error" => error} = json_response(conn, 422)
 417       assert error == "Poll can't contain more than #{limit} options"
 418     end
 419
 420     test "option character limit is enforced", %{conn: conn} do
 421       limit = Config.get([:instance, :poll_limits, :max_option_chars])
 422
 423       conn =
 424         post(conn, "/api/v1/statuses", %{
 425           "status" => "...",
 426           "poll" => %{
 427             "options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
 428             "expires_in" => 1
 429           }
 430         })
 431
 432       %{"error" => error} = json_response(conn, 422)
 433       assert error == "Poll options cannot be longer than #{limit} characters each"
 434     end
 435
 436     test "minimal date limit is enforced", %{conn: conn} do
 437       limit = Config.get([:instance, :poll_limits, :min_expiration])
 438
 439       conn =
 440         post(conn, "/api/v1/statuses", %{
 441           "status" => "imagine arbitrary limits",
 442           "poll" => %{
 443             "options" => ["this post was made by pleroma gang"],
 444             "expires_in" => limit - 1
 445           }
 446         })
 447
 448       %{"error" => error} = json_response(conn, 422)
 449       assert error == "Expiration date is too soon"
 450     end
 451
 452     test "maximum date limit is enforced", %{conn: conn} do
 453       limit = Config.get([:instance, :poll_limits, :max_expiration])
 454
 455       conn =
 456         post(conn, "/api/v1/statuses", %{
 457           "status" => "imagine arbitrary limits",
 458           "poll" => %{
 459             "options" => ["this post was made by pleroma gang"],
 460             "expires_in" => limit + 1
 461           }
 462         })
 463
 464       %{"error" => error} = json_response(conn, 422)
 465       assert error == "Expiration date is too far in the future"
 466     end
 467   end
 468
 469   test "get a status" do
 470     %{conn: conn} = oauth_access(["read:statuses"])
 471     activity = insert(:note_activity)
 472
 473     conn = get(conn, "/api/v1/statuses/#{activity.id}")
 474
 475     assert %{"id" => id} = json_response(conn, 200)
 476     assert id == to_string(activity.id)
 477   end
 478
 479   defp local_and_remote_activities do
 480     local = insert(:note_activity)
 481     remote = insert(:note_activity, local: false)
 482     {:ok, local: local, remote: remote}
 483   end
 484
 485   describe "status with restrict unauthenticated activities for local and remote" do
 486     setup do: local_and_remote_activities()
 487
 488     setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)
 489
 490     setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
 491
 492     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
 493       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
 494
 495       assert json_response(res_conn, :not_found) == %{
 496                "error" => "Record not found"
 497              }
 498
 499       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
 500
 501       assert json_response(res_conn, :not_found) == %{
 502                "error" => "Record not found"
 503              }
 504     end
 505
 506     test "if user is authenticated", %{local: local, remote: remote} do
 507       %{conn: conn} = oauth_access(["read"])
 508       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
 509       assert %{"id" => _} = json_response(res_conn, 200)
 510
 511       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
 512       assert %{"id" => _} = json_response(res_conn, 200)
 513     end
 514   end
 515
 516   describe "status with restrict unauthenticated activities for local" do
 517     setup do: local_and_remote_activities()
 518
 519     setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)
 520
 521     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
 522       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
 523
 524       assert json_response(res_conn, :not_found) == %{
 525                "error" => "Record not found"
 526              }
 527
 528       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
 529       assert %{"id" => _} = json_response(res_conn, 200)
 530     end
 531
 532     test "if user is authenticated", %{local: local, remote: remote} do
 533       %{conn: conn} = oauth_access(["read"])
 534       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
 535       assert %{"id" => _} = json_response(res_conn, 200)
 536
 537       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
 538       assert %{"id" => _} = json_response(res_conn, 200)
 539     end
 540   end
 541
 542   describe "status with restrict unauthenticated activities for remote" do
 543     setup do: local_and_remote_activities()
 544
 545     setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
 546
 547     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
 548       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
 549       assert %{"id" => _} = json_response(res_conn, 200)
 550
 551       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
 552
 553       assert json_response(res_conn, :not_found) == %{
 554                "error" => "Record not found"
 555              }
 556     end
 557
 558     test "if user is authenticated", %{local: local, remote: remote} do
 559       %{conn: conn} = oauth_access(["read"])
 560       res_conn = get(conn, "/api/v1/statuses/#{local.id}")
 561       assert %{"id" => _} = json_response(res_conn, 200)
 562
 563       res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
 564       assert %{"id" => _} = json_response(res_conn, 200)
 565     end
 566   end
 567
 568   test "getting a status that doesn't exist returns 404" do
 569     %{conn: conn} = oauth_access(["read:statuses"])
 570     activity = insert(:note_activity)
 571
 572     conn = get(conn, "/api/v1/statuses/#{String.downcase(activity.id)}")
 573
 574     assert json_response(conn, 404) == %{"error" => "Record not found"}
 575   end
 576
 577   test "get a direct status" do
 578     %{user: user, conn: conn} = oauth_access(["read:statuses"])
 579     other_user = insert(:user)
 580
 581     {:ok, activity} =
 582       CommonAPI.post(user, %{"status" => "@#{other_user.nickname}", "visibility" => "direct"})
 583
 584     conn =
 585       conn
 586       |> assign(:user, user)
 587       |> get("/api/v1/statuses/#{activity.id}")
 588
 589     [participation] = Participation.for_user(user)
 590
 591     res = json_response(conn, 200)
 592     assert res["pleroma"]["direct_conversation_id"] == participation.id
 593   end
 594
 595   test "get statuses by IDs" do
 596     %{conn: conn} = oauth_access(["read:statuses"])
 597     %{id: id1} = insert(:note_activity)
 598     %{id: id2} = insert(:note_activity)
 599
 600     query_string = "ids[]=#{id1}&ids[]=#{id2}"
 601     conn = get(conn, "/api/v1/statuses/?#{query_string}")
 602
 603     assert [%{"id" => ^id1}, %{"id" => ^id2}] = Enum.sort_by(json_response(conn, :ok), & &1["id"])
 604   end
 605
 606   describe "getting statuses by ids with restricted unauthenticated for local and remote" do
 607     setup do: local_and_remote_activities()
 608
 609     setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)
 610
 611     setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
 612
 613     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
 614       res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
 615
 616       assert json_response(res_conn, 200) == []
 617     end
 618
 619     test "if user is authenticated", %{local: local, remote: remote} do
 620       %{conn: conn} = oauth_access(["read"])
 621
 622       res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
 623
 624       assert length(json_response(res_conn, 200)) == 2
 625     end
 626   end
 627
 628   describe "getting statuses by ids with restricted unauthenticated for local" do
 629     setup do: local_and_remote_activities()
 630
 631     setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)
 632
 633     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
 634       res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
 635
 636       remote_id = remote.id
 637       assert [%{"id" => ^remote_id}] = json_response(res_conn, 200)
 638     end
 639
 640     test "if user is authenticated", %{local: local, remote: remote} do
 641       %{conn: conn} = oauth_access(["read"])
 642
 643       res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
 644
 645       assert length(json_response(res_conn, 200)) == 2
 646     end
 647   end
 648
 649   describe "getting statuses by ids with restricted unauthenticated for remote" do
 650     setup do: local_and_remote_activities()
 651
 652     setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
 653
 654     test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
 655       res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
 656
 657       local_id = local.id
 658       assert [%{"id" => ^local_id}] = json_response(res_conn, 200)
 659     end
 660
 661     test "if user is authenticated", %{local: local, remote: remote} do
 662       %{conn: conn} = oauth_access(["read"])
 663
 664       res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})
 665
 666       assert length(json_response(res_conn, 200)) == 2
 667     end
 668   end
 669
 670   describe "deleting a status" do
 671     test "when you created it" do
 672       %{user: author, conn: conn} = oauth_access(["write:statuses"])
 673       activity = insert(:note_activity, user: author)
 674
 675       conn =
 676         conn
 677         |> assign(:user, author)
 678         |> delete("/api/v1/statuses/#{activity.id}")
 679
 680       assert %{} = json_response(conn, 200)
 681
 682       refute Activity.get_by_id(activity.id)
 683     end
 684
 685     test "when it doesn't exist" do
 686       %{user: author, conn: conn} = oauth_access(["write:statuses"])
 687       activity = insert(:note_activity, user: author)
 688
 689       conn =
 690         conn
 691         |> assign(:user, author)
 692         |> delete("/api/v1/statuses/#{String.downcase(activity.id)}")
 693
 694       assert %{"error" => "Record not found"} == json_response(conn, 404)
 695     end
 696
 697     test "when you didn't create it" do
 698       %{conn: conn} = oauth_access(["write:statuses"])
 699       activity = insert(:note_activity)
 700
 701       conn = delete(conn, "/api/v1/statuses/#{activity.id}")
 702
 703       assert %{"error" => _} = json_response(conn, 403)
 704
 705       assert Activity.get_by_id(activity.id) == activity
 706     end
 707
 708     test "when you're an admin or moderator", %{conn: conn} do
 709       activity1 = insert(:note_activity)
 710       activity2 = insert(:note_activity)
 711       admin = insert(:user, is_admin: true)
 712       moderator = insert(:user, is_moderator: true)
 713
 714       res_conn =
 715         conn
 716         |> assign(:user, admin)
 717         |> assign(:token, insert(:oauth_token, user: admin, scopes: ["write:statuses"]))
 718         |> delete("/api/v1/statuses/#{activity1.id}")
 719
 720       assert %{} = json_response(res_conn, 200)
 721
 722       res_conn =
 723         conn
 724         |> assign(:user, moderator)
 725         |> assign(:token, insert(:oauth_token, user: moderator, scopes: ["write:statuses"]))
 726         |> delete("/api/v1/statuses/#{activity2.id}")
 727
 728       assert %{} = json_response(res_conn, 200)
 729
 730       refute Activity.get_by_id(activity1.id)
 731       refute Activity.get_by_id(activity2.id)
 732     end
 733   end
 734
 735   describe "reblogging" do
 736     setup do: oauth_access(["write:statuses"])
 737
 738     test "reblogs and returns the reblogged status", %{conn: conn} do
 739       activity = insert(:note_activity)
 740
 741       conn = post(conn, "/api/v1/statuses/#{activity.id}/reblog")
 742
 743       assert %{
 744                "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
 745                "reblogged" => true
 746              } = json_response(conn, 200)
 747
 748       assert to_string(activity.id) == id
 749     end
 750
 751     test "returns 404 if the reblogged status doesn't exist", %{conn: conn} do
 752       activity = insert(:note_activity)
 753
 754       conn = post(conn, "/api/v1/statuses/#{String.downcase(activity.id)}/reblog")
 755
 756       assert %{"error" => "Record not found"} = json_response(conn, 404)
 757     end
 758
 759     test "reblogs privately and returns the reblogged status", %{conn: conn} do
 760       activity = insert(:note_activity)
 761
 762       conn = post(conn, "/api/v1/statuses/#{activity.id}/reblog", %{"visibility" => "private"})
 763
 764       assert %{
 765                "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
 766                "reblogged" => true,
 767                "visibility" => "private"
 768              } = json_response(conn, 200)
 769
 770       assert to_string(activity.id) == id
 771     end
 772
 773     test "reblogged status for another user" do
 774       activity = insert(:note_activity)
 775       user1 = insert(:user)
 776       user2 = insert(:user)
 777       user3 = insert(:user)
 778       CommonAPI.favorite(activity.id, user2)
 779       {:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
 780       {:ok, reblog_activity1, _object} = CommonAPI.repeat(activity.id, user1)
 781       {:ok, _, _object} = CommonAPI.repeat(activity.id, user2)
 782
 783       conn_res =
 784         build_conn()
 785         |> assign(:user, user3)
 786         |> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
 787         |> get("/api/v1/statuses/#{reblog_activity1.id}")
 788
 789       assert %{
 790                "reblog" => %{"id" => id, "reblogged" => false, "reblogs_count" => 2},
 791                "reblogged" => false,
 792                "favourited" => false,
 793                "bookmarked" => false
 794              } = json_response(conn_res, 200)
 795
 796       conn_res =
 797         build_conn()
 798         |> assign(:user, user2)
 799         |> assign(:token, insert(:oauth_token, user: user2, scopes: ["read:statuses"]))
 800         |> get("/api/v1/statuses/#{reblog_activity1.id}")
 801
 802       assert %{
 803                "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
 804                "reblogged" => true,
 805                "favourited" => true,
 806                "bookmarked" => true
 807              } = json_response(conn_res, 200)
 808
 809       assert to_string(activity.id) == id
 810     end
 811   end
 812
 813   describe "unreblogging" do
 814     setup do: oauth_access(["write:statuses"])
 815
 816     test "unreblogs and returns the unreblogged status", %{user: user, conn: conn} do
 817       activity = insert(:note_activity)
 818
 819       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 820
 821       conn = post(conn, "/api/v1/statuses/#{activity.id}/unreblog")
 822
 823       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 824
 825       assert to_string(activity.id) == id
 826     end
 827
 828     test "returns 404 error when activity does not exist", %{conn: conn} do
 829       conn = post(conn, "/api/v1/statuses/foo/unreblog")
 830
 831       assert json_response(conn, 404) == %{"error" => "Record not found"}
 832     end
 833   end
 834
 835   describe "favoriting" do
 836     setup do: oauth_access(["write:favourites"])
 837
 838     test "favs a status and returns it", %{conn: conn} do
 839       activity = insert(:note_activity)
 840
 841       conn = post(conn, "/api/v1/statuses/#{activity.id}/favourite")
 842
 843       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 844                json_response(conn, 200)
 845
 846       assert to_string(activity.id) == id
 847     end
 848
 849     test "favoriting twice will just return 200", %{conn: conn} do
 850       activity = insert(:note_activity)
 851
 852       post(conn, "/api/v1/statuses/#{activity.id}/favourite")
 853       assert post(conn, "/api/v1/statuses/#{activity.id}/favourite") |> json_response(200)
 854     end
 855
 856     test "returns 404 error for a wrong id", %{conn: conn} do
 857       conn = post(conn, "/api/v1/statuses/1/favourite")
 858
 859       assert json_response(conn, 404) == %{"error" => "Record not found"}
 860     end
 861   end
 862
 863   describe "unfavoriting" do
 864     setup do: oauth_access(["write:favourites"])
 865
 866     test "unfavorites a status and returns it", %{user: user, conn: conn} do
 867       activity = insert(:note_activity)
 868
 869       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 870
 871       conn = post(conn, "/api/v1/statuses/#{activity.id}/unfavourite")
 872
 873       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 874                json_response(conn, 200)
 875
 876       assert to_string(activity.id) == id
 877     end
 878
 879     test "returns 404 error for a wrong id", %{conn: conn} do
 880       conn = post(conn, "/api/v1/statuses/1/unfavourite")
 881
 882       assert json_response(conn, 404) == %{"error" => "Record not found"}
 883     end
 884   end
 885
 886   describe "pinned statuses" do
 887     setup do: oauth_access(["write:accounts"])
 888
 889     setup %{user: user} do
 890       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
 891
 892       %{activity: activity}
 893     end
 894
 895     setup do: clear_config([:instance, :max_pinned_statuses], 1)
 896
 897     test "pin status", %{conn: conn, user: user, activity: activity} do
 898       id_str = to_string(activity.id)
 899
 900       assert %{"id" => ^id_str, "pinned" => true} =
 901                conn
 902                |> post("/api/v1/statuses/#{activity.id}/pin")
 903                |> json_response(200)
 904
 905       assert [%{"id" => ^id_str, "pinned" => true}] =
 906                conn
 907                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 908                |> json_response(200)
 909     end
 910
 911     test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
 912       {:ok, dm} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"})
 913
 914       conn = post(conn, "/api/v1/statuses/#{dm.id}/pin")
 915
 916       assert json_response(conn, 400) == %{"error" => "Could not pin"}
 917     end
 918
 919     test "unpin status", %{conn: conn, user: user, activity: activity} do
 920       {:ok, _} = CommonAPI.pin(activity.id, user)
 921       user = refresh_record(user)
 922
 923       id_str = to_string(activity.id)
 924
 925       assert %{"id" => ^id_str, "pinned" => false} =
 926                conn
 927                |> assign(:user, user)
 928                |> post("/api/v1/statuses/#{activity.id}/unpin")
 929                |> json_response(200)
 930
 931       assert [] =
 932                conn
 933                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 934                |> json_response(200)
 935     end
 936
 937     test "/unpin: returns 400 error when activity is not exist", %{conn: conn} do
 938       conn = post(conn, "/api/v1/statuses/1/unpin")
 939
 940       assert json_response(conn, 400) == %{"error" => "Could not unpin"}
 941     end
 942
 943     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
 944       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
 945
 946       id_str_one = to_string(activity_one.id)
 947
 948       assert %{"id" => ^id_str_one, "pinned" => true} =
 949                conn
 950                |> post("/api/v1/statuses/#{id_str_one}/pin")
 951                |> json_response(200)
 952
 953       user = refresh_record(user)
 954
 955       assert %{"error" => "You have already pinned the maximum number of statuses"} =
 956                conn
 957                |> assign(:user, user)
 958                |> post("/api/v1/statuses/#{activity_two.id}/pin")
 959                |> json_response(400)
 960     end
 961   end
 962
 963   describe "cards" do
 964     setup do
 965       Config.put([:rich_media, :enabled], true)
 966
 967       oauth_access(["read:statuses"])
 968     end
 969
 970     test "returns rich-media card", %{conn: conn, user: user} do
 971       Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
 972
 973       {:ok, activity} = CommonAPI.post(user, %{"status" => "https://example.com/ogp"})
 974
 975       card_data = %{
 976         "image" => "http://ia.media-imdb.com/images/rock.jpg",
 977         "provider_name" => "example.com",
 978         "provider_url" => "https://example.com",
 979         "title" => "The Rock",
 980         "type" => "link",
 981         "url" => "https://example.com/ogp",
 982         "description" =>
 983           "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
 984         "pleroma" => %{
 985           "opengraph" => %{
 986             "image" => "http://ia.media-imdb.com/images/rock.jpg",
 987             "title" => "The Rock",
 988             "type" => "video.movie",
 989             "url" => "https://example.com/ogp",
 990             "description" =>
 991               "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
 992           }
 993         }
 994       }
 995
 996       response =
 997         conn
 998         |> get("/api/v1/statuses/#{activity.id}/card")
 999         |> json_response(200)
1000
1001       assert response == card_data
1002
1003       # works with private posts
1004       {:ok, activity} =
1005         CommonAPI.post(user, %{"status" => "https://example.com/ogp", "visibility" => "direct"})
1006
1007       response_two =
1008         conn
1009         |> get("/api/v1/statuses/#{activity.id}/card")
1010         |> json_response(200)
1011
1012       assert response_two == card_data
1013     end
1014
1015     test "replaces missing description with an empty string", %{conn: conn, user: user} do
1016       Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
1017
1018       {:ok, activity} =
1019         CommonAPI.post(user, %{"status" => "https://example.com/ogp-missing-data"})
1020
1021       response =
1022         conn
1023         |> get("/api/v1/statuses/#{activity.id}/card")
1024         |> json_response(:ok)
1025
1026       assert response == %{
1027                "type" => "link",
1028                "title" => "Pleroma",
1029                "description" => "",
1030                "image" => nil,
1031                "provider_name" => "example.com",
1032                "provider_url" => "https://example.com",
1033                "url" => "https://example.com/ogp-missing-data",
1034                "pleroma" => %{
1035                  "opengraph" => %{
1036                    "title" => "Pleroma",
1037                    "type" => "website",
1038                    "url" => "https://example.com/ogp-missing-data"
1039                  }
1040                }
1041              }
1042     end
1043   end
1044
1045   test "bookmarks" do
1046     %{conn: conn} = oauth_access(["write:bookmarks", "read:bookmarks"])
1047     author = insert(:user)
1048
1049     {:ok, activity1} =
1050       CommonAPI.post(author, %{
1051         "status" => "heweoo?"
1052       })
1053
1054     {:ok, activity2} =
1055       CommonAPI.post(author, %{
1056         "status" => "heweoo!"
1057       })
1058
1059     response1 = post(conn, "/api/v1/statuses/#{activity1.id}/bookmark")
1060
1061     assert json_response(response1, 200)["bookmarked"] == true
1062
1063     response2 = post(conn, "/api/v1/statuses/#{activity2.id}/bookmark")
1064
1065     assert json_response(response2, 200)["bookmarked"] == true
1066
1067     bookmarks = get(conn, "/api/v1/bookmarks")
1068
1069     assert [json_response(response2, 200), json_response(response1, 200)] ==
1070              json_response(bookmarks, 200)
1071
1072     response1 = post(conn, "/api/v1/statuses/#{activity1.id}/unbookmark")
1073
1074     assert json_response(response1, 200)["bookmarked"] == false
1075
1076     bookmarks = get(conn, "/api/v1/bookmarks")
1077
1078     assert [json_response(response2, 200)] == json_response(bookmarks, 200)
1079   end
1080
1081   describe "conversation muting" do
1082     setup do: oauth_access(["write:mutes"])
1083
1084     setup do
1085       post_user = insert(:user)
1086       {:ok, activity} = CommonAPI.post(post_user, %{"status" => "HIE"})
1087       %{activity: activity}
1088     end
1089
1090     test "mute conversation", %{conn: conn, activity: activity} do
1091       id_str = to_string(activity.id)
1092
1093       assert %{"id" => ^id_str, "muted" => true} =
1094                conn
1095                |> post("/api/v1/statuses/#{activity.id}/mute")
1096                |> json_response(200)
1097     end
1098
1099     test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
1100       {:ok, _} = CommonAPI.add_mute(user, activity)
1101
1102       conn = post(conn, "/api/v1/statuses/#{activity.id}/mute")
1103
1104       assert json_response(conn, 400) == %{"error" => "conversation is already muted"}
1105     end
1106
1107     test "unmute conversation", %{conn: conn, user: user, activity: activity} do
1108       {:ok, _} = CommonAPI.add_mute(user, activity)
1109
1110       id_str = to_string(activity.id)
1111
1112       assert %{"id" => ^id_str, "muted" => false} =
1113                conn
1114                # |> assign(:user, user)
1115                |> post("/api/v1/statuses/#{activity.id}/unmute")
1116                |> json_response(200)
1117     end
1118   end
1119
1120   test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
1121     user1 = insert(:user)
1122     user2 = insert(:user)
1123     user3 = insert(:user)
1124
1125     {:ok, replied_to} = CommonAPI.post(user1, %{"status" => "cofe"})
1126
1127     # Reply to status from another user
1128     conn1 =
1129       conn
1130       |> assign(:user, user2)
1131       |> assign(:token, insert(:oauth_token, user: user2, scopes: ["write:statuses"]))
1132       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
1133
1134     assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)
1135
1136     activity = Activity.get_by_id_with_object(id)
1137
1138     assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
1139     assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
1140
1141     # Reblog from the third user
1142     conn2 =
1143       conn
1144       |> assign(:user, user3)
1145       |> assign(:token, insert(:oauth_token, user: user3, scopes: ["write:statuses"]))
1146       |> post("/api/v1/statuses/#{activity.id}/reblog")
1147
1148     assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
1149              json_response(conn2, 200)
1150
1151     assert to_string(activity.id) == id
1152
1153     # Getting third user status
1154     conn3 =
1155       conn
1156       |> assign(:user, user3)
1157       |> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
1158       |> get("api/v1/timelines/home")
1159
1160     [reblogged_activity] = json_response(conn3, 200)
1161
1162     assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id
1163
1164     replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
1165     assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
1166   end
1167
1168   describe "GET /api/v1/statuses/:id/favourited_by" do
1169     setup do: oauth_access(["read:accounts"])
1170
1171     setup %{user: user} do
1172       {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
1173
1174       %{activity: activity}
1175     end
1176
1177     test "returns users who have favorited the status", %{conn: conn, activity: activity} do
1178       other_user = insert(:user)
1179       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1180
1181       response =
1182         conn
1183         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1184         |> json_response(:ok)
1185
1186       [%{"id" => id}] = response
1187
1188       assert id == other_user.id
1189     end
1190
1191     test "returns empty array when status has not been favorited yet", %{
1192       conn: conn,
1193       activity: activity
1194     } do
1195       response =
1196         conn
1197         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1198         |> json_response(:ok)
1199
1200       assert Enum.empty?(response)
1201     end
1202
1203     test "does not return users who have favorited the status but are blocked", %{
1204       conn: %{assigns: %{user: user}} = conn,
1205       activity: activity
1206     } do
1207       other_user = insert(:user)
1208       {:ok, _user_relationship} = User.block(user, other_user)
1209
1210       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1211
1212       response =
1213         conn
1214         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1215         |> json_response(:ok)
1216
1217       assert Enum.empty?(response)
1218     end
1219
1220     test "does not fail on an unauthenticated request", %{activity: activity} do
1221       other_user = insert(:user)
1222       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1223
1224       response =
1225         build_conn()
1226         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1227         |> json_response(:ok)
1228
1229       [%{"id" => id}] = response
1230       assert id == other_user.id
1231     end
1232
1233     test "requires authentication for private posts", %{user: user} do
1234       other_user = insert(:user)
1235
1236       {:ok, activity} =
1237         CommonAPI.post(user, %{
1238           "status" => "@#{other_user.nickname} wanna get some #cofe together?",
1239           "visibility" => "direct"
1240         })
1241
1242       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1243
1244       favourited_by_url = "/api/v1/statuses/#{activity.id}/favourited_by"
1245
1246       build_conn()
1247       |> get(favourited_by_url)
1248       |> json_response(404)
1249
1250       conn =
1251         build_conn()
1252         |> assign(:user, other_user)
1253         |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
1254
1255       conn
1256       |> assign(:token, nil)
1257       |> get(favourited_by_url)
1258       |> json_response(404)
1259
1260       response =
1261         conn
1262         |> get(favourited_by_url)
1263         |> json_response(200)
1264
1265       [%{"id" => id}] = response
1266       assert id == other_user.id
1267     end
1268   end
1269
1270   describe "GET /api/v1/statuses/:id/reblogged_by" do
1271     setup do: oauth_access(["read:accounts"])
1272
1273     setup %{user: user} do
1274       {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
1275
1276       %{activity: activity}
1277     end
1278
1279     test "returns users who have reblogged the status", %{conn: conn, activity: activity} do
1280       other_user = insert(:user)
1281       {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1282
1283       response =
1284         conn
1285         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1286         |> json_response(:ok)
1287
1288       [%{"id" => id}] = response
1289
1290       assert id == other_user.id
1291     end
1292
1293     test "returns empty array when status has not been reblogged yet", %{
1294       conn: conn,
1295       activity: activity
1296     } do
1297       response =
1298         conn
1299         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1300         |> json_response(:ok)
1301
1302       assert Enum.empty?(response)
1303     end
1304
1305     test "does not return users who have reblogged the status but are blocked", %{
1306       conn: %{assigns: %{user: user}} = conn,
1307       activity: activity
1308     } do
1309       other_user = insert(:user)
1310       {:ok, _user_relationship} = User.block(user, other_user)
1311
1312       {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1313
1314       response =
1315         conn
1316         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1317         |> json_response(:ok)
1318
1319       assert Enum.empty?(response)
1320     end
1321
1322     test "does not return users who have reblogged the status privately", %{
1323       conn: conn,
1324       activity: activity
1325     } do
1326       other_user = insert(:user)
1327
1328       {:ok, _, _} = CommonAPI.repeat(activity.id, other_user, %{"visibility" => "private"})
1329
1330       response =
1331         conn
1332         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1333         |> json_response(:ok)
1334
1335       assert Enum.empty?(response)
1336     end
1337
1338     test "does not fail on an unauthenticated request", %{activity: activity} do
1339       other_user = insert(:user)
1340       {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1341
1342       response =
1343         build_conn()
1344         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1345         |> json_response(:ok)
1346
1347       [%{"id" => id}] = response
1348       assert id == other_user.id
1349     end
1350
1351     test "requires authentication for private posts", %{user: user} do
1352       other_user = insert(:user)
1353
1354       {:ok, activity} =
1355         CommonAPI.post(user, %{
1356           "status" => "@#{other_user.nickname} wanna get some #cofe together?",
1357           "visibility" => "direct"
1358         })
1359
1360       build_conn()
1361       |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1362       |> json_response(404)
1363
1364       response =
1365         build_conn()
1366         |> assign(:user, other_user)
1367         |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
1368         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1369         |> json_response(200)
1370
1371       assert [] == response
1372     end
1373   end
1374
1375   test "context" do
1376     user = insert(:user)
1377
1378     {:ok, %{id: id1}} = CommonAPI.post(user, %{"status" => "1"})
1379     {:ok, %{id: id2}} = CommonAPI.post(user, %{"status" => "2", "in_reply_to_status_id" => id1})
1380     {:ok, %{id: id3}} = CommonAPI.post(user, %{"status" => "3", "in_reply_to_status_id" => id2})
1381     {:ok, %{id: id4}} = CommonAPI.post(user, %{"status" => "4", "in_reply_to_status_id" => id3})
1382     {:ok, %{id: id5}} = CommonAPI.post(user, %{"status" => "5", "in_reply_to_status_id" => id4})
1383
1384     response =
1385       build_conn()
1386       |> get("/api/v1/statuses/#{id3}/context")
1387       |> json_response(:ok)
1388
1389     assert %{
1390              "ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
1391              "descendants" => [%{"id" => ^id4}, %{"id" => ^id5}]
1392            } = response
1393   end
1394
1395   test "returns the favorites of a user" do
1396     %{user: user, conn: conn} = oauth_access(["read:favourites"])
1397     other_user = insert(:user)
1398
1399     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1400     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1401
1402     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1403
1404     first_conn = get(conn, "/api/v1/favourites")
1405
1406     assert [status] = json_response(first_conn, 200)
1407     assert status["id"] == to_string(activity.id)
1408
1409     assert [{"link", _link_header}] =
1410              Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1411
1412     # Honours query params
1413     {:ok, second_activity} =
1414       CommonAPI.post(other_user, %{
1415         "status" =>
1416           "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1417       })
1418
1419     {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
1420
1421     last_like = status["id"]
1422
1423     second_conn = get(conn, "/api/v1/favourites?since_id=#{last_like}")
1424
1425     assert [second_status] = json_response(second_conn, 200)
1426     assert second_status["id"] == to_string(second_activity.id)
1427
1428     third_conn = get(conn, "/api/v1/favourites?limit=0")
1429
1430     assert [] = json_response(third_conn, 200)
1431   end
1432
1433   test "expires_at is nil for another user" do
1434     %{conn: conn, user: user} = oauth_access(["read:statuses"])
1435     {:ok, activity} = CommonAPI.post(user, %{"status" => "foobar", "expires_in" => 1_000_000})
1436
1437     expires_at =
1438       activity.id
1439       |> ActivityExpiration.get_by_activity_id()
1440       |> Map.get(:scheduled_at)
1441       |> NaiveDateTime.to_iso8601()
1442
1443     assert %{"pleroma" => %{"expires_at" => ^expires_at}} =
1444              conn |> get("/api/v1/statuses/#{activity.id}") |> json_response(:ok)
1445
1446     %{conn: conn} = oauth_access(["read:statuses"])
1447
1448     assert %{"pleroma" => %{"expires_at" => nil}} =
1449              conn |> get("/api/v1/statuses/#{activity.id}") |> json_response(:ok)
1450   end
1451 end