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.ActivityPub
   6   alias Pleroma.Web.ActivityPub.Builder
   7   alias Pleroma.Web.ActivityPub.ObjectValidator
   8   alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
   9   alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
  10   alias Pleroma.Web.ActivityPub.Utils
  11   alias Pleroma.Web.CommonAPI
  12
  13   import Pleroma.Factory
  14
  15   describe "attachments" do
  16     test "it turns mastodon attachments into our attachments" do
  17       attachment = %{
  18         "url" =>
  19           "http://mastodon.example.org/system/media_attachments/files/000/000/002/original/334ce029e7bfb920.jpg",
  20         "type" => "Document",
  21         "name" => nil,
  22         "mediaType" => "image/jpeg"
  23       }
  24
  25       {:ok, attachment} =
  26         AttachmentValidator.cast_and_validate(attachment)
  27         |> Ecto.Changeset.apply_action(:insert)
  28
  29       assert [
  30                %{
  31                  href:
  32                    "http://mastodon.example.org/system/media_attachments/files/000/000/002/original/334ce029e7bfb920.jpg",
  33                  type: "Link",
  34                  mediaType: "image/jpeg"
  35                }
  36              ] = attachment.url
  37     end
  38   end
  39
  40   describe "chat message create activities" do
  41     test "it is invalid if the object already exists" do
  42       user = insert(:user)
  43       recipient = insert(:user)
  44       {:ok, activity} = CommonAPI.post_chat_message(user, recipient, "hey")
  45       object = Object.normalize(activity, false)
  46
  47       {:ok, create_data, _} = Builder.create(user, object.data, [recipient.ap_id])
  48
  49       {:error, cng} = ObjectValidator.validate(create_data, [])
  50
  51       assert {:object, {"The object to create already exists", []}} in cng.errors
  52     end
  53
  54     test "it is invalid if the object data has a different `to` or `actor` field" do
  55       user = insert(:user)
  56       recipient = insert(:user)
  57       {:ok, object_data, _} = Builder.chat_message(recipient, user.ap_id, "Hey")
  58
  59       {:ok, create_data, _} = Builder.create(user, object_data, [recipient.ap_id])
  60
  61       {:error, cng} = ObjectValidator.validate(create_data, [])
  62
  63       assert {:to, {"Recipients don't match with object recipients", []}} in cng.errors
  64       assert {:actor, {"Actor doesn't match with object actor", []}} in cng.errors
  65     end
  66   end
  67
  68   describe "chat messages" do
  69     setup do
  70       clear_config([:instance, :remote_limit])
  71       user = insert(:user)
  72       recipient = insert(:user, local: false)
  73
  74       {:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey :firefox:")
  75
  76       %{user: user, recipient: recipient, valid_chat_message: valid_chat_message}
  77     end
  78
  79     test "validates for a basic object we build", %{valid_chat_message: valid_chat_message} do
  80       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
  81
  82       assert Map.put(valid_chat_message, "attachment", nil) == object
  83     end
  84
  85     test "validates for a basic object with an attachment", %{
  86       valid_chat_message: valid_chat_message,
  87       user: user
  88     } do
  89       file = %Plug.Upload{
  90         content_type: "image/jpg",
  91         path: Path.absname("test/fixtures/image.jpg"),
  92         filename: "an_image.jpg"
  93       }
  94
  95       {:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)
  96
  97       valid_chat_message =
  98         valid_chat_message
  99         |> Map.put("attachment", attachment.data)
 100
 101       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
 102
 103       assert object["attachment"]
 104     end
 105
 106     test "does not validate if the message is longer than the remote_limit", %{
 107       valid_chat_message: valid_chat_message
 108     } do
 109       Pleroma.Config.put([:instance, :remote_limit], 2)
 110       refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
 111     end
 112
 113     test "does not validate if the recipient is blocking the actor", %{
 114       valid_chat_message: valid_chat_message,
 115       user: user,
 116       recipient: recipient
 117     } do
 118       Pleroma.User.block(recipient, user)
 119       refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
 120     end
 121
 122     test "does not validate if the actor or the recipient is not in our system", %{
 123       valid_chat_message: valid_chat_message
 124     } do
 125       chat_message =
 126         valid_chat_message
 127         |> Map.put("actor", "https://raymoo.com/raymoo")
 128
 129       {:error, _} = ObjectValidator.validate(chat_message, [])
 130
 131       chat_message =
 132         valid_chat_message
 133         |> Map.put("to", ["https://raymoo.com/raymoo"])
 134
 135       {:error, _} = ObjectValidator.validate(chat_message, [])
 136     end
 137
 138     test "does not validate for a message with multiple recipients", %{
 139       valid_chat_message: valid_chat_message,
 140       user: user,
 141       recipient: recipient
 142     } do
 143       chat_message =
 144         valid_chat_message
 145         |> Map.put("to", [user.ap_id, recipient.ap_id])
 146
 147       assert {:error, _} = ObjectValidator.validate(chat_message, [])
 148     end
 149
 150     test "does not validate if it doesn't concern local users" do
 151       user = insert(:user, local: false)
 152       recipient = insert(:user, local: false)
 153
 154       {:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey")
 155       assert {:error, _} = ObjectValidator.validate(valid_chat_message, [])
 156     end
 157   end
 158
 159   describe "deletes" do
 160     setup do
 161       user = insert(:user)
 162       {:ok, post_activity} = CommonAPI.post(user, %{"status" => "cancel me daddy"})
 163
 164       {:ok, valid_post_delete, _} = Builder.delete(user, post_activity.data["object"])
 165       {:ok, valid_user_delete, _} = Builder.delete(user, user.ap_id)
 166
 167       %{user: user, valid_post_delete: valid_post_delete, valid_user_delete: valid_user_delete}
 168     end
 169
 170     test "it is valid for a post deletion", %{valid_post_delete: valid_post_delete} do
 171       {:ok, valid_post_delete, _} = ObjectValidator.validate(valid_post_delete, [])
 172
 173       assert valid_post_delete["deleted_activity_id"]
 174     end
 175
 176     test "it is invalid if the object isn't in a list of certain types", %{
 177       valid_post_delete: valid_post_delete
 178     } do
 179       object = Object.get_by_ap_id(valid_post_delete["object"])
 180
 181       data =
 182         object.data
 183         |> Map.put("type", "Like")
 184
 185       {:ok, _object} =
 186         object
 187         |> Ecto.Changeset.change(%{data: data})
 188         |> Object.update_and_set_cache()
 189
 190       {:error, cng} = ObjectValidator.validate(valid_post_delete, [])
 191       assert {:object, {"object not in allowed types", []}} in cng.errors
 192     end
 193
 194     test "it is valid for a user deletion", %{valid_user_delete: valid_user_delete} do
 195       assert match?({:ok, _, _}, ObjectValidator.validate(valid_user_delete, []))
 196     end
 197
 198     test "it's invalid if the id is missing", %{valid_post_delete: valid_post_delete} do
 199       no_id =
 200         valid_post_delete
 201         |> Map.delete("id")
 202
 203       {:error, cng} = ObjectValidator.validate(no_id, [])
 204
 205       assert {:id, {"can't be blank", [validation: :required]}} in cng.errors
 206     end
 207
 208     test "it's invalid if the object doesn't exist", %{valid_post_delete: valid_post_delete} do
 209       missing_object =
 210         valid_post_delete
 211         |> Map.put("object", "http://does.not/exist")
 212
 213       {:error, cng} = ObjectValidator.validate(missing_object, [])
 214
 215       assert {:object, {"can't find object", []}} in cng.errors
 216     end
 217
 218     test "it's invalid if the actor of the object and the actor of delete are from different domains",
 219          %{valid_post_delete: valid_post_delete} do
 220       valid_user = insert(:user)
 221
 222       valid_other_actor =
 223         valid_post_delete
 224         |> Map.put("actor", valid_user.ap_id)
 225
 226       assert match?({:ok, _, _}, ObjectValidator.validate(valid_other_actor, []))
 227
 228       invalid_other_actor =
 229         valid_post_delete
 230         |> Map.put("actor", "https://gensokyo.2hu/users/raymoo")
 231
 232       {:error, cng} = ObjectValidator.validate(invalid_other_actor, [])
 233
 234       assert {:actor, {"is not allowed to delete object", []}} in cng.errors
 235     end
 236
 237     test "it's valid if the actor of the object is a local superuser",
 238          %{valid_post_delete: valid_post_delete} do
 239       user =
 240         insert(:user, local: true, is_moderator: true, ap_id: "https://gensokyo.2hu/users/raymoo")
 241
 242       valid_other_actor =
 243         valid_post_delete
 244         |> Map.put("actor", user.ap_id)
 245
 246       {:ok, _, meta} = ObjectValidator.validate(valid_other_actor, [])
 247       assert meta[:do_not_federate]
 248     end
 249   end
 250
 251   describe "likes" do
 252     setup do
 253       user = insert(:user)
 254       {:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})
 255
 256       valid_like = %{
 257         "to" => [user.ap_id],
 258         "cc" => [],
 259         "type" => "Like",
 260         "id" => Utils.generate_activity_id(),
 261         "object" => post_activity.data["object"],
 262         "actor" => user.ap_id,
 263         "context" => "a context"
 264       }
 265
 266       %{valid_like: valid_like, user: user, post_activity: post_activity}
 267     end
 268
 269     test "returns ok when called in the ObjectValidator", %{valid_like: valid_like} do
 270       {:ok, object, _meta} = ObjectValidator.validate(valid_like, [])
 271
 272       assert "id" in Map.keys(object)
 273     end
 274
 275     test "is valid for a valid object", %{valid_like: valid_like} do
 276       assert LikeValidator.cast_and_validate(valid_like).valid?
 277     end
 278
 279     test "sets the 'to' field to the object actor if no recipients are given", %{
 280       valid_like: valid_like,
 281       user: user
 282     } do
 283       without_recipients =
 284         valid_like
 285         |> Map.delete("to")
 286
 287       {:ok, object, _meta} = ObjectValidator.validate(without_recipients, [])
 288
 289       assert object["to"] == [user.ap_id]
 290     end
 291
 292     test "sets the context field to the context of the object if no context is given", %{
 293       valid_like: valid_like,
 294       post_activity: post_activity
 295     } do
 296       without_context =
 297         valid_like
 298         |> Map.delete("context")
 299
 300       {:ok, object, _meta} = ObjectValidator.validate(without_context, [])
 301
 302       assert object["context"] == post_activity.data["context"]
 303     end
 304
 305     test "it errors when the actor is missing or not known", %{valid_like: valid_like} do
 306       without_actor = Map.delete(valid_like, "actor")
 307
 308       refute LikeValidator.cast_and_validate(without_actor).valid?
 309
 310       with_invalid_actor = Map.put(valid_like, "actor", "invalidactor")
 311
 312       refute LikeValidator.cast_and_validate(with_invalid_actor).valid?
 313     end
 314
 315     test "it errors when the object is missing or not known", %{valid_like: valid_like} do
 316       without_object = Map.delete(valid_like, "object")
 317
 318       refute LikeValidator.cast_and_validate(without_object).valid?
 319
 320       with_invalid_object = Map.put(valid_like, "object", "invalidobject")
 321
 322       refute LikeValidator.cast_and_validate(with_invalid_object).valid?
 323     end
 324
 325     test "it errors when the actor has already like the object", %{
 326       valid_like: valid_like,
 327       user: user,
 328       post_activity: post_activity
 329     } do
 330       _like = CommonAPI.favorite(user, post_activity.id)
 331
 332       refute LikeValidator.cast_and_validate(valid_like).valid?
 333     end
 334
 335     test "it works when actor or object are wrapped in maps", %{valid_like: valid_like} do
 336       wrapped_like =
 337         valid_like
 338         |> Map.put("actor", %{"id" => valid_like["actor"]})
 339         |> Map.put("object", %{"id" => valid_like["object"]})
 340
 341       validated = LikeValidator.cast_and_validate(wrapped_like)
 342
 343       assert validated.valid?
 344
 345       assert {:actor, valid_like["actor"]} in validated.changes
 346       assert {:object, valid_like["object"]} in validated.changes
 347     end
 348   end
 349 end