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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
   6   use Oban.Testing, repo: Pleroma.Repo
   7   use Pleroma.DataCase
   8
   9   alias Pleroma.Activity
  10   alias Pleroma.Notification
  11   alias Pleroma.Object
  12   alias Pleroma.Repo
  13   alias Pleroma.Tests.ObanHelpers
  14   alias Pleroma.User
  15   alias Pleroma.Web.ActivityPub.ActivityPub
  16   alias Pleroma.Web.ActivityPub.Builder
  17   alias Pleroma.Web.ActivityPub.SideEffects
  18   alias Pleroma.Web.CommonAPI
  19
  20   import Pleroma.Factory
  21   import Mock
  22
  23   describe "delete objects" do
  24     setup do
  25       user = insert(:user)
  26       other_user = insert(:user)
  27
  28       {:ok, op} = CommonAPI.post(other_user, %{"status" => "big oof"})
  29       {:ok, post} = CommonAPI.post(user, %{"status" => "hey", "in_reply_to_id" => op})
  30       object = Object.normalize(post)
  31       {:ok, delete_data, _meta} = Builder.delete(user, object.data["id"])
  32       {:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
  33       {:ok, delete, _meta} = ActivityPub.persist(delete_data, local: true)
  34       {:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)
  35       %{user: user, delete: delete, post: post, object: object, delete_user: delete_user, op: op}
  36     end
  37
  38     test "it handles object deletions", %{
  39       delete: delete,
  40       post: post,
  41       object: object,
  42       user: user,
  43       op: op
  44     } do
  45       with_mock Pleroma.Web.ActivityPub.ActivityPub, [:passthrough],
  46         stream_out: fn _ -> nil end,
  47         stream_out_participations: fn _, _ -> nil end do
  48         {:ok, delete, _} = SideEffects.handle(delete)
  49         user = User.get_cached_by_ap_id(object.data["actor"])
  50
  51         assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out(delete))
  52         assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out_participations(object, user))
  53       end
  54
  55       object = Object.get_by_id(object.id)
  56       assert object.data["type"] == "Tombstone"
  57       refute Activity.get_by_id(post.id)
  58
  59       user = User.get_by_id(user.id)
  60       assert user.note_count == 0
  61
  62       object = Object.normalize(op.data["object"], false)
  63
  64       assert object.data["repliesCount"] == 0
  65     end
  66
  67     test "it handles user deletions", %{delete_user: delete, user: user} do
  68       {:ok, _delete, _} = SideEffects.handle(delete)
  69       ObanHelpers.perform_all()
  70
  71       assert User.get_cached_by_ap_id(user.ap_id).deactivated
  72     end
  73   end
  74
  75   describe "Undo objects" do
  76     setup do
  77       poster = insert(:user)
  78       user = insert(:user)
  79       {:ok, post} = CommonAPI.post(poster, %{"status" => "hey"})
  80       {:ok, like} = CommonAPI.favorite(user, post.id)
  81       {:ok, reaction, _} = CommonAPI.react_with_emoji(post.id, user, "👍")
  82       {:ok, announce, _} = CommonAPI.repeat(post.id, user)
  83       {:ok, block} = ActivityPub.block(user, poster)
  84       User.block(user, poster)
  85
  86       {:ok, undo_data, _meta} = Builder.undo(user, like)
  87       {:ok, like_undo, _meta} = ActivityPub.persist(undo_data, local: true)
  88
  89       {:ok, undo_data, _meta} = Builder.undo(user, reaction)
  90       {:ok, reaction_undo, _meta} = ActivityPub.persist(undo_data, local: true)
  91
  92       {:ok, undo_data, _meta} = Builder.undo(user, announce)
  93       {:ok, announce_undo, _meta} = ActivityPub.persist(undo_data, local: true)
  94
  95       {:ok, undo_data, _meta} = Builder.undo(user, block)
  96       {:ok, block_undo, _meta} = ActivityPub.persist(undo_data, local: true)
  97
  98       %{
  99         like_undo: like_undo,
 100         post: post,
 101         like: like,
 102         reaction_undo: reaction_undo,
 103         reaction: reaction,
 104         announce_undo: announce_undo,
 105         announce: announce,
 106         block_undo: block_undo,
 107         block: block,
 108         poster: poster,
 109         user: user
 110       }
 111     end
 112
 113     test "deletes the original block", %{block_undo: block_undo, block: block} do
 114       {:ok, _block_undo, _} = SideEffects.handle(block_undo)
 115       refute Activity.get_by_id(block.id)
 116     end
 117
 118     test "unblocks the blocked user", %{block_undo: block_undo, block: block} do
 119       blocker = User.get_by_ap_id(block.data["actor"])
 120       blocked = User.get_by_ap_id(block.data["object"])
 121
 122       {:ok, _block_undo, _} = SideEffects.handle(block_undo)
 123       refute User.blocks?(blocker, blocked)
 124     end
 125
 126     test "an announce undo removes the announce from the object", %{
 127       announce_undo: announce_undo,
 128       post: post
 129     } do
 130       {:ok, _announce_undo, _} = SideEffects.handle(announce_undo)
 131
 132       object = Object.get_by_ap_id(post.data["object"])
 133
 134       assert object.data["announcement_count"] == 0
 135       assert object.data["announcements"] == []
 136     end
 137
 138     test "deletes the original announce", %{announce_undo: announce_undo, announce: announce} do
 139       {:ok, _announce_undo, _} = SideEffects.handle(announce_undo)
 140       refute Activity.get_by_id(announce.id)
 141     end
 142
 143     test "a reaction undo removes the reaction from the object", %{
 144       reaction_undo: reaction_undo,
 145       post: post
 146     } do
 147       {:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)
 148
 149       object = Object.get_by_ap_id(post.data["object"])
 150
 151       assert object.data["reaction_count"] == 0
 152       assert object.data["reactions"] == []
 153     end
 154
 155     test "deletes the original reaction", %{reaction_undo: reaction_undo, reaction: reaction} do
 156       {:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)
 157       refute Activity.get_by_id(reaction.id)
 158     end
 159
 160     test "a like undo removes the like from the object", %{like_undo: like_undo, post: post} do
 161       {:ok, _like_undo, _} = SideEffects.handle(like_undo)
 162
 163       object = Object.get_by_ap_id(post.data["object"])
 164
 165       assert object.data["like_count"] == 0
 166       assert object.data["likes"] == []
 167     end
 168
 169     test "deletes the original like", %{like_undo: like_undo, like: like} do
 170       {:ok, _like_undo, _} = SideEffects.handle(like_undo)
 171       refute Activity.get_by_id(like.id)
 172     end
 173   end
 174
 175   describe "like objects" do
 176     setup do
 177       poster = insert(:user)
 178       user = insert(:user)
 179       {:ok, post} = CommonAPI.post(poster, %{"status" => "hey"})
 180
 181       {:ok, like_data, _meta} = Builder.like(user, post.object)
 182       {:ok, like, _meta} = ActivityPub.persist(like_data, local: true)
 183
 184       %{like: like, user: user, poster: poster}
 185     end
 186
 187     test "add the like to the original object", %{like: like, user: user} do
 188       {:ok, like, _} = SideEffects.handle(like)
 189       object = Object.get_by_ap_id(like.data["object"])
 190       assert object.data["like_count"] == 1
 191       assert user.ap_id in object.data["likes"]
 192     end
 193
 194     test "creates a notification", %{like: like, poster: poster} do
 195       {:ok, like, _} = SideEffects.handle(like)
 196       assert Repo.get_by(Notification, user_id: poster.id, activity_id: like.id)
 197     end
 198   end
 199 end