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.Chat
  11   alias Pleroma.Notification
  12   alias Pleroma.Object
  13   alias Pleroma.Repo
  14   alias Pleroma.Tests.ObanHelpers
  15   alias Pleroma.User
  16   alias Pleroma.Web.ActivityPub.ActivityPub
  17   alias Pleroma.Web.ActivityPub.Builder
  18   alias Pleroma.Web.ActivityPub.SideEffects
  19   alias Pleroma.Web.CommonAPI
  20
  21   import Pleroma.Factory
  22   import Mock
  23
  24   describe "delete objects" do
  25     setup do
  26       user = insert(:user)
  27       other_user = insert(:user)
  28
  29       {:ok, op} = CommonAPI.post(other_user, %{"status" => "big oof"})
  30       {:ok, post} = CommonAPI.post(user, %{"status" => "hey", "in_reply_to_id" => op})
  31       object = Object.normalize(post)
  32       {:ok, delete_data, _meta} = Builder.delete(user, object.data["id"])
  33       {:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
  34       {:ok, delete, _meta} = ActivityPub.persist(delete_data, local: true)
  35       {:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)
  36       %{user: user, delete: delete, post: post, object: object, delete_user: delete_user, op: op}
  37     end
  38
  39     test "it handles object deletions", %{
  40       delete: delete,
  41       post: post,
  42       object: object,
  43       user: user,
  44       op: op
  45     } do
  46       with_mock Pleroma.Web.ActivityPub.ActivityPub, [:passthrough],
  47         stream_out: fn _ -> nil end,
  48         stream_out_participations: fn _, _ -> nil end do
  49         {:ok, delete, _} = SideEffects.handle(delete)
  50         user = User.get_cached_by_ap_id(object.data["actor"])
  51
  52         assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out(delete))
  53         assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out_participations(object, user))
  54       end
  55
  56       object = Object.get_by_id(object.id)
  57       assert object.data["type"] == "Tombstone"
  58       refute Activity.get_by_id(post.id)
  59
  60       user = User.get_by_id(user.id)
  61       assert user.note_count == 0
  62
  63       object = Object.normalize(op.data["object"], false)
  64
  65       assert object.data["repliesCount"] == 0
  66     end
  67
  68     test "it handles user deletions", %{delete_user: delete, user: user} do
  69       {:ok, _delete, _} = SideEffects.handle(delete)
  70       ObanHelpers.perform_all()
  71
  72       assert User.get_cached_by_ap_id(user.ap_id).deactivated
  73     end
  74   end
  75
  76   describe "like objects" do
  77     setup do
  78       poster = insert(:user)
  79       user = insert(:user)
  80       {:ok, post} = CommonAPI.post(poster, %{"status" => "hey"})
  81
  82       {:ok, like_data, _meta} = Builder.like(user, post.object)
  83       {:ok, like, _meta} = ActivityPub.persist(like_data, local: true)
  84
  85       %{like: like, user: user, poster: poster}
  86     end
  87
  88     test "add the like to the original object", %{like: like, user: user} do
  89       {:ok, like, _} = SideEffects.handle(like)
  90       object = Object.get_by_ap_id(like.data["object"])
  91       assert object.data["like_count"] == 1
  92       assert user.ap_id in object.data["likes"]
  93     end
  94
  95     test "creates a notification", %{like: like, poster: poster} do
  96       {:ok, like, _} = SideEffects.handle(like)
  97       assert Repo.get_by(Notification, user_id: poster.id, activity_id: like.id)
  98     end
  99   end
 100
 101   describe "creation of ChatMessages" do
 102     test "notifies the recipient" do
 103       author = insert(:user, local: false)
 104       recipient = insert(:user, local: true)
 105
 106       {:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")
 107
 108       {:ok, create_activity_data, _meta} =
 109         Builder.create(author, chat_message_data["id"], [recipient.ap_id])
 110
 111       {:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)
 112
 113       {:ok, _create_activity, _meta} =
 114         SideEffects.handle(create_activity, local: false, object_data: chat_message_data)
 115
 116       assert Repo.get_by(Notification, user_id: recipient.id, activity_id: create_activity.id)
 117     end
 118
 119     test "it creates a Chat for the local users and bumps the unread count" do
 120       author = insert(:user, local: false)
 121       recipient = insert(:user, local: true)
 122
 123       {:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")
 124
 125       {:ok, create_activity_data, _meta} =
 126         Builder.create(author, chat_message_data["id"], [recipient.ap_id])
 127
 128       {:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)
 129
 130       {:ok, _create_activity, _meta} =
 131         SideEffects.handle(create_activity, local: false, object_data: chat_message_data)
 132
 133       # An object is created
 134       assert Object.get_by_ap_id(chat_message_data["id"])
 135
 136       # The remote user won't get a chat
 137       chat = Chat.get(author.id, recipient.ap_id)
 138       refute chat
 139
 140       # The local user will get a chat
 141       chat = Chat.get(recipient.id, author.ap_id)
 142       assert chat
 143
 144       author = insert(:user, local: true)
 145       recipient = insert(:user, local: true)
 146
 147       {:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")
 148
 149       {:ok, create_activity_data, _meta} =
 150         Builder.create(author, chat_message_data["id"], [recipient.ap_id])
 151
 152       {:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)
 153
 154       {:ok, _create_activity, _meta} =
 155         SideEffects.handle(create_activity, local: false, object_data: chat_message_data)
 156
 157       # Both users are local and get the chat
 158       chat = Chat.get(author.id, recipient.ap_id)
 159       assert chat
 160
 161       chat = Chat.get(recipient.id, author.ap_id)
 162       assert chat
 163     end
 164   end
 165 end