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.CommonAPI.Utils
  18   alias Pleroma.Web.MastodonAPI.AccountView
  19   alias Pleroma.Web.MastodonAPI.StatusView
  20
  21   import Pleroma.Factory
  22   import Tesla.Mock
  23   import OpenApiSpex.TestAssertions
  24
  25   setup do
  26     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  27     :ok
  28   end
  29
  30   test "has an emoji reaction list" do
  31     user = insert(:user)
  32     other_user = insert(:user)
  33     third_user = insert(:user)
  34     {:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})
  35
  36     {:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "☕")
  37     {:ok, _} = CommonAPI.react_with_emoji(activity.id, user, ":dinosaur:")
  38     {:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "🍵")
  39     {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
  40     {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, ":dinosaur:")
  41
  42     activity = Repo.get(Activity, activity.id)
  43     status = StatusView.render("show.json", activity: activity)
  44
  45     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
  46
  47     assert status[:pleroma][:emoji_reactions] == [
  48              %{name: "☕", count: 2, me: false, url: nil},
  49              %{
  50                count: 2,
  51                me: false,
  52                name: "dinosaur",
  53                url: "http://localhost:4001/emoji/dino walking.gif"
  54              },
  55              %{name: "🍵", count: 1, me: false, url: nil}
  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},
  64              %{
  65                count: 2,
  66                me: true,
  67                name: "dinosaur",
  68                url: "http://localhost:4001/emoji/dino walking.gif"
  69              },
  70              %{name: "🍵", count: 1, me: false, url: nil}
  71            ]
  72   end
  73
  74   test "works correctly with badly formatted emojis" do
  75     user = insert(:user)
  76     {:ok, activity} = CommonAPI.post(user, %{status: "yo"})
  77
  78     activity
  79     |> Object.normalize(fetch: false)
  80     |> Object.update_data(%{"reactions" => %{"☕" => [user.ap_id], "x" => 1}})
  81
  82     activity = Activity.get_by_id(activity.id)
  83     status = StatusView.render("show.json", activity: activity, for: user)
  84
  85     assert status[:pleroma][:emoji_reactions] == [
  86              %{name: "☕", count: 1, me: true, url: nil}
  87            ]
  88   end
  89
  90   test "doesn't show reactions from muted and blocked users" do
  91     user = insert(:user)
  92     other_user = insert(:user)
  93     third_user = insert(:user)
  94
  95     {:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})
  96
  97     {:ok, _} = User.mute(user, other_user)
  98     {:ok, _} = User.block(other_user, third_user)
  99
 100     {:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
 101
 102     activity = Repo.get(Activity, activity.id)
 103     status = StatusView.render("show.json", activity: activity)
 104
 105     assert status[:pleroma][:emoji_reactions] == [
 106              %{name: "☕", count: 1, me: false, url: nil}
 107            ]
 108
 109     status = StatusView.render("show.json", activity: activity, for: user)
 110
 111     assert status[:pleroma][:emoji_reactions] == []
 112
 113     {:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "☕")
 114
 115     status = StatusView.render("show.json", activity: activity)
 116
 117     assert status[:pleroma][:emoji_reactions] == [
 118              %{name: "☕", count: 2, me: false, url: nil}
 119            ]
 120
 121     status = StatusView.render("show.json", activity: activity, for: user)
 122
 123     assert status[:pleroma][:emoji_reactions] == [
 124              %{name: "☕", count: 1, me: false, url: nil}
 125            ]
 126
 127     status = StatusView.render("show.json", activity: activity, for: other_user)
 128
 129     assert status[:pleroma][:emoji_reactions] == [
 130              %{name: "☕", count: 1, me: true, url: nil}
 131            ]
 132   end
 133
 134   test "loads and returns the direct conversation id when given the `with_direct_conversation_id` option" do
 135     user = insert(:user)
 136
 137     {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 138     [participation] = Participation.for_user(user)
 139
 140     status =
 141       StatusView.render("show.json",
 142         activity: activity,
 143         with_direct_conversation_id: true,
 144         for: user
 145       )
 146
 147     assert status[:pleroma][:direct_conversation_id] == participation.id
 148
 149     status = StatusView.render("show.json", activity: activity, for: user)
 150     assert status[:pleroma][:direct_conversation_id] == nil
 151     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 152   end
 153
 154   test "returns the direct conversation id when given the `direct_conversation_id` option" do
 155     user = insert(:user)
 156
 157     {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 158     [participation] = Participation.for_user(user)
 159
 160     status =
 161       StatusView.render("show.json",
 162         activity: activity,
 163         direct_conversation_id: participation.id,
 164         for: user
 165       )
 166
 167     assert status[:pleroma][:direct_conversation_id] == participation.id
 168     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 169   end
 170
 171   test "returns a temporary ap_id based user for activities missing db users" do
 172     user = insert(:user)
 173
 174     {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 175
 176     Repo.delete(user)
 177     User.invalidate_cache(user)
 178
 179     finger_url =
 180       "https://localhost/.well-known/webfinger?resource=acct:#{user.nickname}@localhost"
 181
 182     Tesla.Mock.mock_global(fn
 183       %{method: :get, url: "http://localhost/.well-known/host-meta"} ->
 184         %Tesla.Env{status: 404, body: ""}
 185
 186       %{method: :get, url: "https://localhost/.well-known/host-meta"} ->
 187         %Tesla.Env{status: 404, body: ""}
 188
 189       %{
 190         method: :get,
 191         url: ^finger_url
 192       } ->
 193         %Tesla.Env{status: 404, body: ""}
 194     end)
 195
 196     %{account: ms_user} = StatusView.render("show.json", activity: activity)
 197
 198     assert ms_user.acct == "erroruser@example.com"
 199   end
 200
 201   test "tries to get a user by nickname if fetching by ap_id doesn't work" do
 202     user = insert(:user)
 203
 204     {:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
 205
 206     {:ok, user} =
 207       user
 208       |> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
 209       |> Repo.update()
 210
 211     User.invalidate_cache(user)
 212
 213     result = StatusView.render("show.json", activity: activity)
 214
 215     assert result[:account][:id] == to_string(user.id)
 216     assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
 217   end
 218
 219   test "a note with null content" do
 220     note = insert(:note_activity)
 221     note_object = Object.normalize(note, fetch: false)
 222
 223     data =
 224       note_object.data
 225       |> Map.put("content", nil)
 226
 227     Object.change(note_object, %{data: data})
 228     |> Object.update_and_set_cache()
 229
 230     User.get_cached_by_ap_id(note.data["actor"])
 231
 232     status = StatusView.render("show.json", %{activity: note})
 233
 234     assert status.content == ""
 235     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 236   end
 237
 238   test "a note activity" do
 239     note = insert(:note_activity)
 240     object_data = Object.normalize(note, fetch: false).data
 241     user = User.get_cached_by_ap_id(note.data["actor"])
 242
 243     convo_id = Utils.context_to_conversation_id(object_data["context"])
 244
 245     status = StatusView.render("show.json", %{activity: note})
 246
 247     created_at =
 248       (object_data["published"] || "")
 249       |> String.replace(~r/\.\d+Z/, ".000Z")
 250
 251     expected = %{
 252       id: to_string(note.id),
 253       uri: object_data["id"],
 254       url: Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, note),
 255       account: AccountView.render("show.json", %{user: user, skip_visibility_check: true}),
 256       in_reply_to_id: nil,
 257       in_reply_to_account_id: nil,
 258       card: nil,
 259       reblog: nil,
 260       content: HTML.filter_tags(object_data["content"]),
 261       text: nil,
 262       created_at: created_at,
 263       reblogs_count: 0,
 264       replies_count: 0,
 265       favourites_count: 0,
 266       reblogged: false,
 267       bookmarked: false,
 268       favourited: false,
 269       muted: false,
 270       pinned: false,
 271       sensitive: false,
 272       poll: nil,
 273       spoiler_text: HTML.filter_tags(object_data["summary"]),
 274       visibility: "public",
 275       media_attachments: [],
 276       mentions: [],
 277       tags: [
 278         %{
 279           name: "#{hd(object_data["tag"])}",
 280           url: "http://localhost:4001/tag/#{hd(object_data["tag"])}"
 281         }
 282       ],
 283       application: nil,
 284       language: nil,
 285       emojis: [
 286         %{
 287           shortcode: "2hu",
 288           url: "corndog.png",
 289           static_url: "corndog.png",
 290           visible_in_picker: false
 291         }
 292       ],
 293       pleroma: %{
 294         local: true,
 295         conversation_id: convo_id,
 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