Mastodon API: Mark the conversation as read for the author when they send a new direc...
[akkoma] / test / web / mastodon_api / views / account_view_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.AccountViewTest do
6 use Pleroma.DataCase
7 import Pleroma.Factory
8 alias Pleroma.User
9 alias Pleroma.Web.CommonAPI
10 alias Pleroma.Web.MastodonAPI.AccountView
11
12 test "Represent a user account" do
13 source_data = %{
14 "tag" => [
15 %{
16 "type" => "Emoji",
17 "icon" => %{"url" => "/file.png"},
18 "name" => ":karjalanpiirakka:"
19 }
20 ]
21 }
22
23 background_image = %{
24 "url" => [%{"href" => "https://example.com/images/asuka_hospital.png"}]
25 }
26
27 user =
28 insert(:user, %{
29 info: %{
30 note_count: 5,
31 follower_count: 3,
32 source_data: source_data,
33 background: background_image
34 },
35 nickname: "shp@shitposter.club",
36 name: ":karjalanpiirakka: shp",
37 bio: "<script src=\"invalid-html\"></script><span>valid html</span>",
38 inserted_at: ~N[2017-08-15 15:47:06.597036]
39 })
40
41 expected = %{
42 id: to_string(user.id),
43 username: "shp",
44 acct: user.nickname,
45 display_name: user.name,
46 locked: false,
47 created_at: "2017-08-15T15:47:06.000Z",
48 followers_count: 3,
49 following_count: 0,
50 statuses_count: 5,
51 note: "<span>valid html</span>",
52 url: user.ap_id,
53 avatar: "http://localhost:4001/images/avi.png",
54 avatar_static: "http://localhost:4001/images/avi.png",
55 header: "http://localhost:4001/images/banner.png",
56 header_static: "http://localhost:4001/images/banner.png",
57 emojis: [
58 %{
59 "static_url" => "/file.png",
60 "url" => "/file.png",
61 "shortcode" => "karjalanpiirakka",
62 "visible_in_picker" => false
63 }
64 ],
65 fields: [],
66 bot: false,
67 source: %{
68 note: "valid html",
69 sensitive: false,
70 pleroma: %{
71 discoverable: false
72 },
73 fields: []
74 },
75 pleroma: %{
76 background_image: "https://example.com/images/asuka_hospital.png",
77 confirmation_pending: false,
78 tags: [],
79 is_admin: false,
80 is_moderator: false,
81 hide_favorites: true,
82 hide_followers: false,
83 hide_follows: false,
84 hide_followers_count: false,
85 hide_follows_count: false,
86 relationship: %{},
87 skip_thread_containment: false
88 }
89 }
90
91 assert expected == AccountView.render("show.json", %{user: user})
92 end
93
94 test "Represent the user account for the account owner" do
95 user = insert(:user)
96
97 notification_settings = %{
98 "followers" => true,
99 "follows" => true,
100 "non_follows" => true,
101 "non_followers" => true
102 }
103
104 privacy = user.info.default_scope
105
106 assert %{
107 pleroma: %{notification_settings: ^notification_settings},
108 source: %{privacy: ^privacy}
109 } = AccountView.render("show.json", %{user: user, for: user})
110 end
111
112 test "Represent a Service(bot) account" do
113 user =
114 insert(:user, %{
115 info: %{note_count: 5, follower_count: 3, source_data: %{"type" => "Service"}},
116 nickname: "shp@shitposter.club",
117 inserted_at: ~N[2017-08-15 15:47:06.597036]
118 })
119
120 expected = %{
121 id: to_string(user.id),
122 username: "shp",
123 acct: user.nickname,
124 display_name: user.name,
125 locked: false,
126 created_at: "2017-08-15T15:47:06.000Z",
127 followers_count: 3,
128 following_count: 0,
129 statuses_count: 5,
130 note: user.bio,
131 url: user.ap_id,
132 avatar: "http://localhost:4001/images/avi.png",
133 avatar_static: "http://localhost:4001/images/avi.png",
134 header: "http://localhost:4001/images/banner.png",
135 header_static: "http://localhost:4001/images/banner.png",
136 emojis: [],
137 fields: [],
138 bot: true,
139 source: %{
140 note: user.bio,
141 sensitive: false,
142 pleroma: %{
143 discoverable: false
144 },
145 fields: []
146 },
147 pleroma: %{
148 background_image: nil,
149 confirmation_pending: false,
150 tags: [],
151 is_admin: false,
152 is_moderator: false,
153 hide_favorites: true,
154 hide_followers: false,
155 hide_follows: false,
156 hide_followers_count: false,
157 hide_follows_count: false,
158 relationship: %{},
159 skip_thread_containment: false
160 }
161 }
162
163 assert expected == AccountView.render("show.json", %{user: user})
164 end
165
166 test "Represent a deactivated user for an admin" do
167 admin = insert(:user, %{info: %{is_admin: true}})
168 deactivated_user = insert(:user, %{info: %{deactivated: true}})
169 represented = AccountView.render("show.json", %{user: deactivated_user, for: admin})
170 assert represented[:pleroma][:deactivated] == true
171 end
172
173 test "Represent a smaller mention" do
174 user = insert(:user)
175
176 expected = %{
177 id: to_string(user.id),
178 acct: user.nickname,
179 username: user.nickname,
180 url: user.ap_id
181 }
182
183 assert expected == AccountView.render("mention.json", %{user: user})
184 end
185
186 describe "relationship" do
187 test "represent a relationship for the following and followed user" do
188 user = insert(:user)
189 other_user = insert(:user)
190
191 {:ok, user} = User.follow(user, other_user)
192 {:ok, other_user} = User.follow(other_user, user)
193 {:ok, other_user} = User.subscribe(user, other_user)
194 {:ok, user} = User.mute(user, other_user, true)
195 {:ok, user} = CommonAPI.hide_reblogs(user, other_user)
196
197 expected = %{
198 id: to_string(other_user.id),
199 following: true,
200 followed_by: true,
201 blocking: false,
202 blocked_by: false,
203 muting: true,
204 muting_notifications: true,
205 subscribing: true,
206 requested: false,
207 domain_blocking: false,
208 showing_reblogs: false,
209 endorsed: false
210 }
211
212 assert expected ==
213 AccountView.render("relationship.json", %{user: user, target: other_user})
214 end
215
216 test "represent a relationship for the blocking and blocked user" do
217 user = insert(:user)
218 other_user = insert(:user)
219
220 {:ok, user} = User.follow(user, other_user)
221 {:ok, other_user} = User.subscribe(user, other_user)
222 {:ok, user} = User.block(user, other_user)
223 {:ok, other_user} = User.block(other_user, user)
224
225 expected = %{
226 id: to_string(other_user.id),
227 following: false,
228 followed_by: false,
229 blocking: true,
230 blocked_by: true,
231 muting: false,
232 muting_notifications: false,
233 subscribing: false,
234 requested: false,
235 domain_blocking: false,
236 showing_reblogs: true,
237 endorsed: false
238 }
239
240 assert expected ==
241 AccountView.render("relationship.json", %{user: user, target: other_user})
242 end
243
244 test "represent a relationship for the user blocking a domain" do
245 user = insert(:user)
246 other_user = insert(:user, ap_id: "https://bad.site/users/other_user")
247
248 {:ok, user} = User.block_domain(user, "bad.site")
249
250 assert %{domain_blocking: true, blocking: false} =
251 AccountView.render("relationship.json", %{user: user, target: other_user})
252 end
253
254 test "represent a relationship for the user with a pending follow request" do
255 user = insert(:user)
256 other_user = insert(:user, %{info: %User.Info{locked: true}})
257
258 {:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
259 user = User.get_cached_by_id(user.id)
260 other_user = User.get_cached_by_id(other_user.id)
261
262 expected = %{
263 id: to_string(other_user.id),
264 following: false,
265 followed_by: false,
266 blocking: false,
267 blocked_by: false,
268 muting: false,
269 muting_notifications: false,
270 subscribing: false,
271 requested: true,
272 domain_blocking: false,
273 showing_reblogs: true,
274 endorsed: false
275 }
276
277 assert expected ==
278 AccountView.render("relationship.json", %{user: user, target: other_user})
279 end
280 end
281
282 test "represent an embedded relationship" do
283 user =
284 insert(:user, %{
285 info: %{note_count: 5, follower_count: 0, source_data: %{"type" => "Service"}},
286 nickname: "shp@shitposter.club",
287 inserted_at: ~N[2017-08-15 15:47:06.597036]
288 })
289
290 other_user = insert(:user)
291 {:ok, other_user} = User.follow(other_user, user)
292 {:ok, other_user} = User.block(other_user, user)
293 {:ok, _} = User.follow(insert(:user), user)
294
295 expected = %{
296 id: to_string(user.id),
297 username: "shp",
298 acct: user.nickname,
299 display_name: user.name,
300 locked: false,
301 created_at: "2017-08-15T15:47:06.000Z",
302 followers_count: 1,
303 following_count: 0,
304 statuses_count: 5,
305 note: user.bio,
306 url: user.ap_id,
307 avatar: "http://localhost:4001/images/avi.png",
308 avatar_static: "http://localhost:4001/images/avi.png",
309 header: "http://localhost:4001/images/banner.png",
310 header_static: "http://localhost:4001/images/banner.png",
311 emojis: [],
312 fields: [],
313 bot: true,
314 source: %{
315 note: user.bio,
316 sensitive: false,
317 pleroma: %{
318 discoverable: false
319 },
320 fields: []
321 },
322 pleroma: %{
323 background_image: nil,
324 confirmation_pending: false,
325 tags: [],
326 is_admin: false,
327 is_moderator: false,
328 hide_favorites: true,
329 hide_followers: false,
330 hide_follows: false,
331 hide_followers_count: false,
332 hide_follows_count: false,
333 relationship: %{
334 id: to_string(user.id),
335 following: false,
336 followed_by: false,
337 blocking: true,
338 blocked_by: false,
339 subscribing: false,
340 muting: false,
341 muting_notifications: false,
342 requested: false,
343 domain_blocking: false,
344 showing_reblogs: true,
345 endorsed: false
346 },
347 skip_thread_containment: false
348 }
349 }
350
351 assert expected == AccountView.render("show.json", %{user: user, for: other_user})
352 end
353
354 test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
355 user = insert(:user, %{info: %User.Info{pleroma_settings_store: %{fe: "test"}}})
356
357 result =
358 AccountView.render("show.json", %{user: user, for: user, with_pleroma_settings: true})
359
360 assert result.pleroma.settings_store == %{:fe => "test"}
361
362 result = AccountView.render("show.json", %{user: user, with_pleroma_settings: true})
363 assert result.pleroma[:settings_store] == nil
364
365 result = AccountView.render("show.json", %{user: user, for: user})
366 assert result.pleroma[:settings_store] == nil
367 end
368
369 test "sanitizes display names" do
370 user = insert(:user, name: "<marquee> username </marquee>")
371 result = AccountView.render("show.json", %{user: user})
372 refute result.display_name == "<marquee> username </marquee>"
373 end
374
375 describe "hiding follows/following" do
376 test "shows when follows/followers stats are hidden and sets follow/follower count to 0" do
377 info = %{
378 hide_followers: true,
379 hide_followers_count: true,
380 hide_follows: true,
381 hide_follows_count: true
382 }
383
384 user = insert(:user, info: info)
385
386 other_user = insert(:user)
387 {:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
388 {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
389
390 assert %{
391 followers_count: 0,
392 following_count: 0,
393 pleroma: %{hide_follows_count: true, hide_followers_count: true}
394 } = AccountView.render("show.json", %{user: user})
395 end
396
397 test "shows when follows/followers are hidden" do
398 user = insert(:user, info: %{hide_followers: true, hide_follows: true})
399 other_user = insert(:user)
400 {:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
401 {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
402
403 assert %{
404 followers_count: 1,
405 following_count: 1,
406 pleroma: %{hide_follows: true, hide_followers: true}
407 } = AccountView.render("show.json", %{user: user})
408 end
409
410 test "shows actual follower/following count to the account owner" do
411 user = insert(:user, info: %{hide_followers: true, hide_follows: true})
412 other_user = insert(:user)
413 {:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
414 {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
415
416 assert %{
417 followers_count: 1,
418 following_count: 1
419 } = AccountView.render("show.json", %{user: user, for: user})
420 end
421
422 test "shows unread_conversation_count only to the account owner" do
423 user = insert(:user)
424 other_user = insert(:user)
425
426 {:ok, _activity} =
427 CommonAPI.post(other_user, %{
428 "status" => "Hey @#{user.nickname}.",
429 "visibility" => "direct"
430 })
431
432 user = User.get_cached_by_ap_id(user.ap_id)
433
434 assert AccountView.render("show.json", %{user: user, for: other_user})[:pleroma][
435 :unread_conversation_count
436 ] == nil
437
438 assert AccountView.render("show.json", %{user: user, for: user})[:pleroma][
439 :unread_conversation_count
440 ] == 1
441 end
442 end
443
444 describe "follow requests counter" do
445 test "shows zero when no follow requests are pending" do
446 user = insert(:user)
447
448 assert %{follow_requests_count: 0} =
449 AccountView.render("show.json", %{user: user, for: user})
450
451 other_user = insert(:user)
452 {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
453
454 assert %{follow_requests_count: 0} =
455 AccountView.render("show.json", %{user: user, for: user})
456 end
457
458 test "shows non-zero when follow requests are pending" do
459 user = insert(:user, %{info: %{locked: true}})
460
461 assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})
462
463 other_user = insert(:user)
464 {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
465
466 assert %{locked: true, follow_requests_count: 1} =
467 AccountView.render("show.json", %{user: user, for: user})
468 end
469
470 test "decreases when accepting a follow request" do
471 user = insert(:user, %{info: %{locked: true}})
472
473 assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})
474
475 other_user = insert(:user)
476 {:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)
477
478 assert %{locked: true, follow_requests_count: 1} =
479 AccountView.render("show.json", %{user: user, for: user})
480
481 {:ok, _other_user} = CommonAPI.accept_follow_request(other_user, user)
482
483 assert %{locked: true, follow_requests_count: 0} =
484 AccountView.render("show.json", %{user: user, for: user})
485 end
486
487 test "decreases when rejecting a follow request" do
488 user = insert(:user, %{info: %{locked: true}})
489
490 assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})
491
492 other_user = insert(:user)
493 {:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)
494
495 assert %{locked: true, follow_requests_count: 1} =
496 AccountView.render("show.json", %{user: user, for: user})
497
498 {:ok, _other_user} = CommonAPI.reject_follow_request(other_user, user)
499
500 assert %{locked: true, follow_requests_count: 0} =
501 AccountView.render("show.json", %{user: user, for: user})
502 end
503
504 test "shows non-zero when historical unapproved requests are present" do
505 user = insert(:user, %{info: %{locked: true}})
506
507 assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})
508
509 other_user = insert(:user)
510 {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
511
512 {:ok, user} = User.update_info(user, &User.Info.user_upgrade(&1, %{locked: false}))
513
514 assert %{locked: false, follow_requests_count: 1} =
515 AccountView.render("show.json", %{user: user, for: user})
516 end
517 end
518 end