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     )
  22
  23     on_exit(fn ->
  24       Config.put(:mrf_simple, orig)
  25     end)
  26   end
  27
  28   describe "when :media_removal" do
  29     test "is empty" do
  30       Config.put([:mrf_simple, :media_removal], [])
  31       media_message = build_media_message()
  32       local_message = build_local_message()
  33
  34       assert SimplePolicy.filter(media_message) == {:ok, media_message}
  35       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  36     end
  37
  38     test "has a matching host" do
  39       Config.put([:mrf_simple, :media_removal], ["remote.instance"])
  40       media_message = build_media_message()
  41       local_message = build_local_message()
  42
  43       assert SimplePolicy.filter(media_message) ==
  44                {:ok,
  45                 media_message
  46                 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
  47
  48       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  49     end
  50   end
  51
  52   describe "when :media_nsfw" do
  53     test "is empty" do
  54       Config.put([:mrf_simple, :media_nsfw], [])
  55       media_message = build_media_message()
  56       local_message = build_local_message()
  57
  58       assert SimplePolicy.filter(media_message) == {:ok, media_message}
  59       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  60     end
  61
  62     test "has a matching host" do
  63       Config.put([:mrf_simple, :media_nsfw], ["remote.instance"])
  64       media_message = build_media_message()
  65       local_message = build_local_message()
  66
  67       assert SimplePolicy.filter(media_message) ==
  68                {:ok,
  69                 media_message
  70                 |> put_in(["object", "tag"], ["foo", "nsfw"])
  71                 |> put_in(["object", "sensitive"], true)}
  72
  73       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  74     end
  75   end
  76
  77   defp build_media_message do
  78     %{
  79       "actor" => "https://remote.instance/users/bob",
  80       "type" => "Create",
  81       "object" => %{
  82         "attachment" => [%{}],
  83         "tag" => ["foo"],
  84         "sensitive" => false
  85       }
  86     }
  87   end
  88
  89   describe "when :report_removal" do
  90     test "is empty" do
  91       Config.put([:mrf_simple, :report_removal], [])
  92       report_message = build_report_message()
  93       local_message = build_local_message()
  94
  95       assert SimplePolicy.filter(report_message) == {:ok, report_message}
  96       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  97     end
  98
  99     test "has a matching host" do
 100       Config.put([:mrf_simple, :report_removal], ["remote.instance"])
 101       report_message = build_report_message()
 102       local_message = build_local_message()
 103
 104       assert SimplePolicy.filter(report_message) == {:reject, nil}
 105       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 106     end
 107   end
 108
 109   defp build_report_message do
 110     %{
 111       "actor" => "https://remote.instance/users/bob",
 112       "type" => "Flag"
 113     }
 114   end
 115
 116   describe "when :federated_timeline_removal" do
 117     test "is empty" do
 118       Config.put([:mrf_simple, :federated_timeline_removal], [])
 119       {_, ftl_message} = build_ftl_actor_and_message()
 120       local_message = build_local_message()
 121
 122       assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
 123       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 124     end
 125
 126     test "has a matching host" do
 127       {actor, ftl_message} = build_ftl_actor_and_message()
 128
 129       ftl_message_actor_host =
 130         ftl_message
 131         |> Map.fetch!("actor")
 132         |> URI.parse()
 133         |> Map.fetch!(:host)
 134
 135       Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
 136       local_message = build_local_message()
 137
 138       assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
 139       assert actor.follower_address in ftl_message["to"]
 140       refute actor.follower_address in ftl_message["cc"]
 141       refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
 142       assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
 143
 144       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 145     end
 146   end
 147
 148   defp build_ftl_actor_and_message do
 149     actor = insert(:user)
 150
 151     {actor,
 152      %{
 153        "actor" => actor.ap_id,
 154        "to" => ["https://www.w3.org/ns/activitystreams#Public", "http://foo.bar/baz"],
 155        "cc" => [actor.follower_address, "http://foo.bar/qux"]
 156      }}
 157   end
 158
 159   describe "when :reject" do
 160     test "is empty" do
 161       Config.put([:mrf_simple, :reject], [])
 162
 163       remote_message = build_remote_message()
 164
 165       assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
 166     end
 167
 168     test "has a matching host" do
 169       Config.put([:mrf_simple, :reject], ["remote.instance"])
 170
 171       remote_message = build_remote_message()
 172
 173       assert SimplePolicy.filter(remote_message) == {:reject, nil}
 174     end
 175   end
 176
 177   describe "when :accept" do
 178     test "is empty" do
 179       Config.put([:mrf_simple, :accept], [])
 180
 181       local_message = build_local_message()
 182       remote_message = build_remote_message()
 183
 184       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 185       assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
 186     end
 187
 188     test "is not empty but it doesn't have a matching host" do
 189       Config.put([:mrf_simple, :accept], ["non.matching.remote"])
 190
 191       local_message = build_local_message()
 192       remote_message = build_remote_message()
 193
 194       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 195       assert SimplePolicy.filter(remote_message) == {:reject, nil}
 196     end
 197
 198     test "has a matching host" do
 199       Config.put([:mrf_simple, :accept], ["remote.instance"])
 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   end
 208
 209   defp build_local_message do
 210     %{
 211       "actor" => "#{Pleroma.Web.base_url()}/users/alice",
 212       "to" => [],
 213       "cc" => []
 214     }
 215   end
 216
 217   defp build_remote_message do
 218     %{"actor" => "https://remote.instance/users/bob"}
 219   end
 220 end