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-2019 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.Object
  12   alias Pleroma.User
  13   alias Pleroma.Web.CommonAPI
  14
  15   import Pleroma.Factory
  16
  17   describe "posting statuses" do
  18     setup do
  19       user = insert(:user)
  20
  21       conn =
  22         build_conn()
  23         |> assign(:user, user)
  24
  25       [conn: conn]
  26     end
  27
  28     test "posting a status", %{conn: conn} do
  29       idempotency_key = "Pikachu rocks!"
  30
  31       conn_one =
  32         conn
  33         |> put_req_header("idempotency-key", idempotency_key)
  34         |> post("/api/v1/statuses", %{
  35           "status" => "cofe",
  36           "spoiler_text" => "2hu",
  37           "sensitive" => "false"
  38         })
  39
  40       {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
  41       # Six hours
  42       assert ttl > :timer.seconds(6 * 60 * 60 - 1)
  43
  44       assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
  45                json_response(conn_one, 200)
  46
  47       assert Activity.get_by_id(id)
  48
  49       conn_two =
  50         conn
  51         |> put_req_header("idempotency-key", idempotency_key)
  52         |> post("/api/v1/statuses", %{
  53           "status" => "cofe",
  54           "spoiler_text" => "2hu",
  55           "sensitive" => "false"
  56         })
  57
  58       assert %{"id" => second_id} = json_response(conn_two, 200)
  59       assert id == second_id
  60
  61       conn_three =
  62         conn
  63         |> post("/api/v1/statuses", %{
  64           "status" => "cofe",
  65           "spoiler_text" => "2hu",
  66           "sensitive" => "false"
  67         })
  68
  69       assert %{"id" => third_id} = json_response(conn_three, 200)
  70       refute id == third_id
  71
  72       # An activity that will expire:
  73       # 2 hours
  74       expires_in = 120 * 60
  75
  76       conn_four =
  77         conn
  78         |> post("api/v1/statuses", %{
  79           "status" => "oolong",
  80           "expires_in" => expires_in
  81         })
  82
  83       assert fourth_response = %{"id" => fourth_id} = json_response(conn_four, 200)
  84       assert activity = Activity.get_by_id(fourth_id)
  85       assert expiration = ActivityExpiration.get_by_activity_id(fourth_id)
  86
  87       estimated_expires_at =
  88         NaiveDateTime.utc_now()
  89         |> NaiveDateTime.add(expires_in)
  90         |> NaiveDateTime.truncate(:second)
  91
  92       # This assert will fail if the test takes longer than a minute. I sure hope it never does:
  93       assert abs(NaiveDateTime.diff(expiration.scheduled_at, estimated_expires_at, :second)) < 60
  94
  95       assert fourth_response["pleroma"]["expires_at"] ==
  96                NaiveDateTime.to_iso8601(expiration.scheduled_at)
  97     end
  98
  99     test "replying to a status", %{conn: conn} do
 100       user = insert(:user)
 101       {:ok, replied_to} = CommonAPI.post(user, %{"status" => "cofe"})
 102
 103       conn =
 104         conn
 105         |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 106
 107       assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 108
 109       activity = Activity.get_by_id(id)
 110
 111       assert activity.data["context"] == replied_to.data["context"]
 112       assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
 113     end
 114
 115     test "replying to a direct message with visibility other than direct", %{conn: conn} do
 116       user = insert(:user)
 117       {:ok, replied_to} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})
 118
 119       Enum.each(["public", "private", "unlisted"], fn visibility ->
 120         conn =
 121           conn
 122           |> post("/api/v1/statuses", %{
 123             "status" => "@#{user.nickname} hey",
 124             "in_reply_to_id" => replied_to.id,
 125             "visibility" => visibility
 126           })
 127
 128         assert json_response(conn, 422) == %{"error" => "The message visibility must be direct"}
 129       end)
 130     end
 131
 132     test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
 133       conn =
 134         conn
 135         |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
 136
 137       assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
 138       assert Activity.get_by_id(id)
 139     end
 140
 141     test "posting a sensitive status", %{conn: conn} do
 142       conn =
 143         conn
 144         |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
 145
 146       assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
 147       assert Activity.get_by_id(id)
 148     end
 149
 150     test "posting a fake status", %{conn: conn} do
 151       real_conn =
 152         conn
 153         |> post("/api/v1/statuses", %{
 154           "status" =>
 155             "\"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"
 156         })
 157
 158       real_status = json_response(real_conn, 200)
 159
 160       assert real_status
 161       assert Object.get_by_ap_id(real_status["uri"])
 162
 163       real_status =
 164         real_status
 165         |> Map.put("id", nil)
 166         |> Map.put("url", nil)
 167         |> Map.put("uri", nil)
 168         |> Map.put("created_at", nil)
 169         |> Kernel.put_in(["pleroma", "conversation_id"], nil)
 170
 171       fake_conn =
 172         conn
 173         |> post("/api/v1/statuses", %{
 174           "status" =>
 175             "\"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",
 176           "preview" => true
 177         })
 178
 179       fake_status = json_response(fake_conn, 200)
 180
 181       assert fake_status
 182       refute Object.get_by_ap_id(fake_status["uri"])
 183
 184       fake_status =
 185         fake_status
 186         |> Map.put("id", nil)
 187         |> Map.put("url", nil)
 188         |> Map.put("uri", nil)
 189         |> Map.put("created_at", nil)
 190         |> Kernel.put_in(["pleroma", "conversation_id"], nil)
 191
 192       assert real_status == fake_status
 193     end
 194
 195     test "posting a status with OGP link preview", %{conn: conn} do
 196       Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
 197       Config.put([:rich_media, :enabled], true)
 198
 199       conn =
 200         conn
 201         |> post("/api/v1/statuses", %{
 202           "status" => "https://example.com/ogp"
 203         })
 204
 205       assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
 206       assert Activity.get_by_id(id)
 207     end
 208
 209     test "posting a direct status", %{conn: conn} do
 210       user2 = insert(:user)
 211       content = "direct cofe @#{user2.nickname}"
 212
 213       conn =
 214         conn
 215         |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
 216
 217       assert %{"id" => id} = response = json_response(conn, 200)
 218       assert response["visibility"] == "direct"
 219       assert response["pleroma"]["direct_conversation_id"]
 220       assert activity = Activity.get_by_id(id)
 221       assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
 222       assert activity.data["to"] == [user2.ap_id]
 223       assert activity.data["cc"] == []
 224     end
 225   end
 226
 227   describe "posting polls" do
 228     test "posting a poll", %{conn: conn} do
 229       user = insert(:user)
 230       time = NaiveDateTime.utc_now()
 231
 232       conn =
 233         conn
 234         |> assign(:user, user)
 235         |> post("/api/v1/statuses", %{
 236           "status" => "Who is the #bestgrill?",
 237           "poll" => %{"options" => ["Rei", "Asuka", "Misato"], "expires_in" => 420}
 238         })
 239
 240       response = json_response(conn, 200)
 241
 242       assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
 243                title in ["Rei", "Asuka", "Misato"]
 244              end)
 245
 246       assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
 247       refute response["poll"]["expred"]
 248     end
 249
 250     test "option limit is enforced", %{conn: conn} do
 251       user = insert(:user)
 252       limit = Config.get([:instance, :poll_limits, :max_options])
 253
 254       conn =
 255         conn
 256         |> assign(:user, user)
 257         |> post("/api/v1/statuses", %{
 258           "status" => "desu~",
 259           "poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
 260         })
 261
 262       %{"error" => error} = json_response(conn, 422)
 263       assert error == "Poll can't contain more than #{limit} options"
 264     end
 265
 266     test "option character limit is enforced", %{conn: conn} do
 267       user = insert(:user)
 268       limit = Config.get([:instance, :poll_limits, :max_option_chars])
 269
 270       conn =
 271         conn
 272         |> assign(:user, user)
 273         |> post("/api/v1/statuses", %{
 274           "status" => "...",
 275           "poll" => %{
 276             "options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
 277             "expires_in" => 1
 278           }
 279         })
 280
 281       %{"error" => error} = json_response(conn, 422)
 282       assert error == "Poll options cannot be longer than #{limit} characters each"
 283     end
 284
 285     test "minimal date limit is enforced", %{conn: conn} do
 286       user = insert(:user)
 287       limit = Config.get([:instance, :poll_limits, :min_expiration])
 288
 289       conn =
 290         conn
 291         |> assign(:user, user)
 292         |> post("/api/v1/statuses", %{
 293           "status" => "imagine arbitrary limits",
 294           "poll" => %{
 295             "options" => ["this post was made by pleroma gang"],
 296             "expires_in" => limit - 1
 297           }
 298         })
 299
 300       %{"error" => error} = json_response(conn, 422)
 301       assert error == "Expiration date is too soon"
 302     end
 303
 304     test "maximum date limit is enforced", %{conn: conn} do
 305       user = insert(:user)
 306       limit = Config.get([:instance, :poll_limits, :max_expiration])
 307
 308       conn =
 309         conn
 310         |> assign(:user, user)
 311         |> post("/api/v1/statuses", %{
 312           "status" => "imagine arbitrary limits",
 313           "poll" => %{
 314             "options" => ["this post was made by pleroma gang"],
 315             "expires_in" => limit + 1
 316           }
 317         })
 318
 319       %{"error" => error} = json_response(conn, 422)
 320       assert error == "Expiration date is too far in the future"
 321     end
 322   end
 323
 324   test "get a status", %{conn: conn} do
 325     activity = insert(:note_activity)
 326
 327     conn =
 328       conn
 329       |> get("/api/v1/statuses/#{activity.id}")
 330
 331     assert %{"id" => id} = json_response(conn, 200)
 332     assert id == to_string(activity.id)
 333   end
 334
 335   test "get statuses by IDs", %{conn: conn} do
 336     %{id: id1} = insert(:note_activity)
 337     %{id: id2} = insert(:note_activity)
 338
 339     query_string = "ids[]=#{id1}&ids[]=#{id2}"
 340     conn = get(conn, "/api/v1/statuses/?#{query_string}")
 341
 342     assert [%{"id" => ^id1}, %{"id" => ^id2}] = Enum.sort_by(json_response(conn, :ok), & &1["id"])
 343   end
 344
 345   describe "deleting a status" do
 346     test "when you created it", %{conn: conn} do
 347       activity = insert(:note_activity)
 348       author = User.get_cached_by_ap_id(activity.data["actor"])
 349
 350       conn =
 351         conn
 352         |> assign(:user, author)
 353         |> delete("/api/v1/statuses/#{activity.id}")
 354
 355       assert %{} = json_response(conn, 200)
 356
 357       refute Activity.get_by_id(activity.id)
 358     end
 359
 360     test "when you didn't create it", %{conn: conn} do
 361       activity = insert(:note_activity)
 362       user = insert(:user)
 363
 364       conn =
 365         conn
 366         |> assign(:user, user)
 367         |> delete("/api/v1/statuses/#{activity.id}")
 368
 369       assert %{"error" => _} = json_response(conn, 403)
 370
 371       assert Activity.get_by_id(activity.id) == activity
 372     end
 373
 374     test "when you're an admin or moderator", %{conn: conn} do
 375       activity1 = insert(:note_activity)
 376       activity2 = insert(:note_activity)
 377       admin = insert(:user, info: %{is_admin: true})
 378       moderator = insert(:user, info: %{is_moderator: true})
 379
 380       res_conn =
 381         conn
 382         |> assign(:user, admin)
 383         |> delete("/api/v1/statuses/#{activity1.id}")
 384
 385       assert %{} = json_response(res_conn, 200)
 386
 387       res_conn =
 388         conn
 389         |> assign(:user, moderator)
 390         |> delete("/api/v1/statuses/#{activity2.id}")
 391
 392       assert %{} = json_response(res_conn, 200)
 393
 394       refute Activity.get_by_id(activity1.id)
 395       refute Activity.get_by_id(activity2.id)
 396     end
 397   end
 398
 399   describe "reblogging" do
 400     test "reblogs and returns the reblogged status", %{conn: conn} do
 401       activity = insert(:note_activity)
 402       user = insert(:user)
 403
 404       conn =
 405         conn
 406         |> assign(:user, user)
 407         |> post("/api/v1/statuses/#{activity.id}/reblog")
 408
 409       assert %{
 410                "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
 411                "reblogged" => true
 412              } = json_response(conn, 200)
 413
 414       assert to_string(activity.id) == id
 415     end
 416
 417     test "reblogged status for another user", %{conn: conn} do
 418       activity = insert(:note_activity)
 419       user1 = insert(:user)
 420       user2 = insert(:user)
 421       user3 = insert(:user)
 422       CommonAPI.favorite(activity.id, user2)
 423       {:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
 424       {:ok, reblog_activity1, _object} = CommonAPI.repeat(activity.id, user1)
 425       {:ok, _, _object} = CommonAPI.repeat(activity.id, user2)
 426
 427       conn_res =
 428         conn
 429         |> assign(:user, user3)
 430         |> get("/api/v1/statuses/#{reblog_activity1.id}")
 431
 432       assert %{
 433                "reblog" => %{"id" => id, "reblogged" => false, "reblogs_count" => 2},
 434                "reblogged" => false,
 435                "favourited" => false,
 436                "bookmarked" => false
 437              } = json_response(conn_res, 200)
 438
 439       conn_res =
 440         conn
 441         |> assign(:user, user2)
 442         |> get("/api/v1/statuses/#{reblog_activity1.id}")
 443
 444       assert %{
 445                "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
 446                "reblogged" => true,
 447                "favourited" => true,
 448                "bookmarked" => true
 449              } = json_response(conn_res, 200)
 450
 451       assert to_string(activity.id) == id
 452     end
 453
 454     test "returns 400 error when activity is not exist", %{conn: conn} do
 455       user = insert(:user)
 456
 457       conn =
 458         conn
 459         |> assign(:user, user)
 460         |> post("/api/v1/statuses/foo/reblog")
 461
 462       assert json_response(conn, 400) == %{"error" => "Could not repeat"}
 463     end
 464   end
 465
 466   describe "unreblogging" do
 467     test "unreblogs and returns the unreblogged status", %{conn: conn} do
 468       activity = insert(:note_activity)
 469       user = insert(:user)
 470
 471       {:ok, _, _} = CommonAPI.repeat(activity.id, user)
 472
 473       conn =
 474         conn
 475         |> assign(:user, user)
 476         |> post("/api/v1/statuses/#{activity.id}/unreblog")
 477
 478       assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
 479
 480       assert to_string(activity.id) == id
 481     end
 482
 483     test "returns 400 error when activity is not exist", %{conn: conn} do
 484       user = insert(:user)
 485
 486       conn =
 487         conn
 488         |> assign(:user, user)
 489         |> post("/api/v1/statuses/foo/unreblog")
 490
 491       assert json_response(conn, 400) == %{"error" => "Could not unrepeat"}
 492     end
 493   end
 494
 495   describe "favoriting" do
 496     test "favs a status and returns it", %{conn: conn} do
 497       activity = insert(:note_activity)
 498       user = insert(:user)
 499
 500       conn =
 501         conn
 502         |> assign(:user, user)
 503         |> post("/api/v1/statuses/#{activity.id}/favourite")
 504
 505       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
 506                json_response(conn, 200)
 507
 508       assert to_string(activity.id) == id
 509     end
 510
 511     test "returns 400 error for a wrong id", %{conn: conn} do
 512       user = insert(:user)
 513
 514       conn =
 515         conn
 516         |> assign(:user, user)
 517         |> post("/api/v1/statuses/1/favourite")
 518
 519       assert json_response(conn, 400) == %{"error" => "Could not favorite"}
 520     end
 521   end
 522
 523   describe "unfavoriting" do
 524     test "unfavorites a status and returns it", %{conn: conn} do
 525       activity = insert(:note_activity)
 526       user = insert(:user)
 527
 528       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 529
 530       conn =
 531         conn
 532         |> assign(:user, user)
 533         |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 534
 535       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
 536                json_response(conn, 200)
 537
 538       assert to_string(activity.id) == id
 539     end
 540
 541     test "returns 400 error for a wrong id", %{conn: conn} do
 542       user = insert(:user)
 543
 544       conn =
 545         conn
 546         |> assign(:user, user)
 547         |> post("/api/v1/statuses/1/unfavourite")
 548
 549       assert json_response(conn, 400) == %{"error" => "Could not unfavorite"}
 550     end
 551   end
 552
 553   describe "pinned statuses" do
 554     setup do
 555       user = insert(:user)
 556       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
 557
 558       [user: user, activity: activity]
 559     end
 560
 561     clear_config([:instance, :max_pinned_statuses]) do
 562       Config.put([:instance, :max_pinned_statuses], 1)
 563     end
 564
 565     test "pin status", %{conn: conn, user: user, activity: activity} do
 566       id_str = to_string(activity.id)
 567
 568       assert %{"id" => ^id_str, "pinned" => true} =
 569                conn
 570                |> assign(:user, user)
 571                |> post("/api/v1/statuses/#{activity.id}/pin")
 572                |> json_response(200)
 573
 574       assert [%{"id" => ^id_str, "pinned" => true}] =
 575                conn
 576                |> assign(:user, user)
 577                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 578                |> json_response(200)
 579     end
 580
 581     test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
 582       {:ok, dm} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"})
 583
 584       conn =
 585         conn
 586         |> assign(:user, user)
 587         |> post("/api/v1/statuses/#{dm.id}/pin")
 588
 589       assert json_response(conn, 400) == %{"error" => "Could not pin"}
 590     end
 591
 592     test "unpin status", %{conn: conn, user: user, activity: activity} do
 593       {:ok, _} = CommonAPI.pin(activity.id, user)
 594
 595       id_str = to_string(activity.id)
 596       user = refresh_record(user)
 597
 598       assert %{"id" => ^id_str, "pinned" => false} =
 599                conn
 600                |> assign(:user, user)
 601                |> post("/api/v1/statuses/#{activity.id}/unpin")
 602                |> json_response(200)
 603
 604       assert [] =
 605                conn
 606                |> assign(:user, user)
 607                |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
 608                |> json_response(200)
 609     end
 610
 611     test "/unpin: returns 400 error when activity is not exist", %{conn: conn, user: user} do
 612       conn =
 613         conn
 614         |> assign(:user, user)
 615         |> post("/api/v1/statuses/1/unpin")
 616
 617       assert json_response(conn, 400) == %{"error" => "Could not unpin"}
 618     end
 619
 620     test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
 621       {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
 622
 623       id_str_one = to_string(activity_one.id)
 624
 625       assert %{"id" => ^id_str_one, "pinned" => true} =
 626                conn
 627                |> assign(:user, user)
 628                |> post("/api/v1/statuses/#{id_str_one}/pin")
 629                |> json_response(200)
 630
 631       user = refresh_record(user)
 632
 633       assert %{"error" => "You have already pinned the maximum number of statuses"} =
 634                conn
 635                |> assign(:user, user)
 636                |> post("/api/v1/statuses/#{activity_two.id}/pin")
 637                |> json_response(400)
 638     end
 639   end
 640
 641   describe "cards" do
 642     setup do
 643       Config.put([:rich_media, :enabled], true)
 644
 645       user = insert(:user)
 646       %{user: user}
 647     end
 648
 649     test "returns rich-media card", %{conn: conn, user: user} do
 650       Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
 651
 652       {:ok, activity} = CommonAPI.post(user, %{"status" => "https://example.com/ogp"})
 653
 654       card_data = %{
 655         "image" => "http://ia.media-imdb.com/images/rock.jpg",
 656         "provider_name" => "example.com",
 657         "provider_url" => "https://example.com",
 658         "title" => "The Rock",
 659         "type" => "link",
 660         "url" => "https://example.com/ogp",
 661         "description" =>
 662           "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
 663         "pleroma" => %{
 664           "opengraph" => %{
 665             "image" => "http://ia.media-imdb.com/images/rock.jpg",
 666             "title" => "The Rock",
 667             "type" => "video.movie",
 668             "url" => "https://example.com/ogp",
 669             "description" =>
 670               "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
 671           }
 672         }
 673       }
 674
 675       response =
 676         conn
 677         |> get("/api/v1/statuses/#{activity.id}/card")
 678         |> json_response(200)
 679
 680       assert response == card_data
 681
 682       # works with private posts
 683       {:ok, activity} =
 684         CommonAPI.post(user, %{"status" => "https://example.com/ogp", "visibility" => "direct"})
 685
 686       response_two =
 687         conn
 688         |> assign(:user, user)
 689         |> get("/api/v1/statuses/#{activity.id}/card")
 690         |> json_response(200)
 691
 692       assert response_two == card_data
 693     end
 694
 695     test "replaces missing description with an empty string", %{conn: conn, user: user} do
 696       Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
 697
 698       {:ok, activity} =
 699         CommonAPI.post(user, %{"status" => "https://example.com/ogp-missing-data"})
 700
 701       response =
 702         conn
 703         |> get("/api/v1/statuses/#{activity.id}/card")
 704         |> json_response(:ok)
 705
 706       assert response == %{
 707                "type" => "link",
 708                "title" => "Pleroma",
 709                "description" => "",
 710                "image" => nil,
 711                "provider_name" => "example.com",
 712                "provider_url" => "https://example.com",
 713                "url" => "https://example.com/ogp-missing-data",
 714                "pleroma" => %{
 715                  "opengraph" => %{
 716                    "title" => "Pleroma",
 717                    "type" => "website",
 718                    "url" => "https://example.com/ogp-missing-data"
 719                  }
 720                }
 721              }
 722     end
 723   end
 724
 725   test "bookmarks" do
 726     user = insert(:user)
 727     for_user = insert(:user)
 728
 729     {:ok, activity1} =
 730       CommonAPI.post(user, %{
 731         "status" => "heweoo?"
 732       })
 733
 734     {:ok, activity2} =
 735       CommonAPI.post(user, %{
 736         "status" => "heweoo!"
 737       })
 738
 739     response1 =
 740       build_conn()
 741       |> assign(:user, for_user)
 742       |> post("/api/v1/statuses/#{activity1.id}/bookmark")
 743
 744     assert json_response(response1, 200)["bookmarked"] == true
 745
 746     response2 =
 747       build_conn()
 748       |> assign(:user, for_user)
 749       |> post("/api/v1/statuses/#{activity2.id}/bookmark")
 750
 751     assert json_response(response2, 200)["bookmarked"] == true
 752
 753     bookmarks =
 754       build_conn()
 755       |> assign(:user, for_user)
 756       |> get("/api/v1/bookmarks")
 757
 758     assert [json_response(response2, 200), json_response(response1, 200)] ==
 759              json_response(bookmarks, 200)
 760
 761     response1 =
 762       build_conn()
 763       |> assign(:user, for_user)
 764       |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
 765
 766     assert json_response(response1, 200)["bookmarked"] == false
 767
 768     bookmarks =
 769       build_conn()
 770       |> assign(:user, for_user)
 771       |> get("/api/v1/bookmarks")
 772
 773     assert [json_response(response2, 200)] == json_response(bookmarks, 200)
 774   end
 775
 776   describe "conversation muting" do
 777     setup do
 778       post_user = insert(:user)
 779       user = insert(:user)
 780
 781       {:ok, activity} = CommonAPI.post(post_user, %{"status" => "HIE"})
 782
 783       [user: user, activity: activity]
 784     end
 785
 786     test "mute conversation", %{conn: conn, user: user, activity: activity} do
 787       id_str = to_string(activity.id)
 788
 789       assert %{"id" => ^id_str, "muted" => true} =
 790                conn
 791                |> assign(:user, user)
 792                |> post("/api/v1/statuses/#{activity.id}/mute")
 793                |> json_response(200)
 794     end
 795
 796     test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
 797       {:ok, _} = CommonAPI.add_mute(user, activity)
 798
 799       conn =
 800         conn
 801         |> assign(:user, user)
 802         |> post("/api/v1/statuses/#{activity.id}/mute")
 803
 804       assert json_response(conn, 400) == %{"error" => "conversation is already muted"}
 805     end
 806
 807     test "unmute conversation", %{conn: conn, user: user, activity: activity} do
 808       {:ok, _} = CommonAPI.add_mute(user, activity)
 809
 810       id_str = to_string(activity.id)
 811       user = refresh_record(user)
 812
 813       assert %{"id" => ^id_str, "muted" => false} =
 814                conn
 815                |> assign(:user, user)
 816                |> post("/api/v1/statuses/#{activity.id}/unmute")
 817                |> json_response(200)
 818     end
 819   end
 820
 821   test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
 822     user1 = insert(:user)
 823     user2 = insert(:user)
 824     user3 = insert(:user)
 825
 826     {:ok, replied_to} = CommonAPI.post(user1, %{"status" => "cofe"})
 827
 828     # Reply to status from another user
 829     conn1 =
 830       conn
 831       |> assign(:user, user2)
 832       |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
 833
 834     assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)
 835
 836     activity = Activity.get_by_id_with_object(id)
 837
 838     assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
 839     assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
 840
 841     # Reblog from the third user
 842     conn2 =
 843       conn
 844       |> assign(:user, user3)
 845       |> post("/api/v1/statuses/#{activity.id}/reblog")
 846
 847     assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
 848              json_response(conn2, 200)
 849
 850     assert to_string(activity.id) == id
 851
 852     # Getting third user status
 853     conn3 =
 854       conn
 855       |> assign(:user, user3)
 856       |> get("api/v1/timelines/home")
 857
 858     [reblogged_activity] = json_response(conn3, 200)
 859
 860     assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id
 861
 862     replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
 863     assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
 864   end
 865
 866   describe "GET /api/v1/statuses/:id/favourited_by" do
 867     setup do
 868       user = insert(:user)
 869       {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
 870
 871       conn =
 872         build_conn()
 873         |> assign(:user, user)
 874
 875       [conn: conn, activity: activity, user: user]
 876     end
 877
 878     test "returns users who have favorited the status", %{conn: conn, activity: activity} do
 879       other_user = insert(:user)
 880       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
 881
 882       response =
 883         conn
 884         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
 885         |> json_response(:ok)
 886
 887       [%{"id" => id}] = response
 888
 889       assert id == other_user.id
 890     end
 891
 892     test "returns empty array when status has not been favorited yet", %{
 893       conn: conn,
 894       activity: activity
 895     } do
 896       response =
 897         conn
 898         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
 899         |> json_response(:ok)
 900
 901       assert Enum.empty?(response)
 902     end
 903
 904     test "does not return users who have favorited the status but are blocked", %{
 905       conn: %{assigns: %{user: user}} = conn,
 906       activity: activity
 907     } do
 908       other_user = insert(:user)
 909       {:ok, user} = User.block(user, other_user)
 910
 911       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
 912
 913       response =
 914         conn
 915         |> assign(:user, user)
 916         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
 917         |> json_response(:ok)
 918
 919       assert Enum.empty?(response)
 920     end
 921
 922     test "does not fail on an unauthenticated request", %{conn: conn, activity: activity} do
 923       other_user = insert(:user)
 924       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
 925
 926       response =
 927         conn
 928         |> assign(:user, nil)
 929         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
 930         |> json_response(:ok)
 931
 932       [%{"id" => id}] = response
 933       assert id == other_user.id
 934     end
 935
 936     test "requires authentification for private posts", %{conn: conn, user: user} do
 937       other_user = insert(:user)
 938
 939       {:ok, activity} =
 940         CommonAPI.post(user, %{
 941           "status" => "@#{other_user.nickname} wanna get some #cofe together?",
 942           "visibility" => "direct"
 943         })
 944
 945       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
 946
 947       conn
 948       |> assign(:user, nil)
 949       |> get("/api/v1/statuses/#{activity.id}/favourited_by")
 950       |> json_response(404)
 951
 952       response =
 953         build_conn()
 954         |> assign(:user, other_user)
 955         |> get("/api/v1/statuses/#{activity.id}/favourited_by")
 956         |> json_response(200)
 957
 958       [%{"id" => id}] = response
 959       assert id == other_user.id
 960     end
 961   end
 962
 963   describe "GET /api/v1/statuses/:id/reblogged_by" do
 964     setup do
 965       user = insert(:user)
 966       {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
 967
 968       conn =
 969         build_conn()
 970         |> assign(:user, user)
 971
 972       [conn: conn, activity: activity, user: user]
 973     end
 974
 975     test "returns users who have reblogged the status", %{conn: conn, activity: activity} do
 976       other_user = insert(:user)
 977       {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
 978
 979       response =
 980         conn
 981         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
 982         |> json_response(:ok)
 983
 984       [%{"id" => id}] = response
 985
 986       assert id == other_user.id
 987     end
 988
 989     test "returns empty array when status has not been reblogged yet", %{
 990       conn: conn,
 991       activity: activity
 992     } do
 993       response =
 994         conn
 995         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
 996         |> json_response(:ok)
 997
 998       assert Enum.empty?(response)
 999     end
1000
1001     test "does not return users who have reblogged the status but are blocked", %{
1002       conn: %{assigns: %{user: user}} = conn,
1003       activity: activity
1004     } do
1005       other_user = insert(:user)
1006       {:ok, user} = User.block(user, other_user)
1007
1008       {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1009
1010       response =
1011         conn
1012         |> assign(:user, user)
1013         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1014         |> json_response(:ok)
1015
1016       assert Enum.empty?(response)
1017     end
1018
1019     test "does not fail on an unauthenticated request", %{conn: conn, activity: activity} do
1020       other_user = insert(:user)
1021       {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1022
1023       response =
1024         conn
1025         |> assign(:user, nil)
1026         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1027         |> json_response(:ok)
1028
1029       [%{"id" => id}] = response
1030       assert id == other_user.id
1031     end
1032
1033     test "requires authentification for private posts", %{conn: conn, user: user} do
1034       other_user = insert(:user)
1035
1036       {:ok, activity} =
1037         CommonAPI.post(user, %{
1038           "status" => "@#{other_user.nickname} wanna get some #cofe together?",
1039           "visibility" => "direct"
1040         })
1041
1042       conn
1043       |> assign(:user, nil)
1044       |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1045       |> json_response(404)
1046
1047       response =
1048         build_conn()
1049         |> assign(:user, other_user)
1050         |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1051         |> json_response(200)
1052
1053       assert [] == response
1054     end
1055   end
1056
1057   test "context" do
1058     user = insert(:user)
1059
1060     {:ok, %{id: id1}} = CommonAPI.post(user, %{"status" => "1"})
1061     {:ok, %{id: id2}} = CommonAPI.post(user, %{"status" => "2", "in_reply_to_status_id" => id1})
1062     {:ok, %{id: id3}} = CommonAPI.post(user, %{"status" => "3", "in_reply_to_status_id" => id2})
1063     {:ok, %{id: id4}} = CommonAPI.post(user, %{"status" => "4", "in_reply_to_status_id" => id3})
1064     {:ok, %{id: id5}} = CommonAPI.post(user, %{"status" => "5", "in_reply_to_status_id" => id4})
1065
1066     response =
1067       build_conn()
1068       |> assign(:user, nil)
1069       |> get("/api/v1/statuses/#{id3}/context")
1070       |> json_response(:ok)
1071
1072     assert %{
1073              "ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
1074              "descendants" => [%{"id" => ^id4}, %{"id" => ^id5}]
1075            } = response
1076   end
1077 end