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 Mix.Tasks.Pleroma.UserTest do
10 alias Pleroma.Tests.ObanHelpers
12 alias Pleroma.Web.CommonAPI
13 alias Pleroma.Web.OAuth.Authorization
14 alias Pleroma.Web.OAuth.Token
17 use Oban.Testing, repo: Pleroma.Repo
19 import ExUnit.CaptureIO
21 import Pleroma.Factory
24 Mix.shell(Mix.Shell.Process)
27 Mix.shell(Mix.Shell.IO)
33 describe "running new" do
34 test "user is created" do
35 # just get random data
36 unsaved = build(:user)
38 # prepare to answer yes
39 send(self(), {:mix_shell_input, :prompt, "Y"})
41 Mix.Tasks.Pleroma.User.run([
55 assert_received {:mix_shell, :info, [message]}
56 assert message =~ "user will be created"
58 assert_received {:mix_shell, :prompt, [message]}
59 assert message =~ "Continue"
61 assert_received {:mix_shell, :info, [message]}
62 assert message =~ "created"
64 user = User.get_cached_by_nickname(unsaved.nickname)
65 assert user.name == unsaved.name
66 assert user.email == unsaved.email
67 assert user.bio == unsaved.bio
68 assert user.is_moderator
72 test "user is not created" do
73 unsaved = build(:user)
75 # prepare to answer no
76 send(self(), {:mix_shell_input, :prompt, "N"})
78 Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])
80 assert_received {:mix_shell, :info, [message]}
81 assert message =~ "user will be created"
83 assert_received {:mix_shell, :prompt, [message]}
84 assert message =~ "Continue"
86 assert_received {:mix_shell, :info, [message]}
87 assert message =~ "will not be created"
89 refute User.get_cached_by_nickname(unsaved.nickname)
93 describe "running rm" do
94 test "user is deleted" do
95 clear_config([:instance, :federating], true)
98 with_mock Pleroma.Web.Federator,
99 publish: fn _ -> nil end do
100 Mix.Tasks.Pleroma.User.run(["rm", user.nickname])
101 ObanHelpers.perform_all()
103 assert_received {:mix_shell, :info, [message]}
104 assert message =~ " deleted"
105 assert %{is_active: false} = User.get_by_nickname(user.nickname)
107 assert called(Pleroma.Web.Federator.publish(:_))
111 test "a remote user's create activity is deleted when the object has been pruned" do
113 user2 = insert(:user)
115 {:ok, post} = CommonAPI.post(user, %{status: "uguu"})
116 {:ok, post2} = CommonAPI.post(user2, %{status: "test"})
117 obj = Object.normalize(post2, fetch: false)
119 {:ok, like_object, meta} = Pleroma.Web.ActivityPub.Builder.like(user, obj)
121 {:ok, like_activity, _meta} =
122 Pleroma.Web.ActivityPub.Pipeline.common_pipeline(
124 Keyword.put(meta, :local, true)
127 like_activity.data["object"]
128 |> Pleroma.Object.get_by_ap_id()
131 clear_config([:instance, :federating], true)
133 object = Object.normalize(post, fetch: false)
136 with_mock Pleroma.Web.Federator,
137 publish: fn _ -> nil end do
138 Mix.Tasks.Pleroma.User.run(["rm", user.nickname])
139 ObanHelpers.perform_all()
141 assert_received {:mix_shell, :info, [message]}
142 assert message =~ " deleted"
143 assert %{is_active: false} = User.get_by_nickname(user.nickname)
145 assert called(Pleroma.Web.Federator.publish(:_))
146 refute Pleroma.Repo.get(Pleroma.Activity, like_activity.id)
149 refute Activity.get_by_id(post.id)
152 test "no user to delete" do
153 Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])
155 assert_received {:mix_shell, :error, [message]}
156 assert message =~ "No local user"
160 describe "running deactivate" do
161 test "active user is deactivated and unsubscribed" do
162 followed = insert(:user)
163 remote_followed = insert(:user, local: false)
166 User.follow(user, followed, :follow_accept)
167 User.follow(user, remote_followed, :follow_accept)
169 Mix.Tasks.Pleroma.User.run(["deactivate", user.nickname])
171 # Note that the task has delay :timer.sleep(500)
172 assert_received {:mix_shell, :info, [message]}
175 "Successfully deactivated #{user.nickname} and unsubscribed all local followers"
177 user = User.get_cached_by_nickname(user.nickname)
178 assert Enum.empty?(Enum.filter(User.get_friends(user), & &1.local))
179 refute user.is_active
182 test "user is deactivated" do
183 %{id: id, nickname: nickname} = insert(:user, is_active: false)
185 assert :ok = Mix.Tasks.Pleroma.User.run(["deactivate", nickname])
186 assert_received {:mix_shell, :info, [message]}
187 assert message == "User #{nickname} already deactivated"
189 user = Repo.get(User, id)
190 refute user.is_active
193 test "no user to deactivate" do
194 Mix.Tasks.Pleroma.User.run(["deactivate", "nonexistent"])
196 assert_received {:mix_shell, :error, [message]}
197 assert message =~ "No user"
201 describe "running set" do
202 test "All statuses set" do
205 Mix.Tasks.Pleroma.User.run([
214 assert_received {:mix_shell, :info, [message]}
215 assert message =~ ~r/Admin status .* true/
217 assert_received {:mix_shell, :info, [message]}
218 assert message =~ ~r/Confirmation status.* true/
220 assert_received {:mix_shell, :info, [message]}
221 assert message =~ ~r/Locked status .* true/
223 assert_received {:mix_shell, :info, [message]}
224 assert message =~ ~r/Moderator status .* true/
226 user = User.get_cached_by_nickname(user.nickname)
227 assert user.is_moderator
228 assert user.is_locked
230 assert user.is_confirmed
233 test "All statuses unset" do
242 Mix.Tasks.Pleroma.User.run([
251 assert_received {:mix_shell, :info, [message]}
252 assert message =~ ~r/Admin status .* false/
254 assert_received {:mix_shell, :info, [message]}
255 assert message =~ ~r/Confirmation status.* false/
257 assert_received {:mix_shell, :info, [message]}
258 assert message =~ ~r/Locked status .* false/
260 assert_received {:mix_shell, :info, [message]}
261 assert message =~ ~r/Moderator status .* false/
263 user = User.get_cached_by_nickname(user.nickname)
264 refute user.is_moderator
265 refute user.is_locked
267 refute user.is_confirmed
270 test "no user to set status" do
271 Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])
273 assert_received {:mix_shell, :error, [message]}
274 assert message =~ "No local user"
278 describe "running reset_password" do
279 test "password reset token is generated" do
282 assert capture_io(fn ->
283 Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
286 assert_received {:mix_shell, :info, [message]}
287 assert message =~ "Generated"
290 test "no user to reset password" do
291 Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
293 assert_received {:mix_shell, :error, [message]}
294 assert message =~ "No local user"
298 describe "running reset_mfa" do
299 test "disables MFA" do
302 multi_factor_authentication_settings: %MFA.Settings{
304 totp: %MFA.Settings.TOTP{secret: "xx", confirmed: true}
308 Mix.Tasks.Pleroma.User.run(["reset_mfa", user.nickname])
310 assert_received {:mix_shell, :info, [message]}
311 assert message == "Multi-Factor Authentication disabled for #{user.nickname}"
313 assert %{enabled: false, totp: false} ==
315 |> User.get_cached_by_nickname()
316 |> MFA.mfa_settings()
319 test "no user to reset MFA" do
320 Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
322 assert_received {:mix_shell, :error, [message]}
323 assert message =~ "No local user"
327 describe "running invite" do
328 test "invite token is generated" do
329 assert capture_io(fn ->
330 Mix.Tasks.Pleroma.User.run(["invite"])
333 assert_received {:mix_shell, :info, [message]}
334 assert message =~ "Generated user invite token one time"
337 test "token is generated with expires_at" do
338 assert capture_io(fn ->
339 Mix.Tasks.Pleroma.User.run([
342 Date.to_string(Date.utc_today())
346 assert_received {:mix_shell, :info, [message]}
347 assert message =~ "Generated user invite token date limited"
350 test "token is generated with max use" do
351 assert capture_io(fn ->
352 Mix.Tasks.Pleroma.User.run([
359 assert_received {:mix_shell, :info, [message]}
360 assert message =~ "Generated user invite token reusable"
363 test "token is generated with max use and expires date" do
364 assert capture_io(fn ->
365 Mix.Tasks.Pleroma.User.run([
370 Date.to_string(Date.utc_today())
374 assert_received {:mix_shell, :info, [message]}
375 assert message =~ "Generated user invite token reusable date limited"
379 describe "running invites" do
380 test "invites are listed" do
381 {:ok, invite} = Pleroma.UserInviteToken.create_invite()
384 Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})
386 # assert capture_io(fn ->
387 Mix.Tasks.Pleroma.User.run([
393 assert_received {:mix_shell, :info, [message]}
394 assert_received {:mix_shell, :info, [message2]}
395 assert_received {:mix_shell, :info, [message3]}
396 assert message =~ "Invites list:"
397 assert message2 =~ invite.invite_type
398 assert message3 =~ invite2.invite_type
402 describe "running revoke_invite" do
403 test "invite is revoked" do
404 {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
406 assert capture_io(fn ->
407 Mix.Tasks.Pleroma.User.run([
413 assert_received {:mix_shell, :info, [message]}
414 assert message =~ "Invite for token #{invite.token} was revoked."
418 describe "running delete_activities" do
419 test "activities are deleted" do
420 %{nickname: nickname} = insert(:user)
422 assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
423 assert_received {:mix_shell, :info, [message]}
424 assert message == "User #{nickname} statuses deleted."
427 test "it prints an error message when user is not exist" do
428 Mix.Tasks.Pleroma.User.run(["delete_activities", "foo"])
430 assert_received {:mix_shell, :error, [message]}
431 assert message =~ "No local user"
435 describe "running confirm" do
436 test "user is confirmed" do
437 %{id: id, nickname: nickname} = insert(:user, is_confirmed: true)
439 assert :ok = Mix.Tasks.Pleroma.User.run(["confirm", nickname])
440 assert_received {:mix_shell, :info, [message]}
441 assert message == "#{nickname} doesn't need confirmation."
443 user = Repo.get(User, id)
444 assert user.is_confirmed
445 refute user.confirmation_token
448 test "user is not confirmed" do
449 %{id: id, nickname: nickname} =
450 insert(:user, is_confirmed: false, confirmation_token: "some token")
452 assert :ok = Mix.Tasks.Pleroma.User.run(["confirm", nickname])
453 assert_received {:mix_shell, :info, [message]}
454 assert message == "#{nickname} doesn't need confirmation."
456 user = Repo.get(User, id)
457 assert user.is_confirmed
458 refute user.confirmation_token
461 test "it prints an error message when user is not exist" do
462 Mix.Tasks.Pleroma.User.run(["confirm", "foo"])
464 assert_received {:mix_shell, :error, [message]}
465 assert message =~ "No local user"
469 describe "running activate" do
470 test "user is activated" do
471 %{id: id, nickname: nickname} = insert(:user, is_active: true)
473 assert :ok = Mix.Tasks.Pleroma.User.run(["activate", nickname])
474 assert_received {:mix_shell, :info, [message]}
475 assert message == "User #{nickname} already activated"
477 user = Repo.get(User, id)
478 assert user.is_active
481 test "user is not activated" do
482 %{id: id, nickname: nickname} = insert(:user, is_active: false)
484 assert :ok = Mix.Tasks.Pleroma.User.run(["activate", nickname])
485 assert_received {:mix_shell, :info, [message]}
486 assert message == "Successfully activated #{nickname}"
488 user = Repo.get(User, id)
489 assert user.is_active
492 test "no user to activate" do
493 Mix.Tasks.Pleroma.User.run(["activate", "foo"])
495 assert_received {:mix_shell, :error, [message]}
496 assert message =~ "No user"
501 test "it returns users matching" do
503 moon = insert(:user, nickname: "moon", name: "fediverse expert moon")
504 moot = insert(:user, nickname: "moot")
505 kawen = insert(:user, nickname: "kawen", name: "fediverse expert moon")
507 {:ok, user, moon} = User.follow(user, moon)
509 assert [moon.id, kawen.id] == User.Search.search("moon") |> Enum.map(& &1.id)
511 res = User.search("moo") |> Enum.map(& &1.id)
512 assert Enum.sort([moon.id, moot.id, kawen.id]) == Enum.sort(res)
514 assert [kawen.id, moon.id] == User.Search.search("expert fediverse") |> Enum.map(& &1.id)
516 assert [moon.id, kawen.id] ==
517 User.Search.search("expert fediverse", for_user: user) |> Enum.map(& &1.id)
521 describe "signing out" do
522 test "it deletes all user's tokens and authorizations" do
524 insert(:oauth_token, user: user)
525 insert(:oauth_authorization, user: user)
527 assert Repo.get_by(Token, user_id: user.id)
528 assert Repo.get_by(Authorization, user_id: user.id)
530 :ok = Mix.Tasks.Pleroma.User.run(["sign_out", user.nickname])
532 refute Repo.get_by(Token, user_id: user.id)
533 refute Repo.get_by(Authorization, user_id: user.id)
536 test "it prints an error message when user is not exist" do
537 Mix.Tasks.Pleroma.User.run(["sign_out", "foo"])
539 assert_received {:mix_shell, :error, [message]}
540 assert message =~ "No local user"
544 describe "tagging" do
545 test "it add tags to a user" do
548 :ok = Mix.Tasks.Pleroma.User.run(["tag", user.nickname, "pleroma"])
550 user = User.get_cached_by_nickname(user.nickname)
551 assert "pleroma" in user.tags
554 test "it prints an error message when user is not exist" do
555 Mix.Tasks.Pleroma.User.run(["tag", "foo"])
557 assert_received {:mix_shell, :error, [message]}
558 assert message =~ "Could not change user tags"
562 describe "untagging" do
563 test "it deletes tags from a user" do
564 user = insert(:user, tags: ["pleroma"])
565 assert "pleroma" in user.tags
567 :ok = Mix.Tasks.Pleroma.User.run(["untag", user.nickname, "pleroma"])
569 user = User.get_cached_by_nickname(user.nickname)
570 assert Enum.empty?(user.tags)
573 test "it prints an error message when user is not exist" do
574 Mix.Tasks.Pleroma.User.run(["untag", "foo"])
576 assert_received {:mix_shell, :error, [message]}
577 assert message =~ "Could not change user tags"
581 describe "bulk confirm and unconfirm" do
582 test "confirm all" do
583 user1 = insert(:user, is_confirmed: false)
584 user2 = insert(:user, is_confirmed: false)
586 refute user1.is_confirmed
587 refute user2.is_confirmed
589 Mix.Tasks.Pleroma.User.run(["confirm_all"])
591 user1 = User.get_cached_by_nickname(user1.nickname)
592 user2 = User.get_cached_by_nickname(user2.nickname)
594 assert user1.is_confirmed
595 assert user2.is_confirmed
598 test "unconfirm all" do
599 user1 = insert(:user, is_confirmed: true)
600 user2 = insert(:user, is_confirmed: true)
601 admin = insert(:user, is_admin: true, is_confirmed: true)
602 mod = insert(:user, is_moderator: true, is_confirmed: true)
604 assert user1.is_confirmed
605 assert user2.is_confirmed
607 Mix.Tasks.Pleroma.User.run(["unconfirm_all"])
609 user1 = User.get_cached_by_nickname(user1.nickname)
610 user2 = User.get_cached_by_nickname(user2.nickname)
611 admin = User.get_cached_by_nickname(admin.nickname)
612 mod = User.get_cached_by_nickname(mod.nickname)
614 refute user1.is_confirmed
615 refute user2.is_confirmed
616 assert admin.is_confirmed
617 assert mod.is_confirmed