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     }
 307
 308     assert status == expected
 309     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 310   end
 311
 312   test "tells if the message is muted for some reason" do
 313     user = insert(:user)
 314     other_user = insert(:user)
 315
 316     {:ok, _user_relationships} = User.mute(user, other_user)
 317
 318     {:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
 319
 320     relationships_opt = UserRelationship.view_relationships_option(user, [other_user])
 321
 322     opts = %{activity: activity}
 323     status = StatusView.render("show.json", opts)
 324     assert status.muted == false
 325     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 326
 327     status = StatusView.render("show.json", Map.put(opts, :relationships, relationships_opt))
 328     assert status.muted == false
 329
 330     for_opts = %{activity: activity, for: user}
 331     status = StatusView.render("show.json", for_opts)
 332     assert status.muted == true
 333
 334     status = StatusView.render("show.json", Map.put(for_opts, :relationships, relationships_opt))
 335     assert status.muted == true
 336     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 337   end
 338
 339   test "tells if the message is thread muted" do
 340     user = insert(:user)
 341     other_user = insert(:user)
 342
 343     {:ok, _user_relationships} = User.mute(user, other_user)
 344
 345     {:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
 346     status = StatusView.render("show.json", %{activity: activity, for: user})
 347
 348     assert status.pleroma.thread_muted == false
 349
 350     {:ok, activity} = CommonAPI.add_mute(user, activity)
 351
 352     status = StatusView.render("show.json", %{activity: activity, for: user})
 353
 354     assert status.pleroma.thread_muted == true
 355   end
 356
 357   test "tells if the status is bookmarked" do
 358     user = insert(:user)
 359
 360     {:ok, activity} = CommonAPI.post(user, %{status: "Cute girls doing cute things"})
 361     status = StatusView.render("show.json", %{activity: activity})
 362
 363     assert status.bookmarked == false
 364
 365     status = StatusView.render("show.json", %{activity: activity, for: user})
 366
 367     assert status.bookmarked == false
 368
 369     {:ok, _bookmark} = Bookmark.create(user.id, activity.id)
 370
 371     activity = Activity.get_by_id_with_object(activity.id)
 372
 373     status = StatusView.render("show.json", %{activity: activity, for: user})
 374
 375     assert status.bookmarked == true
 376   end
 377
 378   test "a reply" do
 379     note = insert(:note_activity)
 380     user = insert(:user)
 381
 382     {:ok, activity} = CommonAPI.post(user, %{status: "he", in_reply_to_status_id: note.id})
 383
 384     status = StatusView.render("show.json", %{activity: activity})
 385
 386     assert status.in_reply_to_id == to_string(note.id)
 387
 388     [status] = StatusView.render("index.json", %{activities: [activity], as: :activity})
 389
 390     assert status.in_reply_to_id == to_string(note.id)
 391   end
 392
 393   test "contains mentions" do
 394     user = insert(:user)
 395     mentioned = insert(:user)
 396
 397     {:ok, activity} = CommonAPI.post(user, %{status: "hi @#{mentioned.nickname}"})
 398
 399     status = StatusView.render("show.json", %{activity: activity})
 400
 401     assert status.mentions ==
 402              Enum.map([mentioned], fn u -> AccountView.render("mention.json", %{user: u}) end)
 403
 404     assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
 405   end
 406
 407   test "create mentions from the 'to' field" do
 408     %User{ap_id: recipient_ap_id} = insert(:user)
 409     cc = insert_pair(:user) |> Enum.map(& &1.ap_id)
 410
 411     object =
 412       insert(:note, %{
 413         data: %{
 414           "to" => [recipient_ap_id],
 415           "cc" => cc
 416         }
 417       })
 418
 419     activity =
 420       insert(:note_activity, %{
 421         note: object,
 422         recipients: [recipient_ap_id | cc]
 423       })
 424
 425     assert length(activity.recipients) == 3
 426
 427     %{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})
 428
 429     assert length(mentions) == 1
 430     assert mention.url == recipient_ap_id
 431   end
 432
 433   test "create mentions from the 'tag' field" do
 434     recipient = insert(:user)
 435     cc = insert_pair(:user) |> Enum.map(& &1.ap_id)
 436
 437     object =
 438       insert(:note, %{
 439         data: %{
 440           "cc" => cc,
 441           "tag" => [
 442             %{
 443               "href" => recipient.ap_id,
 444               "name" => recipient.nickname,
 445               "type" => "Mention"
 446             },
 447             %{
 448               "href" => "https://example.com/search?tag=test",
 449               "name" => "#test",
 450               "type" => "Hashtag"
 451             }
 452           ]
 453         }
 454       })
 455
 456     activity =
 457       insert(:note_activity, %{
 458         note: object,
 459         recipients: [recipient.ap_id | cc]
 460       })
 461
 462     assert length(activity.recipients) == 3
 463
 464     %{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})
 465
 466     assert length(mentions) == 1
 467     assert mention.url == recipient.ap_id
 468   end
 469
 470   test "attachments" do
 471     object = %{
 472       "type" => "Image",
 473       "url" => [
 474         %{
 475           "mediaType" => "image/png",
 476           "href" => "someurl",
 477           "width" => 200,
 478           "height" => 100
 479         }
 480       ],
 481       "blurhash" => "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM|9GV=WHRn",
 482       "uuid" => 6
 483     }
 484
 485     expected = %{
 486       id: "1638338801",
 487       type: "image",
 488       url: "someurl",
 489       remote_url: "someurl",
 490       preview_url: "someurl",
 491       text_url: "someurl",
 492       description: nil,
 493       pleroma: %{mime_type: "image/png"},
 494       meta: %{original: %{width: 200, height: 100, aspect: 2}},
 495       blurhash: "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM|9GV=WHRn"
 496     }
 497
 498     api_spec = Pleroma.Web.ApiSpec.spec()
 499
 500     assert expected == StatusView.render("attachment.json", %{attachment: object})
 501     assert_schema(expected, "Attachment", api_spec)
 502
 503     # If theres a "id", use that instead of the generated one
 504     object = Map.put(object, "id", 2)
 505     result = StatusView.render("attachment.json", %{attachment: object})
 506
 507     assert %{id: "2"} = result
 508     assert_schema(result, "Attachment", api_spec)
 509   end
 510
 511   test "put the url advertised in the Activity in to the url attribute" do
 512     id = "https://wedistribute.org/wp-json/pterotype/v1/object/85810"
 513     [activity] = Activity.search(nil, id)
 514
 515     status = StatusView.render("show.json", %{activity: activity})
 516
 517     assert status.uri == id
 518     assert status.url == "https://wedistribute.org/2019/07/mastodon-drops-ostatus/"
 519   end
 520
 521   test "a reblog" do
 522     user = insert(:user)
 523     activity = insert(:note_activity)
 524
 525     {:ok, reblog} = CommonAPI.repeat(activity.id, user)
 526
 527     represented = StatusView.render("show.json", %{for: user, activity: reblog})
 528
 529     assert represented[:id] == to_string(reblog.id)
 530     assert represented[:reblog][:id] == to_string(activity.id)
 531     assert represented[:emojis] == []
 532     assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
 533   end
 534
 535   test "a peertube video" do
 536     user = insert(:user)
 537
 538     {:ok, object} =
 539       Pleroma.Object.Fetcher.fetch_object_from_id(
 540         "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
 541       )
 542
 543     %Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])
 544
 545     represented = StatusView.render("show.json", %{for: user, activity: activity})
 546
 547     assert represented[:id] == to_string(activity.id)
 548     assert length(represented[:media_attachments]) == 1
 549     assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
 550   end
 551
 552   test "funkwhale audio" do
 553     user = insert(:user)
 554
 555     {:ok, object} =
 556       Pleroma.Object.Fetcher.fetch_object_from_id(
 557         "https://channels.tests.funkwhale.audio/federation/music/uploads/42342395-0208-4fee-a38d-259a6dae0871"
 558       )
 559
 560     %Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])
 561
 562     represented = StatusView.render("show.json", %{for: user, activity: activity})
 563
 564     assert represented[:id] == to_string(activity.id)
 565     assert length(represented[:media_attachments]) == 1
 566   end
 567
 568   test "a Mobilizon event" do
 569     user = insert(:user)
 570
 571     {:ok, object} =
 572       Pleroma.Object.Fetcher.fetch_object_from_id(
 573         "https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
 574       )
 575
 576     %Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])
 577
 578     represented = StatusView.render("show.json", %{for: user, activity: activity})
 579
 580     assert represented[:id] == to_string(activity.id)
 581
 582     assert represented[:url] ==
 583              "https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
 584
 585     assert represented[:content] ==
 586              "<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>"
 587   end
 588
 589   describe "build_tags/1" do
 590     test "it returns a a dictionary tags" do
 591       object_tags = [
 592         "fediverse",
 593         "mastodon",
 594         "nextcloud",
 595         %{
 596           "href" => "https://kawen.space/users/lain",
 597           "name" => "@lain@kawen.space",
 598           "type" => "Mention"
 599         }
 600       ]
 601
 602       assert StatusView.build_tags(object_tags) == [
 603                %{name: "fediverse", url: "http://localhost:4001/tag/fediverse"},
 604                %{name: "mastodon", url: "http://localhost:4001/tag/mastodon"},
 605                %{name: "nextcloud", url: "http://localhost:4001/tag/nextcloud"}
 606              ]
 607     end
 608   end
 609
 610   describe "rich media cards" do
 611     test "a rich media card without a site name renders correctly" do
 612       page_url = "http://example.com"
 613
 614       card = %{
 615         url: page_url,
 616         image: page_url <> "/example.jpg",
 617         title: "Example website"
 618       }
 619
 620       %{provider_name: "example.com"} =
 621         StatusView.render("card.json", %{page_url: page_url, rich_media: card})
 622     end
 623
 624     test "a rich media card without a site name or image renders correctly" do
 625       page_url = "http://example.com"
 626
 627       card = %{
 628         url: page_url,
 629         title: "Example website"
 630       }
 631
 632       %{provider_name: "example.com"} =
 633         StatusView.render("card.json", %{page_url: page_url, rich_media: card})
 634     end
 635
 636     test "a rich media card without an image renders correctly" do
 637       page_url = "http://example.com"
 638
 639       card = %{
 640         url: page_url,
 641         site_name: "Example site name",
 642         title: "Example website"
 643       }
 644
 645       %{provider_name: "example.com"} =
 646         StatusView.render("card.json", %{page_url: page_url, rich_media: card})
 647     end
 648
 649     test "a rich media card with all relevant data renders correctly" do
 650       page_url = "http://example.com"
 651
 652       card = %{
 653         url: page_url,
 654         site_name: "Example site name",
 655         title: "Example website",
 656         image: page_url <> "/example.jpg",
 657         description: "Example description"
 658       }
 659
 660       %{provider_name: "example.com"} =
 661         StatusView.render("card.json", %{page_url: page_url, rich_media: card})
 662     end
 663   end
 664
 665   test "does not embed a relationship in the account" do
 666     user = insert(:user)
 667     other_user = insert(:user)
 668
 669     {:ok, activity} =
 670       CommonAPI.post(user, %{
 671         status: "drink more water"
 672       })
 673
 674     result = StatusView.render("show.json", %{activity: activity, for: other_user})
 675
 676     assert result[:account][:pleroma][:relationship] == %{}
 677     assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
 678   end
 679
 680   test "does not embed a relationship in the account in reposts" do
 681     user = insert(:user)
 682     other_user = insert(:user)
 683
 684     {:ok, activity} =
 685       CommonAPI.post(user, %{
 686         status: "˙˙ɐʎns"
 687       })
 688
 689     {:ok, activity} = CommonAPI.repeat(activity.id, other_user)
 690
 691     result = StatusView.render("show.json", %{activity: activity, for: user})
 692
 693     assert result[:account][:pleroma][:relationship] == %{}
 694     assert result[:reblog][:account][:pleroma][:relationship] == %{}
 695     assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
 696   end
 697
 698   test "visibility/list" do
 699     user = insert(:user)
 700
 701     {:ok, list} = Pleroma.List.create("foo", user)
 702
 703     {:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})
 704
 705     status = StatusView.render("show.json", activity: activity)
 706
 707     assert status.visibility == "list"
 708   end
 709
 710   test "has a field for parent visibility" do
 711     user = insert(:user)
 712     poster = insert(:user)
 713
 714     {:ok, invisible} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})
 715
 716     {:ok, visible} =
 717       CommonAPI.post(poster, %{status: "hey", visibility: "private", in_reply_to_id: invisible.id})
 718
 719     status = StatusView.render("show.json", activity: visible, for: user)
 720     refute status.pleroma.parent_visible
 721
 722     status = StatusView.render("show.json", activity: visible, for: poster)
 723     assert status.pleroma.parent_visible
 724   end
 725 end