Merge branch 'develop' into issue/1383
[akkoma] / test / web / mastodon_api / controllers / notification_controller_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.Web.MastodonAPI.NotificationControllerTest do
6 use Pleroma.Web.ConnCase
7
8 alias Pleroma.Notification
9 alias Pleroma.Repo
10 alias Pleroma.User
11 alias Pleroma.Web.CommonAPI
12
13 import Pleroma.Factory
14
15 test "list of notifications" do
16 %{user: user, conn: conn} = oauth_access(["read:notifications"])
17 other_user = insert(:user)
18
19 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
20
21 {:ok, [_notification]} = Notification.create_notifications(activity)
22
23 conn =
24 conn
25 |> assign(:user, user)
26 |> get("/api/v1/notifications")
27
28 expected_response =
29 "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
30 user.ap_id
31 }\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
32
33 assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
34 assert response == expected_response
35 end
36
37 test "getting a single notification" do
38 %{user: user, conn: conn} = oauth_access(["read:notifications"])
39 other_user = insert(:user)
40
41 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
42
43 {:ok, [notification]} = Notification.create_notifications(activity)
44
45 conn = get(conn, "/api/v1/notifications/#{notification.id}")
46
47 expected_response =
48 "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
49 user.ap_id
50 }\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
51
52 assert %{"status" => %{"content" => response}} = json_response(conn, 200)
53 assert response == expected_response
54 end
55
56 test "dismissing a single notification" do
57 %{user: user, conn: conn} = oauth_access(["write:notifications"])
58 other_user = insert(:user)
59
60 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
61
62 {:ok, [notification]} = Notification.create_notifications(activity)
63
64 conn =
65 conn
66 |> assign(:user, user)
67 |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
68
69 assert %{} = json_response(conn, 200)
70 end
71
72 test "clearing all notifications" do
73 %{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
74 other_user = insert(:user)
75
76 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
77
78 {:ok, [_notification]} = Notification.create_notifications(activity)
79
80 ret_conn = post(conn, "/api/v1/notifications/clear")
81
82 assert %{} = json_response(ret_conn, 200)
83
84 ret_conn = get(conn, "/api/v1/notifications")
85
86 assert all = json_response(ret_conn, 200)
87 assert all == []
88 end
89
90 test "paginates notifications using min_id, since_id, max_id, and limit" do
91 %{user: user, conn: conn} = oauth_access(["read:notifications"])
92 other_user = insert(:user)
93
94 {:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
95 {:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
96 {:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
97 {:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
98
99 notification1_id = get_notification_id_by_activity(activity1)
100 notification2_id = get_notification_id_by_activity(activity2)
101 notification3_id = get_notification_id_by_activity(activity3)
102 notification4_id = get_notification_id_by_activity(activity4)
103
104 conn = assign(conn, :user, user)
105
106 # min_id
107 result =
108 conn
109 |> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
110 |> json_response(:ok)
111
112 assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
113
114 # since_id
115 result =
116 conn
117 |> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
118 |> json_response(:ok)
119
120 assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
121
122 # max_id
123 result =
124 conn
125 |> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
126 |> json_response(:ok)
127
128 assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
129 end
130
131 describe "exclude_visibilities" do
132 test "filters notifications for mentions" do
133 %{user: user, conn: conn} = oauth_access(["read:notifications"])
134 other_user = insert(:user)
135
136 {:ok, public_activity} =
137 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "public"})
138
139 {:ok, direct_activity} =
140 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"})
141
142 {:ok, unlisted_activity} =
143 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "unlisted"})
144
145 {:ok, private_activity} =
146 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "private"})
147
148 conn_res =
149 get(conn, "/api/v1/notifications", %{
150 exclude_visibilities: ["public", "unlisted", "private"]
151 })
152
153 assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
154 assert id == direct_activity.id
155
156 conn_res =
157 get(conn, "/api/v1/notifications", %{
158 exclude_visibilities: ["public", "unlisted", "direct"]
159 })
160
161 assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
162 assert id == private_activity.id
163
164 conn_res =
165 get(conn, "/api/v1/notifications", %{
166 exclude_visibilities: ["public", "private", "direct"]
167 })
168
169 assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
170 assert id == unlisted_activity.id
171
172 conn_res =
173 get(conn, "/api/v1/notifications", %{
174 exclude_visibilities: ["unlisted", "private", "direct"]
175 })
176
177 assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
178 assert id == public_activity.id
179 end
180
181 test "filters notifications for Like activities" do
182 user = insert(:user)
183 %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
184
185 {:ok, public_activity} =
186 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
187
188 {:ok, direct_activity} =
189 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"})
190
191 {:ok, unlisted_activity} =
192 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})
193
194 {:ok, private_activity} =
195 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "private"})
196
197 {:ok, _, _} = CommonAPI.favorite(public_activity.id, user)
198 {:ok, _, _} = CommonAPI.favorite(direct_activity.id, user)
199 {:ok, _, _} = CommonAPI.favorite(unlisted_activity.id, user)
200 {:ok, _, _} = CommonAPI.favorite(private_activity.id, user)
201
202 activity_ids =
203 conn
204 |> get("/api/v1/notifications", %{exclude_visibilities: ["direct"]})
205 |> json_response(200)
206 |> Enum.map(& &1["status"]["id"])
207
208 assert public_activity.id in activity_ids
209 assert unlisted_activity.id in activity_ids
210 assert private_activity.id in activity_ids
211 refute direct_activity.id in activity_ids
212
213 activity_ids =
214 conn
215 |> get("/api/v1/notifications", %{exclude_visibilities: ["unlisted"]})
216 |> json_response(200)
217 |> Enum.map(& &1["status"]["id"])
218
219 assert public_activity.id in activity_ids
220 refute unlisted_activity.id in activity_ids
221 assert private_activity.id in activity_ids
222 assert direct_activity.id in activity_ids
223
224 activity_ids =
225 conn
226 |> get("/api/v1/notifications", %{exclude_visibilities: ["private"]})
227 |> json_response(200)
228 |> Enum.map(& &1["status"]["id"])
229
230 assert public_activity.id in activity_ids
231 assert unlisted_activity.id in activity_ids
232 refute private_activity.id in activity_ids
233 assert direct_activity.id in activity_ids
234
235 activity_ids =
236 conn
237 |> get("/api/v1/notifications", %{exclude_visibilities: ["public"]})
238 |> json_response(200)
239 |> Enum.map(& &1["status"]["id"])
240
241 refute public_activity.id in activity_ids
242 assert unlisted_activity.id in activity_ids
243 assert private_activity.id in activity_ids
244 assert direct_activity.id in activity_ids
245 end
246
247 test "filters notifications for Announce activities" do
248 user = insert(:user)
249 %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
250
251 {:ok, public_activity} =
252 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
253
254 {:ok, unlisted_activity} =
255 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})
256
257 {:ok, _, _} = CommonAPI.repeat(public_activity.id, user)
258 {:ok, _, _} = CommonAPI.repeat(unlisted_activity.id, user)
259
260 activity_ids =
261 conn
262 |> get("/api/v1/notifications", %{exclude_visibilities: ["unlisted"]})
263 |> json_response(200)
264 |> Enum.map(& &1["status"]["id"])
265
266 assert public_activity.id in activity_ids
267 refute unlisted_activity.id in activity_ids
268 end
269 end
270
271 test "filters notifications using exclude_types" do
272 %{user: user, conn: conn} = oauth_access(["read:notifications"])
273 other_user = insert(:user)
274
275 {:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
276 {:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
277 {:ok, favorite_activity, _} = CommonAPI.favorite(create_activity.id, other_user)
278 {:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
279 {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
280
281 mention_notification_id = get_notification_id_by_activity(mention_activity)
282 favorite_notification_id = get_notification_id_by_activity(favorite_activity)
283 reblog_notification_id = get_notification_id_by_activity(reblog_activity)
284 follow_notification_id = get_notification_id_by_activity(follow_activity)
285
286 conn_res =
287 get(conn, "/api/v1/notifications", %{exclude_types: ["mention", "favourite", "reblog"]})
288
289 assert [%{"id" => ^follow_notification_id}] = json_response(conn_res, 200)
290
291 conn_res =
292 get(conn, "/api/v1/notifications", %{exclude_types: ["favourite", "reblog", "follow"]})
293
294 assert [%{"id" => ^mention_notification_id}] = json_response(conn_res, 200)
295
296 conn_res =
297 get(conn, "/api/v1/notifications", %{exclude_types: ["reblog", "follow", "mention"]})
298
299 assert [%{"id" => ^favorite_notification_id}] = json_response(conn_res, 200)
300
301 conn_res =
302 get(conn, "/api/v1/notifications", %{exclude_types: ["follow", "mention", "favourite"]})
303
304 assert [%{"id" => ^reblog_notification_id}] = json_response(conn_res, 200)
305 end
306
307 test "destroy multiple" do
308 %{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
309 other_user = insert(:user)
310
311 {:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
312 {:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
313 {:ok, activity3} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
314 {:ok, activity4} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
315
316 notification1_id = get_notification_id_by_activity(activity1)
317 notification2_id = get_notification_id_by_activity(activity2)
318 notification3_id = get_notification_id_by_activity(activity3)
319 notification4_id = get_notification_id_by_activity(activity4)
320
321 result =
322 conn
323 |> get("/api/v1/notifications")
324 |> json_response(:ok)
325
326 assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result
327
328 conn2 =
329 conn
330 |> assign(:user, other_user)
331 |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:notifications"]))
332
333 result =
334 conn2
335 |> get("/api/v1/notifications")
336 |> json_response(:ok)
337
338 assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
339
340 conn_destroy =
341 conn
342 |> delete("/api/v1/notifications/destroy_multiple", %{
343 "ids" => [notification1_id, notification2_id]
344 })
345
346 assert json_response(conn_destroy, 200) == %{}
347
348 result =
349 conn2
350 |> get("/api/v1/notifications")
351 |> json_response(:ok)
352
353 assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
354 end
355
356 test "doesn't see notifications after muting user with notifications" do
357 %{user: user, conn: conn} = oauth_access(["read:notifications"])
358 user2 = insert(:user)
359
360 {:ok, _, _, _} = CommonAPI.follow(user, user2)
361 {:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})
362
363 ret_conn = get(conn, "/api/v1/notifications")
364
365 assert length(json_response(ret_conn, 200)) == 1
366
367 {:ok, _user_relationships} = User.mute(user, user2)
368
369 conn = get(conn, "/api/v1/notifications")
370
371 assert json_response(conn, 200) == []
372 end
373
374 test "see notifications after muting user without notifications" do
375 %{user: user, conn: conn} = oauth_access(["read:notifications"])
376 user2 = insert(:user)
377
378 {:ok, _, _, _} = CommonAPI.follow(user, user2)
379 {:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})
380
381 ret_conn = get(conn, "/api/v1/notifications")
382
383 assert length(json_response(ret_conn, 200)) == 1
384
385 {:ok, _user_relationships} = User.mute(user, user2, false)
386
387 conn = get(conn, "/api/v1/notifications")
388
389 assert length(json_response(conn, 200)) == 1
390 end
391
392 test "see notifications after muting user with notifications and with_muted parameter" do
393 %{user: user, conn: conn} = oauth_access(["read:notifications"])
394 user2 = insert(:user)
395
396 {:ok, _, _, _} = CommonAPI.follow(user, user2)
397 {:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})
398
399 ret_conn = get(conn, "/api/v1/notifications")
400
401 assert length(json_response(ret_conn, 200)) == 1
402
403 {:ok, _user_relationships} = User.mute(user, user2)
404
405 conn = get(conn, "/api/v1/notifications", %{"with_muted" => "true"})
406
407 assert length(json_response(conn, 200)) == 1
408 end
409
410 test "see move notifications with `with_move` parameter" do
411 old_user = insert(:user)
412 new_user = insert(:user, also_known_as: [old_user.ap_id])
413 %{user: follower, conn: conn} = oauth_access(["read:notifications"])
414
415 User.follow(follower, old_user)
416 Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
417 Pleroma.Tests.ObanHelpers.perform_all()
418
419 ret_conn = get(conn, "/api/v1/notifications")
420
421 assert json_response(ret_conn, 200) == []
422
423 conn = get(conn, "/api/v1/notifications", %{"with_move" => "true"})
424
425 assert length(json_response(conn, 200)) == 1
426 end
427
428 describe "link headers" do
429 test "preserves parameters in link headers" do
430 %{user: user, conn: conn} = oauth_access(["read:notifications"])
431 other_user = insert(:user)
432
433 {:ok, activity1} =
434 CommonAPI.post(other_user, %{
435 "status" => "hi @#{user.nickname}",
436 "visibility" => "public"
437 })
438
439 {:ok, activity2} =
440 CommonAPI.post(other_user, %{
441 "status" => "hi @#{user.nickname}",
442 "visibility" => "public"
443 })
444
445 notification1 = Repo.get_by(Notification, activity_id: activity1.id)
446 notification2 = Repo.get_by(Notification, activity_id: activity2.id)
447
448 conn =
449 conn
450 |> assign(:user, user)
451 |> get("/api/v1/notifications", %{media_only: true})
452
453 assert [link_header] = get_resp_header(conn, "link")
454 assert link_header =~ ~r/media_only=true/
455 assert link_header =~ ~r/min_id=#{notification2.id}/
456 assert link_header =~ ~r/max_id=#{notification1.id}/
457 end
458 end
459
460 describe "from specified user" do
461 test "account_id" do
462 %{user: user, conn: conn} = oauth_access(["read:notifications"])
463
464 %{id: account_id} = other_user1 = insert(:user)
465 other_user2 = insert(:user)
466
467 {:ok, _activity} = CommonAPI.post(other_user1, %{"status" => "hi @#{user.nickname}"})
468 {:ok, _activity} = CommonAPI.post(other_user2, %{"status" => "bye @#{user.nickname}"})
469
470 assert [%{"account" => %{"id" => ^account_id}}] =
471 conn
472 |> assign(:user, user)
473 |> get("/api/v1/notifications", %{account_id: account_id})
474 |> json_response(200)
475
476 assert %{"error" => "Account is not found"} =
477 conn
478 |> assign(:user, user)
479 |> get("/api/v1/notifications", %{account_id: "cofe"})
480 |> json_response(404)
481 end
482 end
483
484 defp get_notification_id_by_activity(%{id: id}) do
485 Notification
486 |> Repo.get_by(activity_id: id)
487 |> Map.get(:id)
488 |> to_string()
489 end
490 end