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 "works with honkerific attachments" do
  17       attachment = %{
  18         "mediaType" => "image/jpeg",
  19         "name" => "298p3RG7j27tfsZ9RQ.jpg",
  20         "summary" => "298p3RG7j27tfsZ9RQ.jpg",
  21         "type" => "Document",
  22         "url" => "https://honk.tedunangst.com/d/298p3RG7j27tfsZ9RQ.jpg"
  23       }
  24
  25       assert {:ok, attachment} =
  26                AttachmentValidator.cast_and_validate(attachment)
  27                |> Ecto.Changeset.apply_action(:insert)
  28     end
  29
  30     test "it turns mastodon attachments into our attachments" do
  31       attachment = %{
  32         "url" =>
  33           "http://mastodon.example.org/system/media_attachments/files/000/000/002/original/334ce029e7bfb920.jpg",
  34         "type" => "Document",
  35         "name" => nil,
  36         "mediaType" => "image/jpeg"
  37       }
  38
  39       {:ok, attachment} =
  40         AttachmentValidator.cast_and_validate(attachment)
  41         |> Ecto.Changeset.apply_action(:insert)
  42
  43       assert [
  44                %{
  45                  href:
  46                    "http://mastodon.example.org/system/media_attachments/files/000/000/002/original/334ce029e7bfb920.jpg",
  47                  type: "Link",
  48                  mediaType: "image/jpeg"
  49                }
  50              ] = attachment.url
  51     end
  52   end
  53
  54   describe "chat message create activities" do
  55     test "it is invalid if the object already exists" do
  56       user = insert(:user)
  57       recipient = insert(:user)
  58       {:ok, activity} = CommonAPI.post_chat_message(user, recipient, "hey")
  59       object = Object.normalize(activity, false)
  60
  61       {:ok, create_data, _} = Builder.create(user, object.data, [recipient.ap_id])
  62
  63       {:error, cng} = ObjectValidator.validate(create_data, [])
  64
  65       assert {:object, {"The object to create already exists", []}} in cng.errors
  66     end
  67
  68     test "it is invalid if the object data has a different `to` or `actor` field" do
  69       user = insert(:user)
  70       recipient = insert(:user)
  71       {:ok, object_data, _} = Builder.chat_message(recipient, user.ap_id, "Hey")
  72
  73       {:ok, create_data, _} = Builder.create(user, object_data, [recipient.ap_id])
  74
  75       {:error, cng} = ObjectValidator.validate(create_data, [])
  76
  77       assert {:to, {"Recipients don't match with object recipients", []}} in cng.errors
  78       assert {:actor, {"Actor doesn't match with object actor", []}} in cng.errors
  79     end
  80   end
  81
  82   describe "chat messages" do
  83     setup do
  84       clear_config([:instance, :remote_limit])
  85       user = insert(:user)
  86       recipient = insert(:user, local: false)
  87
  88       {:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey :firefox:")
  89
  90       %{user: user, recipient: recipient, valid_chat_message: valid_chat_message}
  91     end
  92
  93     test "validates for a basic object we build", %{valid_chat_message: valid_chat_message} do
  94       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
  95
  96       assert Map.put(valid_chat_message, "attachment", nil) == object
  97     end
  98
  99     test "validates for a basic object with an attachment", %{
 100       valid_chat_message: valid_chat_message,
 101       user: user
 102     } do
 103       file = %Plug.Upload{
 104         content_type: "image/jpg",
 105         path: Path.absname("test/fixtures/image.jpg"),
 106         filename: "an_image.jpg"
 107       }
 108
 109       {:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)
 110
 111       valid_chat_message =
 112         valid_chat_message
 113         |> Map.put("attachment", attachment.data)
 114
 115       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
 116
 117       assert object["attachment"]
 118     end
 119
 120     test "validates for a basic object with an attachment in an array", %{
 121       valid_chat_message: valid_chat_message,
 122       user: user
 123     } do
 124       file = %Plug.Upload{
 125         content_type: "image/jpg",
 126         path: Path.absname("test/fixtures/image.jpg"),
 127         filename: "an_image.jpg"
 128       }
 129
 130       {:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)
 131
 132       valid_chat_message =
 133         valid_chat_message
 134         |> Map.put("attachment", [attachment.data])
 135
 136       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
 137
 138       assert object["attachment"]
 139     end
 140
 141     test "validates for a basic object with an attachment but without content", %{
 142       valid_chat_message: valid_chat_message,
 143       user: user
 144     } do
 145       file = %Plug.Upload{
 146         content_type: "image/jpg",
 147         path: Path.absname("test/fixtures/image.jpg"),
 148         filename: "an_image.jpg"
 149       }
 150
 151       {:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)
 152
 153       valid_chat_message =
 154         valid_chat_message
 155         |> Map.put("attachment", attachment.data)
 156         |> Map.delete("content")
 157
 158       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
 159
 160       assert object["attachment"]
 161     end
 162
 163     test "does not validate if the message has no content", %{
 164       valid_chat_message: valid_chat_message
 165     } do
 166       contentless =
 167         valid_chat_message
 168         |> Map.delete("content")
 169
 170       refute match?({:ok, _object, _meta}, ObjectValidator.validate(contentless, []))
 171     end
 172
 173     test "does not validate if the message is longer than the remote_limit", %{
 174       valid_chat_message: valid_chat_message
 175     } do
 176       Pleroma.Config.put([:instance, :remote_limit], 2)
 177       refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
 178     end
 179
 180     test "does not validate if the recipient is blocking the actor", %{
 181       valid_chat_message: valid_chat_message,
 182       user: user,
 183       recipient: recipient
 184     } do
 185       Pleroma.User.block(recipient, user)
 186       refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
 187     end
 188
 189     test "does not validate if the actor or the recipient is not in our system", %{
 190       valid_chat_message: valid_chat_message
 191     } do
 192       chat_message =
 193         valid_chat_message
 194         |> Map.put("actor", "https://raymoo.com/raymoo")
 195
 196       {:error, _} = ObjectValidator.validate(chat_message, [])
 197
 198       chat_message =
 199         valid_chat_message
 200         |> Map.put("to", ["https://raymoo.com/raymoo"])
 201
 202       {:error, _} = ObjectValidator.validate(chat_message, [])
 203     end
 204
 205     test "does not validate for a message with multiple recipients", %{
 206       valid_chat_message: valid_chat_message,
 207       user: user,
 208       recipient: recipient
 209     } do
 210       chat_message =
 211         valid_chat_message
 212         |> Map.put("to", [user.ap_id, recipient.ap_id])
 213
 214       assert {:error, _} = ObjectValidator.validate(chat_message, [])
 215     end
 216
 217     test "does not validate if it doesn't concern local users" do
 218       user = insert(:user, local: false)
 219       recipient = insert(:user, local: false)
 220
 221       {:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey")
 222       assert {:error, _} = ObjectValidator.validate(valid_chat_message, [])
 223     end
 224   end
 225
 226   describe "EmojiReacts" do
 227     setup do
 228       user = insert(:user)
 229       {:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
 230
 231       object = Pleroma.Object.get_by_ap_id(post_activity.data["object"])
 232
 233       {:ok, valid_emoji_react, []} = Builder.emoji_react(user, object, "👌")
 234
 235       %{user: user, post_activity: post_activity, valid_emoji_react: valid_emoji_react}
 236     end
 237
 238     test "it validates a valid EmojiReact", %{valid_emoji_react: valid_emoji_react} do
 239       assert {:ok, _, _} = ObjectValidator.validate(valid_emoji_react, [])
 240     end
 241
 242     test "it is not valid without a 'content' field", %{valid_emoji_react: valid_emoji_react} do
 243       without_content =
 244         valid_emoji_react
 245         |> Map.delete("content")
 246
 247       {:error, cng} = ObjectValidator.validate(without_content, [])
 248
 249       refute cng.valid?
 250       assert {:content, {"can't be blank", [validation: :required]}} in cng.errors
 251     end
 252
 253     test "it is not valid with a non-emoji content field", %{valid_emoji_react: valid_emoji_react} do
 254       without_emoji_content =
 255         valid_emoji_react
 256         |> Map.put("content", "x")
 257
 258       {:error, cng} = ObjectValidator.validate(without_emoji_content, [])
 259
 260       refute cng.valid?
 261
 262       assert {:content, {"must be a single character emoji", []}} in cng.errors
 263     end
 264   end
 265
 266   describe "Undos" do
 267     setup do
 268       user = insert(:user)
 269       {:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
 270       {:ok, like} = CommonAPI.favorite(user, post_activity.id)
 271       {:ok, valid_like_undo, []} = Builder.undo(user, like)
 272
 273       %{user: user, like: like, valid_like_undo: valid_like_undo}
 274     end
 275
 276     test "it validates a basic like undo", %{valid_like_undo: valid_like_undo} do
 277       assert {:ok, _, _} = ObjectValidator.validate(valid_like_undo, [])
 278     end
 279
 280     test "it does not validate if the actor of the undo is not the actor of the object", %{
 281       valid_like_undo: valid_like_undo
 282     } do
 283       other_user = insert(:user, ap_id: "https://gensokyo.2hu/users/raymoo")
 284
 285       bad_actor =
 286         valid_like_undo
 287         |> Map.put("actor", other_user.ap_id)
 288
 289       {:error, cng} = ObjectValidator.validate(bad_actor, [])
 290
 291       assert {:actor, {"not the same as object actor", []}} in cng.errors
 292     end
 293
 294     test "it does not validate if the object is missing", %{valid_like_undo: valid_like_undo} do
 295       missing_object =
 296         valid_like_undo
 297         |> Map.put("object", "https://gensokyo.2hu/objects/1")
 298
 299       {:error, cng} = ObjectValidator.validate(missing_object, [])
 300
 301       assert {:object, {"can't find object", []}} in cng.errors
 302       assert length(cng.errors) == 1
 303     end
 304   end
 305
 306   describe "deletes" do
 307     setup do
 308       user = insert(:user)
 309       {:ok, post_activity} = CommonAPI.post(user, %{status: "cancel me daddy"})
 310
 311       {:ok, valid_post_delete, _} = Builder.delete(user, post_activity.data["object"])
 312       {:ok, valid_user_delete, _} = Builder.delete(user, user.ap_id)
 313
 314       %{user: user, valid_post_delete: valid_post_delete, valid_user_delete: valid_user_delete}
 315     end
 316
 317     test "it is valid for a post deletion", %{valid_post_delete: valid_post_delete} do
 318       {:ok, valid_post_delete, _} = ObjectValidator.validate(valid_post_delete, [])
 319
 320       assert valid_post_delete["deleted_activity_id"]
 321     end
 322
 323     test "it is invalid if the object isn't in a list of certain types", %{
 324       valid_post_delete: valid_post_delete
 325     } do
 326       object = Object.get_by_ap_id(valid_post_delete["object"])
 327
 328       data =
 329         object.data
 330         |> Map.put("type", "Like")
 331
 332       {:ok, _object} =
 333         object
 334         |> Ecto.Changeset.change(%{data: data})
 335         |> Object.update_and_set_cache()
 336
 337       {:error, cng} = ObjectValidator.validate(valid_post_delete, [])
 338       assert {:object, {"object not in allowed types", []}} in cng.errors
 339     end
 340
 341     test "it is valid for a user deletion", %{valid_user_delete: valid_user_delete} do
 342       assert match?({:ok, _, _}, ObjectValidator.validate(valid_user_delete, []))
 343     end
 344
 345     test "it's invalid if the id is missing", %{valid_post_delete: valid_post_delete} do
 346       no_id =
 347         valid_post_delete
 348         |> Map.delete("id")
 349
 350       {:error, cng} = ObjectValidator.validate(no_id, [])
 351
 352       assert {:id, {"can't be blank", [validation: :required]}} in cng.errors
 353     end
 354
 355     test "it's invalid if the object doesn't exist", %{valid_post_delete: valid_post_delete} do
 356       missing_object =
 357         valid_post_delete
 358         |> Map.put("object", "http://does.not/exist")
 359
 360       {:error, cng} = ObjectValidator.validate(missing_object, [])
 361
 362       assert {:object, {"can't find object", []}} in cng.errors
 363     end
 364
 365     test "it's invalid if the actor of the object and the actor of delete are from different domains",
 366          %{valid_post_delete: valid_post_delete} do
 367       valid_user = insert(:user)
 368
 369       valid_other_actor =
 370         valid_post_delete
 371         |> Map.put("actor", valid_user.ap_id)
 372
 373       assert match?({:ok, _, _}, ObjectValidator.validate(valid_other_actor, []))
 374
 375       invalid_other_actor =
 376         valid_post_delete
 377         |> Map.put("actor", "https://gensokyo.2hu/users/raymoo")
 378
 379       {:error, cng} = ObjectValidator.validate(invalid_other_actor, [])
 380
 381       assert {:actor, {"is not allowed to delete object", []}} in cng.errors
 382     end
 383
 384     test "it's valid if the actor of the object is a local superuser",
 385          %{valid_post_delete: valid_post_delete} do
 386       user =
 387         insert(:user, local: true, is_moderator: true, ap_id: "https://gensokyo.2hu/users/raymoo")
 388
 389       valid_other_actor =
 390         valid_post_delete
 391         |> Map.put("actor", user.ap_id)
 392
 393       {:ok, _, meta} = ObjectValidator.validate(valid_other_actor, [])
 394       assert meta[:do_not_federate]
 395     end
 396   end
 397
 398   describe "likes" do
 399     setup do
 400       user = insert(:user)
 401       {:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
 402
 403       valid_like = %{
 404         "to" => [user.ap_id],
 405         "cc" => [],
 406         "type" => "Like",
 407         "id" => Utils.generate_activity_id(),
 408         "object" => post_activity.data["object"],
 409         "actor" => user.ap_id,
 410         "context" => "a context"
 411       }
 412
 413       %{valid_like: valid_like, user: user, post_activity: post_activity}
 414     end
 415
 416     test "returns ok when called in the ObjectValidator", %{valid_like: valid_like} do
 417       {:ok, object, _meta} = ObjectValidator.validate(valid_like, [])
 418
 419       assert "id" in Map.keys(object)
 420     end
 421
 422     test "is valid for a valid object", %{valid_like: valid_like} do
 423       assert LikeValidator.cast_and_validate(valid_like).valid?
 424     end
 425
 426     test "sets the 'to' field to the object actor if no recipients are given", %{
 427       valid_like: valid_like,
 428       user: user
 429     } do
 430       without_recipients =
 431         valid_like
 432         |> Map.delete("to")
 433
 434       {:ok, object, _meta} = ObjectValidator.validate(without_recipients, [])
 435
 436       assert object["to"] == [user.ap_id]
 437     end
 438
 439     test "sets the context field to the context of the object if no context is given", %{
 440       valid_like: valid_like,
 441       post_activity: post_activity
 442     } do
 443       without_context =
 444         valid_like
 445         |> Map.delete("context")
 446
 447       {:ok, object, _meta} = ObjectValidator.validate(without_context, [])
 448
 449       assert object["context"] == post_activity.data["context"]
 450     end
 451
 452     test "it errors when the actor is missing or not known", %{valid_like: valid_like} do
 453       without_actor = Map.delete(valid_like, "actor")
 454
 455       refute LikeValidator.cast_and_validate(without_actor).valid?
 456
 457       with_invalid_actor = Map.put(valid_like, "actor", "invalidactor")
 458
 459       refute LikeValidator.cast_and_validate(with_invalid_actor).valid?
 460     end
 461
 462     test "it errors when the object is missing or not known", %{valid_like: valid_like} do
 463       without_object = Map.delete(valid_like, "object")
 464
 465       refute LikeValidator.cast_and_validate(without_object).valid?
 466
 467       with_invalid_object = Map.put(valid_like, "object", "invalidobject")
 468
 469       refute LikeValidator.cast_and_validate(with_invalid_object).valid?
 470     end
 471
 472     test "it errors when the actor has already like the object", %{
 473       valid_like: valid_like,
 474       user: user,
 475       post_activity: post_activity
 476     } do
 477       _like = CommonAPI.favorite(user, post_activity.id)
 478
 479       refute LikeValidator.cast_and_validate(valid_like).valid?
 480     end
 481
 482     test "it works when actor or object are wrapped in maps", %{valid_like: valid_like} do
 483       wrapped_like =
 484         valid_like
 485         |> Map.put("actor", %{"id" => valid_like["actor"]})
 486         |> Map.put("object", %{"id" => valid_like["object"]})
 487
 488       validated = LikeValidator.cast_and_validate(wrapped_like)
 489
 490       assert validated.valid?
 491
 492       assert {:actor, valid_like["actor"]} in validated.changes
 493       assert {:object, valid_like["object"]} in validated.changes
 494     end
 495   end
 496 end