git.squeep.com Git - akkoma/blob - test/web/activity_pub/mrf/simple_policy_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest do
   6   use Pleroma.DataCase
   7   import Pleroma.Factory
   8   alias Pleroma.Config
   9   alias Pleroma.Web.ActivityPub.MRF.SimplePolicy
  10
  11   setup do
  12     orig = Config.get!(:mrf_simple)
  13
  14     Config.put(:mrf_simple,
  15       media_removal: [],
  16       media_nsfw: [],
  17       federated_timeline_removal: [],
  18       report_removal: [],
  19       reject: [],
  20       accept: [],
  21       avatar_removal: [],
  22       banner_removal: []
  23     )
  24
  25     on_exit(fn ->
  26       Config.put(:mrf_simple, orig)
  27     end)
  28   end
  29
  30   describe "when :media_removal" do
  31     test "is empty" do
  32       Config.put([:mrf_simple, :media_removal], [])
  33       media_message = build_media_message()
  34       local_message = build_local_message()
  35
  36       assert SimplePolicy.filter(media_message) == {:ok, media_message}
  37       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  38     end
  39
  40     test "has a matching host" do
  41       Config.put([:mrf_simple, :media_removal], ["remote.instance"])
  42       media_message = build_media_message()
  43       local_message = build_local_message()
  44
  45       assert SimplePolicy.filter(media_message) ==
  46                {:ok,
  47                 media_message
  48                 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
  49
  50       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  51     end
  52   end
  53
  54   describe "when :media_nsfw" do
  55     test "is empty" do
  56       Config.put([:mrf_simple, :media_nsfw], [])
  57       media_message = build_media_message()
  58       local_message = build_local_message()
  59
  60       assert SimplePolicy.filter(media_message) == {:ok, media_message}
  61       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  62     end
  63
  64     test "has a matching host" do
  65       Config.put([:mrf_simple, :media_nsfw], ["remote.instance"])
  66       media_message = build_media_message()
  67       local_message = build_local_message()
  68
  69       assert SimplePolicy.filter(media_message) ==
  70                {:ok,
  71                 media_message
  72                 |> put_in(["object", "tag"], ["foo", "nsfw"])
  73                 |> put_in(["object", "sensitive"], true)}
  74
  75       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  76     end
  77   end
  78
  79   defp build_media_message do
  80     %{
  81       "actor" => "https://remote.instance/users/bob",
  82       "type" => "Create",
  83       "object" => %{
  84         "attachment" => [%{}],
  85         "tag" => ["foo"],
  86         "sensitive" => false
  87       }
  88     }
  89   end
  90
  91   describe "when :report_removal" do
  92     test "is empty" do
  93       Config.put([:mrf_simple, :report_removal], [])
  94       report_message = build_report_message()
  95       local_message = build_local_message()
  96
  97       assert SimplePolicy.filter(report_message) == {:ok, report_message}
  98       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  99     end
 100
 101     test "has a matching host" do
 102       Config.put([:mrf_simple, :report_removal], ["remote.instance"])
 103       report_message = build_report_message()
 104       local_message = build_local_message()
 105
 106       assert SimplePolicy.filter(report_message) == {:reject, nil}
 107       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 108     end
 109   end
 110
 111   defp build_report_message do
 112     %{
 113       "actor" => "https://remote.instance/users/bob",
 114       "type" => "Flag"
 115     }
 116   end
 117
 118   describe "when :federated_timeline_removal" do
 119     test "is empty" do
 120       Config.put([:mrf_simple, :federated_timeline_removal], [])
 121       {_, ftl_message} = build_ftl_actor_and_message()
 122       local_message = build_local_message()
 123
 124       assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
 125       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 126     end
 127
 128     test "has a matching host" do
 129       {actor, ftl_message} = build_ftl_actor_and_message()
 130
 131       ftl_message_actor_host =
 132         ftl_message
 133         |> Map.fetch!("actor")
 134         |> URI.parse()
 135         |> Map.fetch!(:host)
 136
 137       Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
 138       local_message = build_local_message()
 139
 140       assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
 141       assert actor.follower_address in ftl_message["to"]
 142       refute actor.follower_address in ftl_message["cc"]
 143       refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
 144       assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
 145
 146       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 147     end
 148
 149     test "has a matching host but only as:Public in to" do
 150       {_actor, ftl_message} = build_ftl_actor_and_message()
 151
 152       ftl_message_actor_host =
 153         ftl_message
 154         |> Map.fetch!("actor")
 155         |> URI.parse()
 156         |> Map.fetch!(:host)
 157
 158       ftl_message = Map.put(ftl_message, "cc", [])
 159
 160       Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
 161
 162       assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
 163       refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
 164       assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
 165     end
 166   end
 167
 168   defp build_ftl_actor_and_message do
 169     actor = insert(:user)
 170
 171     {actor,
 172      %{
 173        "actor" => actor.ap_id,
 174        "to" => ["https://www.w3.org/ns/activitystreams#Public", "http://foo.bar/baz"],
 175        "cc" => [actor.follower_address, "http://foo.bar/qux"]
 176      }}
 177   end
 178
 179   describe "when :reject" do
 180     test "is empty" do
 181       Config.put([:mrf_simple, :reject], [])
 182
 183       remote_message = build_remote_message()
 184
 185       assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
 186     end
 187
 188     test "has a matching host" do
 189       Config.put([:mrf_simple, :reject], ["remote.instance"])
 190
 191       remote_message = build_remote_message()
 192
 193       assert SimplePolicy.filter(remote_message) == {:reject, nil}
 194     end
 195   end
 196
 197   describe "when :accept" do
 198     test "is empty" do
 199       Config.put([:mrf_simple, :accept], [])
 200
 201       local_message = build_local_message()
 202       remote_message = build_remote_message()
 203
 204       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 205       assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
 206     end
 207
 208     test "is not empty but it doesn't have a matching host" do
 209       Config.put([:mrf_simple, :accept], ["non.matching.remote"])
 210
 211       local_message = build_local_message()
 212       remote_message = build_remote_message()
 213
 214       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 215       assert SimplePolicy.filter(remote_message) == {:reject, nil}
 216     end
 217
 218     test "has a matching host" do
 219       Config.put([:mrf_simple, :accept], ["remote.instance"])
 220
 221       local_message = build_local_message()
 222       remote_message = build_remote_message()
 223
 224       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 225       assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
 226     end
 227   end
 228
 229   describe "when :avatar_removal" do
 230     test "is empty" do
 231       Config.put([:mrf_simple, :avatar_removal], [])
 232
 233       remote_user = build_remote_user()
 234
 235       assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
 236     end
 237
 238     test "is not empty but it doesn't have a matching host" do
 239       Config.put([:mrf_simple, :avatar_removal], ["non.matching.remote"])
 240
 241       remote_user = build_remote_user()
 242
 243       assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
 244     end
 245
 246     test "has a matching host" do
 247       Config.put([:mrf_simple, :avatar_removal], ["remote.instance"])
 248
 249       remote_user = build_remote_user()
 250       {:ok, filtered} = SimplePolicy.filter(remote_user)
 251
 252       refute filtered["icon"]
 253     end
 254   end
 255
 256   describe "when :banner_removal" do
 257     test "is empty" do
 258       Config.put([:mrf_simple, :banner_removal], [])
 259
 260       remote_user = build_remote_user()
 261
 262       assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
 263     end
 264
 265     test "is not empty but it doesn't have a matching host" do
 266       Config.put([:mrf_simple, :banner_removal], ["non.matching.remote"])
 267
 268       remote_user = build_remote_user()
 269
 270       assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
 271     end
 272
 273     test "has a matching host" do
 274       Config.put([:mrf_simple, :banner_removal], ["remote.instance"])
 275
 276       remote_user = build_remote_user()
 277       {:ok, filtered} = SimplePolicy.filter(remote_user)
 278
 279       refute filtered["image"]
 280     end
 281   end
 282
 283   defp build_local_message do
 284     %{
 285       "actor" => "#{Pleroma.Web.base_url()}/users/alice",
 286       "to" => [],
 287       "cc" => []
 288     }
 289   end
 290
 291   defp build_remote_message do
 292     %{"actor" => "https://remote.instance/users/bob"}
 293   end
 294
 295   defp build_remote_user do
 296     %{
 297       "id" => "https://remote.instance/users/bob",
 298       "icon" => %{
 299         "url" => "http://example.com/image.jpg",
 300         "type" => "Image"
 301       },
 302       "image" => %{
 303         "url" => "http://example.com/image.jpg",
 304         "type" => "Image"
 305       },
 306       "type" => "Person"
 307     }
 308   end
 309 end