1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 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=\"#{
49 }\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
51 assert [%{"status" => %{"content" => response}} | _rest] =
52 json_response_and_validate_schema(conn, 200)
54 assert response == expected_response
57 test "getting a single notification" do
58 %{user: user, conn: conn} = oauth_access(["read:notifications"])
59 other_user = insert(:user)
61 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
63 {:ok, [notification]} = Notification.create_notifications(activity)
65 conn = get(conn, "/api/v1/notifications/#{notification.id}")
68 "hi <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{user.id}\" href=\"#{
70 }\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"
72 assert %{"status" => %{"content" => response}} = json_response_and_validate_schema(conn, 200)
73 assert response == expected_response
76 test "dismissing a single notification (deprecated endpoint)" do
77 %{user: user, conn: conn} = oauth_access(["write:notifications"])
78 other_user = insert(:user)
80 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
82 {:ok, [notification]} = Notification.create_notifications(activity)
86 |> assign(:user, user)
87 |> put_req_header("content-type", "application/json")
88 |> post("/api/v1/notifications/dismiss", %{"id" => to_string(notification.id)})
90 assert %{} = json_response_and_validate_schema(conn, 200)
93 test "dismissing a single notification" do
94 %{user: user, conn: conn} = oauth_access(["write:notifications"])
95 other_user = insert(:user)
97 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
99 {:ok, [notification]} = Notification.create_notifications(activity)
103 |> assign(:user, user)
104 |> post("/api/v1/notifications/#{notification.id}/dismiss")
106 assert %{} = json_response_and_validate_schema(conn, 200)
109 test "clearing all notifications" do
110 %{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
111 other_user = insert(:user)
113 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
115 {:ok, [_notification]} = Notification.create_notifications(activity)
117 ret_conn = post(conn, "/api/v1/notifications/clear")
119 assert %{} = json_response_and_validate_schema(ret_conn, 200)
121 ret_conn = get(conn, "/api/v1/notifications")
123 assert all = json_response_and_validate_schema(ret_conn, 200)
127 test "paginates notifications using min_id, since_id, max_id, and limit" do
128 %{user: user, conn: conn} = oauth_access(["read:notifications"])
129 other_user = insert(:user)
131 {:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
132 {:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
133 {:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
134 {:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
136 notification1_id = get_notification_id_by_activity(activity1)
137 notification2_id = get_notification_id_by_activity(activity2)
138 notification3_id = get_notification_id_by_activity(activity3)
139 notification4_id = get_notification_id_by_activity(activity4)
141 conn = assign(conn, :user, user)
146 |> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
147 |> json_response_and_validate_schema(:ok)
149 assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
154 |> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
155 |> json_response_and_validate_schema(:ok)
157 assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
162 |> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
163 |> json_response_and_validate_schema(:ok)
165 assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
168 describe "exclude_visibilities" do
169 test "filters notifications for mentions" do
170 %{user: user, conn: conn} = oauth_access(["read:notifications"])
171 other_user = insert(:user)
173 {:ok, public_activity} =
174 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "public"})
176 {:ok, direct_activity} =
177 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"})
179 {:ok, unlisted_activity} =
180 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "unlisted"})
182 {:ok, private_activity} =
183 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "private"})
185 query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]})
186 conn_res = get(conn, "/api/v1/notifications?" <> query)
188 assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
189 assert id == direct_activity.id
191 query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "direct"]})
192 conn_res = get(conn, "/api/v1/notifications?" <> query)
194 assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
195 assert id == private_activity.id
197 query = params_to_query(%{exclude_visibilities: ["public", "private", "direct"]})
198 conn_res = get(conn, "/api/v1/notifications?" <> query)
200 assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
201 assert id == unlisted_activity.id
203 query = params_to_query(%{exclude_visibilities: ["unlisted", "private", "direct"]})
204 conn_res = get(conn, "/api/v1/notifications?" <> query)
206 assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
207 assert id == public_activity.id
210 test "filters notifications for Like activities" do
212 %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
214 {:ok, public_activity} =
215 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
217 {:ok, direct_activity} =
218 CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"})
220 {:ok, unlisted_activity} =
221 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})
223 {:ok, private_activity} =
224 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "private"})
226 {:ok, _} = CommonAPI.favorite(user, public_activity.id)
227 {:ok, _} = CommonAPI.favorite(user, direct_activity.id)
228 {:ok, _} = CommonAPI.favorite(user, unlisted_activity.id)
229 {:ok, _} = CommonAPI.favorite(user, private_activity.id)
233 |> get("/api/v1/notifications?exclude_visibilities[]=direct")
234 |> json_response_and_validate_schema(200)
235 |> Enum.map(& &1["status"]["id"])
237 assert public_activity.id in activity_ids
238 assert unlisted_activity.id in activity_ids
239 assert private_activity.id in activity_ids
240 refute direct_activity.id in activity_ids
244 |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
245 |> json_response_and_validate_schema(200)
246 |> Enum.map(& &1["status"]["id"])
248 assert public_activity.id in activity_ids
249 refute unlisted_activity.id in activity_ids
250 assert private_activity.id in activity_ids
251 assert direct_activity.id in activity_ids
255 |> get("/api/v1/notifications?exclude_visibilities[]=private")
256 |> json_response_and_validate_schema(200)
257 |> Enum.map(& &1["status"]["id"])
259 assert public_activity.id in activity_ids
260 assert unlisted_activity.id in activity_ids
261 refute private_activity.id in activity_ids
262 assert direct_activity.id in activity_ids
266 |> get("/api/v1/notifications?exclude_visibilities[]=public")
267 |> json_response_and_validate_schema(200)
268 |> Enum.map(& &1["status"]["id"])
270 refute public_activity.id in activity_ids
271 assert unlisted_activity.id in activity_ids
272 assert private_activity.id in activity_ids
273 assert direct_activity.id in activity_ids
276 test "filters notifications for Announce activities" do
278 %{user: other_user, conn: conn} = oauth_access(["read:notifications"])
280 {:ok, public_activity} =
281 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
283 {:ok, unlisted_activity} =
284 CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})
286 {:ok, _, _} = CommonAPI.repeat(public_activity.id, user)
287 {:ok, _, _} = CommonAPI.repeat(unlisted_activity.id, user)
291 |> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
292 |> json_response_and_validate_schema(200)
293 |> Enum.map(& &1["status"]["id"])
295 assert public_activity.id in activity_ids
296 refute unlisted_activity.id in activity_ids
300 test "filters notifications using exclude_types" do
301 %{user: user, conn: conn} = oauth_access(["read:notifications"])
302 other_user = insert(:user)
304 {:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
305 {:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
306 {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
307 {:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
308 {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
310 mention_notification_id = get_notification_id_by_activity(mention_activity)
311 favorite_notification_id = get_notification_id_by_activity(favorite_activity)
312 reblog_notification_id = get_notification_id_by_activity(reblog_activity)
313 follow_notification_id = get_notification_id_by_activity(follow_activity)
315 query = params_to_query(%{exclude_types: ["mention", "favourite", "reblog"]})
316 conn_res = get(conn, "/api/v1/notifications?" <> query)
318 assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
320 query = params_to_query(%{exclude_types: ["favourite", "reblog", "follow"]})
321 conn_res = get(conn, "/api/v1/notifications?" <> query)
323 assert [%{"id" => ^mention_notification_id}] =
324 json_response_and_validate_schema(conn_res, 200)
326 query = params_to_query(%{exclude_types: ["reblog", "follow", "mention"]})
327 conn_res = get(conn, "/api/v1/notifications?" <> query)
329 assert [%{"id" => ^favorite_notification_id}] =
330 json_response_and_validate_schema(conn_res, 200)
332 query = params_to_query(%{exclude_types: ["follow", "mention", "favourite"]})
333 conn_res = get(conn, "/api/v1/notifications?" <> query)
335 assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
338 test "filters notifications using include_types" do
339 %{user: user, conn: conn} = oauth_access(["read:notifications"])
340 other_user = insert(:user)
342 {:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
343 {:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
344 {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
345 {:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
346 {:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)
348 mention_notification_id = get_notification_id_by_activity(mention_activity)
349 favorite_notification_id = get_notification_id_by_activity(favorite_activity)
350 reblog_notification_id = get_notification_id_by_activity(reblog_activity)
351 follow_notification_id = get_notification_id_by_activity(follow_activity)
353 conn_res = get(conn, "/api/v1/notifications?include_types[]=follow")
355 assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
357 conn_res = get(conn, "/api/v1/notifications?include_types[]=mention")
359 assert [%{"id" => ^mention_notification_id}] =
360 json_response_and_validate_schema(conn_res, 200)
362 conn_res = get(conn, "/api/v1/notifications?include_types[]=favourite")
364 assert [%{"id" => ^favorite_notification_id}] =
365 json_response_and_validate_schema(conn_res, 200)
367 conn_res = get(conn, "/api/v1/notifications?include_types[]=reblog")
369 assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
371 result = conn |> get("/api/v1/notifications") |> json_response_and_validate_schema(200)
373 assert length(result) == 4
375 query = params_to_query(%{include_types: ["follow", "mention", "favourite", "reblog"]})
379 |> get("/api/v1/notifications?" <> query)
380 |> json_response_and_validate_schema(200)
382 assert length(result) == 4
385 test "destroy multiple" do
386 %{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
387 other_user = insert(:user)
389 {:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
390 {:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
391 {:ok, activity3} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
392 {:ok, activity4} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
394 notification1_id = get_notification_id_by_activity(activity1)
395 notification2_id = get_notification_id_by_activity(activity2)
396 notification3_id = get_notification_id_by_activity(activity3)
397 notification4_id = get_notification_id_by_activity(activity4)
401 |> get("/api/v1/notifications")
402 |> json_response_and_validate_schema(:ok)
404 assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result
408 |> assign(:user, other_user)
409 |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:notifications"]))
413 |> get("/api/v1/notifications")
414 |> json_response_and_validate_schema(:ok)
416 assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
418 query = params_to_query(%{ids: [notification1_id, notification2_id]})
419 conn_destroy = delete(conn, "/api/v1/notifications/destroy_multiple?" <> query)
421 assert json_response_and_validate_schema(conn_destroy, 200) == %{}
425 |> get("/api/v1/notifications")
426 |> json_response_and_validate_schema(:ok)
428 assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
431 test "doesn't see notifications after muting user with notifications" do
432 %{user: user, conn: conn} = oauth_access(["read:notifications"])
433 user2 = insert(:user)
435 {:ok, _, _, _} = CommonAPI.follow(user, user2)
436 {:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})
438 ret_conn = get(conn, "/api/v1/notifications")
440 assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
442 {:ok, _user_relationships} = User.mute(user, user2)
444 conn = get(conn, "/api/v1/notifications")
446 assert json_response_and_validate_schema(conn, 200) == []
449 test "see notifications after muting user without notifications" do
450 %{user: user, conn: conn} = oauth_access(["read:notifications"])
451 user2 = insert(:user)
453 {:ok, _, _, _} = CommonAPI.follow(user, user2)
454 {:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})
456 ret_conn = get(conn, "/api/v1/notifications")
458 assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
460 {:ok, _user_relationships} = User.mute(user, user2, false)
462 conn = get(conn, "/api/v1/notifications")
464 assert length(json_response_and_validate_schema(conn, 200)) == 1
467 test "see notifications after muting user with notifications and with_muted parameter" do
468 %{user: user, conn: conn} = oauth_access(["read:notifications"])
469 user2 = insert(:user)
471 {:ok, _, _, _} = CommonAPI.follow(user, user2)
472 {:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})
474 ret_conn = get(conn, "/api/v1/notifications")
476 assert length(json_response_and_validate_schema(ret_conn, 200)) == 1
478 {:ok, _user_relationships} = User.mute(user, user2)
480 conn = get(conn, "/api/v1/notifications?with_muted=true")
482 assert length(json_response_and_validate_schema(conn, 200)) == 1
485 @tag capture_log: true
486 test "see move notifications" do
487 old_user = insert(:user)
488 new_user = insert(:user, also_known_as: [old_user.ap_id])
489 %{user: follower, conn: conn} = oauth_access(["read:notifications"])
491 old_user_url = old_user.ap_id
494 File.read!("test/fixtures/users_mock/localhost.json")
495 |> String.replace("{{nickname}}", old_user.nickname)
499 %{method: :get, url: ^old_user_url} ->
500 %Tesla.Env{status: 200, body: body}
503 User.follow(follower, old_user)
504 Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
505 Pleroma.Tests.ObanHelpers.perform_all()
507 conn = get(conn, "/api/v1/notifications")
509 assert length(json_response_and_validate_schema(conn, 200)) == 1
512 describe "link headers" do
513 test "preserves parameters in link headers" do
514 %{user: user, conn: conn} = oauth_access(["read:notifications"])
515 other_user = insert(:user)
518 CommonAPI.post(other_user, %{
519 "status" => "hi @#{user.nickname}",
520 "visibility" => "public"
524 CommonAPI.post(other_user, %{
525 "status" => "hi @#{user.nickname}",
526 "visibility" => "public"
529 notification1 = Repo.get_by(Notification, activity_id: activity1.id)
530 notification2 = Repo.get_by(Notification, activity_id: activity2.id)
534 |> assign(:user, user)
535 |> get("/api/v1/notifications?limit=5")
537 assert [link_header] = get_resp_header(conn, "link")
538 assert link_header =~ ~r/limit=5/
539 assert link_header =~ ~r/min_id=#{notification2.id}/
540 assert link_header =~ ~r/max_id=#{notification1.id}/
544 describe "from specified user" do
546 %{user: user, conn: conn} = oauth_access(["read:notifications"])
548 %{id: account_id} = other_user1 = insert(:user)
549 other_user2 = insert(:user)
551 {:ok, _activity} = CommonAPI.post(other_user1, %{"status" => "hi @#{user.nickname}"})
552 {:ok, _activity} = CommonAPI.post(other_user2, %{"status" => "bye @#{user.nickname}"})
554 assert [%{"account" => %{"id" => ^account_id}}] =
556 |> assign(:user, user)
557 |> get("/api/v1/notifications?account_id=#{account_id}")
558 |> json_response_and_validate_schema(200)
560 assert %{"error" => "Account is not found"} =
562 |> assign(:user, user)
563 |> get("/api/v1/notifications?account_id=cofe")
564 |> json_response_and_validate_schema(404)
568 defp get_notification_id_by_activity(%{id: id}) do
570 |> Repo.get_by(activity_id: id)
575 defp params_to_query(%{} = params) do
576 Enum.map_join(params, "&", fn
577 {k, v} when is_list(v) -> Enum.map_join(v, "&", &"#{k}[]=#{&1}")
578 {k, v} -> k <> "=" <> v