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