git.squeep.com Git - akkoma/blob - test/pleroma/web/activity_pub/visibility_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.ActivityPub.VisibilityTest do
   6   use Pleroma.DataCase, async: true
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.Web.ActivityPub.Visibility
  10   alias Pleroma.Web.CommonAPI
  11   import Pleroma.Factory
  12
  13   setup do
  14     user = insert(:user)
  15     mentioned = insert(:user)
  16     following = insert(:user)
  17     unrelated = insert(:user)
  18     {:ok, following, user} = Pleroma.User.follow(following, user)
  19     {:ok, list} = Pleroma.List.create("foo", user)
  20
  21     Pleroma.List.follow(list, unrelated)
  22
  23     {:ok, public} =
  24       CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "public"})
  25
  26     {:ok, private} =
  27       CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "private"})
  28
  29     {:ok, direct} =
  30       CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "direct"})
  31
  32     {:ok, unlisted} =
  33       CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "unlisted"})
  34
  35     {:ok, list} =
  36       CommonAPI.post(user, %{
  37         status: "@#{mentioned.nickname}",
  38         visibility: "list:#{list.id}"
  39       })
  40
  41     %{
  42       public: public,
  43       private: private,
  44       direct: direct,
  45       unlisted: unlisted,
  46       user: user,
  47       mentioned: mentioned,
  48       following: following,
  49       unrelated: unrelated,
  50       list: list
  51     }
  52   end
  53
  54   test "is_direct?", %{
  55     public: public,
  56     private: private,
  57     direct: direct,
  58     unlisted: unlisted,
  59     list: list
  60   } do
  61     assert Visibility.is_direct?(direct)
  62     refute Visibility.is_direct?(public)
  63     refute Visibility.is_direct?(private)
  64     refute Visibility.is_direct?(unlisted)
  65     assert Visibility.is_direct?(list)
  66   end
  67
  68   test "is_public?", %{
  69     public: public,
  70     private: private,
  71     direct: direct,
  72     unlisted: unlisted,
  73     list: list
  74   } do
  75     refute Visibility.is_public?(direct)
  76     assert Visibility.is_public?(public)
  77     refute Visibility.is_public?(private)
  78     assert Visibility.is_public?(unlisted)
  79     refute Visibility.is_public?(list)
  80   end
  81
  82   test "is_private?", %{
  83     public: public,
  84     private: private,
  85     direct: direct,
  86     unlisted: unlisted,
  87     list: list
  88   } do
  89     refute Visibility.is_private?(direct)
  90     refute Visibility.is_private?(public)
  91     assert Visibility.is_private?(private)
  92     refute Visibility.is_private?(unlisted)
  93     refute Visibility.is_private?(list)
  94   end
  95
  96   test "is_list?", %{
  97     public: public,
  98     private: private,
  99     direct: direct,
 100     unlisted: unlisted,
 101     list: list
 102   } do
 103     refute Visibility.is_list?(direct)
 104     refute Visibility.is_list?(public)
 105     refute Visibility.is_list?(private)
 106     refute Visibility.is_list?(unlisted)
 107     assert Visibility.is_list?(list)
 108   end
 109
 110   test "visible_for_user?", %{
 111     public: public,
 112     private: private,
 113     direct: direct,
 114     unlisted: unlisted,
 115     user: user,
 116     mentioned: mentioned,
 117     following: following,
 118     unrelated: unrelated,
 119     list: list
 120   } do
 121     # All visible to author
 122
 123     assert Visibility.visible_for_user?(public, user)
 124     assert Visibility.visible_for_user?(private, user)
 125     assert Visibility.visible_for_user?(unlisted, user)
 126     assert Visibility.visible_for_user?(direct, user)
 127     assert Visibility.visible_for_user?(list, user)
 128
 129     # All visible to a mentioned user
 130
 131     assert Visibility.visible_for_user?(public, mentioned)
 132     assert Visibility.visible_for_user?(private, mentioned)
 133     assert Visibility.visible_for_user?(unlisted, mentioned)
 134     assert Visibility.visible_for_user?(direct, mentioned)
 135     assert Visibility.visible_for_user?(list, mentioned)
 136
 137     # DM not visible for just follower
 138
 139     assert Visibility.visible_for_user?(public, following)
 140     assert Visibility.visible_for_user?(private, following)
 141     assert Visibility.visible_for_user?(unlisted, following)
 142     refute Visibility.visible_for_user?(direct, following)
 143     refute Visibility.visible_for_user?(list, following)
 144
 145     # Public and unlisted visible for unrelated user
 146
 147     assert Visibility.visible_for_user?(public, unrelated)
 148     assert Visibility.visible_for_user?(unlisted, unrelated)
 149     refute Visibility.visible_for_user?(private, unrelated)
 150     refute Visibility.visible_for_user?(direct, unrelated)
 151
 152     # Visible for a list member
 153     assert Visibility.visible_for_user?(list, unrelated)
 154   end
 155
 156   test "doesn't die when the user doesn't exist",
 157        %{
 158          direct: direct,
 159          user: user
 160        } do
 161     Repo.delete(user)
 162     Pleroma.User.invalidate_cache(user)
 163     refute Visibility.is_private?(direct)
 164   end
 165
 166   test "get_visibility", %{
 167     public: public,
 168     private: private,
 169     direct: direct,
 170     unlisted: unlisted,
 171     list: list
 172   } do
 173     assert Visibility.get_visibility(public) == "public"
 174     assert Visibility.get_visibility(private) == "private"
 175     assert Visibility.get_visibility(direct) == "direct"
 176     assert Visibility.get_visibility(unlisted) == "unlisted"
 177     assert Visibility.get_visibility(list) == "list"
 178   end
 179
 180   test "get_visibility with directMessage flag" do
 181     assert Visibility.get_visibility(%{data: %{"directMessage" => true}}) == "direct"
 182   end
 183
 184   test "get_visibility with listMessage flag" do
 185     assert Visibility.get_visibility(%{data: %{"listMessage" => ""}}) == "list"
 186   end
 187
 188   describe "entire_thread_visible_for_user?/2" do
 189     test "returns false if not found activity", %{user: user} do
 190       refute Visibility.entire_thread_visible_for_user?(%Activity{}, user)
 191     end
 192
 193     test "returns true if activity hasn't 'Create' type", %{user: user} do
 194       activity = insert(:like_activity)
 195       assert Visibility.entire_thread_visible_for_user?(activity, user)
 196     end
 197
 198     test "returns false when invalid recipients", %{user: user} do
 199       author = insert(:user)
 200
 201       activity =
 202         insert(:note_activity,
 203           note:
 204             insert(:note,
 205               user: author,
 206               data: %{"to" => ["test-user"]}
 207             )
 208         )
 209
 210       refute Visibility.entire_thread_visible_for_user?(activity, user)
 211     end
 212
 213     test "returns true if user following to author" do
 214       author = insert(:user)
 215       user = insert(:user)
 216       Pleroma.User.follow(user, author)
 217
 218       activity =
 219         insert(:note_activity,
 220           note:
 221             insert(:note,
 222               user: author,
 223               data: %{"to" => [user.ap_id]}
 224             )
 225         )
 226
 227       assert Visibility.entire_thread_visible_for_user?(activity, user)
 228     end
 229   end
 230 end