git.squeep.com Git - akkoma/blob - test/conversation/participation_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Conversation.ParticipationTest do
   6   use Pleroma.DataCase
   7   import Pleroma.Factory
   8   alias Pleroma.Conversation.Participation
   9   alias Pleroma.User
  10   alias Pleroma.Web.CommonAPI
  11
  12   test "getting a participation will also preload things" do
  13     user = insert(:user)
  14     other_user = insert(:user)
  15
  16     {:ok, _activity} =
  17       CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"})
  18
  19     [participation] = Participation.for_user(user)
  20
  21     participation = Participation.get(participation.id, preload: [:conversation])
  22
  23     assert %Pleroma.Conversation{} = participation.conversation
  24   end
  25
  26   test "for a new conversation, it sets the recipents of the participation" do
  27     user = insert(:user)
  28     other_user = insert(:user)
  29     third_user = insert(:user)
  30
  31     {:ok, activity} =
  32       CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"})
  33
  34     user = User.get_cached_by_id(user.id)
  35     other_user = User.get_cached_by_id(user.id)
  36     [participation] = Participation.for_user(user)
  37     participation = Pleroma.Repo.preload(participation, :recipients)
  38
  39     assert length(participation.recipients) == 2
  40     assert user in participation.recipients
  41     assert other_user in participation.recipients
  42
  43     # Mentioning another user in the same conversation will not add a new recipients.
  44
  45     {:ok, _activity} =
  46       CommonAPI.post(user, %{
  47         "in_reply_to_status_id" => activity.id,
  48         "status" => "Hey @#{third_user.nickname}.",
  49         "visibility" => "direct"
  50       })
  51
  52     [participation] = Participation.for_user(user)
  53     participation = Pleroma.Repo.preload(participation, :recipients)
  54
  55     assert length(participation.recipients) == 2
  56   end
  57
  58   test "it creates a participation for a conversation and a user" do
  59     user = insert(:user)
  60     conversation = insert(:conversation)
  61
  62     {:ok, %Participation{} = participation} =
  63       Participation.create_for_user_and_conversation(user, conversation)
  64
  65     assert participation.user_id == user.id
  66     assert participation.conversation_id == conversation.id
  67
  68     :timer.sleep(1000)
  69     # Creating again returns the same participation
  70     {:ok, %Participation{} = participation_two} =
  71       Participation.create_for_user_and_conversation(user, conversation)
  72
  73     assert participation.id == participation_two.id
  74     refute participation.updated_at == participation_two.updated_at
  75   end
  76
  77   test "recreating an existing participations sets it to unread" do
  78     participation = insert(:participation, %{read: true})
  79
  80     {:ok, participation} =
  81       Participation.create_for_user_and_conversation(
  82         participation.user,
  83         participation.conversation
  84       )
  85
  86     refute participation.read
  87   end
  88
  89   test "it marks a participation as read" do
  90     participation = insert(:participation, %{read: false})
  91     {:ok, participation} = Participation.mark_as_read(participation)
  92
  93     assert participation.read
  94   end
  95
  96   test "it marks a participation as unread" do
  97     participation = insert(:participation, %{read: true})
  98     {:ok, participation} = Participation.mark_as_unread(participation)
  99
 100     refute participation.read
 101   end
 102
 103   test "gets all the participations for a user, ordered by updated at descending" do
 104     user = insert(:user)
 105     {:ok, activity_one} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
 106     :timer.sleep(1000)
 107     {:ok, activity_two} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
 108     :timer.sleep(1000)
 109
 110     {:ok, activity_three} =
 111       CommonAPI.post(user, %{
 112         "status" => "x",
 113         "visibility" => "direct",
 114         "in_reply_to_status_id" => activity_one.id
 115       })
 116
 117     assert [participation_one, participation_two] = Participation.for_user(user)
 118
 119     object2 = Pleroma.Object.normalize(activity_two)
 120     object3 = Pleroma.Object.normalize(activity_three)
 121
 122     user = Repo.get(Pleroma.User, user.id)
 123
 124     assert participation_one.conversation.ap_id == object3.data["context"]
 125     assert participation_two.conversation.ap_id == object2.data["context"]
 126     assert participation_one.conversation.users == [user]
 127
 128     # Pagination
 129     assert [participation_one] = Participation.for_user(user, %{"limit" => 1})
 130
 131     assert participation_one.conversation.ap_id == object3.data["context"]
 132
 133     # With last_activity_id
 134     assert [participation_one] =
 135              Participation.for_user_with_last_activity_id(user, %{"limit" => 1})
 136
 137     assert participation_one.last_activity_id == activity_three.id
 138   end
 139
 140   test "Doesn't die when the conversation gets empty" do
 141     user = insert(:user)
 142
 143     {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
 144     [participation] = Participation.for_user_with_last_activity_id(user)
 145
 146     assert participation.last_activity_id == activity.id
 147
 148     {:ok, _} = CommonAPI.delete(activity.id, user)
 149
 150     [] = Participation.for_user_with_last_activity_id(user)
 151   end
 152
 153   test "it sets recipients, always keeping the owner of the participation even when not explicitly set" do
 154     user = insert(:user)
 155     other_user = insert(:user)
 156
 157     {:ok, _activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
 158     [participation] = Participation.for_user_with_last_activity_id(user)
 159
 160     participation = Repo.preload(participation, :recipients)
 161     user = User.get_cached_by_id(user.id)
 162
 163     assert participation.recipients |> length() == 1
 164     assert user in participation.recipients
 165
 166     {:ok, participation} = Participation.set_recipients(participation, [other_user.id])
 167
 168     assert participation.recipients |> length() == 2
 169     assert user in participation.recipients
 170     assert other_user in participation.recipients
 171   end
 172 end