1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
6 use Oban.Testing, repo: Pleroma.Repo
10 alias Pleroma.Notification
13 alias Pleroma.Tests.ObanHelpers
15 alias Pleroma.Web.ActivityPub.ActivityPub
16 alias Pleroma.Web.ActivityPub.Builder
17 alias Pleroma.Web.ActivityPub.SideEffects
18 alias Pleroma.Web.ActivityPub.Utils
19 alias Pleroma.Web.CommonAPI
22 import Pleroma.Factory
24 describe "handle_after_transaction" do
25 test "it streams out notifications and streams" do
26 author = insert(:user, local: true)
27 recipient = insert(:user, local: true)
29 {:ok, note_data, _meta} =
30 Builder.note(%Pleroma.Web.CommonAPI.ActivityDraft{
32 to: [recipient.ap_id],
33 mentions: [recipient],
35 extra: %{"id" => Utils.generate_object_id()}
38 {:ok, create_activity_data, _meta} =
39 Builder.create(author, note_data["id"], [recipient.ap_id])
41 {:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)
43 {:ok, _create_activity, meta} =
44 SideEffects.handle(create_activity, local: false, object_data: note_data)
46 assert [notification] = meta[:notifications]
53 stream: fn _, _ -> nil end
64 SideEffects.handle_after_transaction(meta)
66 assert called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
67 assert called(Pleroma.Web.Push.send(notification))
72 describe "blocking users" do
75 blocked = insert(:user)
76 User.follow(blocked, user)
77 User.follow(user, blocked)
79 {:ok, block_data, []} = Builder.block(user, blocked)
80 {:ok, block, _meta} = ActivityPub.persist(block_data, local: true)
82 %{user: user, blocked: blocked, block: block}
85 test "it unfollows and blocks", %{user: user, blocked: blocked, block: block} do
86 assert User.following?(user, blocked)
87 assert User.following?(blocked, user)
89 {:ok, _, _} = SideEffects.handle(block)
91 refute User.following?(user, blocked)
92 refute User.following?(blocked, user)
93 assert User.blocks?(user, blocked)
96 test "it updates following relationship", %{user: user, blocked: blocked, block: block} do
97 {:ok, _, _} = SideEffects.handle(block)
99 refute Pleroma.FollowingRelationship.get(user, blocked)
100 assert User.get_follow_state(user, blocked) == nil
101 assert User.get_follow_state(blocked, user) == nil
102 assert User.get_follow_state(user, blocked, nil) == nil
103 assert User.get_follow_state(blocked, user, nil) == nil
106 test "it blocks but does not unfollow if the relevant setting is set", %{
111 clear_config([:activitypub, :unfollow_blocked], false)
112 assert User.following?(user, blocked)
113 assert User.following?(blocked, user)
115 {:ok, _, _} = SideEffects.handle(block)
117 refute User.following?(user, blocked)
118 assert User.following?(blocked, user)
119 assert User.blocks?(user, blocked)
123 describe "update users" do
125 user = insert(:user, local: false)
126 {:ok, update_data, []} = Builder.update(user, %{"id" => user.ap_id, "name" => "new name!"})
127 {:ok, update, _meta} = ActivityPub.persist(update_data, local: true)
129 %{user: user, update_data: update_data, update: update}
132 test "it updates the user", %{user: user, update: update} do
133 {:ok, _, _} = SideEffects.handle(update)
134 user = User.get_by_id(user.id)
135 assert user.name == "new name!"
138 test "it uses a given changeset to update", %{user: user, update: update} do
139 changeset = Ecto.Changeset.change(user, %{default_scope: "direct"})
141 assert user.default_scope == "public"
142 {:ok, _, _} = SideEffects.handle(update, user_update_changeset: changeset)
143 user = User.get_by_id(user.id)
144 assert user.default_scope == "direct"
148 describe "EmojiReact objects" do
150 poster = insert(:user)
153 {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
155 {:ok, emoji_react_data, []} = Builder.emoji_react(user, post.object, "👌")
156 {:ok, emoji_react, _meta} = ActivityPub.persist(emoji_react_data, local: true)
158 %{emoji_react: emoji_react, user: user, poster: poster}
161 test "adds the reaction to the object", %{emoji_react: emoji_react, user: user} do
162 {:ok, emoji_react, _} = SideEffects.handle(emoji_react)
163 object = Object.get_by_ap_id(emoji_react.data["object"])
165 assert object.data["reaction_count"] == 1
166 assert ["👌", [user.ap_id], nil] in object.data["reactions"]
169 test "creates a notification", %{emoji_react: emoji_react, poster: poster} do
170 {:ok, emoji_react, _} = SideEffects.handle(emoji_react)
171 assert Repo.get_by(Notification, user_id: poster.id, activity_id: emoji_react.id)
175 describe "Question objects" do
178 question = build(:question, user: user)
179 question_activity = build(:question_activity, question: question)
180 activity_data = Map.put(question_activity.data, "object", question.data["id"])
181 meta = [object_data: question.data, local: false]
183 {:ok, activity, meta} = ActivityPub.persist(activity_data, meta)
185 %{activity: activity, meta: meta}
188 test "enqueues the poll end", %{activity: activity, meta: meta} do
189 {:ok, activity, meta} = SideEffects.handle(activity, meta)
192 worker: Pleroma.Workers.PollWorker,
193 args: %{op: "poll_end", activity_id: activity.id},
194 scheduled_at: NaiveDateTime.from_iso8601!(meta[:object_data]["closed"])
199 describe "delete users with confirmation pending" do
201 user = insert(:user, is_confirmed: false)
202 {:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
203 {:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)
204 {:ok, delete: delete_user, user: user}
207 test "when activation is required", %{delete: delete, user: user} do
208 clear_config([:instance, :account_activation_required], true)
209 {:ok, _, _} = SideEffects.handle(delete)
210 ObanHelpers.perform_all()
212 refute User.get_cached_by_id(user.id)
216 describe "Undo objects" do
218 poster = insert(:user)
220 {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
221 {:ok, like} = CommonAPI.favorite(user, post.id)
222 {:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍")
223 {:ok, announce} = CommonAPI.repeat(post.id, user)
224 {:ok, block} = CommonAPI.block(user, poster)
226 {:ok, undo_data, _meta} = Builder.undo(user, like)
227 {:ok, like_undo, _meta} = ActivityPub.persist(undo_data, local: true)
229 {:ok, undo_data, _meta} = Builder.undo(user, reaction)
230 {:ok, reaction_undo, _meta} = ActivityPub.persist(undo_data, local: true)
232 {:ok, undo_data, _meta} = Builder.undo(user, announce)
233 {:ok, announce_undo, _meta} = ActivityPub.persist(undo_data, local: true)
235 {:ok, undo_data, _meta} = Builder.undo(user, block)
236 {:ok, block_undo, _meta} = ActivityPub.persist(undo_data, local: true)
239 like_undo: like_undo,
242 reaction_undo: reaction_undo,
244 announce_undo: announce_undo,
246 block_undo: block_undo,
253 test "deletes the original block", %{
254 block_undo: block_undo,
257 {:ok, _block_undo, _meta} = SideEffects.handle(block_undo)
259 refute Activity.get_by_id(block.id)
262 test "unblocks the blocked user", %{block_undo: block_undo, block: block} do
263 blocker = User.get_by_ap_id(block.data["actor"])
264 blocked = User.get_by_ap_id(block.data["object"])
266 {:ok, _block_undo, _} = SideEffects.handle(block_undo)
267 refute User.blocks?(blocker, blocked)
270 test "an announce undo removes the announce from the object", %{
271 announce_undo: announce_undo,
274 {:ok, _announce_undo, _} = SideEffects.handle(announce_undo)
276 object = Object.get_by_ap_id(post.data["object"])
278 assert object.data["announcement_count"] == 0
279 assert object.data["announcements"] == []
282 test "deletes the original announce", %{announce_undo: announce_undo, announce: announce} do
283 {:ok, _announce_undo, _} = SideEffects.handle(announce_undo)
284 refute Activity.get_by_id(announce.id)
287 test "a reaction undo removes the reaction from the object", %{
288 reaction_undo: reaction_undo,
291 {:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)
293 object = Object.get_by_ap_id(post.data["object"])
295 assert object.data["reaction_count"] == 0
296 assert object.data["reactions"] == []
299 test "deletes the original reaction", %{reaction_undo: reaction_undo, reaction: reaction} do
300 {:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)
301 refute Activity.get_by_id(reaction.id)
304 test "a like undo removes the like from the object", %{like_undo: like_undo, post: post} do
305 {:ok, _like_undo, _} = SideEffects.handle(like_undo)
307 object = Object.get_by_ap_id(post.data["object"])
309 assert object.data["like_count"] == 0
310 assert object.data["likes"] == []
313 test "deletes the original like", %{like_undo: like_undo, like: like} do
314 {:ok, _like_undo, _} = SideEffects.handle(like_undo)
315 refute Activity.get_by_id(like.id)
319 describe "like objects" do
321 poster = insert(:user)
323 {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
325 {:ok, like_data, _meta} = Builder.like(user, post.object)
326 {:ok, like, _meta} = ActivityPub.persist(like_data, local: true)
328 %{like: like, user: user, poster: poster}
331 test "add the like to the original object", %{like: like, user: user} do
332 {:ok, like, _} = SideEffects.handle(like)
333 object = Object.get_by_ap_id(like.data["object"])
334 assert object.data["like_count"] == 1
335 assert user.ap_id in object.data["likes"]
338 test "creates a notification", %{like: like, poster: poster} do
339 {:ok, like, _} = SideEffects.handle(like)
340 assert Repo.get_by(Notification, user_id: poster.id, activity_id: like.id)
344 describe "announce objects" do
346 poster = insert(:user)
348 {:ok, post} = CommonAPI.post(poster, %{status: "hey"})
349 {:ok, private_post} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})
351 {:ok, announce_data, _meta} = Builder.announce(user, post.object, public: true)
353 {:ok, private_announce_data, _meta} =
354 Builder.announce(user, private_post.object, public: false)
356 {:ok, relay_announce_data, _meta} =
357 Builder.announce(Pleroma.Web.ActivityPub.Relay.get_actor(), post.object, public: true)
359 {:ok, announce, _meta} = ActivityPub.persist(announce_data, local: true)
360 {:ok, private_announce, _meta} = ActivityPub.persist(private_announce_data, local: true)
361 {:ok, relay_announce, _meta} = ActivityPub.persist(relay_announce_data, local: true)
367 private_announce: private_announce,
368 relay_announce: relay_announce
372 test "adds the announce to the original object", %{announce: announce, user: user} do
373 {:ok, announce, _} = SideEffects.handle(announce)
374 object = Object.get_by_ap_id(announce.data["object"])
375 assert object.data["announcement_count"] == 1
376 assert user.ap_id in object.data["announcements"]
379 test "does not add the announce to the original object if the actor is a service actor", %{
380 relay_announce: announce
382 {:ok, announce, _} = SideEffects.handle(announce)
383 object = Object.get_by_ap_id(announce.data["object"])
384 assert object.data["announcement_count"] == nil
387 test "creates a notification", %{announce: announce, poster: poster} do
388 {:ok, announce, _} = SideEffects.handle(announce)
389 assert Repo.get_by(Notification, user_id: poster.id, activity_id: announce.id)
392 test "it streams out the announce", %{announce: announce} do
395 Pleroma.Web.Streamer,
398 stream: fn _, _ -> nil end
405 send: fn _ -> nil end
409 {:ok, announce, _} = SideEffects.handle(announce)
412 Pleroma.Web.Streamer.stream(["user", "list", "public", "public:local"], announce)
415 assert called(Pleroma.Web.Push.send(:_))
420 describe "removing a follower" do
423 followed = insert(:user)
425 {:ok, _, _, follow_activity} = CommonAPI.follow(user, followed)
427 {:ok, reject_data, []} = Builder.reject(followed, follow_activity)
428 {:ok, reject, _meta} = ActivityPub.persist(reject_data, local: true)
430 %{user: user, followed: followed, reject: reject}
433 test "", %{user: user, followed: followed, reject: reject} do
434 assert User.following?(user, followed)
435 assert Pleroma.FollowingRelationship.get(user, followed)
437 {:ok, _, _} = SideEffects.handle(reject)
439 refute User.following?(user, followed)
440 refute Pleroma.FollowingRelationship.get(user, followed)
441 assert User.get_follow_state(user, followed) == nil
442 assert User.get_follow_state(user, followed, nil) == nil
446 describe "removing a follower from remote" do
449 followed = insert(:user, local: false)
451 # Mock a local-to-remote follow
452 {:ok, follow_data, []} = Builder.follow(user, followed)
456 |> Map.put("state", "accept")
458 {:ok, follow, _meta} = ActivityPub.persist(follow_data, local: true)
459 {:ok, _, _} = SideEffects.handle(follow)
461 # Mock a remote-to-local accept
462 {:ok, accept_data, _} = Builder.accept(followed, follow)
463 {:ok, accept, _} = ActivityPub.persist(accept_data, local: false)
464 {:ok, _, _} = SideEffects.handle(accept)
466 # Mock a remote-to-local reject
467 {:ok, reject_data, []} = Builder.reject(followed, follow)
468 {:ok, reject, _meta} = ActivityPub.persist(reject_data, local: false)
470 %{user: user, followed: followed, reject: reject}
473 test "", %{user: user, followed: followed, reject: reject} do
474 assert User.following?(user, followed)
475 assert Pleroma.FollowingRelationship.get(user, followed)
477 {:ok, _, _} = SideEffects.handle(reject)
479 refute User.following?(user, followed)
480 refute Pleroma.FollowingRelationship.get(user, followed)
482 assert Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(user, followed).data["state"] ==
485 assert User.get_follow_state(user, followed) == nil
486 assert User.get_follow_state(user, followed, nil) == nil