1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
6 use Pleroma.Web.ConnCase
8 alias Pleroma.Notification
11 alias Pleroma.Web.CommonAPI
13 import Pleroma.Factory
15 test "does NOT render account/pleroma/relationship by default" do
16 %{user: user, conn: conn} = oauth_access(["read:notifications"])
17 other_user = insert(:user)
19 {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
20 {:ok, [_notification]} = Notification.create_notifications(activity)
24 |> assign(:user, user)
25 |> get("/api/v1/notifications")
26 |> json_response_and_validate_schema(200)
28 assert Enum.all?(response, fn n ->
29 get_in(n, ["account", "pleroma", "relationship"]) == %{}
33 test "list of notifications" do
34 %{user: user, conn: conn} = oauth_access(["read:notifications"])
35 other_user = insert(:user)
37 {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
39 {:ok, [_notification]} = Notification.create_notifications(activity)
43 |> assign(:user, user)
44 |> get("/api/v1/notifications")
47 "hi <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{user.id}\" href=\"#{user.ap_id}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
49 assert [%{"status" => %{"content" => response}} | _rest] =
50 json_response_and_validate_schema(conn, 200)
52 assert response == expected_response
55 test "by default, does not contain pleroma:chat_mention" do
56 %{user: user, conn: conn} = oauth_access(["read:notifications"])
57 other_user = insert(:user)
59 {:ok, _activity} = CommonAPI.post_chat_message(other_user, user, "hey")
63 |> get("/api/v1/notifications")
64 |> json_response_and_validate_schema(200)
70 |> get("/api/v1/notifications?include_types[]=pleroma:chat_mention")
71 |> json_response_and_validate_schema(200)
76 test "by default, does not contain pleroma:report" do
77 %{user: user, conn: conn} = oauth_access(["read:notifications"])
78 other_user = insert(:user)
79 third_user = insert(:user)
82 |> User.admin_api_update(%{is_moderator: true})
84 {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
87 CommonAPI.report(third_user, %{account_id: other_user.id, status_ids: [activity.id]})
91 |> get("/api/v1/notifications")
92 |> json_response_and_validate_schema(200)
98 |> get("/api/v1/notifications?include_types[]=pleroma:report")
99 |> json_response_and_validate_schema(200)
104 test "getting a single notification" do
105 %{user: user, conn: conn} = oauth_access(["read:notifications"])
106 other_user = insert(:user)
108 {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
110 {:ok, [notification]} = Notification.create_notifications(activity)
112 conn = get(conn, "/api/v1/notifications/#{notification.id}")
115 "hi <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{user.id}\" href=\"#{user.ap_id}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
117 assert %{"status" => %{"content" => response}} = json_response_and_validate_schema(conn, 200)
118 assert response == expected_response
121 test "dismissing a single notification (deprecated endpoint)" do
122 %{user: user, conn: conn} = oauth_access(["write:notifications"])
123 other_user = insert(:user)
125 {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
127 {:ok, [notification]} = Notification.create_notifications(activity)
131 |> assign(:user, user)
132 |> put_req_header("content-type", "application/json")
133 |> post("/api/v1/notifications/dismiss", %{"id" => to_string(notification.id)})
135 assert %{} = json_response_and_validate_schema(conn, 200)
138 test "dismissing a single notification" do
139 %{user: user, conn: conn} = oauth_access(["write:notifications"])
140 other_user = insert(:user)
142 {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
144 {:ok, [notification]} = Notification.create_notifications(activity)
148 |> assign(:user, user)
149 |> post("/api/v1/notifications/#{notification.id}/dismiss")
151 assert %{} = json_response_and_validate_schema(conn, 200)
154 test "clearing all notifications" do
155 %{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
156 other_user = insert(:user)
158 {:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
160 {:ok, [_notification]} = Notification.create_notifications(activity)
162 ret_conn = post(conn, "/api/v1/notifications/clear")
164 assert %{} = json_response_and_validate_schema(ret_conn, 200)
166 ret_conn = get(conn, "/api/v1/notifications")
168 assert all = json_response_and_validate_schema(ret_conn, 200)
172 test "paginates notifications using min_id, since_id, max_id, and limit" do
173 %{user: user, conn: conn} = oauth_access(["read:notifications"])
174 other_user = insert(:user)
176 {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
177 {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
178 {:ok, activity3} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
179 {:ok, activity4} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
181 notification1_id = get_notification_id_by_activity(activity1)
182 notification2_id = get_notification_id_by_activity(activity2)
183 notification3_id = get_notification_id_by_activity(activity3)
184 notification4_id = get_notification_id_by_activity(activity4)
186 conn = assign(conn, :user, user)
191 |> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
192 |> json_response_and_validate_schema(:ok)
194 assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
199 |> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
200 |> json_response_and_validate_schema(:ok)
202 assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
207 |> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
208 |> json_response_and_validate_schema(:ok)
210 assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
213 describe "exclude_visibilities" do
214 test "filters notifications for mentions" do
215 %{user: user, conn: conn} = oauth_access(["read:notifications"])
216 other_user = insert(:user)
218 {:ok, public_activity} =
219 CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "public"})
221 {:ok, direct_activity} =
222 CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
224 {:ok, unlisted_activity} =
225 CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "unlisted"})
227 {:ok, private_activity} =
228 CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "private"})
230 query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]})
231 conn_res = get(conn, "/api/v1/notifications?" <> query)
233 assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
234 assert id == direct_activity.id
236 query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "direct"]})
237 conn_res = get(conn, "/api/v1/notifications?" <> query)
239 assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
240 assert id == private_activity.id
242 query = params_to_query(%{exclude_visibilities: ["public", "private", "direct"]})
243 conn_res = get(conn, "/api/v1/notifications?" <> query)
245 assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
246 assert id == unlisted_activity.id
248 query = params_to_query(%{exclude_visibilities: ["unlisted", "private", "direct"]})
249 conn_res = get(conn, "/api/v1/notifications?" <> query)
251 assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
252 assert id == public_activity.id
255 test "filters notifications for Like activities" do
257 %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
259 {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
261 {:ok, direct_activity} =
262 CommonAPI.post(other_user, %{status: "@#{user.nickname}", visibility: "direct"})
264 {:ok, unlisted_activity} =
265 CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
267 {:ok, private_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "private"})
269 {:ok, _} = CommonAPI.favorite(user, public_activity.id)
270 {:ok, _} = CommonAPI.favorite(user, direct_activity.id)
271 {:ok, _} = CommonAPI.favorite(user, unlisted_activity.id)
272 {:ok, _} = CommonAPI.favorite(user, private_activity.id)
276 |> get("/api/v1/notifications?exclude_visibilities[]=direct")
277 |> json_response_and_validate_schema(200)
278 |> Enum.map(& &1["status"]["id"])
280 assert public_activity.id in activity_ids
281 assert unlisted_activity.id in activity_ids
282 assert private_activity.id in activity_ids
283 refute direct_activity.id in activity_ids
287 |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
288 |> json_response_and_validate_schema(200)
289 |> Enum.map(& &1["status"]["id"])
291 assert public_activity.id in activity_ids
292 refute unlisted_activity.id in activity_ids
293 assert private_activity.id in activity_ids
294 assert direct_activity.id in activity_ids
298 |> get("/api/v1/notifications?exclude_visibilities[]=private")
299 |> json_response_and_validate_schema(200)
300 |> Enum.map(& &1["status"]["id"])
302 assert public_activity.id in activity_ids
303 assert unlisted_activity.id in activity_ids
304 refute private_activity.id in activity_ids
305 assert direct_activity.id in activity_ids
309 |> get("/api/v1/notifications?exclude_visibilities[]=public")
310 |> json_response_and_validate_schema(200)
311 |> Enum.map(& &1["status"]["id"])
313 refute public_activity.id in activity_ids
314 assert unlisted_activity.id in activity_ids
315 assert private_activity.id in activity_ids
316 assert direct_activity.id in activity_ids
319 test "filters notifications for Announce activities" do
321 %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
323 {:ok, public_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "public"})
325 {:ok, unlisted_activity} =
326 CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})
328 {:ok, _} = CommonAPI.repeat(public_activity.id, user)
329 {:ok, _} = CommonAPI.repeat(unlisted_activity.id, user)
333 |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
334 |> json_response_and_validate_schema(200)
335 |> Enum.map(& &1["status"]["id"])
337 assert public_activity.id in activity_ids
338 refute unlisted_activity.id in activity_ids
341 test "doesn't return less than the requested amount of records when the user's reply is liked" do
343 %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
346 CommonAPI.post(user, %{status: "@#{other_user.nickname}", visibility: "public"})
348 {:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})
351 CommonAPI.post(other_user, %{
353 visibility: "public",
354 in_reply_to_status_id: activity.id
357 {:ok, _favorite} = CommonAPI.favorite(user, reply.id)
361 |> get("/api/v1/notifications?exclude_visibilities[]=direct&limit=2")
362 |> json_response_and_validate_schema(200)
363 |> Enum.map(& &1["status"]["id"])
365 assert [reply.id, mention.id] == activity_ids
369 test "filters notifications using exclude_types" do
370 %{user: user, conn: conn} = oauth_access(["read:notifications"])
371 other_user = insert(:user)
373 {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
374 {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
375 {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
376 {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
377 {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
379 mention_notification_id = get_notification_id_by_activity(mention_activity)
380 favorite_notification_id = get_notification_id_by_activity(favorite_activity)
381 reblog_notification_id = get_notification_id_by_activity(reblog_activity)
382 follow_notification_id = get_notification_id_by_activity(follow_activity)
384 query = params_to_query(%{exclude_types: ["mention", "favourite", "reblog"]})
385 conn_res = get(conn, "/api/v1/notifications?" <> query)
387 assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
389 query = params_to_query(%{exclude_types: ["favourite", "reblog", "follow"]})
390 conn_res = get(conn, "/api/v1/notifications?" <> query)
392 assert [%{"id" => ^mention_notification_id}] =
393 json_response_and_validate_schema(conn_res, 200)
395 query = params_to_query(%{exclude_types: ["reblog", "follow", "mention"]})
396 conn_res = get(conn, "/api/v1/notifications?" <> query)
398 assert [%{"id" => ^favorite_notification_id}] =
399 json_response_and_validate_schema(conn_res, 200)
401 query = params_to_query(%{exclude_types: ["follow", "mention", "favourite"]})
402 conn_res = get(conn, "/api/v1/notifications?" <> query)
404 assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
407 test "filters notifications using include_types" do
408 %{user: user, conn: conn} = oauth_access(["read:notifications"])
409 other_user = insert(:user)
411 {:ok, mention_activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
412 {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
413 {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
414 {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, other_user)
415 {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
417 mention_notification_id = get_notification_id_by_activity(mention_activity)
418 favorite_notification_id = get_notification_id_by_activity(favorite_activity)
419 reblog_notification_id = get_notification_id_by_activity(reblog_activity)
420 follow_notification_id = get_notification_id_by_activity(follow_activity)
422 conn_res = get(conn, "/api/v1/notifications?include_types[]=follow")
424 assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
426 conn_res = get(conn, "/api/v1/notifications?include_types[]=mention")
428 assert [%{"id" => ^mention_notification_id}] =
429 json_response_and_validate_schema(conn_res, 200)
431 conn_res = get(conn, "/api/v1/notifications?include_types[]=favourite")
433 assert [%{"id" => ^favorite_notification_id}] =
434 json_response_and_validate_schema(conn_res, 200)
436 conn_res = get(conn, "/api/v1/notifications?include_types[]=reblog")
438 assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
440 result = conn |> get("/api/v1/notifications") |> json_response_and_validate_schema(200)
442 assert length(result) == 4
444 query = params_to_query(%{include_types: ["follow", "mention", "favourite", "reblog"]})
448 |> get("/api/v1/notifications?" <> query)
449 |> json_response_and_validate_schema(200)
451 assert length(result) == 4
454 test "destroy multiple" do
455 %{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
456 other_user = insert(:user)
458 {:ok, activity1} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
459 {:ok, activity2} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
460 {:ok, activity3} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
461 {:ok, activity4} = CommonAPI.post(user, %{status: "hi @#{other_user.nickname}"})
463 notification1_id = get_notification_id_by_activity(activity1)
464 notification2_id = get_notification_id_by_activity(activity2)
465 notification3_id = get_notification_id_by_activity(activity3)
466 notification4_id = get_notification_id_by_activity(activity4)
470 |> get("/api/v1/notifications")
471 |> json_response_and_validate_schema(:ok)
473 assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result
477 |> assign(:user, other_user)
478 |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:notifications"]))
482 |> get("/api/v1/notifications")
483 |> json_response_and_validate_schema(:ok)
485 assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
487 query = params_to_query(%{ids: [notification1_id, notification2_id]})
488 conn_destroy = delete(conn, "/api/v1/notifications/destroy_multiple?" <> query)
490 assert json_response_and_validate_schema(conn_destroy, 200) == %{}
494 |> get("/api/v1/notifications")
495 |> json_response_and_validate_schema(:ok)
497 assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
500 test "doesn't see notifications after muting user with notifications" do
501 %{user: user, conn: conn} = oauth_access(["read:notifications"])
502 user2 = insert(:user)
504 {:ok, _, _, _} = CommonAPI.follow(user, user2)
505 {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
507 ret_conn = get(conn, "/api/v1/notifications")
509 assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
511 {:ok, _user_relationships} = User.mute(user, user2)
513 conn = get(conn, "/api/v1/notifications")
515 assert json_response_and_validate_schema(conn, 200) == []
518 test "see notifications after muting user without notifications" do
519 %{user: user, conn: conn} = oauth_access(["read:notifications"])
520 user2 = insert(:user)
522 {:ok, _, _, _} = CommonAPI.follow(user, user2)
523 {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
525 ret_conn = get(conn, "/api/v1/notifications")
527 assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
529 {:ok, _user_relationships} = User.mute(user, user2, %{notifications: false})
531 conn = get(conn, "/api/v1/notifications")
533 assert length(json_response_and_validate_schema(conn, 200)) == 1
536 test "see notifications after muting user with notifications and with_muted parameter" do
537 %{user: user, conn: conn} = oauth_access(["read:notifications"])
538 user2 = insert(:user)
540 {:ok, _, _, _} = CommonAPI.follow(user, user2)
541 {:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})
543 ret_conn = get(conn, "/api/v1/notifications")
545 assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
547 {:ok, _user_relationships} = User.mute(user, user2)
549 conn = get(conn, "/api/v1/notifications?with_muted=true")
551 assert length(json_response_and_validate_schema(conn, 200)) == 1
554 test "see move notifications" do
555 old_user = insert(:user)
556 new_user = insert(:user, also_known_as: [old_user.ap_id])
557 %{user: follower, conn: conn} = oauth_access(["read:notifications"])
559 User.follow(follower, old_user)
560 Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
561 Pleroma.Tests.ObanHelpers.perform_all()
563 conn = get(conn, "/api/v1/notifications")
565 assert length(json_response_and_validate_schema(conn, 200)) == 1
568 describe "link headers" do
569 test "preserves parameters in link headers" do
570 %{user: user, conn: conn} = oauth_access(["read:notifications"])
571 other_user = insert(:user)
574 CommonAPI.post(other_user, %{
575 status: "hi @#{user.nickname}",
580 CommonAPI.post(other_user, %{
581 status: "hi @#{user.nickname}",
585 notification1 = Repo.get_by(Notification, activity_id: activity1.id)
586 notification2 = Repo.get_by(Notification, activity_id: activity2.id)
590 |> assign(:user, user)
591 |> get("/api/v1/notifications?limit=5")
593 assert [link_header] = get_resp_header(conn, "link")
594 assert link_header =~ ~r/limit=5/
595 assert link_header =~ ~r/min_id=#{notification2.id}/
596 assert link_header =~ ~r/max_id=#{notification1.id}/
600 describe "from specified user" do
602 %{user: user, conn: conn} = oauth_access(["read:notifications"])
604 %{id: account_id} = other_user1 = insert(:user)
605 other_user2 = insert(:user)
607 {:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi @#{user.nickname}"})
608 {:ok, _activity} = CommonAPI.post(other_user2, %{status: "bye @#{user.nickname}"})
610 assert [%{"account" => %{"id" => ^account_id}}] =
612 |> assign(:user, user)
613 |> get("/api/v1/notifications?account_id=#{account_id}")
614 |> json_response_and_validate_schema(200)
616 assert %{"error" => "Account is not found"} =
618 |> assign(:user, user)
619 |> get("/api/v1/notifications?account_id=cofe")
620 |> json_response_and_validate_schema(404)
624 defp get_notification_id_by_activity(%{id: id}) do
626 |> Repo.get_by(activity_id: id)
631 defp params_to_query(%{} = params) do
632 Enum.map_join(params, "&", fn
633 {k, v} when is_list(v) -> Enum.map_join(v, "&", &"#{k}[]=#{&1}")
634 {k, v} -> k <> "=" <> v