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.LikeValidator
   9   alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
  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 "likes" do
 160     setup do
 161       user = insert(:user)
 162       {:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})
 163
 164       valid_like = %{
 165         "to" => [user.ap_id],
 166         "cc" => [],
 167         "type" => "Like",
 168         "id" => Utils.generate_activity_id(),
 169         "object" => post_activity.data["object"],
 170         "actor" => user.ap_id,
 171         "context" => "a context"
 172       }
 173
 174       %{valid_like: valid_like, user: user, post_activity: post_activity}
 175     end
 176
 177     test "returns ok when called in the ObjectValidator", %{valid_like: valid_like} do
 178       {:ok, object, _meta} = ObjectValidator.validate(valid_like, [])
 179
 180       assert "id" in Map.keys(object)
 181     end
 182
 183     test "is valid for a valid object", %{valid_like: valid_like} do
 184       assert LikeValidator.cast_and_validate(valid_like).valid?
 185     end
 186
 187     test "sets the 'to' field to the object actor if no recipients are given", %{
 188       valid_like: valid_like,
 189       user: user
 190     } do
 191       without_recipients =
 192         valid_like
 193         |> Map.delete("to")
 194
 195       {:ok, object, _meta} = ObjectValidator.validate(without_recipients, [])
 196
 197       assert object["to"] == [user.ap_id]
 198     end
 199
 200     test "sets the context field to the context of the object if no context is given", %{
 201       valid_like: valid_like,
 202       post_activity: post_activity
 203     } do
 204       without_context =
 205         valid_like
 206         |> Map.delete("context")
 207
 208       {:ok, object, _meta} = ObjectValidator.validate(without_context, [])
 209
 210       assert object["context"] == post_activity.data["context"]
 211     end
 212
 213     test "it errors when the actor is missing or not known", %{valid_like: valid_like} do
 214       without_actor = Map.delete(valid_like, "actor")
 215
 216       refute LikeValidator.cast_and_validate(without_actor).valid?
 217
 218       with_invalid_actor = Map.put(valid_like, "actor", "invalidactor")
 219
 220       refute LikeValidator.cast_and_validate(with_invalid_actor).valid?
 221     end
 222
 223     test "it errors when the object is missing or not known", %{valid_like: valid_like} do
 224       without_object = Map.delete(valid_like, "object")
 225
 226       refute LikeValidator.cast_and_validate(without_object).valid?
 227
 228       with_invalid_object = Map.put(valid_like, "object", "invalidobject")
 229
 230       refute LikeValidator.cast_and_validate(with_invalid_object).valid?
 231     end
 232
 233     test "it errors when the actor has already like the object", %{
 234       valid_like: valid_like,
 235       user: user,
 236       post_activity: post_activity
 237     } do
 238       _like = CommonAPI.favorite(user, post_activity.id)
 239
 240       refute LikeValidator.cast_and_validate(valid_like).valid?
 241     end
 242
 243     test "it works when actor or object are wrapped in maps", %{valid_like: valid_like} do
 244       wrapped_like =
 245         valid_like
 246         |> Map.put("actor", %{"id" => valid_like["actor"]})
 247         |> Map.put("object", %{"id" => valid_like["object"]})
 248
 249       validated = LikeValidator.cast_and_validate(wrapped_like)
 250
 251       assert validated.valid?
 252
 253       assert {:actor, valid_like["actor"]} in validated.changes
 254       assert {:object, valid_like["object"]} in validated.changes
 255     end
 256   end
 257 end