9de11a87e4238d04ae1960bb37d5dcc24b5eef25
[akkoma] / test / pleroma / web / mastodon_api / views / notification_view_test.exs
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
6 use Pleroma.DataCase
7
8 alias Pleroma.Activity
9 alias Pleroma.Chat
10 alias Pleroma.Chat.MessageReference
11 alias Pleroma.Notification
12 alias Pleroma.Object
13 alias Pleroma.Repo
14 alias Pleroma.User
15 alias Pleroma.Web.AdminAPI.Report
16 alias Pleroma.Web.AdminAPI.ReportView
17 alias Pleroma.Web.CommonAPI
18 alias Pleroma.Web.CommonAPI.Utils
19 alias Pleroma.Web.MastodonAPI.AccountView
20 alias Pleroma.Web.MastodonAPI.NotificationView
21 alias Pleroma.Web.MastodonAPI.StatusView
22 alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView
23 import Pleroma.Factory
24
25 defp test_notifications_rendering(notifications, user, expected_result) do
26 result = NotificationView.render("index.json", %{notifications: notifications, for: user})
27
28 assert expected_result == result
29
30 result =
31 NotificationView.render("index.json", %{
32 notifications: notifications,
33 for: user,
34 relationships: nil
35 })
36
37 assert expected_result == result
38 end
39
40 test "ChatMessage notification" do
41 user = insert(:user)
42 recipient = insert(:user)
43 {:ok, activity} = CommonAPI.post_chat_message(user, recipient, "what's up my dude")
44
45 {:ok, [notification]} = Notification.create_notifications(activity)
46
47 object = Object.normalize(activity)
48 chat = Chat.get(recipient.id, user.ap_id)
49
50 cm_ref = MessageReference.for_chat_and_object(chat, object)
51
52 expected = %{
53 id: to_string(notification.id),
54 pleroma: %{is_seen: false, is_muted: false},
55 type: "pleroma:chat_mention",
56 account: AccountView.render("show.json", %{user: user, for: recipient}),
57 chat_message: MessageReferenceView.render("show.json", %{chat_message_reference: cm_ref}),
58 created_at: Utils.to_masto_date(notification.inserted_at)
59 }
60
61 test_notifications_rendering([notification], recipient, [expected])
62 end
63
64 test "Mention notification" do
65 user = insert(:user)
66 mentioned_user = insert(:user)
67 {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{mentioned_user.nickname}"})
68 {:ok, [notification]} = Notification.create_notifications(activity)
69 user = User.get_cached_by_id(user.id)
70
71 expected = %{
72 id: to_string(notification.id),
73 pleroma: %{is_seen: false, is_muted: false},
74 type: "mention",
75 account:
76 AccountView.render("show.json", %{
77 user: user,
78 for: mentioned_user
79 }),
80 status: StatusView.render("show.json", %{activity: activity, for: mentioned_user}),
81 created_at: Utils.to_masto_date(notification.inserted_at)
82 }
83
84 test_notifications_rendering([notification], mentioned_user, [expected])
85 end
86
87 test "Favourite notification" do
88 user = insert(:user)
89 another_user = insert(:user)
90 {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
91 {:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id)
92 {:ok, [notification]} = Notification.create_notifications(favorite_activity)
93 create_activity = Activity.get_by_id(create_activity.id)
94
95 expected = %{
96 id: to_string(notification.id),
97 pleroma: %{is_seen: false, is_muted: false},
98 type: "favourite",
99 account: AccountView.render("show.json", %{user: another_user, for: user}),
100 status: StatusView.render("show.json", %{activity: create_activity, for: user}),
101 created_at: Utils.to_masto_date(notification.inserted_at)
102 }
103
104 test_notifications_rendering([notification], user, [expected])
105 end
106
107 test "Reblog notification" do
108 user = insert(:user)
109 another_user = insert(:user)
110 {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
111 {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, another_user)
112 {:ok, [notification]} = Notification.create_notifications(reblog_activity)
113 reblog_activity = Activity.get_by_id(create_activity.id)
114
115 expected = %{
116 id: to_string(notification.id),
117 pleroma: %{is_seen: false, is_muted: false},
118 type: "reblog",
119 account: AccountView.render("show.json", %{user: another_user, for: user}),
120 status: StatusView.render("show.json", %{activity: reblog_activity, for: user}),
121 created_at: Utils.to_masto_date(notification.inserted_at)
122 }
123
124 test_notifications_rendering([notification], user, [expected])
125 end
126
127 test "Follow notification" do
128 follower = insert(:user)
129 followed = insert(:user)
130 {:ok, follower, followed, _activity} = CommonAPI.follow(follower, followed)
131 notification = Notification |> Repo.one() |> Repo.preload(:activity)
132
133 expected = %{
134 id: to_string(notification.id),
135 pleroma: %{is_seen: false, is_muted: false},
136 type: "follow",
137 account: AccountView.render("show.json", %{user: follower, for: followed}),
138 created_at: Utils.to_masto_date(notification.inserted_at)
139 }
140
141 test_notifications_rendering([notification], followed, [expected])
142
143 User.perform(:delete, follower)
144 refute Repo.one(Notification)
145 end
146
147 @tag capture_log: true
148 test "Move notification" do
149 old_user = insert(:user)
150 new_user = insert(:user, also_known_as: [old_user.ap_id])
151 follower = insert(:user)
152
153 old_user_url = old_user.ap_id
154
155 body =
156 File.read!("test/fixtures/users_mock/localhost.json")
157 |> String.replace("{{nickname}}", old_user.nickname)
158 |> Jason.encode!()
159
160 Tesla.Mock.mock(fn
161 %{method: :get, url: ^old_user_url} ->
162 %Tesla.Env{status: 200, body: body}
163 end)
164
165 User.follow(follower, old_user)
166 Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
167 Pleroma.Tests.ObanHelpers.perform_all()
168
169 old_user = refresh_record(old_user)
170 new_user = refresh_record(new_user)
171
172 [notification] = Notification.for_user(follower)
173
174 expected = %{
175 id: to_string(notification.id),
176 pleroma: %{is_seen: false, is_muted: false},
177 type: "move",
178 account: AccountView.render("show.json", %{user: old_user, for: follower}),
179 target: AccountView.render("show.json", %{user: new_user, for: follower}),
180 created_at: Utils.to_masto_date(notification.inserted_at)
181 }
182
183 test_notifications_rendering([notification], follower, [expected])
184 end
185
186 test "EmojiReact notification" do
187 user = insert(:user)
188 other_user = insert(:user)
189
190 {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
191 {:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
192
193 activity = Repo.get(Activity, activity.id)
194
195 [notification] = Notification.for_user(user)
196
197 assert notification
198
199 expected = %{
200 id: to_string(notification.id),
201 pleroma: %{is_seen: false, is_muted: false},
202 type: "pleroma:emoji_reaction",
203 emoji: "☕",
204 account: AccountView.render("show.json", %{user: other_user, for: user}),
205 status: StatusView.render("show.json", %{activity: activity, for: user}),
206 created_at: Utils.to_masto_date(notification.inserted_at)
207 }
208
209 test_notifications_rendering([notification], user, [expected])
210 end
211
212 test "Report notification" do
213 reporting_user = insert(:user)
214 reported_user = insert(:user)
215 {:ok, moderator_user} = insert(:user) |> User.admin_api_update(%{is_moderator: true})
216
217 {:ok, activity} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
218 {:ok, [notification]} = Notification.create_notifications(activity)
219
220 expected = %{
221 id: to_string(notification.id),
222 pleroma: %{is_seen: false, is_muted: false},
223 type: "pleroma:report",
224 account: AccountView.render("show.json", %{user: reporting_user, for: moderator_user}),
225 created_at: Utils.to_masto_date(notification.inserted_at),
226 report: ReportView.render("show.json", Report.extract_report_info(activity))
227 }
228
229 test_notifications_rendering([notification], moderator_user, [expected])
230 end
231
232 test "muted notification" do
233 user = insert(:user)
234 another_user = insert(:user)
235
236 {:ok, _} = Pleroma.UserRelationship.create_mute(user, another_user)
237 {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
238 {:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id)
239 {:ok, [notification]} = Notification.create_notifications(favorite_activity)
240 create_activity = Activity.get_by_id(create_activity.id)
241
242 expected = %{
243 id: to_string(notification.id),
244 pleroma: %{is_seen: true, is_muted: true},
245 type: "favourite",
246 account: AccountView.render("show.json", %{user: another_user, for: user}),
247 status: StatusView.render("show.json", %{activity: create_activity, for: user}),
248 created_at: Utils.to_masto_date(notification.inserted_at)
249 }
250
251 test_notifications_rendering([notification], user, [expected])
252 end
253 end