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           "to" => ["https://www.w3.org/ns/activitystreams#Public"]
 128         },
 129         "to" => ["https://www.w3.org/ns/activitystreams#Public"]
 130       }
 131
 132       {:ok, local_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "find me!"})
 133       {:ok, japanese_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "更新情報"})
 134       {:ok, job} = Pleroma.Web.Federator.incoming_ap_doc(params)
 135       {:ok, remote_activity} = ObanHelpers.perform(job)
 136       remote_activity = Activity.get_by_id_with_object(remote_activity.id)
 137
 138       %{
 139         japanese_activity: japanese_activity,
 140         local_activity: local_activity,
 141         remote_activity: remote_activity,
 142         user: user
 143       }
 144     end
 145
 146     setup do: clear_config([:instance, :limit_to_local_content])
 147
 148     test "finds utf8 text in statuses", %{
 149       japanese_activity: japanese_activity,
 150       user: user
 151     } do
 152       activities = Activity.search(user, "更新情報")
 153
 154       assert [^japanese_activity] = activities
 155     end
 156
 157     test "find local and remote statuses for authenticated users", %{
 158       local_activity: local_activity,
 159       remote_activity: remote_activity,
 160       user: user
 161     } do
 162       activities = Enum.sort_by(Activity.search(user, "find me"), & &1.id)
 163
 164       assert [^local_activity, ^remote_activity] = activities
 165     end
 166
 167     test "find only local statuses for unauthenticated users", %{local_activity: local_activity} do
 168       assert [^local_activity] = Activity.search(nil, "find me")
 169     end
 170
 171     test "find only local statuses for unauthenticated users  when `limit_to_local_content` is `:all`",
 172          %{local_activity: local_activity} do
 173       clear_config([:instance, :limit_to_local_content], :all)
 174       assert [^local_activity] = Activity.search(nil, "find me")
 175     end
 176
 177     test "find all statuses for unauthenticated users when `limit_to_local_content` is `false`",
 178          %{
 179            local_activity: local_activity,
 180            remote_activity: remote_activity
 181          } do
 182       clear_config([:instance, :limit_to_local_content], false)
 183
 184       activities = Enum.sort_by(Activity.search(nil, "find me"), & &1.id)
 185
 186       assert [^local_activity, ^remote_activity] = activities
 187     end
 188   end
 189
 190   test "all_by_ids_with_object/1" do
 191     %{id: id1} = insert(:note_activity)
 192     %{id: id2} = insert(:note_activity)
 193
 194     activities =
 195       [id1, id2]
 196       |> Activity.all_by_ids_with_object()
 197       |> Enum.sort(&(&1.id < &2.id))
 198
 199     assert [%{id: ^id1, object: %Object{}}, %{id: ^id2, object: %Object{}}] = activities
 200   end
 201
 202   test "get_by_id_with_user_actor/1" do
 203     user = insert(:user)
 204     activity = insert(:note_activity, note: insert(:note, user: user))
 205
 206     assert Activity.get_by_id_with_user_actor(activity.id).user_actor == user
 207   end
 208
 209   test "get_by_id_with_object/1" do
 210     %{id: id} = insert(:note_activity)
 211
 212     assert %Activity{id: ^id, object: %Object{}} = Activity.get_by_id_with_object(id)
 213   end
 214
 215   test "get_by_ap_id_with_object/1" do
 216     %{data: %{"id" => ap_id}} = insert(:note_activity)
 217
 218     assert %Activity{data: %{"id" => ^ap_id}, object: %Object{}} =
 219              Activity.get_by_ap_id_with_object(ap_id)
 220   end
 221
 222   test "get_by_id/1" do
 223     %{id: id} = insert(:note_activity)
 224
 225     assert %Activity{id: ^id} = Activity.get_by_id(id)
 226   end
 227
 228   test "all_by_actor_and_id/2" do
 229     user = insert(:user)
 230
 231     {:ok, %{id: id1}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
 232     {:ok, %{id: id2}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofefe"})
 233
 234     assert [] == Activity.all_by_actor_and_id(user, [])
 235
 236     activities =
 237       user.ap_id
 238       |> Activity.all_by_actor_and_id([id1, id2])
 239       |> Enum.sort(&(&1.id < &2.id))
 240
 241     assert [%Activity{id: ^id1}, %Activity{id: ^id2}] = activities
 242   end
 243
 244   test "get_by_object_ap_id_with_object/1" do
 245     user = insert(:user)
 246     another = insert(:user)
 247
 248     {:ok, %{id: id, object: %{data: %{"id" => obj_id}}}} =
 249       Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
 250
 251     Pleroma.Web.CommonAPI.favorite(another, id)
 252
 253     assert obj_id
 254            |> Pleroma.Activity.Queries.by_object_id()
 255            |> Repo.aggregate(:count, :id) == 2
 256
 257     assert %{id: ^id} = Activity.get_by_object_ap_id_with_object(obj_id)
 258   end
 259
 260   test "add_by_params_query/3" do
 261     user = insert(:user)
 262
 263     note = insert(:note_activity, user: user)
 264
 265     insert(:add_activity, user: user, note: note)
 266     insert(:add_activity, user: user, note: note)
 267     insert(:add_activity, user: user)
 268
 269     assert Repo.aggregate(Activity, :count, :id) == 4
 270
 271     add_query =
 272       Activity.add_by_params_query(note.data["object"], user.ap_id, user.featured_address)
 273
 274     assert Repo.aggregate(add_query, :count, :id) == 2
 275
 276     Repo.delete_all(add_query)
 277     assert Repo.aggregate(add_query, :count, :id) == 0
 278
 279     assert Repo.aggregate(Activity, :count, :id) == 2
 280   end
 281 end