git.squeep.com Git - akkoma/blob - test/pleroma/web/mastodon_api/views/status_view_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
   6   use Pleroma.DataCase
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.Bookmark
  10   alias Pleroma.Conversation.Participation
  11   alias Pleroma.HTML
  12   alias Pleroma.Object
  13   alias Pleroma.Repo
  14   alias Pleroma.User
  15   alias Pleroma.UserRelationship
  16   alias Pleroma.Web.CommonAPI
  17   alias Pleroma.Web.MastodonAPI.AccountView
  18   alias Pleroma.Web.MastodonAPI.StatusView
  19
  20   import Pleroma.Factory
  21   import Tesla.Mock
  22   import OpenApiSpex.TestAssertions
  23
  24   setup do
  25     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  26     :ok
  27   end
  28
  29   test "has an emoji reaction list" do
  30     user = insert(:user)
  31     other_user = insert(:user)
  32     third_user = insert(:user)
  33     {:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})
  34
  35     {:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "☕")
  36     {:ok, _} = CommonAPI.react_with_emoji(activity.id, user, ":dinosaur:")
  37     {:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "🍵")
  38     {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
  39     {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, ":dinosaur:")
  40
  41     activity = Repo.get(Activity, activity.id)
  42     status = StatusView.render("show.json", activity: activity)
  43
  44     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
  45
  46     assert status[:pleroma][:emoji_reactions] == [
  47              %{name: "☕", count: 2, me: false, url: nil},
  48              %{
  49                count: 2,
  50                me: false,
  51                name: "dinosaur",
  52                url: "http://localhost:4001/emoji/dino walking.gif"
  53              },
  54              %{name: "🍵", count: 1, me: false, url: nil}
  55            ]
  56
  57     status = StatusView.render("show.json", activity: activity, for: user)
  58
  59     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
  60
  61     assert status[:pleroma][:emoji_reactions] == [
  62              %{name: "☕", count: 2, me: true, url: nil},
  63              %{
  64                count: 2,
  65                me: true,
  66                name: "dinosaur",
  67                url: "http://localhost:4001/emoji/dino walking.gif"
  68              },
  69              %{name: "🍵", count: 1, me: false, url: nil}
  70            ]
  71   end
  72
  73   test "works correctly with badly formatted emojis" do
  74     user = insert(:user)
  75     {:ok, activity} = CommonAPI.post(user, %{status: "yo"})
  76
  77     activity
  78     |> Object.normalize(fetch: false)
  79     |> Object.update_data(%{"reactions" => %{"☕" => [user.ap_id], "x" => 1}})
  80
  81     activity = Activity.get_by_id(activity.id)
  82     status = StatusView.render("show.json", activity: activity, for: user)
  83
  84     assert status[:pleroma][:emoji_reactions] == [
  85              %{name: "☕", count: 1, me: true, url: nil}
  86            ]
  87   end
  88
  89   test "doesn't show reactions from muted and blocked users" do
  90     user = insert(:user)
  91     other_user = insert(:user)
  92     third_user = insert(:user)
  93
  94     {:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})
  95
  96     {:ok, _} = User.mute(user, other_user)
  97     {:ok, _} = User.block(other_user, third_user)
  98
  99     {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
 100
 101     activity = Repo.get(Activity, activity.id)
 102     status = StatusView.render("show.json", activity: activity)
 103
 104     assert status[:pleroma][:emoji_reactions] == [
 105              %{name: "☕", count: 1, me: false, url: nil}
 106            ]
 107
 108     status = StatusView.render("show.json", activity: activity, for: user)
 109
 110     assert status[:pleroma][:emoji_reactions] == []
 111
 112     {:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "☕")
 113
 114     status = StatusView.render("show.json", activity: activity)
 115
 116     assert status[:pleroma][:emoji_reactions] == [
 117              %{name: "☕", count: 2, me: false, url: nil}
 118            ]
 119
 120     status = StatusView.render("show.json", activity: activity, for: user)
 121
 122     assert status[:pleroma][:emoji_reactions] == [
 123              %{name: "☕", count: 1, me: false, url: nil}
 124            ]
 125
 126     status = StatusView.render("show.json", activity: activity, for: other_user)
 127
 128     assert status[:pleroma][:emoji_reactions] == [
 129              %{name: "☕", count: 1, me: true, url: nil}
 130            ]
 131   end
 132
 133   test "loads and returns the direct conversation id when given the `with_direct_conversation_id` option" do
 134     user = insert(:user)
 135
 136     {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 137     [participation] = Participation.for_user(user)
 138
 139     status =
 140       StatusView.render("show.json",
 141         activity: activity,
 142         with_direct_conversation_id: true,
 143         for: user
 144       )
 145
 146     assert status[:pleroma][:direct_conversation_id] == participation.id
 147
 148     status = StatusView.render("show.json", activity: activity, for: user)
 149     assert status[:pleroma][:direct_conversation_id] == nil
 150     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 151   end
 152
 153   test "returns the direct conversation id when given the `direct_conversation_id` option" do
 154     user = insert(:user)
 155
 156     {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 157     [participation] = Participation.for_user(user)
 158
 159     status =
 160       StatusView.render("show.json",
 161         activity: activity,
 162         direct_conversation_id: participation.id,
 163         for: user
 164       )
 165
 166     assert status[:pleroma][:direct_conversation_id] == participation.id
 167     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 168   end
 169
 170   test "returns a temporary ap_id based user for activities missing db users" do
 171     user = insert(:user)
 172
 173     {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 174
 175     Repo.delete(user)
 176     User.invalidate_cache(user)
 177
 178     finger_url =
 179       "https://localhost/.well-known/webfinger?resource=acct:#{user.nickname}@localhost"
 180
 181     Tesla.Mock.mock_global(fn
 182       %{method: :get, url: "http://localhost/.well-known/host-meta"} ->
 183         %Tesla.Env{status: 404, body: ""}
 184
 185       %{method: :get, url: "https://localhost/.well-known/host-meta"} ->
 186         %Tesla.Env{status: 404, body: ""}
 187
 188       %{
 189         method: :get,
 190         url: ^finger_url
 191       } ->
 192         %Tesla.Env{status: 404, body: ""}
 193     end)
 194
 195     %{account: ms_user} = StatusView.render("show.json", activity: activity)
 196
 197     assert ms_user.acct == "erroruser@example.com"
 198   end
 199
 200   test "tries to get a user by nickname if fetching by ap_id doesn't work" do
 201     user = insert(:user)
 202
 203     {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 204
 205     {:ok, user} =
 206       user
 207       |> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
 208       |> Repo.update()
 209
 210     User.invalidate_cache(user)
 211
 212     result = StatusView.render("show.json", activity: activity)
 213
 214     assert result[:account][:id] == to_string(user.id)
 215     assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
 216   end
 217
 218   test "a note with null content" do
 219     note = insert(:note_activity)
 220     note_object = Object.normalize(note, fetch: false)
 221
 222     data =
 223       note_object.data
 224       |> Map.put("content", nil)
 225
 226     Object.change(note_object, %{data: data})
 227     |> Object.update_and_set_cache()
 228
 229     User.get_cached_by_ap_id(note.data["actor"])
 230
 231     status = StatusView.render("show.json", %{activity: note})
 232
 233     assert status.content == ""
 234     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 235   end
 236
 237   test "a note activity" do
 238     note = insert(:note_activity)
 239     object_data = Object.normalize(note, fetch: false).data
 240     user = User.get_cached_by_ap_id(note.data["actor"])
 241
 242     convo_id = :erlang.crc32(object_data["context"]) |> Bitwise.band(Bitwise.bnot(0x8000_0000))
 243
 244     status = StatusView.render("show.json", %{activity: note})
 245
 246     created_at =
 247       (object_data["published"] || "")
 248       |> String.replace(~r/\.\d+Z/, ".000Z")
 249
 250     expected = %{
 251       id: to_string(note.id),
 252       uri: object_data["id"],
 253       url: Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, note),
 254       account: AccountView.render("show.json", %{user: user, skip_visibility_check: true}),
 255       in_reply_to_id: nil,
 256       in_reply_to_account_id: nil,
 257       card: nil,
 258       reblog: nil,
 259       content: HTML.filter_tags(object_data["content"]),
 260       text: nil,
 261       created_at: created_at,
 262       reblogs_count: 0,
 263       replies_count: 0,
 264       favourites_count: 0,
 265       reblogged: false,
 266       bookmarked: false,
 267       favourited: false,
 268       muted: false,
 269       pinned: false,
 270       sensitive: false,
 271       poll: nil,
 272       spoiler_text: HTML.filter_tags(object_data["summary"]),
 273       visibility: "public",
 274       media_attachments: [],
 275       mentions: [],
 276       tags: [
 277         %{
 278           name: "#{hd(object_data["tag"])}",
 279           url: "http://localhost:4001/tag/#{hd(object_data["tag"])}"
 280         }
 281       ],
 282       application: nil,
 283       language: nil,
 284       emojis: [
 285         %{
 286           shortcode: "2hu",
 287           url: "corndog.png",
 288           static_url: "corndog.png",
 289           visible_in_picker: false
 290         }
 291       ],
 292       pleroma: %{
 293         local: true,
 294         conversation_id: convo_id,
 295         context: object_data["context"],
 296         in_reply_to_account_acct: nil,
 297         content: %{"text/plain" => HTML.strip_tags(object_data["content"])},
 298         spoiler_text: %{"text/plain" => HTML.strip_tags(object_data["summary"])},
 299         expires_at: nil,
 300         direct_conversation_id: nil,
 301         thread_muted: false,
 302         emoji_reactions: [],
 303         parent_visible: false,
 304         pinned_at: nil
 305       },
 306       akkoma: %{
 307         source: HTML.filter_tags(object_data["content"])
 308       },
 309       quote_id: nil,
 310       quote: nil
 311     }
 312
 313     assert status == expected
 314     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 315   end
 316
 317   test "tells if the message is muted for some reason" do
 318     user = insert(:user)
 319     other_user = insert(:user)
 320
 321     {:ok, _user_relationships} = User.mute(user, other_user)
 322
 323     {:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
 324
 325     relationships_opt = UserRelationship.view_relationships_option(user, [other_user])
 326
 327     opts = %{activity: activity}
 328     status = StatusView.render("show.json", opts)
 329     assert status.muted == false
 330     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 331
 332     status = StatusView.render("show.json", Map.put(opts, :relationships, relationships_opt))
 333     assert status.muted == false
 334
 335     for_opts = %{activity: activity, for: user}
 336     status = StatusView.render("show.json", for_opts)
 337     assert status.muted == true
 338
 339     status = StatusView.render("show.json", Map.put(for_opts, :relationships, relationships_opt))
 340     assert status.muted == true
 341     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 342   end
 343
 344   test "tells if the message is thread muted" do
 345     user = insert(:user)
 346     other_user = insert(:user)
 347
 348     {:ok, _user_relationships} = User.mute(user, other_user)
 349
 350     {:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
 351     status = StatusView.render("show.json", %{activity: activity, for: user})
 352
 353     assert status.pleroma.thread_muted == false
 354
 355     {:ok, activity} = CommonAPI.add_mute(user, activity)
 356
 357     status = StatusView.render("show.json", %{activity: activity, for: user})
 358
 359     assert status.pleroma.thread_muted == true
 360   end
 361
 362   test "tells if the status is bookmarked" do
 363     user = insert(:user)
 364
 365     {:ok, activity} = CommonAPI.post(user, %{status: "Cute girls doing cute things"})
 366     status = StatusView.render("show.json", %{activity: activity})
 367
 368     assert status.bookmarked == false
 369
 370     status = StatusView.render("show.json", %{activity: activity, for: user})
 371
 372     assert status.bookmarked == false
 373
 374     {:ok, _bookmark} = Bookmark.create(user.id, activity.id)
 375
 376     activity = Activity.get_by_id_with_object(activity.id)
 377
 378     status = StatusView.render("show.json", %{activity: activity, for: user})
 379
 380     assert status.bookmarked == true
 381   end
 382
 383   test "a reply" do
 384     note = insert(:note_activity)
 385     user = insert(:user)
 386
 387     {:ok, activity} = CommonAPI.post(user, %{status: "he", in_reply_to_status_id: note.id})
 388
 389     status = StatusView.render("show.json", %{activity: activity})
 390
 391     assert status.in_reply_to_id == to_string(note.id)
 392
 393     [status] = StatusView.render("index.json", %{activities: [activity], as: :activity})
 394
 395     assert status.in_reply_to_id == to_string(note.id)
 396   end
 397
 398   test "a quote" do
 399     note = insert(:note_activity)
 400     user = insert(:user)
 401
 402     {:ok, activity} = CommonAPI.post(user, %{status: "hehe", quote_id: note.id})
 403
 404     status = StatusView.render("show.json", %{activity: activity})
 405
 406     assert status.quote_id == to_string(note.id)
 407
 408     [status] = StatusView.render("index.json", %{activities: [activity], as: :activity})
 409
 410     assert status.quote_id == to_string(note.id)
 411   end
 412
 413   test "a quote that we can't resolve" do
 414     note = insert(:note_activity, quoteUri: "oopsie")
 415
 416     status = StatusView.render("show.json", %{activity: note})
 417
 418     assert is_nil(status.quote_id)
 419     assert is_nil(status.quote)
 420   end
 421
 422   test "contains mentions" do
 423     user = insert(:user)
 424     mentioned = insert(:user)
 425
 426     {:ok, activity} = CommonAPI.post(user, %{status: "hi @#{mentioned.nickname}"})
 427
 428     status = StatusView.render("show.json", %{activity: activity})
 429
 430     assert status.mentions ==
 431              Enum.map([mentioned], fn u -> AccountView.render("mention.json", %{user: u}) end)
 432
 433     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 434   end
 435
 436   test "create mentions from the 'to' field" do
 437     %User{ap_id: recipient_ap_id} = insert(:user)
 438     cc = insert_pair(:user) |> Enum.map(& &1.ap_id)
 439
 440     object =
 441       insert(:note, %{
 442         data: %{
 443           "to" => [recipient_ap_id],
 444           "cc" => cc
 445         }
 446       })
 447
 448     activity =
 449       insert(:note_activity, %{
 450         note: object,
 451         recipients: [recipient_ap_id | cc]
 452       })
 453
 454     assert length(activity.recipients) == 3
 455
 456     %{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})
 457
 458     assert length(mentions) == 1
 459     assert mention.url == recipient_ap_id
 460   end
 461
 462   test "create mentions from the 'tag' field" do
 463     recipient = insert(:user)
 464     cc = insert_pair(:user) |> Enum.map(& &1.ap_id)
 465
 466     object =
 467       insert(:note, %{
 468         data: %{
 469           "cc" => cc,
 470           "tag" => [
 471             %{
 472               "href" => recipient.ap_id,
 473               "name" => recipient.nickname,
 474               "type" => "Mention"
 475             },
 476             %{
 477               "href" => "https://example.com/search?tag=test",
 478               "name" => "#test",
 479               "type" => "Hashtag"
 480             }
 481           ]
 482         }
 483       })
 484
 485     activity =
 486       insert(:note_activity, %{
 487         note: object,
 488         recipients: [recipient.ap_id | cc]
 489       })
 490
 491     assert length(activity.recipients) == 3
 492
 493     %{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})
 494
 495     assert length(mentions) == 1
 496     assert mention.url == recipient.ap_id
 497   end
 498
 499   test "attachments" do
 500     object = %{
 501       "type" => "Image",
 502       "url" => [
 503         %{
 504           "mediaType" => "image/png",
 505           "href" => "someurl",
 506           "width" => 200,
 507           "height" => 100
 508         }
 509       ],
 510       "blurhash" => "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM|9GV=WHRn",
 511       "uuid" => 6
 512     }
 513
 514     expected = %{
 515       id: "1638338801",
 516       type: "image",
 517       url: "someurl",
 518       remote_url: "someurl",
 519       preview_url: "someurl",
 520       text_url: "someurl",
 521       description: nil,
 522       pleroma: %{mime_type: "image/png"},
 523       meta: %{original: %{width: 200, height: 100, aspect: 2}},
 524       blurhash: "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM|9GV=WHRn"
 525     }
 526
 527     api_spec = Pleroma.Web.ApiSpec.spec()
 528
 529     assert expected == StatusView.render("attachment.json", %{attachment: object})
 530     assert_schema(expected, "Attachment", api_spec)
 531
 532     # If theres a "id", use that instead of the generated one
 533     object = Map.put(object, "id", 2)
 534     result = StatusView.render("attachment.json", %{attachment: object})
 535
 536     assert %{id: "2"} = result
 537     assert_schema(result, "Attachment", api_spec)
 538   end
 539
 540   test "put the url advertised in the Activity in to the url attribute" do
 541     id = "https://wedistribute.org/wp-json/pterotype/v1/object/85810"
 542     [activity] = Activity.search(nil, id)
 543
 544     status = StatusView.render("show.json", %{activity: activity})
 545
 546     assert status.uri == id
 547     assert status.url == "https://wedistribute.org/2019/07/mastodon-drops-ostatus/"
 548   end
 549
 550   test "a reblog" do
 551     user = insert(:user)
 552     activity = insert(:note_activity)
 553
 554     {:ok, reblog} = CommonAPI.repeat(activity.id, user)
 555
 556     represented = StatusView.render("show.json", %{for: user, activity: reblog})
 557
 558     assert represented[:id] == to_string(reblog.id)
 559     assert represented[:reblog][:id] == to_string(activity.id)
 560     assert represented[:emojis] == []
 561     assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
 562   end
 563
 564   test "a peertube video" do
 565     user = insert(:user)
 566
 567     {:ok, object} =
 568       Pleroma.Object.Fetcher.fetch_object_from_id(
 569         "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
 570       )
 571
 572     %Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])
 573
 574     represented = StatusView.render("show.json", %{for: user, activity: activity})
 575
 576     assert represented[:id] == to_string(activity.id)
 577     assert length(represented[:media_attachments]) == 1
 578     assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
 579   end
 580
 581   test "funkwhale audio" do
 582     user = insert(:user)
 583
 584     {:ok, object} =
 585       Pleroma.Object.Fetcher.fetch_object_from_id(
 586         "https://channels.tests.funkwhale.audio/federation/music/uploads/42342395-0208-4fee-a38d-259a6dae0871"
 587       )
 588
 589     %Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])
 590
 591     represented = StatusView.render("show.json", %{for: user, activity: activity})
 592
 593     assert represented[:id] == to_string(activity.id)
 594     assert length(represented[:media_attachments]) == 1
 595   end
 596
 597   test "a Mobilizon event" do
 598     user = insert(:user)
 599
 600     {:ok, object} =
 601       Pleroma.Object.Fetcher.fetch_object_from_id(
 602         "https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
 603       )
 604
 605     %Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])
 606
 607     represented = StatusView.render("show.json", %{for: user, activity: activity})
 608
 609     assert represented[:id] == to_string(activity.id)
 610
 611     assert represented[:url] ==
 612              "https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
 613
 614     assert represented[:content] ==
 615              "<p><a href=\"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39\">Mobilizon Launching Party</a></p><p>Mobilizon is now federated! 🎉</p><p></p><p>You can view this event from other instances if they are subscribed to mobilizon.org, and soon directly from Mastodon and Pleroma. It is possible that you may see some comments from other instances, including Mastodon ones, just below.</p><p></p><p>With a Mobilizon account on an instance, you may <strong>participate</strong> at events from other instances and <strong>add comments</strong> on events.</p><p></p><p>Of course, it&#39;s still <u>a work in progress</u>: if reports made from an instance on events and comments can be federated, you can&#39;t block people right now, and moderators actions are rather limited, but this <strong>will definitely get fixed over time</strong> until first stable version next year.</p><p></p><p>Anyway, if you want to come up with some feedback, head over to our forum or - if you feel you have technical skills and are familiar with it - on our Gitlab repository.</p><p></p><p>Also, to people that want to set Mobilizon themselves even though we really don&#39;t advise to do that for now, we have a little documentation but it&#39;s quite the early days and you&#39;ll probably need some help. No worries, you can chat with us on our Forum or though our Matrix channel.</p><p></p><p>Check our website for more informations and follow us on Twitter or Mastodon.</p>"
 616   end
 617
 618   describe "build_tags/1" do
 619     test "it returns a a dictionary tags" do
 620       object_tags = [
 621         "fediverse",
 622         "mastodon",
 623         "nextcloud",
 624         %{
 625           "href" => "https://kawen.space/users/lain",
 626           "name" => "@lain@kawen.space",
 627           "type" => "Mention"
 628         }
 629       ]
 630
 631       assert StatusView.build_tags(object_tags) == [
 632                %{name: "fediverse", url: "http://localhost:4001/tag/fediverse"},
 633                %{name: "mastodon", url: "http://localhost:4001/tag/mastodon"},
 634                %{name: "nextcloud", url: "http://localhost:4001/tag/nextcloud"}
 635              ]
 636     end
 637   end
 638
 639   describe "rich media cards" do
 640     test "a rich media card without a site name renders correctly" do
 641       page_url = "http://example.com"
 642
 643       card = %{
 644         url: page_url,
 645         image: page_url <> "/example.jpg",
 646         title: "Example website"
 647       }
 648
 649       %{provider_name: "example.com"} =
 650         StatusView.render("card.json", %{page_url: page_url, rich_media: card})
 651     end
 652
 653     test "a rich media card without a site name or image renders correctly" do
 654       page_url = "http://example.com"
 655
 656       card = %{
 657         url: page_url,
 658         title: "Example website"
 659       }
 660
 661       %{provider_name: "example.com"} =
 662         StatusView.render("card.json", %{page_url: page_url, rich_media: card})
 663     end
 664
 665     test "a rich media card without an image renders correctly" do
 666       page_url = "http://example.com"
 667
 668       card = %{
 669         url: page_url,
 670         site_name: "Example site name",
 671         title: "Example website"
 672       }
 673
 674       %{provider_name: "example.com"} =
 675         StatusView.render("card.json", %{page_url: page_url, rich_media: card})
 676     end
 677
 678     test "a rich media card with all relevant data renders correctly" do
 679       page_url = "http://example.com"
 680
 681       card = %{
 682         url: page_url,
 683         site_name: "Example site name",
 684         title: "Example website",
 685         image: page_url <> "/example.jpg",
 686         description: "Example description"
 687       }
 688
 689       %{provider_name: "example.com"} =
 690         StatusView.render("card.json", %{page_url: page_url, rich_media: card})
 691     end
 692   end
 693
 694   test "does not embed a relationship in the account" do
 695     user = insert(:user)
 696     other_user = insert(:user)
 697
 698     {:ok, activity} =
 699       CommonAPI.post(user, %{
 700         status: "drink more water"
 701       })
 702
 703     result = StatusView.render("show.json", %{activity: activity, for: other_user})
 704
 705     assert result[:account][:pleroma][:relationship] == %{}
 706     assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
 707   end
 708
 709   test "does not embed a relationship in the account in reposts" do
 710     user = insert(:user)
 711     other_user = insert(:user)
 712
 713     {:ok, activity} =
 714       CommonAPI.post(user, %{
 715         status: "˙˙ɐʎns"
 716       })
 717
 718     {:ok, activity} = CommonAPI.repeat(activity.id, other_user)
 719
 720     result = StatusView.render("show.json", %{activity: activity, for: user})
 721
 722     assert result[:account][:pleroma][:relationship] == %{}
 723     assert result[:reblog][:account][:pleroma][:relationship] == %{}
 724     assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
 725   end
 726
 727   test "visibility/list" do
 728     user = insert(:user)
 729
 730     {:ok, list} = Pleroma.List.create("foo", user)
 731
 732     {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
 733
 734     status = StatusView.render("show.json", activity: activity)
 735
 736     assert status.visibility == "list"
 737   end
 738
 739   test "has a field for parent visibility" do
 740     user = insert(:user)
 741     poster = insert(:user)
 742
 743     {:ok, invisible} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})
 744
 745     {:ok, visible} =
 746       CommonAPI.post(poster, %{status: "hey", visibility: "private", in_reply_to_id: invisible.id})
 747
 748     status = StatusView.render("show.json", activity: visible, for: user)
 749     refute status.pleroma.parent_visible
 750
 751     status = StatusView.render("show.json", activity: visible, for: poster)
 752     assert status.pleroma.parent_visible
 753   end
 754 end