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 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, :yes?, true})
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, :yes?, [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, :yes?, false})
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, :yes?, [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 %{deactivated: true} = 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)
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)
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 %{deactivated: true} = 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 toggle_activated" do
161 test "user is deactivated" do
164 Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
166 assert_received {:mix_shell, :info, [message]}
167 assert message =~ " deactivated"
169 user = User.get_cached_by_nickname(user.nickname)
170 assert user.deactivated
173 test "user is activated" do
174 user = insert(:user, deactivated: true)
176 Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
178 assert_received {:mix_shell, :info, [message]}
179 assert message =~ " activated"
181 user = User.get_cached_by_nickname(user.nickname)
182 refute user.deactivated
185 test "no user to toggle" do
186 Mix.Tasks.Pleroma.User.run(["toggle_activated", "nonexistent"])
188 assert_received {:mix_shell, :error, [message]}
189 assert message =~ "No user"
193 describe "running deactivate" do
194 test "user is unsubscribed" do
195 followed = insert(:user)
196 remote_followed = insert(:user, local: false)
199 User.follow(user, followed, :follow_accept)
200 User.follow(user, remote_followed, :follow_accept)
202 Mix.Tasks.Pleroma.User.run(["deactivate", user.nickname])
204 assert_received {:mix_shell, :info, [message]}
205 assert message =~ "Deactivating"
207 # Note that the task has delay :timer.sleep(500)
208 assert_received {:mix_shell, :info, [message]}
209 assert message =~ "Successfully unsubscribed"
211 user = User.get_cached_by_nickname(user.nickname)
212 assert Enum.empty?(Enum.filter(User.get_friends(user), & &1.local))
213 assert user.deactivated
216 test "no user to deactivate" do
217 Mix.Tasks.Pleroma.User.run(["deactivate", "nonexistent"])
219 assert_received {:mix_shell, :error, [message]}
220 assert message =~ "No user"
224 describe "running set" do
225 test "All statuses set" do
228 Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])
230 assert_received {:mix_shell, :info, [message]}
231 assert message =~ ~r/Moderator status .* true/
233 assert_received {:mix_shell, :info, [message]}
234 assert message =~ ~r/Locked status .* true/
236 assert_received {:mix_shell, :info, [message]}
237 assert message =~ ~r/Admin status .* true/
239 user = User.get_cached_by_nickname(user.nickname)
240 assert user.is_moderator
245 test "All statuses unset" do
246 user = insert(:user, locked: true, is_moderator: true, is_admin: true)
248 Mix.Tasks.Pleroma.User.run([
256 assert_received {:mix_shell, :info, [message]}
257 assert message =~ ~r/Moderator status .* false/
259 assert_received {:mix_shell, :info, [message]}
260 assert message =~ ~r/Locked status .* false/
262 assert_received {:mix_shell, :info, [message]}
263 assert message =~ ~r/Admin status .* false/
265 user = User.get_cached_by_nickname(user.nickname)
266 refute user.is_moderator
271 test "no user to set status" do
272 Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])
274 assert_received {:mix_shell, :error, [message]}
275 assert message =~ "No local user"
279 describe "running reset_password" do
280 test "password reset token is generated" do
283 assert capture_io(fn ->
284 Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
287 assert_received {:mix_shell, :info, [message]}
288 assert message =~ "Generated"
291 test "no user to reset password" do
292 Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
294 assert_received {:mix_shell, :error, [message]}
295 assert message =~ "No local user"
299 describe "running reset_mfa" do
300 test "disables MFA" do
303 multi_factor_authentication_settings: %MFA.Settings{
305 totp: %MFA.Settings.TOTP{secret: "xx", confirmed: true}
309 Mix.Tasks.Pleroma.User.run(["reset_mfa", user.nickname])
311 assert_received {:mix_shell, :info, [message]}
312 assert message == "Multi-Factor Authentication disabled for #{user.nickname}"
314 assert %{enabled: false, totp: false} ==
316 |> User.get_cached_by_nickname()
317 |> MFA.mfa_settings()
320 test "no user to reset MFA" do
321 Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
323 assert_received {:mix_shell, :error, [message]}
324 assert message =~ "No local user"
328 describe "running invite" do
329 test "invite token is generated" do
330 assert capture_io(fn ->
331 Mix.Tasks.Pleroma.User.run(["invite"])
334 assert_received {:mix_shell, :info, [message]}
335 assert message =~ "Generated user invite token one time"
338 test "token is generated with expires_at" do
339 assert capture_io(fn ->
340 Mix.Tasks.Pleroma.User.run([
343 Date.to_string(Date.utc_today())
347 assert_received {:mix_shell, :info, [message]}
348 assert message =~ "Generated user invite token date limited"
351 test "token is generated with max use" do
352 assert capture_io(fn ->
353 Mix.Tasks.Pleroma.User.run([
360 assert_received {:mix_shell, :info, [message]}
361 assert message =~ "Generated user invite token reusable"
364 test "token is generated with max use and expires date" do
365 assert capture_io(fn ->
366 Mix.Tasks.Pleroma.User.run([
371 Date.to_string(Date.utc_today())
375 assert_received {:mix_shell, :info, [message]}
376 assert message =~ "Generated user invite token reusable date limited"
380 describe "running invites" do
381 test "invites are listed" do
382 {:ok, invite} = Pleroma.UserInviteToken.create_invite()
385 Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})
387 # assert capture_io(fn ->
388 Mix.Tasks.Pleroma.User.run([
394 assert_received {:mix_shell, :info, [message]}
395 assert_received {:mix_shell, :info, [message2]}
396 assert_received {:mix_shell, :info, [message3]}
397 assert message =~ "Invites list:"
398 assert message2 =~ invite.invite_type
399 assert message3 =~ invite2.invite_type
403 describe "running revoke_invite" do
404 test "invite is revoked" do
405 {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
407 assert capture_io(fn ->
408 Mix.Tasks.Pleroma.User.run([
414 assert_received {:mix_shell, :info, [message]}
415 assert message =~ "Invite for token #{invite.token} was revoked."
418 test "it prints an error message when invite is not exist" do
419 Mix.Tasks.Pleroma.User.run(["revoke_invite", "foo"])
421 assert_received {:mix_shell, :error, [message]}
422 assert message =~ "No invite found"
426 describe "running delete_activities" do
427 test "activities are deleted" do
428 %{nickname: nickname} = insert(:user)
430 assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
431 assert_received {:mix_shell, :info, [message]}
432 assert message == "User #{nickname} statuses deleted."
435 test "it prints an error message when user is not exist" do
436 Mix.Tasks.Pleroma.User.run(["delete_activities", "foo"])
438 assert_received {:mix_shell, :error, [message]}
439 assert message =~ "No local user"
443 describe "running toggle_confirmed" do
444 test "user is confirmed" do
445 %{id: id, nickname: nickname} = insert(:user, confirmation_pending: false)
447 assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
448 assert_received {:mix_shell, :info, [message]}
449 assert message == "#{nickname} needs confirmation."
451 user = Repo.get(User, id)
452 assert user.confirmation_pending
453 assert user.confirmation_token
456 test "user is not confirmed" do
457 %{id: id, nickname: nickname} =
458 insert(:user, confirmation_pending: true, confirmation_token: "some token")
460 assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
461 assert_received {:mix_shell, :info, [message]}
462 assert message == "#{nickname} doesn't need confirmation."
464 user = Repo.get(User, id)
465 refute user.confirmation_pending
466 refute user.confirmation_token
469 test "it prints an error message when user is not exist" do
470 Mix.Tasks.Pleroma.User.run(["toggle_confirmed", "foo"])
472 assert_received {:mix_shell, :error, [message]}
473 assert message =~ "No local user"
478 test "it returns users matching" do
480 moon = insert(:user, nickname: "moon", name: "fediverse expert moon")
481 moot = insert(:user, nickname: "moot")
482 kawen = insert(:user, nickname: "kawen", name: "fediverse expert moon")
484 {:ok, user} = User.follow(user, moon)
486 assert [moon.id, kawen.id] == User.Search.search("moon") |> Enum.map(& &1.id)
488 res = User.search("moo") |> Enum.map(& &1.id)
489 assert Enum.sort([moon.id, moot.id, kawen.id]) == Enum.sort(res)
491 assert [kawen.id, moon.id] == User.Search.search("expert fediverse") |> Enum.map(& &1.id)
493 assert [moon.id, kawen.id] ==
494 User.Search.search("expert fediverse", for_user: user) |> Enum.map(& &1.id)
498 describe "signing out" do
499 test "it deletes all user's tokens and authorizations" do
501 insert(:oauth_token, user: user)
502 insert(:oauth_authorization, user: user)
504 assert Repo.get_by(Token, user_id: user.id)
505 assert Repo.get_by(Authorization, user_id: user.id)
507 :ok = Mix.Tasks.Pleroma.User.run(["sign_out", user.nickname])
509 refute Repo.get_by(Token, user_id: user.id)
510 refute Repo.get_by(Authorization, user_id: user.id)
513 test "it prints an error message when user is not exist" do
514 Mix.Tasks.Pleroma.User.run(["sign_out", "foo"])
516 assert_received {:mix_shell, :error, [message]}
517 assert message =~ "No local user"
521 describe "tagging" do
522 test "it add tags to a user" do
525 :ok = Mix.Tasks.Pleroma.User.run(["tag", user.nickname, "pleroma"])
527 user = User.get_cached_by_nickname(user.nickname)
528 assert "pleroma" in user.tags
531 test "it prints an error message when user is not exist" do
532 Mix.Tasks.Pleroma.User.run(["tag", "foo"])
534 assert_received {:mix_shell, :error, [message]}
535 assert message =~ "Could not change user tags"
539 describe "untagging" do
540 test "it deletes tags from a user" do
541 user = insert(:user, tags: ["pleroma"])
542 assert "pleroma" in user.tags
544 :ok = Mix.Tasks.Pleroma.User.run(["untag", user.nickname, "pleroma"])
546 user = User.get_cached_by_nickname(user.nickname)
547 assert Enum.empty?(user.tags)
550 test "it prints an error message when user is not exist" do
551 Mix.Tasks.Pleroma.User.run(["untag", "foo"])
553 assert_received {:mix_shell, :error, [message]}
554 assert message =~ "Could not change user tags"