git.squeep.com Git - akkoma/blob - test/pleroma/activity_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.ActivityTest do
   6   use Pleroma.DataCase
   7   alias Pleroma.Activity
   8   alias Pleroma.Bookmark
   9   alias Pleroma.Object
  10   alias Pleroma.Tests.ObanHelpers
  11   alias Pleroma.ThreadMute
  12   import Pleroma.Factory
  13
  14   setup_all do
  15     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  16     :ok
  17   end
  18
  19   test "returns an activity by it's AP id" do
  20     activity = insert(:note_activity)
  21     found_activity = Activity.get_by_ap_id(activity.data["id"])
  22
  23     assert activity == found_activity
  24   end
  25
  26   test "returns activities by it's objects AP ids" do
  27     activity = insert(:note_activity)
  28     object_data = Object.normalize(activity, fetch: false).data
  29
  30     [found_activity] = Activity.get_all_create_by_object_ap_id(object_data["id"])
  31
  32     assert activity == found_activity
  33   end
  34
  35   test "returns the activity that created an object" do
  36     activity = insert(:note_activity)
  37     object_data = Object.normalize(activity, fetch: false).data
  38
  39     found_activity = Activity.get_create_by_object_ap_id(object_data["id"])
  40
  41     assert activity == found_activity
  42   end
  43
  44   test "preloading a bookmark" do
  45     user = insert(:user)
  46     user2 = insert(:user)
  47     user3 = insert(:user)
  48     activity = insert(:note_activity)
  49     {:ok, _bookmark} = Bookmark.create(user.id, activity.id)
  50     {:ok, _bookmark2} = Bookmark.create(user2.id, activity.id)
  51     {:ok, bookmark3} = Bookmark.create(user3.id, activity.id)
  52
  53     queried_activity =
  54       Ecto.Query.from(Pleroma.Activity)
  55       |> Activity.with_preloaded_bookmark(user3)
  56       |> Repo.one()
  57
  58     assert queried_activity.bookmark == bookmark3
  59   end
  60
  61   test "setting thread_muted?" do
  62     activity = insert(:note_activity)
  63     user = insert(:user)
  64     annoyed_user = insert(:user)
  65     {:ok, _} = ThreadMute.add_mute(annoyed_user.id, activity.data["context"])
  66
  67     activity_with_unset_thread_muted_field =
  68       Ecto.Query.from(Activity)
  69       |> Repo.one()
  70
  71     activity_for_user =
  72       Ecto.Query.from(Activity)
  73       |> Activity.with_set_thread_muted_field(user)
  74       |> Repo.one()
  75
  76     activity_for_annoyed_user =
  77       Ecto.Query.from(Activity)
  78       |> Activity.with_set_thread_muted_field(annoyed_user)
  79       |> Repo.one()
  80
  81     assert activity_with_unset_thread_muted_field.thread_muted? == nil
  82     assert activity_for_user.thread_muted? == false
  83     assert activity_for_annoyed_user.thread_muted? == true
  84   end
  85
  86   describe "getting a bookmark" do
  87     test "when association is loaded" do
  88       user = insert(:user)
  89       activity = insert(:note_activity)
  90       {:ok, bookmark} = Bookmark.create(user.id, activity.id)
  91
  92       queried_activity =
  93         Ecto.Query.from(Pleroma.Activity)
  94         |> Activity.with_preloaded_bookmark(user)
  95         |> Repo.one()
  96
  97       assert Activity.get_bookmark(queried_activity, user) == bookmark
  98     end
  99
 100     test "when association is not loaded" do
 101       user = insert(:user)
 102       activity = insert(:note_activity)
 103       {:ok, bookmark} = Bookmark.create(user.id, activity.id)
 104
 105       queried_activity =
 106         Ecto.Query.from(Pleroma.Activity)
 107         |> Repo.one()
 108
 109       assert Activity.get_bookmark(queried_activity, user) == bookmark
 110     end
 111   end
 112
 113   describe "search" do
 114     setup do
 115       user = insert(:user)
 116
 117       params = %{
 118         "@context" => "https://www.w3.org/ns/activitystreams",
 119         "actor" => "http://mastodon.example.org/users/admin",
 120         "type" => "Create",
 121         "id" => "http://mastodon.example.org/users/admin/activities/1",
 122         "object" => %{
 123           "type" => "Note",
 124           "content" => "find me!",
 125           "id" => "http://mastodon.example.org/users/admin/objects/1",
 126           "attributedTo" => "http://mastodon.example.org/users/admin"
 127         },
 128         "to" => ["https://www.w3.org/ns/activitystreams#Public"]
 129       }
 130
 131       {:ok, local_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "find me!"})
 132       {:ok, japanese_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "更新情報"})
 133       {:ok, job} = Pleroma.Web.Federator.incoming_ap_doc(params)
 134       {:ok, remote_activity} = ObanHelpers.perform(job)
 135
 136       %{
 137         japanese_activity: japanese_activity,
 138         local_activity: local_activity,
 139         remote_activity: remote_activity,
 140         user: user
 141       }
 142     end
 143
 144     setup do: clear_config([:instance, :limit_to_local_content])
 145
 146     test "finds utf8 text in statuses", %{
 147       japanese_activity: japanese_activity,
 148       user: user
 149     } do
 150       activities = Activity.search(user, "更新情報")
 151
 152       assert [^japanese_activity] = activities
 153     end
 154
 155     test "find local and remote statuses for authenticated users", %{
 156       local_activity: local_activity,
 157       remote_activity: remote_activity,
 158       user: user
 159     } do
 160       activities = Enum.sort_by(Activity.search(user, "find me"), & &1.id)
 161
 162       assert [^local_activity, ^remote_activity] = activities
 163     end
 164
 165     test "find only local statuses for unauthenticated users", %{local_activity: local_activity} do
 166       assert [^local_activity] = Activity.search(nil, "find me")
 167     end
 168
 169     test "find only local statuses for unauthenticated users  when `limit_to_local_content` is `:all`",
 170          %{local_activity: local_activity} do
 171       clear_config([:instance, :limit_to_local_content], :all)
 172       assert [^local_activity] = Activity.search(nil, "find me")
 173     end
 174
 175     test "find all statuses for unauthenticated users when `limit_to_local_content` is `false`",
 176          %{
 177            local_activity: local_activity,
 178            remote_activity: remote_activity
 179          } do
 180       clear_config([:instance, :limit_to_local_content], false)
 181
 182       activities = Enum.sort_by(Activity.search(nil, "find me"), & &1.id)
 183
 184       assert [^local_activity, ^remote_activity] = activities
 185     end
 186   end
 187
 188   test "all_by_ids_with_object/1" do
 189     %{id: id1} = insert(:note_activity)
 190     %{id: id2} = insert(:note_activity)
 191
 192     activities =
 193       [id1, id2]
 194       |> Activity.all_by_ids_with_object()
 195       |> Enum.sort(&(&1.id < &2.id))
 196
 197     assert [%{id: ^id1, object: %Object{}}, %{id: ^id2, object: %Object{}}] = activities
 198   end
 199
 200   test "get_by_id_with_user_actor/1" do
 201     user = insert(:user)
 202     activity = insert(:note_activity, note: insert(:note, user: user))
 203
 204     assert Activity.get_by_id_with_user_actor(activity.id).user_actor == user
 205   end
 206
 207   test "get_by_id_with_object/1" do
 208     %{id: id} = insert(:note_activity)
 209
 210     assert %Activity{id: ^id, object: %Object{}} = Activity.get_by_id_with_object(id)
 211   end
 212
 213   test "get_by_ap_id_with_object/1" do
 214     %{data: %{"id" => ap_id}} = insert(:note_activity)
 215
 216     assert %Activity{data: %{"id" => ^ap_id}, object: %Object{}} =
 217              Activity.get_by_ap_id_with_object(ap_id)
 218   end
 219
 220   test "get_by_id/1" do
 221     %{id: id} = insert(:note_activity)
 222
 223     assert %Activity{id: ^id} = Activity.get_by_id(id)
 224   end
 225
 226   test "all_by_actor_and_id/2" do
 227     user = insert(:user)
 228
 229     {:ok, %{id: id1}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
 230     {:ok, %{id: id2}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofefe"})
 231
 232     assert [] == Activity.all_by_actor_and_id(user, [])
 233
 234     activities =
 235       user.ap_id
 236       |> Activity.all_by_actor_and_id([id1, id2])
 237       |> Enum.sort(&(&1.id < &2.id))
 238
 239     assert [%Activity{id: ^id1}, %Activity{id: ^id2}] = activities
 240   end
 241
 242   test "get_by_object_ap_id_with_object/1" do
 243     user = insert(:user)
 244     another = insert(:user)
 245
 246     {:ok, %{id: id, object: %{data: %{"id" => obj_id}}}} =
 247       Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
 248
 249     Pleroma.Web.CommonAPI.favorite(another, id)
 250
 251     assert obj_id
 252            |> Pleroma.Activity.Queries.by_object_id()
 253            |> Repo.aggregate(:count, :id) == 2
 254
 255     assert %{id: ^id} = Activity.get_by_object_ap_id_with_object(obj_id)
 256   end
 257
 258   test "add_by_params_query/3" do
 259     user = insert(:user)
 260
 261     note = insert(:note_activity, user: user)
 262
 263     insert(:add_activity, user: user, note: note)
 264     insert(:add_activity, user: user, note: note)
 265     insert(:add_activity, user: user)
 266
 267     assert Repo.aggregate(Activity, :count, :id) == 4
 268
 269     add_query =
 270       Activity.add_by_params_query(note.data["object"], user.ap_id, user.featured_address)
 271
 272     assert Repo.aggregate(add_query, :count, :id) == 2
 273
 274     Repo.delete_all(add_query)
 275     assert Repo.aggregate(add_query, :count, :id) == 0
 276
 277     assert Repo.aggregate(Activity, :count, :id) == 2
 278   end
 279 end