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

   1 defmodule Pleroma.Web.ActivityPub.ObjectValidatorTest do
   2   use Pleroma.DataCase
   3
   4   alias Pleroma.Object
   5   alias Pleroma.Web.ActivityPub.Builder
   6   alias Pleroma.Web.ActivityPub.ObjectValidator
   7   alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
   8   alias Pleroma.Web.ActivityPub.Utils
   9   alias Pleroma.Web.CommonAPI
  10
  11   import Pleroma.Factory
  12
  13   describe "Undos" do
  14     setup do
  15       user = insert(:user)
  16       {:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})
  17       {:ok, like} = CommonAPI.favorite(user, post_activity.id)
  18       {:ok, valid_like_undo, []} = Builder.undo(user, like)
  19
  20       %{user: user, like: like, valid_like_undo: valid_like_undo}
  21     end
  22
  23     test "it validates a basic like undo", %{valid_like_undo: valid_like_undo} do
  24       assert {:ok, _, _} = ObjectValidator.validate(valid_like_undo, [])
  25     end
  26
  27     test "it does not validate if the actor of the undo is not the actor of the object", %{
  28       valid_like_undo: valid_like_undo
  29     } do
  30       other_user = insert(:user, ap_id: "https://gensokyo.2hu/users/raymoo")
  31
  32       bad_actor =
  33         valid_like_undo
  34         |> Map.put("actor", other_user.ap_id)
  35
  36       {:error, cng} = ObjectValidator.validate(bad_actor, [])
  37
  38       assert {:actor, {"not the same as object actor", []}} in cng.errors
  39     end
  40
  41     test "it does not validate if the object is missing", %{valid_like_undo: valid_like_undo} do
  42       missing_object =
  43         valid_like_undo
  44         |> Map.put("object", "https://gensokyo.2hu/objects/1")
  45
  46       {:error, cng} = ObjectValidator.validate(missing_object, [])
  47
  48       assert {:object, {"can't find object", []}} in cng.errors
  49       assert length(cng.errors) == 1
  50     end
  51   end
  52
  53   describe "deletes" do
  54     setup do
  55       user = insert(:user)
  56       {:ok, post_activity} = CommonAPI.post(user, %{"status" => "cancel me daddy"})
  57
  58       {:ok, valid_post_delete, _} = Builder.delete(user, post_activity.data["object"])
  59       {:ok, valid_user_delete, _} = Builder.delete(user, user.ap_id)
  60
  61       %{user: user, valid_post_delete: valid_post_delete, valid_user_delete: valid_user_delete}
  62     end
  63
  64     test "it is valid for a post deletion", %{valid_post_delete: valid_post_delete} do
  65       {:ok, valid_post_delete, _} = ObjectValidator.validate(valid_post_delete, [])
  66
  67       assert valid_post_delete["deleted_activity_id"]
  68     end
  69
  70     test "it is invalid if the object isn't in a list of certain types", %{
  71       valid_post_delete: valid_post_delete
  72     } do
  73       object = Object.get_by_ap_id(valid_post_delete["object"])
  74
  75       data =
  76         object.data
  77         |> Map.put("type", "Like")
  78
  79       {:ok, _object} =
  80         object
  81         |> Ecto.Changeset.change(%{data: data})
  82         |> Object.update_and_set_cache()
  83
  84       {:error, cng} = ObjectValidator.validate(valid_post_delete, [])
  85       assert {:object, {"object not in allowed types", []}} in cng.errors
  86     end
  87
  88     test "it is valid for a user deletion", %{valid_user_delete: valid_user_delete} do
  89       assert match?({:ok, _, _}, ObjectValidator.validate(valid_user_delete, []))
  90     end
  91
  92     test "it's invalid if the id is missing", %{valid_post_delete: valid_post_delete} do
  93       no_id =
  94         valid_post_delete
  95         |> Map.delete("id")
  96
  97       {:error, cng} = ObjectValidator.validate(no_id, [])
  98
  99       assert {:id, {"can't be blank", [validation: :required]}} in cng.errors
 100     end
 101
 102     test "it's invalid if the object doesn't exist", %{valid_post_delete: valid_post_delete} do
 103       missing_object =
 104         valid_post_delete
 105         |> Map.put("object", "http://does.not/exist")
 106
 107       {:error, cng} = ObjectValidator.validate(missing_object, [])
 108
 109       assert {:object, {"can't find object", []}} in cng.errors
 110       assert length(cng.errors) == 1
 111     end
 112
 113     test "it's invalid if the actor of the object and the actor of delete are from different domains",
 114          %{valid_post_delete: valid_post_delete} do
 115       valid_user = insert(:user)
 116
 117       valid_other_actor =
 118         valid_post_delete
 119         |> Map.put("actor", valid_user.ap_id)
 120
 121       assert match?({:ok, _, _}, ObjectValidator.validate(valid_other_actor, []))
 122
 123       invalid_other_actor =
 124         valid_post_delete
 125         |> Map.put("actor", "https://gensokyo.2hu/users/raymoo")
 126
 127       {:error, cng} = ObjectValidator.validate(invalid_other_actor, [])
 128
 129       assert {:actor, {"is not allowed to delete object", []}} in cng.errors
 130     end
 131
 132     test "it's valid if the actor of the object is a local superuser",
 133          %{valid_post_delete: valid_post_delete} do
 134       user =
 135         insert(:user, local: true, is_moderator: true, ap_id: "https://gensokyo.2hu/users/raymoo")
 136
 137       valid_other_actor =
 138         valid_post_delete
 139         |> Map.put("actor", user.ap_id)
 140
 141       {:ok, _, meta} = ObjectValidator.validate(valid_other_actor, [])
 142       assert meta[:do_not_federate]
 143     end
 144   end
 145
 146   describe "likes" do
 147     setup do
 148       user = insert(:user)
 149       {:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})
 150
 151       valid_like = %{
 152         "to" => [user.ap_id],
 153         "cc" => [],
 154         "type" => "Like",
 155         "id" => Utils.generate_activity_id(),
 156         "object" => post_activity.data["object"],
 157         "actor" => user.ap_id,
 158         "context" => "a context"
 159       }
 160
 161       %{valid_like: valid_like, user: user, post_activity: post_activity}
 162     end
 163
 164     test "returns ok when called in the ObjectValidator", %{valid_like: valid_like} do
 165       {:ok, object, _meta} = ObjectValidator.validate(valid_like, [])
 166
 167       assert "id" in Map.keys(object)
 168     end
 169
 170     test "is valid for a valid object", %{valid_like: valid_like} do
 171       assert LikeValidator.cast_and_validate(valid_like).valid?
 172     end
 173
 174     test "sets the 'to' field to the object actor if no recipients are given", %{
 175       valid_like: valid_like,
 176       user: user
 177     } do
 178       without_recipients =
 179         valid_like
 180         |> Map.delete("to")
 181
 182       {:ok, object, _meta} = ObjectValidator.validate(without_recipients, [])
 183
 184       assert object["to"] == [user.ap_id]
 185     end
 186
 187     test "sets the context field to the context of the object if no context is given", %{
 188       valid_like: valid_like,
 189       post_activity: post_activity
 190     } do
 191       without_context =
 192         valid_like
 193         |> Map.delete("context")
 194
 195       {:ok, object, _meta} = ObjectValidator.validate(without_context, [])
 196
 197       assert object["context"] == post_activity.data["context"]
 198     end
 199
 200     test "it errors when the actor is missing or not known", %{valid_like: valid_like} do
 201       without_actor = Map.delete(valid_like, "actor")
 202
 203       refute LikeValidator.cast_and_validate(without_actor).valid?
 204
 205       with_invalid_actor = Map.put(valid_like, "actor", "invalidactor")
 206
 207       refute LikeValidator.cast_and_validate(with_invalid_actor).valid?
 208     end
 209
 210     test "it errors when the object is missing or not known", %{valid_like: valid_like} do
 211       without_object = Map.delete(valid_like, "object")
 212
 213       refute LikeValidator.cast_and_validate(without_object).valid?
 214
 215       with_invalid_object = Map.put(valid_like, "object", "invalidobject")
 216
 217       refute LikeValidator.cast_and_validate(with_invalid_object).valid?
 218     end
 219
 220     test "it errors when the actor has already like the object", %{
 221       valid_like: valid_like,
 222       user: user,
 223       post_activity: post_activity
 224     } do
 225       _like = CommonAPI.favorite(user, post_activity.id)
 226
 227       refute LikeValidator.cast_and_validate(valid_like).valid?
 228     end
 229
 230     test "it works when actor or object are wrapped in maps", %{valid_like: valid_like} do
 231       wrapped_like =
 232         valid_like
 233         |> Map.put("actor", %{"id" => valid_like["actor"]})
 234         |> Map.put("object", %{"id" => valid_like["object"]})
 235
 236       validated = LikeValidator.cast_and_validate(wrapped_like)
 237
 238       assert validated.valid?
 239
 240       assert {:actor, valid_like["actor"]} in validated.changes
 241       assert {:object, valid_like["object"]} in validated.changes
 242     end
 243   end
 244 end