1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.CommonAPITest do
8 alias Pleroma.Conversation.Participation
11 alias Pleroma.Web.ActivityPub.ActivityPub
12 alias Pleroma.Web.ActivityPub.Visibility
13 alias Pleroma.Web.CommonAPI
15 import Pleroma.Factory
16 import ExUnit.CaptureLog
18 require Pleroma.Constants
20 clear_config([:instance, :safe_dm_mentions])
21 clear_config([:instance, :limit])
22 clear_config([:instance, :max_pinned_statuses])
24 test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
26 {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
28 [participation] = Participation.for_user(user)
31 CommonAPI.post(user, %{"status" => ".", "in_reply_to_conversation_id" => participation.id})
33 assert Visibility.is_direct?(convo_reply)
35 assert activity.data["context"] == convo_reply.data["context"]
38 test "when replying to a conversation / participation, it only mentions the recipients explicitly declared in the participation" do
40 jafnhar = insert(:user)
44 CommonAPI.post(har, %{
45 "status" => "@#{jafnhar.nickname} hey",
46 "visibility" => "direct"
49 assert har.ap_id in activity.recipients
50 assert jafnhar.ap_id in activity.recipients
52 [participation] = Participation.for_user(har)
55 CommonAPI.post(har, %{
56 "status" => "I don't really like @#{tridi.nickname}",
57 "visibility" => "direct",
58 "in_reply_to_status_id" => activity.id,
59 "in_reply_to_conversation_id" => participation.id
62 assert har.ap_id in activity.recipients
63 assert jafnhar.ap_id in activity.recipients
64 refute tridi.ap_id in activity.recipients
67 test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
69 jafnhar = insert(:user)
71 Pleroma.Config.put([:instance, :safe_dm_mentions], true)
74 CommonAPI.post(har, %{
75 "status" => "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
76 "visibility" => "direct"
79 refute tridi.ap_id in activity.recipients
80 assert jafnhar.ap_id in activity.recipients
83 test "it de-duplicates tags" do
85 {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu #2HU"})
87 object = Object.normalize(activity)
89 assert object.data["tag"] == ["2hu"]
92 test "it adds emoji in the object" do
94 {:ok, activity} = CommonAPI.post(user, %{"status" => ":firefox:"})
96 assert Object.normalize(activity).data["emoji"]["firefox"]
99 test "it adds emoji when updating profiles" do
100 user = insert(:user, %{name: ":firefox:"})
102 {:ok, activity} = CommonAPI.update(user)
103 user = User.get_cached_by_ap_id(user.ap_id)
104 [firefox] = user.info.source_data["tag"]
106 assert firefox["name"] == ":firefox:"
108 assert Pleroma.Constants.as_public() in activity.recipients
111 describe "posting" do
112 test "it supports explicit addressing" do
114 user_two = insert(:user)
115 user_three = insert(:user)
116 user_four = insert(:user)
119 CommonAPI.post(user, %{
121 "Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
122 "to" => [user_two.nickname, user_four.nickname, "nonexistent"]
125 assert user.ap_id in activity.recipients
126 assert user_two.ap_id in activity.recipients
127 assert user_four.ap_id in activity.recipients
128 refute user_three.ap_id in activity.recipients
131 test "it filters out obviously bad tags when accepting a post as HTML" do
134 post = "<p><b>2hu</b></p><script>alert('xss')</script>"
137 CommonAPI.post(user, %{
139 "content_type" => "text/html"
142 object = Object.normalize(activity)
144 assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
147 test "it filters out obviously bad tags when accepting a post as Markdown" do
150 post = "<p><b>2hu</b></p><script>alert('xss')</script>"
153 CommonAPI.post(user, %{
155 "content_type" => "text/markdown"
158 object = Object.normalize(activity)
160 assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
163 test "it does not allow replies to direct messages that are not direct messages themselves" do
166 {:ok, activity} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})
169 CommonAPI.post(user, %{
170 "status" => "suya..",
171 "visibility" => "direct",
172 "in_reply_to_status_id" => activity.id
175 Enum.each(["public", "private", "unlisted"], fn visibility ->
176 assert {:error, "The message visibility must be direct"} =
177 CommonAPI.post(user, %{
178 "status" => "suya..",
179 "visibility" => visibility,
180 "in_reply_to_status_id" => activity.id
185 test "it allows to address a list" do
187 {:ok, list} = Pleroma.List.create("foo", user)
190 CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
192 assert activity.data["bcc"] == [list.ap_id]
193 assert activity.recipients == [list.ap_id, user.ap_id]
194 assert activity.data["listMessage"] == list.ap_id
197 test "it returns error when status is empty and no attachments" do
200 assert {:error, "Cannot post an empty status without attachments"} =
201 CommonAPI.post(user, %{"status" => ""})
204 test "it returns error when character limit is exceeded" do
205 Pleroma.Config.put([:instance, :limit], 5)
209 assert {:error, "The status is over the character limit"} =
210 CommonAPI.post(user, %{"status" => "foobar"})
213 test "it can handle activities that expire" do
217 NaiveDateTime.utc_now()
218 |> NaiveDateTime.truncate(:second)
219 |> NaiveDateTime.add(1_000_000, :second)
221 assert {:ok, activity} =
222 CommonAPI.post(user, %{"status" => "chai", "expires_in" => 1_000_000})
224 assert expiration = Pleroma.ActivityExpiration.get_by_activity_id(activity.id)
225 assert expiration.scheduled_at == expires_at
229 describe "reactions" do
230 test "repeating a status" do
232 other_user = insert(:user)
234 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
236 {:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, user)
239 test "repeating a status privately" do
241 other_user = insert(:user)
243 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
245 {:ok, %Activity{} = announce_activity, _} =
246 CommonAPI.repeat(activity.id, user, %{"visibility" => "private"})
248 assert Visibility.is_private?(announce_activity)
251 test "favoriting a status" do
253 other_user = insert(:user)
255 {:ok, post_activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
257 {:ok, %Activity{data: data}} = CommonAPI.favorite(user, post_activity.id)
258 assert data["type"] == "Like"
259 assert data["actor"] == user.ap_id
260 assert data["object"] == post_activity.data["object"]
263 test "retweeting a status twice returns an error" do
265 other_user = insert(:user)
267 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
268 {:ok, %Activity{}, _object} = CommonAPI.repeat(activity.id, user)
269 {:error, _} = CommonAPI.repeat(activity.id, user)
272 test "favoriting a status twice returns an error" do
274 other_user = insert(:user)
276 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
277 {:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)
279 assert capture_log(fn ->
280 assert {:error, _} = CommonAPI.favorite(user, activity.id)
285 describe "pinned statuses" do
287 Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
290 {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
292 [user: user, activity: activity]
295 test "pin status", %{user: user, activity: activity} do
296 assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
299 user = refresh_record(user)
301 assert %User{info: %{pinned_activities: [^id]}} = user
304 test "unlisted statuses can be pinned", %{user: user} do
305 {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!", "visibility" => "unlisted"})
306 assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
309 test "only self-authored can be pinned", %{activity: activity} do
312 assert {:error, "Could not pin"} = CommonAPI.pin(activity.id, user)
315 test "max pinned statuses", %{user: user, activity: activity_one} do
316 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
318 assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)
320 user = refresh_record(user)
322 assert {:error, "You have already pinned the maximum number of statuses"} =
323 CommonAPI.pin(activity_two.id, user)
326 test "unpin status", %{user: user, activity: activity} do
327 {:ok, activity} = CommonAPI.pin(activity.id, user)
329 user = refresh_record(user)
331 assert {:ok, ^activity} = CommonAPI.unpin(activity.id, user)
333 user = refresh_record(user)
335 assert %User{info: %{pinned_activities: []}} = user
338 test "should unpin when deleting a status", %{user: user, activity: activity} do
339 {:ok, activity} = CommonAPI.pin(activity.id, user)
341 user = refresh_record(user)
343 assert {:ok, _} = CommonAPI.delete(activity.id, user)
345 user = refresh_record(user)
347 assert %User{info: %{pinned_activities: []}} = user
351 describe "mute tests" do
355 activity = insert(:note_activity)
357 [user: user, activity: activity]
360 test "add mute", %{user: user, activity: activity} do
361 {:ok, _} = CommonAPI.add_mute(user, activity)
362 assert CommonAPI.thread_muted?(user, activity)
365 test "remove mute", %{user: user, activity: activity} do
366 CommonAPI.add_mute(user, activity)
367 {:ok, _} = CommonAPI.remove_mute(user, activity)
368 refute CommonAPI.thread_muted?(user, activity)
371 test "check that mutes can't be duplicate", %{user: user, activity: activity} do
372 CommonAPI.add_mute(user, activity)
373 {:error, _} = CommonAPI.add_mute(user, activity)
377 describe "reports" do
378 test "creates a report" do
379 reporter = insert(:user)
380 target_user = insert(:user)
382 {:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})
384 reporter_ap_id = reporter.ap_id
385 target_ap_id = target_user.ap_id
386 activity_ap_id = activity.data["id"]
390 "account_id" => target_user.id,
391 "comment" => comment,
392 "status_ids" => [activity.id]
395 assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)
398 actor: ^reporter_ap_id,
401 "content" => ^comment,
402 "object" => [^target_ap_id, ^activity_ap_id],
408 test "updates report state" do
409 [reporter, target_user] = insert_pair(:user)
410 activity = insert(:note_activity, user: target_user)
412 {:ok, %Activity{id: report_id}} =
413 CommonAPI.report(reporter, %{
414 "account_id" => target_user.id,
415 "comment" => "I feel offended",
416 "status_ids" => [activity.id]
419 {:ok, report} = CommonAPI.update_report_state(report_id, "resolved")
421 assert report.data["state"] == "resolved"
424 test "does not update report state when state is unsupported" do
425 [reporter, target_user] = insert_pair(:user)
426 activity = insert(:note_activity, user: target_user)
428 {:ok, %Activity{id: report_id}} =
429 CommonAPI.report(reporter, %{
430 "account_id" => target_user.id,
431 "comment" => "I feel offended",
432 "status_ids" => [activity.id]
435 assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
439 describe "reblog muting" do
441 muter = insert(:user)
443 muted = insert(:user)
445 [muter: muter, muted: muted]
448 test "add a reblog mute", %{muter: muter, muted: muted} do
449 {:ok, muter} = CommonAPI.hide_reblogs(muter, muted)
451 assert User.showing_reblogs?(muter, muted) == false
454 test "remove a reblog mute", %{muter: muter, muted: muted} do
455 {:ok, muter} = CommonAPI.hide_reblogs(muter, muted)
456 {:ok, muter} = CommonAPI.show_reblogs(muter, muted)
458 assert User.showing_reblogs?(muter, muted) == true
462 describe "unfollow/2" do
463 test "also unsubscribes a user" do
464 [follower, followed] = insert_pair(:user)
465 {:ok, follower, followed, _} = CommonAPI.follow(follower, followed)
466 {:ok, followed} = User.subscribe(follower, followed)
468 assert User.subscribed_to?(follower, followed)
470 {:ok, follower} = CommonAPI.unfollow(follower, followed)
472 refute User.subscribed_to?(follower, followed)
476 describe "accept_follow_request/2" do
477 test "after acceptance, it sets all existing pending follow request states to 'accept'" do
478 user = insert(:user, info: %{locked: true})
479 follower = insert(:user)
480 follower_two = insert(:user)
482 {:ok, follow_activity} = ActivityPub.follow(follower, user)
483 {:ok, follow_activity_two} = ActivityPub.follow(follower, user)
484 {:ok, follow_activity_three} = ActivityPub.follow(follower_two, user)
486 assert follow_activity.data["state"] == "pending"
487 assert follow_activity_two.data["state"] == "pending"
488 assert follow_activity_three.data["state"] == "pending"
490 {:ok, _follower} = CommonAPI.accept_follow_request(follower, user)
492 assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
493 assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
494 assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
497 test "after rejection, it sets all existing pending follow request states to 'reject'" do
498 user = insert(:user, info: %{locked: true})
499 follower = insert(:user)
500 follower_two = insert(:user)
502 {:ok, follow_activity} = ActivityPub.follow(follower, user)
503 {:ok, follow_activity_two} = ActivityPub.follow(follower, user)
504 {:ok, follow_activity_three} = ActivityPub.follow(follower_two, user)
506 assert follow_activity.data["state"] == "pending"
507 assert follow_activity_two.data["state"] == "pending"
508 assert follow_activity_three.data["state"] == "pending"
510 {:ok, _follower} = CommonAPI.reject_follow_request(follower, user)
512 assert Repo.get(Activity, follow_activity.id).data["state"] == "reject"
513 assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
514 assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
519 test "does not allow to vote twice" do
521 other_user = insert(:user)
524 CommonAPI.post(user, %{
525 "status" => "Am I cute?",
526 "poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
529 object = Object.normalize(activity)
531 {:ok, _, object} = CommonAPI.vote(other_user, object, [0])
533 assert {:error, "Already voted"} == CommonAPI.vote(other_user, object, [1])
537 describe "listen/2" do
538 test "returns a valid activity" do
542 CommonAPI.listen(user, %{
543 "title" => "lain radio episode 1",
544 "album" => "lain radio",
549 object = Object.normalize(activity)
551 assert object.data["title"] == "lain radio episode 1"
553 assert Visibility.get_visibility(activity) == "public"
556 test "respects visibility=private" do
560 CommonAPI.listen(user, %{
561 "title" => "lain radio episode 1",
562 "album" => "lain radio",
565 "visibility" => "private"
568 object = Object.normalize(activity)
570 assert object.data["title"] == "lain radio episode 1"
572 assert Visibility.get_visibility(activity) == "private"