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     end
 111
 112     test "it's invalid if the actor of the object and the actor of delete are from different domains",
 113          %{valid_post_delete: valid_post_delete} do
 114       valid_user = insert(:user)
 115
 116       valid_other_actor =
 117         valid_post_delete
 118         |> Map.put("actor", valid_user.ap_id)
 119
 120       assert match?({:ok, _, _}, ObjectValidator.validate(valid_other_actor, []))
 121
 122       invalid_other_actor =
 123         valid_post_delete
 124         |> Map.put("actor", "https://gensokyo.2hu/users/raymoo")
 125
 126       {:error, cng} = ObjectValidator.validate(invalid_other_actor, [])
 127
 128       assert {:actor, {"is not allowed to delete object", []}} in cng.errors
 129     end
 130
 131     test "it's valid if the actor of the object is a local superuser",
 132          %{valid_post_delete: valid_post_delete} do
 133       user =
 134         insert(:user, local: true, is_moderator: true, ap_id: "https://gensokyo.2hu/users/raymoo")
 135
 136       valid_other_actor =
 137         valid_post_delete
 138         |> Map.put("actor", user.ap_id)
 139
 140       {:ok, _, meta} = ObjectValidator.validate(valid_other_actor, [])
 141       assert meta[:do_not_federate]
 142     end
 143   end
 144
 145   describe "likes" do
 146     setup do
 147       user = insert(:user)
 148       {:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})
 149
 150       valid_like = %{
 151         "to" => [user.ap_id],
 152         "cc" => [],
 153         "type" => "Like",
 154         "id" => Utils.generate_activity_id(),
 155         "object" => post_activity.data["object"],
 156         "actor" => user.ap_id,
 157         "context" => "a context"
 158       }
 159
 160       %{valid_like: valid_like, user: user, post_activity: post_activity}
 161     end
 162
 163     test "returns ok when called in the ObjectValidator", %{valid_like: valid_like} do
 164       {:ok, object, _meta} = ObjectValidator.validate(valid_like, [])
 165
 166       assert "id" in Map.keys(object)
 167     end
 168
 169     test "is valid for a valid object", %{valid_like: valid_like} do
 170       assert LikeValidator.cast_and_validate(valid_like).valid?
 171     end
 172
 173     test "sets the 'to' field to the object actor if no recipients are given", %{
 174       valid_like: valid_like,
 175       user: user
 176     } do
 177       without_recipients =
 178         valid_like
 179         |> Map.delete("to")
 180
 181       {:ok, object, _meta} = ObjectValidator.validate(without_recipients, [])
 182
 183       assert object["to"] == [user.ap_id]
 184     end
 185
 186     test "sets the context field to the context of the object if no context is given", %{
 187       valid_like: valid_like,
 188       post_activity: post_activity
 189     } do
 190       without_context =
 191         valid_like
 192         |> Map.delete("context")
 193
 194       {:ok, object, _meta} = ObjectValidator.validate(without_context, [])
 195
 196       assert object["context"] == post_activity.data["context"]
 197     end
 198
 199     test "it errors when the actor is missing or not known", %{valid_like: valid_like} do
 200       without_actor = Map.delete(valid_like, "actor")
 201
 202       refute LikeValidator.cast_and_validate(without_actor).valid?
 203
 204       with_invalid_actor = Map.put(valid_like, "actor", "invalidactor")
 205
 206       refute LikeValidator.cast_and_validate(with_invalid_actor).valid?
 207     end
 208
 209     test "it errors when the object is missing or not known", %{valid_like: valid_like} do
 210       without_object = Map.delete(valid_like, "object")
 211
 212       refute LikeValidator.cast_and_validate(without_object).valid?
 213
 214       with_invalid_object = Map.put(valid_like, "object", "invalidobject")
 215
 216       refute LikeValidator.cast_and_validate(with_invalid_object).valid?
 217     end
 218
 219     test "it errors when the actor has already like the object", %{
 220       valid_like: valid_like,
 221       user: user,
 222       post_activity: post_activity
 223     } do
 224       _like = CommonAPI.favorite(user, post_activity.id)
 225
 226       refute LikeValidator.cast_and_validate(valid_like).valid?
 227     end
 228
 229     test "it works when actor or object are wrapped in maps", %{valid_like: valid_like} do
 230       wrapped_like =
 231         valid_like
 232         |> Map.put("actor", %{"id" => valid_like["actor"]})
 233         |> Map.put("object", %{"id" => valid_like["object"]})
 234
 235       validated = LikeValidator.cast_and_validate(wrapped_like)
 236
 237       assert validated.valid?
 238
 239       assert {:actor, valid_like["actor"]} in validated.changes
 240       assert {:object, valid_like["object"]} in validated.changes
 241     end
 242   end
 243 end