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
7 alias Pleroma.Tests.ObanHelpers
9 alias Pleroma.Web.OAuth.Authorization
10 alias Pleroma.Web.OAuth.Token
13 use Oban.Testing, repo: Pleroma.Repo
15 import ExUnit.CaptureIO
17 import Pleroma.Factory
20 Mix.shell(Mix.Shell.Process)
23 Mix.shell(Mix.Shell.IO)
29 describe "running new" do
30 test "user is created" do
31 # just get random data
32 unsaved = build(:user)
34 # prepare to answer yes
35 send(self(), {:mix_shell_input, :yes?, true})
37 Mix.Tasks.Pleroma.User.run([
51 assert_received {:mix_shell, :info, [message]}
52 assert message =~ "user will be created"
54 assert_received {:mix_shell, :yes?, [message]}
55 assert message =~ "Continue"
57 assert_received {:mix_shell, :info, [message]}
58 assert message =~ "created"
60 user = User.get_cached_by_nickname(unsaved.nickname)
61 assert user.name == unsaved.name
62 assert user.email == unsaved.email
63 assert user.bio == unsaved.bio
64 assert user.is_moderator
68 test "user is not created" do
69 unsaved = build(:user)
71 # prepare to answer no
72 send(self(), {:mix_shell_input, :yes?, false})
74 Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])
76 assert_received {:mix_shell, :info, [message]}
77 assert message =~ "user will be created"
79 assert_received {:mix_shell, :yes?, [message]}
80 assert message =~ "Continue"
82 assert_received {:mix_shell, :info, [message]}
83 assert message =~ "will not be created"
85 refute User.get_cached_by_nickname(unsaved.nickname)
89 describe "running rm" do
90 test "user is deleted" do
93 with_mock Pleroma.Web.Federator,
94 publish: fn _ -> nil end do
95 Mix.Tasks.Pleroma.User.run(["rm", user.nickname])
96 ObanHelpers.perform_all()
98 assert_received {:mix_shell, :info, [message]}
99 assert message =~ " deleted"
100 refute User.get_by_nickname(user.nickname)
102 assert called(Pleroma.Web.Federator.publish(:_))
106 test "no user to delete" do
107 Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])
109 assert_received {:mix_shell, :error, [message]}
110 assert message =~ "No local user"
114 describe "running toggle_activated" do
115 test "user is deactivated" do
118 Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
120 assert_received {:mix_shell, :info, [message]}
121 assert message =~ " deactivated"
123 user = User.get_cached_by_nickname(user.nickname)
124 assert user.deactivated
127 test "user is activated" do
128 user = insert(:user, deactivated: true)
130 Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
132 assert_received {:mix_shell, :info, [message]}
133 assert message =~ " activated"
135 user = User.get_cached_by_nickname(user.nickname)
136 refute user.deactivated
139 test "no user to toggle" do
140 Mix.Tasks.Pleroma.User.run(["toggle_activated", "nonexistent"])
142 assert_received {:mix_shell, :error, [message]}
143 assert message =~ "No user"
147 describe "running unsubscribe" do
148 test "user is unsubscribed" do
149 followed = insert(:user)
151 User.follow(user, followed, :follow_accept)
153 Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname])
155 assert_received {:mix_shell, :info, [message]}
156 assert message =~ "Deactivating"
158 assert_received {:mix_shell, :info, [message]}
159 assert message =~ "Unsubscribing"
161 # Note that the task has delay :timer.sleep(500)
162 assert_received {:mix_shell, :info, [message]}
163 assert message =~ "Successfully unsubscribed"
165 user = User.get_cached_by_nickname(user.nickname)
166 assert Enum.empty?(User.get_friends(user))
167 assert user.deactivated
170 test "no user to unsubscribe" do
171 Mix.Tasks.Pleroma.User.run(["unsubscribe", "nonexistent"])
173 assert_received {:mix_shell, :error, [message]}
174 assert message =~ "No user"
178 describe "running set" do
179 test "All statuses set" do
182 Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])
184 assert_received {:mix_shell, :info, [message]}
185 assert message =~ ~r/Moderator status .* true/
187 assert_received {:mix_shell, :info, [message]}
188 assert message =~ ~r/Locked status .* true/
190 assert_received {:mix_shell, :info, [message]}
191 assert message =~ ~r/Admin status .* true/
193 user = User.get_cached_by_nickname(user.nickname)
194 assert user.is_moderator
199 test "All statuses unset" do
200 user = insert(:user, locked: true, is_moderator: true, is_admin: true)
202 Mix.Tasks.Pleroma.User.run([
210 assert_received {:mix_shell, :info, [message]}
211 assert message =~ ~r/Moderator status .* false/
213 assert_received {:mix_shell, :info, [message]}
214 assert message =~ ~r/Locked status .* false/
216 assert_received {:mix_shell, :info, [message]}
217 assert message =~ ~r/Admin status .* false/
219 user = User.get_cached_by_nickname(user.nickname)
220 refute user.is_moderator
225 test "no user to set status" do
226 Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])
228 assert_received {:mix_shell, :error, [message]}
229 assert message =~ "No local user"
233 describe "running reset_password" do
234 test "password reset token is generated" do
237 assert capture_io(fn ->
238 Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
241 assert_received {:mix_shell, :info, [message]}
242 assert message =~ "Generated"
245 test "no user to reset password" do
246 Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
248 assert_received {:mix_shell, :error, [message]}
249 assert message =~ "No local user"
253 describe "running invite" do
254 test "invite token is generated" do
255 assert capture_io(fn ->
256 Mix.Tasks.Pleroma.User.run(["invite"])
259 assert_received {:mix_shell, :info, [message]}
260 assert message =~ "Generated user invite token one time"
263 test "token is generated with expires_at" do
264 assert capture_io(fn ->
265 Mix.Tasks.Pleroma.User.run([
268 Date.to_string(Date.utc_today())
272 assert_received {:mix_shell, :info, [message]}
273 assert message =~ "Generated user invite token date limited"
276 test "token is generated with max use" do
277 assert capture_io(fn ->
278 Mix.Tasks.Pleroma.User.run([
285 assert_received {:mix_shell, :info, [message]}
286 assert message =~ "Generated user invite token reusable"
289 test "token is generated with max use and expires date" do
290 assert capture_io(fn ->
291 Mix.Tasks.Pleroma.User.run([
296 Date.to_string(Date.utc_today())
300 assert_received {:mix_shell, :info, [message]}
301 assert message =~ "Generated user invite token reusable date limited"
305 describe "running invites" do
306 test "invites are listed" do
307 {:ok, invite} = Pleroma.UserInviteToken.create_invite()
310 Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})
312 # assert capture_io(fn ->
313 Mix.Tasks.Pleroma.User.run([
319 assert_received {:mix_shell, :info, [message]}
320 assert_received {:mix_shell, :info, [message2]}
321 assert_received {:mix_shell, :info, [message3]}
322 assert message =~ "Invites list:"
323 assert message2 =~ invite.invite_type
324 assert message3 =~ invite2.invite_type
328 describe "running revoke_invite" do
329 test "invite is revoked" do
330 {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
332 assert capture_io(fn ->
333 Mix.Tasks.Pleroma.User.run([
339 assert_received {:mix_shell, :info, [message]}
340 assert message =~ "Invite for token #{invite.token} was revoked."
343 test "it prints an error message when invite is not exist" do
344 Mix.Tasks.Pleroma.User.run(["revoke_invite", "foo"])
346 assert_received {:mix_shell, :error, [message]}
347 assert message =~ "No invite found"
351 describe "running delete_activities" do
352 test "activities are deleted" do
353 %{nickname: nickname} = insert(:user)
355 assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
356 assert_received {:mix_shell, :info, [message]}
357 assert message == "User #{nickname} statuses deleted."
360 test "it prints an error message when user is not exist" do
361 Mix.Tasks.Pleroma.User.run(["delete_activities", "foo"])
363 assert_received {:mix_shell, :error, [message]}
364 assert message =~ "No local user"
368 describe "running toggle_confirmed" do
369 test "user is confirmed" do
370 %{id: id, nickname: nickname} = insert(:user, confirmation_pending: false)
372 assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
373 assert_received {:mix_shell, :info, [message]}
374 assert message == "#{nickname} needs confirmation."
376 user = Repo.get(User, id)
377 assert user.confirmation_pending
378 assert user.confirmation_token
381 test "user is not confirmed" do
382 %{id: id, nickname: nickname} =
383 insert(:user, confirmation_pending: true, confirmation_token: "some token")
385 assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
386 assert_received {:mix_shell, :info, [message]}
387 assert message == "#{nickname} doesn't need confirmation."
389 user = Repo.get(User, id)
390 refute user.confirmation_pending
391 refute user.confirmation_token
394 test "it prints an error message when user is not exist" do
395 Mix.Tasks.Pleroma.User.run(["toggle_confirmed", "foo"])
397 assert_received {:mix_shell, :error, [message]}
398 assert message =~ "No local user"
403 test "it returns users matching" do
405 moon = insert(:user, nickname: "moon", name: "fediverse expert moon")
406 moot = insert(:user, nickname: "moot")
407 kawen = insert(:user, nickname: "kawen", name: "fediverse expert moon")
409 {:ok, user} = User.follow(user, kawen)
411 assert [moon.id, kawen.id] == User.Search.search("moon") |> Enum.map(& &1.id)
412 res = User.search("moo") |> Enum.map(& &1.id)
413 assert moon.id in res
414 assert moot.id in res
415 assert kawen.id in res
416 assert [moon.id, kawen.id] == User.Search.search("moon fediverse") |> Enum.map(& &1.id)
418 assert [kawen.id, moon.id] ==
419 User.Search.search("moon fediverse", for_user: user) |> Enum.map(& &1.id)
423 describe "signing out" do
424 test "it deletes all user's tokens and authorizations" do
426 insert(:oauth_token, user: user)
427 insert(:oauth_authorization, user: user)
429 assert Repo.get_by(Token, user_id: user.id)
430 assert Repo.get_by(Authorization, user_id: user.id)
432 :ok = Mix.Tasks.Pleroma.User.run(["sign_out", user.nickname])
434 refute Repo.get_by(Token, user_id: user.id)
435 refute Repo.get_by(Authorization, user_id: user.id)
438 test "it prints an error message when user is not exist" do
439 Mix.Tasks.Pleroma.User.run(["sign_out", "foo"])
441 assert_received {:mix_shell, :error, [message]}
442 assert message =~ "No local user"
446 describe "tagging" do
447 test "it add tags to a user" do
450 :ok = Mix.Tasks.Pleroma.User.run(["tag", user.nickname, "pleroma"])
452 user = User.get_cached_by_nickname(user.nickname)
453 assert "pleroma" in user.tags
456 test "it prints an error message when user is not exist" do
457 Mix.Tasks.Pleroma.User.run(["tag", "foo"])
459 assert_received {:mix_shell, :error, [message]}
460 assert message =~ "Could not change user tags"
464 describe "untagging" do
465 test "it deletes tags from a user" do
466 user = insert(:user, tags: ["pleroma"])
467 assert "pleroma" in user.tags
469 :ok = Mix.Tasks.Pleroma.User.run(["untag", user.nickname, "pleroma"])
471 user = User.get_cached_by_nickname(user.nickname)
472 assert Enum.empty?(user.tags)
475 test "it prints an error message when user is not exist" do
476 Mix.Tasks.Pleroma.User.run(["untag", "foo"])
478 assert_received {:mix_shell, :error, [message]}
479 assert message =~ "Could not change user tags"