1 # Pleroma: A lightweight social networking server
2 # Copyright © 2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest do
9 alias Pleroma.Web.ActivityPub.MRF.SimplePolicy
12 orig = Config.get!(:mrf_simple)
14 Config.put(:mrf_simple,
17 federated_timeline_removal: [],
26 Config.put(:mrf_simple, orig)
30 describe "when :media_removal" do
32 Config.put([:mrf_simple, :media_removal], [])
33 media_message = build_media_message()
34 local_message = build_local_message()
36 assert SimplePolicy.filter(media_message) == {:ok, media_message}
37 assert SimplePolicy.filter(local_message) == {:ok, local_message}
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()
45 assert SimplePolicy.filter(media_message) ==
48 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
50 assert SimplePolicy.filter(local_message) == {:ok, local_message}
53 test "match with wildcard domain" do
54 Config.put([:mrf_simple, :media_removal], ["*.remote.instance"])
55 media_message = build_media_message()
56 local_message = build_local_message()
58 assert SimplePolicy.filter(media_message) ==
61 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
63 assert SimplePolicy.filter(local_message) == {:ok, local_message}
67 describe "when :media_nsfw" do
69 Config.put([:mrf_simple, :media_nsfw], [])
70 media_message = build_media_message()
71 local_message = build_local_message()
73 assert SimplePolicy.filter(media_message) == {:ok, media_message}
74 assert SimplePolicy.filter(local_message) == {:ok, local_message}
77 test "has a matching host" do
78 Config.put([:mrf_simple, :media_nsfw], ["remote.instance"])
79 media_message = build_media_message()
80 local_message = build_local_message()
82 assert SimplePolicy.filter(media_message) ==
85 |> put_in(["object", "tag"], ["foo", "nsfw"])
86 |> put_in(["object", "sensitive"], true)}
88 assert SimplePolicy.filter(local_message) == {:ok, local_message}
91 test "match with wildcard domain" do
92 Config.put([:mrf_simple, :media_nsfw], ["*.remote.instance"])
93 media_message = build_media_message()
94 local_message = build_local_message()
96 assert SimplePolicy.filter(media_message) ==
99 |> put_in(["object", "tag"], ["foo", "nsfw"])
100 |> put_in(["object", "sensitive"], true)}
102 assert SimplePolicy.filter(local_message) == {:ok, local_message}
106 defp build_media_message do
108 "actor" => "https://remote.instance/users/bob",
111 "attachment" => [%{}],
118 describe "when :report_removal" do
120 Config.put([:mrf_simple, :report_removal], [])
121 report_message = build_report_message()
122 local_message = build_local_message()
124 assert SimplePolicy.filter(report_message) == {:ok, report_message}
125 assert SimplePolicy.filter(local_message) == {:ok, local_message}
128 test "has a matching host" do
129 Config.put([:mrf_simple, :report_removal], ["remote.instance"])
130 report_message = build_report_message()
131 local_message = build_local_message()
133 assert SimplePolicy.filter(report_message) == {:reject, nil}
134 assert SimplePolicy.filter(local_message) == {:ok, local_message}
137 test "match with wildcard domain" do
138 Config.put([:mrf_simple, :report_removal], ["*.remote.instance"])
139 report_message = build_report_message()
140 local_message = build_local_message()
142 assert SimplePolicy.filter(report_message) == {:reject, nil}
143 assert SimplePolicy.filter(local_message) == {:ok, local_message}
147 defp build_report_message do
149 "actor" => "https://remote.instance/users/bob",
154 describe "when :federated_timeline_removal" do
156 Config.put([:mrf_simple, :federated_timeline_removal], [])
157 {_, ftl_message} = build_ftl_actor_and_message()
158 local_message = build_local_message()
160 assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
161 assert SimplePolicy.filter(local_message) == {:ok, local_message}
164 test "has a matching host" do
165 {actor, ftl_message} = build_ftl_actor_and_message()
167 ftl_message_actor_host =
169 |> Map.fetch!("actor")
173 Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
174 local_message = build_local_message()
176 assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
177 assert actor.follower_address in ftl_message["to"]
178 refute actor.follower_address in ftl_message["cc"]
179 refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
180 assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
182 assert SimplePolicy.filter(local_message) == {:ok, local_message}
185 test "match with wildcard domain" do
186 {actor, ftl_message} = build_ftl_actor_and_message()
188 ftl_message_actor_host =
190 |> Map.fetch!("actor")
194 Config.put([:mrf_simple, :federated_timeline_removal], ["*." <> ftl_message_actor_host])
195 local_message = build_local_message()
197 assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
198 assert actor.follower_address in ftl_message["to"]
199 refute actor.follower_address in ftl_message["cc"]
200 refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
201 assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
203 assert SimplePolicy.filter(local_message) == {:ok, local_message}
206 test "has a matching host but only as:Public in to" do
207 {_actor, ftl_message} = build_ftl_actor_and_message()
209 ftl_message_actor_host =
211 |> Map.fetch!("actor")
215 ftl_message = Map.put(ftl_message, "cc", [])
217 Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
219 assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
220 refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
221 assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
225 defp build_ftl_actor_and_message do
226 actor = insert(:user)
230 "actor" => actor.ap_id,
231 "to" => ["https://www.w3.org/ns/activitystreams#Public", "http://foo.bar/baz"],
232 "cc" => [actor.follower_address, "http://foo.bar/qux"]
236 describe "when :reject" do
238 Config.put([:mrf_simple, :reject], [])
240 remote_message = build_remote_message()
242 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
245 test "has a matching host" do
246 Config.put([:mrf_simple, :reject], ["remote.instance"])
248 remote_message = build_remote_message()
250 assert SimplePolicy.filter(remote_message) == {:reject, nil}
253 test "match with wildcard domain" do
254 Config.put([:mrf_simple, :reject], ["*.remote.instance"])
256 remote_message = build_remote_message()
258 assert SimplePolicy.filter(remote_message) == {:reject, nil}
262 describe "when :accept" do
264 Config.put([:mrf_simple, :accept], [])
266 local_message = build_local_message()
267 remote_message = build_remote_message()
269 assert SimplePolicy.filter(local_message) == {:ok, local_message}
270 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
273 test "is not empty but it doesn't have a matching host" do
274 Config.put([:mrf_simple, :accept], ["non.matching.remote"])
276 local_message = build_local_message()
277 remote_message = build_remote_message()
279 assert SimplePolicy.filter(local_message) == {:ok, local_message}
280 assert SimplePolicy.filter(remote_message) == {:reject, nil}
283 test "has a matching host" do
284 Config.put([:mrf_simple, :accept], ["remote.instance"])
286 local_message = build_local_message()
287 remote_message = build_remote_message()
289 assert SimplePolicy.filter(local_message) == {:ok, local_message}
290 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
293 test "match with wildcard domain" do
294 Config.put([:mrf_simple, :accept], ["*.remote.instance"])
296 local_message = build_local_message()
297 remote_message = build_remote_message()
299 assert SimplePolicy.filter(local_message) == {:ok, local_message}
300 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
304 describe "when :avatar_removal" do
306 Config.put([:mrf_simple, :avatar_removal], [])
308 remote_user = build_remote_user()
310 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
313 test "is not empty but it doesn't have a matching host" do
314 Config.put([:mrf_simple, :avatar_removal], ["non.matching.remote"])
316 remote_user = build_remote_user()
318 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
321 test "has a matching host" do
322 Config.put([:mrf_simple, :avatar_removal], ["remote.instance"])
324 remote_user = build_remote_user()
325 {:ok, filtered} = SimplePolicy.filter(remote_user)
327 refute filtered["icon"]
330 test "match with wildcard domain" do
331 Config.put([:mrf_simple, :avatar_removal], ["*.remote.instance"])
333 remote_user = build_remote_user()
334 {:ok, filtered} = SimplePolicy.filter(remote_user)
336 refute filtered["icon"]
340 describe "when :banner_removal" do
342 Config.put([:mrf_simple, :banner_removal], [])
344 remote_user = build_remote_user()
346 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
349 test "is not empty but it doesn't have a matching host" do
350 Config.put([:mrf_simple, :banner_removal], ["non.matching.remote"])
352 remote_user = build_remote_user()
354 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
357 test "has a matching host" do
358 Config.put([:mrf_simple, :banner_removal], ["remote.instance"])
360 remote_user = build_remote_user()
361 {:ok, filtered} = SimplePolicy.filter(remote_user)
363 refute filtered["image"]
366 test "match with wildcard domain" do
367 Config.put([:mrf_simple, :banner_removal], ["*.remote.instance"])
369 remote_user = build_remote_user()
370 {:ok, filtered} = SimplePolicy.filter(remote_user)
372 refute filtered["image"]
376 defp build_local_message do
378 "actor" => "#{Pleroma.Web.base_url()}/users/alice",
384 defp build_remote_message do
385 %{"actor" => "https://remote.instance/users/bob"}
388 defp build_remote_user do
390 "id" => "https://remote.instance/users/bob",
392 "url" => "http://example.com/image.jpg",
396 "url" => "http://example.com/image.jpg",