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