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.Object
  10   alias Pleroma.Web.ActivityPub.Visibility
  11   alias Pleroma.Web.CommonAPI
  12   import Pleroma.Factory
  13
  14   setup do
  15     user = insert(:user)
  16     mentioned = insert(:user)
  17     following = insert(:user)
  18     unrelated = insert(:user)
  19     remote = insert(:user, local: false)
  20     {:ok, following, user} = Pleroma.User.follow(following, user)
  21     {:ok, list} = Pleroma.List.create("foo", user)
  22
  23     Pleroma.List.follow(list, unrelated)
  24
  25     {:ok, public} =
  26       CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "public"})
  27
  28     {:ok, private} =
  29       CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "private"})
  30
  31     {:ok, direct} =
  32       CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "direct"})
  33
  34     {:ok, unlisted} =
  35       CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "unlisted"})
  36
  37     {:ok, local} =
  38       CommonAPI.post(user, %{status: "@#{mentioned.nickname}", visibility: "local"})
  39
  40     {:ok, list} =
  41       CommonAPI.post(user, %{
  42         status: "@#{mentioned.nickname}",
  43         visibility: "list:#{list.id}"
  44       })
  45
  46     %{
  47       public: public,
  48       private: private,
  49       direct: direct,
  50       unlisted: unlisted,
  51       user: user,
  52       mentioned: mentioned,
  53       following: following,
  54       unrelated: unrelated,
  55       list: list,
  56       local: local,
  57       remote: remote
  58     }
  59   end
  60
  61   test "is_direct?", %{
  62     public: public,
  63     private: private,
  64     direct: direct,
  65     unlisted: unlisted,
  66     list: list,
  67     local: local
  68   } do
  69     assert Visibility.is_direct?(direct)
  70     refute Visibility.is_direct?(public)
  71     refute Visibility.is_direct?(private)
  72     refute Visibility.is_direct?(unlisted)
  73     assert Visibility.is_direct?(list)
  74     refute Visibility.is_direct?(local)
  75   end
  76
  77   test "is_public?", %{
  78     public: public,
  79     private: private,
  80     direct: direct,
  81     unlisted: unlisted,
  82     local: local,
  83     list: list
  84   } do
  85     refute Visibility.is_public?(direct)
  86     assert Visibility.is_public?(public)
  87     refute Visibility.is_public?(private)
  88     assert Visibility.is_public?(unlisted)
  89     assert Visibility.is_public?(local)
  90     refute Visibility.is_public?(list)
  91   end
  92
  93   test "is_private?", %{
  94     public: public,
  95     private: private,
  96     direct: direct,
  97     unlisted: unlisted,
  98     list: list,
  99     local: local
 100   } do
 101     refute Visibility.is_private?(direct)
 102     refute Visibility.is_private?(public)
 103     assert Visibility.is_private?(private)
 104     refute Visibility.is_private?(unlisted)
 105     refute Visibility.is_private?(list)
 106     refute Visibility.is_private?(local)
 107   end
 108
 109   test "is_list?", %{
 110     public: public,
 111     private: private,
 112     direct: direct,
 113     unlisted: unlisted,
 114     list: list,
 115     local: local
 116   } do
 117     refute Visibility.is_list?(direct)
 118     refute Visibility.is_list?(public)
 119     refute Visibility.is_list?(private)
 120     refute Visibility.is_list?(unlisted)
 121     assert Visibility.is_list?(list)
 122     refute Visibility.is_list?(local)
 123   end
 124
 125   test "visible_for_user? Activity", %{
 126     public: public,
 127     private: private,
 128     direct: direct,
 129     unlisted: unlisted,
 130     user: user,
 131     mentioned: mentioned,
 132     following: following,
 133     unrelated: unrelated,
 134     list: list,
 135     local: local,
 136     remote: remote
 137   } do
 138     # All visible to author
 139
 140     assert Visibility.visible_for_user?(public, user)
 141     assert Visibility.visible_for_user?(private, user)
 142     assert Visibility.visible_for_user?(unlisted, user)
 143     assert Visibility.visible_for_user?(direct, user)
 144     assert Visibility.visible_for_user?(list, user)
 145     assert Visibility.visible_for_user?(local, user)
 146
 147     # All visible to a mentioned user
 148
 149     assert Visibility.visible_for_user?(public, mentioned)
 150     assert Visibility.visible_for_user?(private, mentioned)
 151     assert Visibility.visible_for_user?(unlisted, mentioned)
 152     assert Visibility.visible_for_user?(direct, mentioned)
 153     assert Visibility.visible_for_user?(list, mentioned)
 154     assert Visibility.visible_for_user?(local, mentioned)
 155
 156     # DM not visible for just follower
 157
 158     assert Visibility.visible_for_user?(public, following)
 159     assert Visibility.visible_for_user?(private, following)
 160     assert Visibility.visible_for_user?(unlisted, following)
 161     refute Visibility.visible_for_user?(direct, following)
 162     refute Visibility.visible_for_user?(list, following)
 163     assert Visibility.visible_for_user?(local, following)
 164
 165     # Public and unlisted visible for unrelated user
 166
 167     assert Visibility.visible_for_user?(public, unrelated)
 168     assert Visibility.visible_for_user?(unlisted, unrelated)
 169     refute Visibility.visible_for_user?(private, unrelated)
 170     refute Visibility.visible_for_user?(direct, unrelated)
 171     assert Visibility.visible_for_user?(local, unrelated)
 172
 173     # Public and unlisted visible for unauthenticated
 174
 175     assert Visibility.visible_for_user?(public, nil)
 176     assert Visibility.visible_for_user?(unlisted, nil)
 177     refute Visibility.visible_for_user?(private, nil)
 178     refute Visibility.visible_for_user?(direct, nil)
 179     refute Visibility.visible_for_user?(local, nil)
 180
 181     # Visible for a list member
 182     assert Visibility.visible_for_user?(list, unrelated)
 183
 184     # Local not visible to remote user
 185     refute Visibility.visible_for_user?(local, remote)
 186   end
 187
 188   test "visible_for_user? Object", %{
 189     public: public,
 190     private: private,
 191     direct: direct,
 192     unlisted: unlisted,
 193     user: user,
 194     mentioned: mentioned,
 195     following: following,
 196     unrelated: unrelated,
 197     list: list,
 198     local: local,
 199     remote: remote
 200   } do
 201     public = Object.normalize(public)
 202     private = Object.normalize(private)
 203     unlisted = Object.normalize(unlisted)
 204     direct = Object.normalize(direct)
 205     list = Object.normalize(list)
 206     local = Object.normalize(local)
 207
 208     # All visible to author
 209
 210     assert Visibility.visible_for_user?(public, user)
 211     assert Visibility.visible_for_user?(private, user)
 212     assert Visibility.visible_for_user?(unlisted, user)
 213     assert Visibility.visible_for_user?(direct, user)
 214     assert Visibility.visible_for_user?(list, user)
 215
 216     # All visible to a mentioned user
 217
 218     assert Visibility.visible_for_user?(public, mentioned)
 219     assert Visibility.visible_for_user?(private, mentioned)
 220     assert Visibility.visible_for_user?(unlisted, mentioned)
 221     assert Visibility.visible_for_user?(direct, mentioned)
 222     assert Visibility.visible_for_user?(list, mentioned)
 223
 224     # DM not visible for just follower
 225
 226     assert Visibility.visible_for_user?(public, following)
 227     assert Visibility.visible_for_user?(private, following)
 228     assert Visibility.visible_for_user?(unlisted, following)
 229     refute Visibility.visible_for_user?(direct, following)
 230     refute Visibility.visible_for_user?(list, following)
 231
 232     # Public and unlisted visible for unrelated user
 233
 234     assert Visibility.visible_for_user?(public, unrelated)
 235     assert Visibility.visible_for_user?(unlisted, unrelated)
 236     refute Visibility.visible_for_user?(private, unrelated)
 237     refute Visibility.visible_for_user?(direct, unrelated)
 238
 239     # Public and unlisted visible for unauthenticated
 240
 241     assert Visibility.visible_for_user?(public, nil)
 242     assert Visibility.visible_for_user?(unlisted, nil)
 243     refute Visibility.visible_for_user?(private, nil)
 244     refute Visibility.visible_for_user?(direct, nil)
 245     refute Visibility.visible_for_user?(local, nil)
 246
 247     # Local posts to remote
 248     refute Visibility.visible_for_user?(local, remote)
 249     # Visible for a list member
 250     # assert Visibility.visible_for_user?(list, unrelated)
 251   end
 252
 253   test "doesn't die when the user doesn't exist",
 254        %{
 255          direct: direct,
 256          user: user
 257        } do
 258     Repo.delete(user)
 259     Pleroma.User.invalidate_cache(user)
 260     refute Visibility.is_private?(direct)
 261   end
 262
 263   test "get_visibility", %{
 264     public: public,
 265     private: private,
 266     direct: direct,
 267     unlisted: unlisted,
 268     list: list
 269   } do
 270     assert Visibility.get_visibility(public) == "public"
 271     assert Visibility.get_visibility(private) == "private"
 272     assert Visibility.get_visibility(direct) == "direct"
 273     assert Visibility.get_visibility(unlisted) == "unlisted"
 274     assert Visibility.get_visibility(list) == "list"
 275   end
 276
 277   test "get_visibility with directMessage flag" do
 278     assert Visibility.get_visibility(%{data: %{"directMessage" => true}}) == "direct"
 279   end
 280
 281   test "get_visibility with listMessage flag" do
 282     assert Visibility.get_visibility(%{data: %{"listMessage" => ""}}) == "list"
 283   end
 284
 285   describe "entire_thread_visible_for_user?/2" do
 286     test "returns false if not found activity", %{user: user} do
 287       refute Visibility.entire_thread_visible_for_user?(%Activity{}, user)
 288     end
 289
 290     test "returns true if activity hasn't 'Create' type", %{user: user} do
 291       activity = insert(:like_activity)
 292       assert Visibility.entire_thread_visible_for_user?(activity, user)
 293     end
 294
 295     test "returns false when invalid recipients", %{user: user} do
 296       author = insert(:user)
 297
 298       activity =
 299         insert(:note_activity,
 300           note:
 301             insert(:note,
 302               user: author,
 303               data: %{"to" => ["test-user"]}
 304             )
 305         )
 306
 307       refute Visibility.entire_thread_visible_for_user?(activity, user)
 308     end
 309
 310     test "returns true if user following to author" do
 311       author = insert(:user)
 312       user = insert(:user)
 313       Pleroma.User.follow(user, author)
 314
 315       activity =
 316         insert(:note_activity,
 317           note:
 318             insert(:note,
 319               user: author,
 320               data: %{"to" => [user.ap_id]}
 321             )
 322         )
 323
 324       assert Visibility.entire_thread_visible_for_user?(activity, user)
 325     end
 326   end
 327 end