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