Merge branch 'feature/ci-registry' into 'develop'
[akkoma] / 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
9 alias Pleroma.Conversation.Participation
10 alias Pleroma.Repo
11 alias Pleroma.User
12 alias Pleroma.Web.CommonAPI
13
14 test "getting a participation will also preload things" do
15 user = insert(:user)
16 other_user = insert(:user)
17
18 {:ok, _activity} =
19 CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"})
20
21 [participation] = Participation.for_user(user)
22
23 participation = Participation.get(participation.id, preload: [:conversation])
24
25 assert %Pleroma.Conversation{} = participation.conversation
26 end
27
28 test "for a new conversation or a reply, it doesn't mark the author's participation as unread" do
29 user = insert(:user)
30 other_user = insert(:user)
31
32 {:ok, _} =
33 CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"})
34
35 user = User.get_cached_by_id(user.id)
36 other_user = User.get_cached_by_id(other_user.id)
37
38 [%{read: true}] = Participation.for_user(user)
39 [%{read: false} = participation] = Participation.for_user(other_user)
40
41 assert User.get_cached_by_id(user.id).unread_conversation_count == 0
42 assert User.get_cached_by_id(other_user.id).unread_conversation_count == 1
43
44 {:ok, _} =
45 CommonAPI.post(other_user, %{
46 "status" => "Hey @#{user.nickname}.",
47 "visibility" => "direct",
48 "in_reply_to_conversation_id" => participation.id
49 })
50
51 user = User.get_cached_by_id(user.id)
52 other_user = User.get_cached_by_id(other_user.id)
53
54 [%{read: false}] = Participation.for_user(user)
55 [%{read: true}] = Participation.for_user(other_user)
56
57 assert User.get_cached_by_id(user.id).unread_conversation_count == 1
58 assert User.get_cached_by_id(other_user.id).unread_conversation_count == 0
59 end
60
61 test "for a new conversation, it sets the recipents of the participation" do
62 user = insert(:user)
63 other_user = insert(:user)
64 third_user = insert(:user)
65
66 {:ok, activity} =
67 CommonAPI.post(user, %{"status" => "Hey @#{other_user.nickname}.", "visibility" => "direct"})
68
69 user = User.get_cached_by_id(user.id)
70 other_user = User.get_cached_by_id(other_user.id)
71 [participation] = Participation.for_user(user)
72 participation = Pleroma.Repo.preload(participation, :recipients)
73
74 assert length(participation.recipients) == 2
75 assert user in participation.recipients
76 assert other_user in participation.recipients
77
78 # Mentioning another user in the same conversation will not add a new recipients.
79
80 {:ok, _activity} =
81 CommonAPI.post(user, %{
82 "in_reply_to_status_id" => activity.id,
83 "status" => "Hey @#{third_user.nickname}.",
84 "visibility" => "direct"
85 })
86
87 [participation] = Participation.for_user(user)
88 participation = Pleroma.Repo.preload(participation, :recipients)
89
90 assert length(participation.recipients) == 2
91 end
92
93 test "it creates a participation for a conversation and a user" do
94 user = insert(:user)
95 conversation = insert(:conversation)
96
97 {:ok, %Participation{} = participation} =
98 Participation.create_for_user_and_conversation(user, conversation)
99
100 assert participation.user_id == user.id
101 assert participation.conversation_id == conversation.id
102
103 # Needed because updated_at is accurate down to a second
104 :timer.sleep(1000)
105
106 # Creating again returns the same participation
107 {:ok, %Participation{} = participation_two} =
108 Participation.create_for_user_and_conversation(user, conversation)
109
110 assert participation.id == participation_two.id
111 refute participation.updated_at == participation_two.updated_at
112 end
113
114 test "recreating an existing participations sets it to unread" do
115 participation = insert(:participation, %{read: true})
116
117 {:ok, participation} =
118 Participation.create_for_user_and_conversation(
119 participation.user,
120 participation.conversation
121 )
122
123 refute participation.read
124 end
125
126 test "it marks a participation as read" do
127 participation = insert(:participation, %{read: false})
128 {:ok, updated_participation} = Participation.mark_as_read(participation)
129
130 assert updated_participation.read
131 assert updated_participation.updated_at == participation.updated_at
132 end
133
134 test "it marks a participation as unread" do
135 participation = insert(:participation, %{read: true})
136 {:ok, participation} = Participation.mark_as_unread(participation)
137
138 refute participation.read
139 end
140
141 test "it marks all the user's participations as read" do
142 user = insert(:user)
143 other_user = insert(:user)
144 participation1 = insert(:participation, %{read: false, user: user})
145 participation2 = insert(:participation, %{read: false, user: user})
146 participation3 = insert(:participation, %{read: false, user: other_user})
147
148 {:ok, _, [%{read: true}, %{read: true}]} = Participation.mark_all_as_read(user)
149
150 assert Participation.get(participation1.id).read == true
151 assert Participation.get(participation2.id).read == true
152 assert Participation.get(participation3.id).read == false
153 end
154
155 test "gets all the participations for a user, ordered by updated at descending" do
156 user = insert(:user)
157 {:ok, activity_one} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
158 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
159
160 {:ok, activity_three} =
161 CommonAPI.post(user, %{
162 "status" => "x",
163 "visibility" => "direct",
164 "in_reply_to_status_id" => activity_one.id
165 })
166
167 # Offset participations because the accuracy of updated_at is down to a second
168
169 for {activity, offset} <- [{activity_two, 1}, {activity_three, 2}] do
170 conversation = Conversation.get_for_ap_id(activity.data["context"])
171 participation = Participation.for_user_and_conversation(user, conversation)
172 updated_at = NaiveDateTime.add(Map.get(participation, :updated_at), offset)
173
174 Ecto.Changeset.change(participation, %{updated_at: updated_at})
175 |> Repo.update!()
176 end
177
178 assert [participation_one, participation_two] = Participation.for_user(user)
179
180 object2 = Pleroma.Object.normalize(activity_two)
181 object3 = Pleroma.Object.normalize(activity_three)
182
183 user = Repo.get(Pleroma.User, user.id)
184
185 assert participation_one.conversation.ap_id == object3.data["context"]
186 assert participation_two.conversation.ap_id == object2.data["context"]
187 assert participation_one.conversation.users == [user]
188
189 # Pagination
190 assert [participation_one] = Participation.for_user(user, %{"limit" => 1})
191
192 assert participation_one.conversation.ap_id == object3.data["context"]
193
194 # With last_activity_id
195 assert [participation_one] =
196 Participation.for_user_with_last_activity_id(user, %{"limit" => 1})
197
198 assert participation_one.last_activity_id == activity_three.id
199 end
200
201 test "Doesn't die when the conversation gets empty" do
202 user = insert(:user)
203
204 {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
205 [participation] = Participation.for_user_with_last_activity_id(user)
206
207 assert participation.last_activity_id == activity.id
208
209 {:ok, _} = CommonAPI.delete(activity.id, user)
210
211 [] = Participation.for_user_with_last_activity_id(user)
212 end
213
214 test "it sets recipients, always keeping the owner of the participation even when not explicitly set" do
215 user = insert(:user)
216 other_user = insert(:user)
217
218 {:ok, _activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
219 [participation] = Participation.for_user_with_last_activity_id(user)
220
221 participation = Repo.preload(participation, :recipients)
222 user = User.get_cached_by_id(user.id)
223
224 assert participation.recipients |> length() == 1
225 assert user in participation.recipients
226
227 {:ok, participation} = Participation.set_recipients(participation, [other_user.id])
228
229 assert participation.recipients |> length() == 2
230 assert user in participation.recipients
231 assert other_user in participation.recipients
232 end
233
234 describe "blocking" do
235 test "when the user blocks a recipient, the existing conversations with them are marked as read" do
236 blocker = insert(:user)
237 blocked = insert(:user)
238 third_user = insert(:user)
239
240 {:ok, _direct1} =
241 CommonAPI.post(third_user, %{
242 "status" => "Hi @#{blocker.nickname}",
243 "visibility" => "direct"
244 })
245
246 {:ok, _direct2} =
247 CommonAPI.post(third_user, %{
248 "status" => "Hi @#{blocker.nickname}, @#{blocked.nickname}",
249 "visibility" => "direct"
250 })
251
252 {:ok, _direct3} =
253 CommonAPI.post(blocked, %{
254 "status" => "Hi @#{blocker.nickname}",
255 "visibility" => "direct"
256 })
257
258 {:ok, _direct4} =
259 CommonAPI.post(blocked, %{
260 "status" => "Hi @#{blocker.nickname}, @#{third_user.nickname}",
261 "visibility" => "direct"
262 })
263
264 assert [%{read: false}, %{read: false}, %{read: false}, %{read: false}] =
265 Participation.for_user(blocker)
266
267 assert User.get_cached_by_id(blocker.id).unread_conversation_count == 4
268
269 {:ok, _user_relationship} = User.block(blocker, blocked)
270
271 # The conversations with the blocked user are marked as read
272 assert [%{read: true}, %{read: true}, %{read: true}, %{read: false}] =
273 Participation.for_user(blocker)
274
275 assert User.get_cached_by_id(blocker.id).unread_conversation_count == 1
276
277 # The conversation is not marked as read for the blocked user
278 assert [_, _, %{read: false}] = Participation.for_user(blocked)
279 assert User.get_cached_by_id(blocked.id).unread_conversation_count == 1
280
281 # The conversation is not marked as read for the third user
282 assert [%{read: false}, _, _] = Participation.for_user(third_user)
283 assert User.get_cached_by_id(third_user.id).unread_conversation_count == 1
284 end
285
286 test "the new conversation with the blocked user is not marked as unread " do
287 blocker = insert(:user)
288 blocked = insert(:user)
289 third_user = insert(:user)
290
291 {:ok, _user_relationship} = User.block(blocker, blocked)
292
293 # When the blocked user is the author
294 {:ok, _direct1} =
295 CommonAPI.post(blocked, %{
296 "status" => "Hi @#{blocker.nickname}",
297 "visibility" => "direct"
298 })
299
300 assert [%{read: true}] = Participation.for_user(blocker)
301 assert User.get_cached_by_id(blocker.id).unread_conversation_count == 0
302
303 # When the blocked user is a recipient
304 {:ok, _direct2} =
305 CommonAPI.post(third_user, %{
306 "status" => "Hi @#{blocker.nickname}, @#{blocked.nickname}",
307 "visibility" => "direct"
308 })
309
310 assert [%{read: true}, %{read: true}] = Participation.for_user(blocker)
311 assert User.get_cached_by_id(blocker.id).unread_conversation_count == 0
312
313 assert [%{read: false}, _] = Participation.for_user(blocked)
314 assert User.get_cached_by_id(blocked.id).unread_conversation_count == 1
315 end
316
317 test "the conversation with the blocked user is not marked as unread on a reply" do
318 blocker = insert(:user)
319 blocked = insert(:user)
320 third_user = insert(:user)
321
322 {:ok, _direct1} =
323 CommonAPI.post(blocker, %{
324 "status" => "Hi @#{third_user.nickname}, @#{blocked.nickname}",
325 "visibility" => "direct"
326 })
327
328 {:ok, _user_relationship} = User.block(blocker, blocked)
329 assert [%{read: true}] = Participation.for_user(blocker)
330 assert User.get_cached_by_id(blocker.id).unread_conversation_count == 0
331
332 assert [blocked_participation] = Participation.for_user(blocked)
333
334 # When it's a reply from the blocked user
335 {:ok, _direct2} =
336 CommonAPI.post(blocked, %{
337 "status" => "reply",
338 "visibility" => "direct",
339 "in_reply_to_conversation_id" => blocked_participation.id
340 })
341
342 assert [%{read: true}] = Participation.for_user(blocker)
343 assert User.get_cached_by_id(blocker.id).unread_conversation_count == 0
344
345 assert [third_user_participation] = Participation.for_user(third_user)
346
347 # When it's a reply from the third user
348 {:ok, _direct3} =
349 CommonAPI.post(third_user, %{
350 "status" => "reply",
351 "visibility" => "direct",
352 "in_reply_to_conversation_id" => third_user_participation.id
353 })
354
355 assert [%{read: true}] = Participation.for_user(blocker)
356 assert User.get_cached_by_id(blocker.id).unread_conversation_count == 0
357
358 # Marked as unread for the blocked user
359 assert [%{read: false}] = Participation.for_user(blocked)
360 assert User.get_cached_by_id(blocked.id).unread_conversation_count == 1
361 end
362 end
363 end