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 recipient is not accepting chat messages", %{
 165       valid_chat_message: valid_chat_message,
 166       recipient: recipient
 167     } do
 168       recipient
 169       |> Ecto.Changeset.change(%{accepts_chat_messages: false})
 170       |> Pleroma.Repo.update!()
 171
 172       refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
 173     end
 174
 175     test "does not validate if the actor or the recipient is not in our system", %{
 176       valid_chat_message: valid_chat_message
 177     } do
 178       chat_message =
 179         valid_chat_message
 180         |> Map.put("actor", "https://raymoo.com/raymoo")
 181
 182       {:error, _} = ObjectValidator.validate(chat_message, [])
 183
 184       chat_message =
 185         valid_chat_message
 186         |> Map.put("to", ["https://raymoo.com/raymoo"])
 187
 188       {:error, _} = ObjectValidator.validate(chat_message, [])
 189     end
 190
 191     test "does not validate for a message with multiple recipients", %{
 192       valid_chat_message: valid_chat_message,
 193       user: user,
 194       recipient: recipient
 195     } do
 196       chat_message =
 197         valid_chat_message
 198         |> Map.put("to", [user.ap_id, recipient.ap_id])
 199
 200       assert {:error, _} = ObjectValidator.validate(chat_message, [])
 201     end
 202
 203     test "does not validate if it doesn't concern local users" do
 204       user = insert(:user, local: false)
 205       recipient = insert(:user, local: false)
 206
 207       {:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey")
 208       assert {:error, _} = ObjectValidator.validate(valid_chat_message, [])
 209     end
 210   end
 211 end