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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.ObjectValidators.ChatValidationTest do
   6   use Pleroma.DataCase
   7   alias Pleroma.Object
   8   alias Pleroma.Web.ActivityPub.ActivityPub
   9   alias Pleroma.Web.ActivityPub.Builder
  10   alias Pleroma.Web.ActivityPub.ObjectValidator
  11   alias Pleroma.Web.CommonAPI
  12
  13   import Pleroma.Factory
  14
  15   describe "chat message create activities" do
  16     test "it is invalid if the object already exists" do
  17       user = insert(:user)
  18       recipient = insert(:user)
  19       {:ok, activity} = CommonAPI.post_chat_message(user, recipient, "hey")
  20       object = Object.normalize(activity, false)
  21
  22       {:ok, create_data, _} = Builder.create(user, object.data, [recipient.ap_id])
  23
  24       {:error, cng} = ObjectValidator.validate(create_data, [])
  25
  26       assert {:object, {"The object to create already exists", []}} in cng.errors
  27     end
  28
  29     test "it is invalid if the object data has a different `to` or `actor` field" do
  30       user = insert(:user)
  31       recipient = insert(:user)
  32       {:ok, object_data, _} = Builder.chat_message(recipient, user.ap_id, "Hey")
  33
  34       {:ok, create_data, _} = Builder.create(user, object_data, [recipient.ap_id])
  35
  36       {:error, cng} = ObjectValidator.validate(create_data, [])
  37
  38       assert {:to, {"Recipients don't match with object recipients", []}} in cng.errors
  39       assert {:actor, {"Actor doesn't match with object actor", []}} in cng.errors
  40     end
  41   end
  42
  43   describe "chat messages" do
  44     setup do
  45       clear_config([:instance, :remote_limit])
  46       user = insert(:user)
  47       recipient = insert(:user, local: false)
  48
  49       {:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey :firefox:")
  50
  51       %{user: user, recipient: recipient, valid_chat_message: valid_chat_message}
  52     end
  53
  54     test "let's through some basic html", %{user: user, recipient: recipient} do
  55       {:ok, valid_chat_message, _} =
  56         Builder.chat_message(
  57           user,
  58           recipient.ap_id,
  59           "hey <a href='https://example.org'>example</a> <script>alert('uguu')</script>"
  60         )
  61
  62       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
  63
  64       assert object["content"] ==
  65                "hey <a href=\"https://example.org\">example</a> alert(&#39;uguu&#39;)"
  66     end
  67
  68     test "validates for a basic object we build", %{valid_chat_message: valid_chat_message} do
  69       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
  70
  71       assert Map.put(valid_chat_message, "attachment", nil) == object
  72     end
  73
  74     test "validates for a basic object with an attachment", %{
  75       valid_chat_message: valid_chat_message,
  76       user: user
  77     } do
  78       file = %Plug.Upload{
  79         content_type: "image/jpg",
  80         path: Path.absname("test/fixtures/image.jpg"),
  81         filename: "an_image.jpg"
  82       }
  83
  84       {:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)
  85
  86       valid_chat_message =
  87         valid_chat_message
  88         |> Map.put("attachment", attachment.data)
  89
  90       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
  91
  92       assert object["attachment"]
  93     end
  94
  95     test "validates for a basic object with an attachment in an array", %{
  96       valid_chat_message: valid_chat_message,
  97       user: user
  98     } do
  99       file = %Plug.Upload{
 100         content_type: "image/jpg",
 101         path: Path.absname("test/fixtures/image.jpg"),
 102         filename: "an_image.jpg"
 103       }
 104
 105       {:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)
 106
 107       valid_chat_message =
 108         valid_chat_message
 109         |> Map.put("attachment", [attachment.data])
 110
 111       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
 112
 113       assert object["attachment"]
 114     end
 115
 116     test "validates for a basic object with an attachment but without content", %{
 117       valid_chat_message: valid_chat_message,
 118       user: user
 119     } do
 120       file = %Plug.Upload{
 121         content_type: "image/jpg",
 122         path: Path.absname("test/fixtures/image.jpg"),
 123         filename: "an_image.jpg"
 124       }
 125
 126       {:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)
 127
 128       valid_chat_message =
 129         valid_chat_message
 130         |> Map.put("attachment", attachment.data)
 131         |> Map.delete("content")
 132
 133       assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])
 134
 135       assert object["attachment"]
 136     end
 137
 138     test "does not validate if the message has no content", %{
 139       valid_chat_message: valid_chat_message
 140     } do
 141       contentless =
 142         valid_chat_message
 143         |> Map.delete("content")
 144
 145       refute match?({:ok, _object, _meta}, ObjectValidator.validate(contentless, []))
 146     end
 147
 148     test "does not validate if the message is longer than the remote_limit", %{
 149       valid_chat_message: valid_chat_message
 150     } do
 151       Pleroma.Config.put([:instance, :remote_limit], 2)
 152       refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
 153     end
 154
 155     test "does not validate if the recipient is blocking the actor", %{
 156       valid_chat_message: valid_chat_message,
 157       user: user,
 158       recipient: recipient
 159     } do
 160       Pleroma.User.block(recipient, user)
 161       refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
 162     end
 163
 164     test "does not validate if the actor or the recipient is not in our system", %{
 165       valid_chat_message: valid_chat_message
 166     } do
 167       chat_message =
 168         valid_chat_message
 169         |> Map.put("actor", "https://raymoo.com/raymoo")
 170
 171       {:error, _} = ObjectValidator.validate(chat_message, [])
 172
 173       chat_message =
 174         valid_chat_message
 175         |> Map.put("to", ["https://raymoo.com/raymoo"])
 176
 177       {:error, _} = ObjectValidator.validate(chat_message, [])
 178     end
 179
 180     test "does not validate for a message with multiple recipients", %{
 181       valid_chat_message: valid_chat_message,
 182       user: user,
 183       recipient: recipient
 184     } do
 185       chat_message =
 186         valid_chat_message
 187         |> Map.put("to", [user.ap_id, recipient.ap_id])
 188
 189       assert {:error, _} = ObjectValidator.validate(chat_message, [])
 190     end
 191
 192     test "does not validate if it doesn't concern local users" do
 193       user = insert(:user, local: false)
 194       recipient = insert(:user, local: false)
 195
 196       {:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey")
 197       assert {:error, _} = ObjectValidator.validate(valid_chat_message, [])
 198     end
 199   end
 200 end