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
8 alias Pleroma.Web.OAuth.Authorization
9 alias Pleroma.Web.OAuth.Token
13 import Pleroma.Factory
14 import ExUnit.CaptureIO
17 Mix.shell(Mix.Shell.Process)
20 Mix.shell(Mix.Shell.IO)
26 describe "running new" do
27 test "user is created" do
28 # just get random data
29 unsaved = build(:user)
31 # prepare to answer yes
32 send(self(), {:mix_shell_input, :yes?, true})
34 Mix.Tasks.Pleroma.User.run([
48 assert_received {:mix_shell, :info, [message]}
49 assert message =~ "user will be created"
51 assert_received {:mix_shell, :yes?, [message]}
52 assert message =~ "Continue"
54 assert_received {:mix_shell, :info, [message]}
55 assert message =~ "created"
57 user = User.get_cached_by_nickname(unsaved.nickname)
58 assert user.name == unsaved.name
59 assert user.email == unsaved.email
60 assert user.bio == unsaved.bio
61 assert user.is_moderator
65 test "user is not created" do
66 unsaved = build(:user)
68 # prepare to answer no
69 send(self(), {:mix_shell_input, :yes?, false})
71 Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])
73 assert_received {:mix_shell, :info, [message]}
74 assert message =~ "user will be created"
76 assert_received {:mix_shell, :yes?, [message]}
77 assert message =~ "Continue"
79 assert_received {:mix_shell, :info, [message]}
80 assert message =~ "will not be created"
82 refute User.get_cached_by_nickname(unsaved.nickname)
86 describe "running rm" do
87 test "user is deleted" do
90 Mix.Tasks.Pleroma.User.run(["rm", user.nickname])
92 assert_received {:mix_shell, :info, [message]}
93 assert message =~ " deleted"
95 refute User.get_by_nickname(user.nickname)
98 test "no user to delete" do
99 Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])
101 assert_received {:mix_shell, :error, [message]}
102 assert message =~ "No local user"
106 describe "running toggle_activated" do
107 test "user is deactivated" do
110 Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
112 assert_received {:mix_shell, :info, [message]}
113 assert message =~ " deactivated"
115 user = User.get_cached_by_nickname(user.nickname)
116 assert user.deactivated
119 test "user is activated" do
120 user = insert(:user, deactivated: true)
122 Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
124 assert_received {:mix_shell, :info, [message]}
125 assert message =~ " activated"
127 user = User.get_cached_by_nickname(user.nickname)
128 refute user.deactivated
131 test "no user to toggle" do
132 Mix.Tasks.Pleroma.User.run(["toggle_activated", "nonexistent"])
134 assert_received {:mix_shell, :error, [message]}
135 assert message =~ "No user"
139 describe "running unsubscribe" do
140 test "user is unsubscribed" do
141 followed = insert(:user)
143 User.follow(user, followed, "accept")
145 Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname])
147 assert_received {:mix_shell, :info, [message]}
148 assert message =~ "Deactivating"
150 assert_received {:mix_shell, :info, [message]}
151 assert message =~ "Unsubscribing"
153 # Note that the task has delay :timer.sleep(500)
154 assert_received {:mix_shell, :info, [message]}
155 assert message =~ "Successfully unsubscribed"
157 user = User.get_cached_by_nickname(user.nickname)
158 assert Enum.empty?(User.get_friends(user))
159 assert user.deactivated
162 test "no user to unsubscribe" do
163 Mix.Tasks.Pleroma.User.run(["unsubscribe", "nonexistent"])
165 assert_received {:mix_shell, :error, [message]}
166 assert message =~ "No user"
170 describe "running set" do
171 test "All statuses set" do
174 Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])
176 assert_received {:mix_shell, :info, [message]}
177 assert message =~ ~r/Moderator status .* true/
179 assert_received {:mix_shell, :info, [message]}
180 assert message =~ ~r/Locked status .* true/
182 assert_received {:mix_shell, :info, [message]}
183 assert message =~ ~r/Admin status .* true/
185 user = User.get_cached_by_nickname(user.nickname)
186 assert user.is_moderator
191 test "All statuses unset" do
192 user = insert(:user, locked: true, is_moderator: true, is_admin: true)
194 Mix.Tasks.Pleroma.User.run([
202 assert_received {:mix_shell, :info, [message]}
203 assert message =~ ~r/Moderator status .* false/
205 assert_received {:mix_shell, :info, [message]}
206 assert message =~ ~r/Locked status .* false/
208 assert_received {:mix_shell, :info, [message]}
209 assert message =~ ~r/Admin status .* false/
211 user = User.get_cached_by_nickname(user.nickname)
212 refute user.is_moderator
217 test "no user to set status" do
218 Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])
220 assert_received {:mix_shell, :error, [message]}
221 assert message =~ "No local user"
225 describe "running reset_password" do
226 test "password reset token is generated" do
229 assert capture_io(fn ->
230 Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
233 assert_received {:mix_shell, :info, [message]}
234 assert message =~ "Generated"
237 test "no user to reset password" do
238 Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
240 assert_received {:mix_shell, :error, [message]}
241 assert message =~ "No local user"
245 describe "running invite" do
246 test "invite token is generated" do
247 assert capture_io(fn ->
248 Mix.Tasks.Pleroma.User.run(["invite"])
251 assert_received {:mix_shell, :info, [message]}
252 assert message =~ "Generated user invite token one time"
255 test "token is generated with expires_at" do
256 assert capture_io(fn ->
257 Mix.Tasks.Pleroma.User.run([
260 Date.to_string(Date.utc_today())
264 assert_received {:mix_shell, :info, [message]}
265 assert message =~ "Generated user invite token date limited"
268 test "token is generated with max use" do
269 assert capture_io(fn ->
270 Mix.Tasks.Pleroma.User.run([
277 assert_received {:mix_shell, :info, [message]}
278 assert message =~ "Generated user invite token reusable"
281 test "token is generated with max use and expires date" do
282 assert capture_io(fn ->
283 Mix.Tasks.Pleroma.User.run([
288 Date.to_string(Date.utc_today())
292 assert_received {:mix_shell, :info, [message]}
293 assert message =~ "Generated user invite token reusable date limited"
297 describe "running invites" do
298 test "invites are listed" do
299 {:ok, invite} = Pleroma.UserInviteToken.create_invite()
302 Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})
304 # assert capture_io(fn ->
305 Mix.Tasks.Pleroma.User.run([
311 assert_received {:mix_shell, :info, [message]}
312 assert_received {:mix_shell, :info, [message2]}
313 assert_received {:mix_shell, :info, [message3]}
314 assert message =~ "Invites list:"
315 assert message2 =~ invite.invite_type
316 assert message3 =~ invite2.invite_type
320 describe "running revoke_invite" do
321 test "invite is revoked" do
322 {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
324 assert capture_io(fn ->
325 Mix.Tasks.Pleroma.User.run([
331 assert_received {:mix_shell, :info, [message]}
332 assert message =~ "Invite for token #{invite.token} was revoked."
335 test "it prints an error message when invite is not exist" do
336 Mix.Tasks.Pleroma.User.run(["revoke_invite", "foo"])
338 assert_received {:mix_shell, :error, [message]}
339 assert message =~ "No invite found"
343 describe "running delete_activities" do
344 test "activities are deleted" do
345 %{nickname: nickname} = insert(:user)
347 assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
348 assert_received {:mix_shell, :info, [message]}
349 assert message == "User #{nickname} statuses deleted."
352 test "it prints an error message when user is not exist" do
353 Mix.Tasks.Pleroma.User.run(["delete_activities", "foo"])
355 assert_received {:mix_shell, :error, [message]}
356 assert message =~ "No local user"
360 describe "running toggle_confirmed" do
361 test "user is confirmed" do
362 %{id: id, nickname: nickname} = insert(:user, confirmation_pending: false)
364 assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
365 assert_received {:mix_shell, :info, [message]}
366 assert message == "#{nickname} needs confirmation."
368 user = Repo.get(User, id)
369 assert user.confirmation_pending
370 assert user.confirmation_token
373 test "user is not confirmed" do
374 %{id: id, nickname: nickname} =
375 insert(:user, confirmation_pending: true, confirmation_token: "some token")
377 assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
378 assert_received {:mix_shell, :info, [message]}
379 assert message == "#{nickname} doesn't need confirmation."
381 user = Repo.get(User, id)
382 refute user.confirmation_pending
383 refute user.confirmation_token
386 test "it prints an error message when user is not exist" do
387 Mix.Tasks.Pleroma.User.run(["toggle_confirmed", "foo"])
389 assert_received {:mix_shell, :error, [message]}
390 assert message =~ "No local user"
395 test "it returns users matching" do
397 moon = insert(:user, nickname: "moon", name: "fediverse expert moon")
398 moot = insert(:user, nickname: "moot")
399 kawen = insert(:user, nickname: "kawen", name: "fediverse expert moon")
401 {:ok, user} = User.follow(user, kawen)
403 assert [moon.id, kawen.id] == User.Search.search("moon") |> Enum.map(& &1.id)
404 res = User.search("moo") |> Enum.map(& &1.id)
405 assert moon.id in res
406 assert moot.id in res
407 assert kawen.id in res
408 assert [moon.id, kawen.id] == User.Search.search("moon fediverse") |> Enum.map(& &1.id)
410 assert [kawen.id, moon.id] ==
411 User.Search.search("moon fediverse", for_user: user) |> Enum.map(& &1.id)
415 describe "signing out" do
416 test "it deletes all user's tokens and authorizations" do
418 insert(:oauth_token, user: user)
419 insert(:oauth_authorization, user: user)
421 assert Repo.get_by(Token, user_id: user.id)
422 assert Repo.get_by(Authorization, user_id: user.id)
424 :ok = Mix.Tasks.Pleroma.User.run(["sign_out", user.nickname])
426 refute Repo.get_by(Token, user_id: user.id)
427 refute Repo.get_by(Authorization, user_id: user.id)
430 test "it prints an error message when user is not exist" do
431 Mix.Tasks.Pleroma.User.run(["sign_out", "foo"])
433 assert_received {:mix_shell, :error, [message]}
434 assert message =~ "No local user"
438 describe "tagging" do
439 test "it add tags to a user" do
442 :ok = Mix.Tasks.Pleroma.User.run(["tag", user.nickname, "pleroma"])
444 user = User.get_cached_by_nickname(user.nickname)
445 assert "pleroma" in user.tags
448 test "it prints an error message when user is not exist" do
449 Mix.Tasks.Pleroma.User.run(["tag", "foo"])
451 assert_received {:mix_shell, :error, [message]}
452 assert message =~ "Could not change user tags"
456 describe "untagging" do
457 test "it deletes tags from a user" do
458 user = insert(:user, tags: ["pleroma"])
459 assert "pleroma" in user.tags
461 :ok = Mix.Tasks.Pleroma.User.run(["untag", user.nickname, "pleroma"])
463 user = User.get_cached_by_nickname(user.nickname)
464 assert Enum.empty?(user.tags)
467 test "it prints an error message when user is not exist" do
468 Mix.Tasks.Pleroma.User.run(["untag", "foo"])
470 assert_received {:mix_shell, :error, [message]}
471 assert message =~ "Could not change user tags"