git.squeep.com Git - akkoma/blob - test/web/activity_pub/visibilty_test.exs

   1 defmodule Pleroma.Web.ActivityPub.VisibilityTest do
   2   use Pleroma.DataCase
   3
   4   alias Pleroma.Activity
   5   alias Pleroma.Web.ActivityPub.Visibility
   6   alias Pleroma.Web.CommonAPI
   7   import Pleroma.Factory
   8
   9   setup do
  10     user = insert(:user)
  11     mentioned = insert(:user)
  12     following = insert(:user)
  13     unrelated = insert(:user)
  14     {:ok, following} = Pleroma.User.follow(following, user)
  15
  16     {:ok, public} =
  17       CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "public"})
  18
  19     {:ok, private} =
  20       CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "private"})
  21
  22     {:ok, direct} =
  23       CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "direct"})
  24
  25     {:ok, unlisted} =
  26       CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "unlisted"})
  27
  28     %{
  29       public: public,
  30       private: private,
  31       direct: direct,
  32       unlisted: unlisted,
  33       user: user,
  34       mentioned: mentioned,
  35       following: following,
  36       unrelated: unrelated
  37     }
  38   end
  39
  40   test "is_direct?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
  41     assert Visibility.is_direct?(direct)
  42     refute Visibility.is_direct?(public)
  43     refute Visibility.is_direct?(private)
  44     refute Visibility.is_direct?(unlisted)
  45   end
  46
  47   test "is_public?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
  48     refute Visibility.is_public?(direct)
  49     assert Visibility.is_public?(public)
  50     refute Visibility.is_public?(private)
  51     assert Visibility.is_public?(unlisted)
  52   end
  53
  54   test "is_private?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
  55     refute Visibility.is_private?(direct)
  56     refute Visibility.is_private?(public)
  57     assert Visibility.is_private?(private)
  58     refute Visibility.is_private?(unlisted)
  59   end
  60
  61   test "visible_for_user?", %{
  62     public: public,
  63     private: private,
  64     direct: direct,
  65     unlisted: unlisted,
  66     user: user,
  67     mentioned: mentioned,
  68     following: following,
  69     unrelated: unrelated
  70   } do
  71     # All visible to author
  72
  73     assert Visibility.visible_for_user?(public, user)
  74     assert Visibility.visible_for_user?(private, user)
  75     assert Visibility.visible_for_user?(unlisted, user)
  76     assert Visibility.visible_for_user?(direct, user)
  77
  78     # All visible to a mentioned user
  79
  80     assert Visibility.visible_for_user?(public, mentioned)
  81     assert Visibility.visible_for_user?(private, mentioned)
  82     assert Visibility.visible_for_user?(unlisted, mentioned)
  83     assert Visibility.visible_for_user?(direct, mentioned)
  84
  85     # DM not visible for just follower
  86
  87     assert Visibility.visible_for_user?(public, following)
  88     assert Visibility.visible_for_user?(private, following)
  89     assert Visibility.visible_for_user?(unlisted, following)
  90     refute Visibility.visible_for_user?(direct, following)
  91
  92     # Public and unlisted visible for unrelated user
  93
  94     assert Visibility.visible_for_user?(public, unrelated)
  95     assert Visibility.visible_for_user?(unlisted, unrelated)
  96     refute Visibility.visible_for_user?(private, unrelated)
  97     refute Visibility.visible_for_user?(direct, unrelated)
  98   end
  99
 100   test "doesn't die when the user doesn't exist",
 101        %{
 102          direct: direct,
 103          user: user
 104        } do
 105     Repo.delete(user)
 106     Cachex.clear(:user_cache)
 107     refute Visibility.is_private?(direct)
 108   end
 109
 110   test "get_visibility", %{
 111     public: public,
 112     private: private,
 113     direct: direct,
 114     unlisted: unlisted
 115   } do
 116     assert Visibility.get_visibility(public) == "public"
 117     assert Visibility.get_visibility(private) == "private"
 118     assert Visibility.get_visibility(direct) == "direct"
 119     assert Visibility.get_visibility(unlisted) == "unlisted"
 120   end
 121
 122   test "get_visibility with directMessage flag" do
 123     assert Visibility.get_visibility(%{data: %{"directMessage" => true}}) == "direct"
 124   end
 125
 126   describe "entire_thread_visible_for_user?/2" do
 127     test "returns false if not found activity", %{user: user} do
 128       refute Visibility.entire_thread_visible_for_user?(%Activity{}, user)
 129     end
 130
 131     test "returns true if activity hasn't 'Create' type", %{user: user} do
 132       activity = insert(:like_activity)
 133       assert Visibility.entire_thread_visible_for_user?(activity, user)
 134     end
 135
 136     test "returns false when invalid recipients", %{user: user} do
 137       author = insert(:user)
 138
 139       activity =
 140         insert(:note_activity,
 141           note:
 142             insert(:note,
 143               user: author,
 144               data: %{"to" => ["test-user"]}
 145             )
 146         )
 147
 148       refute Visibility.entire_thread_visible_for_user?(activity, user)
 149     end
 150
 151     test "returns true if user following to author" do
 152       author = insert(:user)
 153       user = insert(:user, following: [author.ap_id])
 154
 155       activity =
 156         insert(:note_activity,
 157           note:
 158             insert(:note,
 159               user: author,
 160               data: %{"to" => [user.ap_id]}
 161             )
 162         )
 163
 164       assert Visibility.entire_thread_visible_for_user?(activity, user)
 165     end
 166   end
 167 end