Merge branch 'develop' of https://git.pleroma.social/pleroma/pleroma into develop
[akkoma] / test / tasks / user_test.exs
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Mix.Tasks.Pleroma.UserTest do
6 alias Pleroma.Repo
7 alias Pleroma.User
8 alias Pleroma.Web.OAuth.Authorization
9 alias Pleroma.Web.OAuth.Token
10
11 use Pleroma.DataCase
12
13 import Pleroma.Factory
14 import ExUnit.CaptureIO
15
16 setup_all do
17 Mix.shell(Mix.Shell.Process)
18
19 on_exit(fn ->
20 Mix.shell(Mix.Shell.IO)
21 end)
22
23 :ok
24 end
25
26 describe "running new" do
27 test "user is created" do
28 # just get random data
29 unsaved = build(:user)
30
31 # prepare to answer yes
32 send(self(), {:mix_shell_input, :yes?, true})
33
34 Mix.Tasks.Pleroma.User.run([
35 "new",
36 unsaved.nickname,
37 unsaved.email,
38 "--name",
39 unsaved.name,
40 "--bio",
41 unsaved.bio,
42 "--password",
43 "test",
44 "--moderator",
45 "--admin"
46 ])
47
48 assert_received {:mix_shell, :info, [message]}
49 assert message =~ "user will be created"
50
51 assert_received {:mix_shell, :yes?, [message]}
52 assert message =~ "Continue"
53
54 assert_received {:mix_shell, :info, [message]}
55 assert message =~ "created"
56
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.info.is_moderator
62 assert user.info.is_admin
63 end
64
65 test "user is not created" do
66 unsaved = build(:user)
67
68 # prepare to answer no
69 send(self(), {:mix_shell_input, :yes?, false})
70
71 Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])
72
73 assert_received {:mix_shell, :info, [message]}
74 assert message =~ "user will be created"
75
76 assert_received {:mix_shell, :yes?, [message]}
77 assert message =~ "Continue"
78
79 assert_received {:mix_shell, :info, [message]}
80 assert message =~ "will not be created"
81
82 refute User.get_cached_by_nickname(unsaved.nickname)
83 end
84 end
85
86 describe "running rm" do
87 test "user is deleted" do
88 user = insert(:user)
89
90 Mix.Tasks.Pleroma.User.run(["rm", user.nickname])
91
92 assert_received {:mix_shell, :info, [message]}
93 assert message =~ " deleted"
94
95 refute User.get_by_nickname(user.nickname)
96 end
97
98 test "no user to delete" do
99 Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])
100
101 assert_received {:mix_shell, :error, [message]}
102 assert message =~ "No local user"
103 end
104 end
105
106 describe "running toggle_activated" do
107 test "user is deactivated" do
108 user = insert(:user)
109
110 Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
111
112 assert_received {:mix_shell, :info, [message]}
113 assert message =~ " deactivated"
114
115 user = User.get_cached_by_nickname(user.nickname)
116 assert user.info.deactivated
117 end
118
119 test "user is activated" do
120 user = insert(:user, info: %{deactivated: true})
121
122 Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
123
124 assert_received {:mix_shell, :info, [message]}
125 assert message =~ " activated"
126
127 user = User.get_cached_by_nickname(user.nickname)
128 refute user.info.deactivated
129 end
130
131 test "no user to toggle" do
132 Mix.Tasks.Pleroma.User.run(["toggle_activated", "nonexistent"])
133
134 assert_received {:mix_shell, :error, [message]}
135 assert message =~ "No user"
136 end
137 end
138
139 describe "running unsubscribe" do
140 test "user is unsubscribed" do
141 followed = insert(:user)
142 user = insert(:user, %{following: [User.ap_followers(followed)]})
143
144 Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname])
145
146 assert_received {:mix_shell, :info, [message]}
147 assert message =~ "Deactivating"
148
149 assert_received {:mix_shell, :info, [message]}
150 assert message =~ "Unsubscribing"
151
152 # Note that the task has delay :timer.sleep(500)
153 assert_received {:mix_shell, :info, [message]}
154 assert message =~ "Successfully unsubscribed"
155
156 user = User.get_cached_by_nickname(user.nickname)
157 assert Enum.empty?(user.following)
158 assert user.info.deactivated
159 end
160
161 test "no user to unsubscribe" do
162 Mix.Tasks.Pleroma.User.run(["unsubscribe", "nonexistent"])
163
164 assert_received {:mix_shell, :error, [message]}
165 assert message =~ "No user"
166 end
167 end
168
169 describe "running set" do
170 test "All statuses set" do
171 user = insert(:user)
172
173 Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])
174
175 assert_received {:mix_shell, :info, [message]}
176 assert message =~ ~r/Moderator status .* true/
177
178 assert_received {:mix_shell, :info, [message]}
179 assert message =~ ~r/Locked status .* true/
180
181 assert_received {:mix_shell, :info, [message]}
182 assert message =~ ~r/Admin status .* true/
183
184 user = User.get_cached_by_nickname(user.nickname)
185 assert user.info.is_moderator
186 assert user.info.locked
187 assert user.info.is_admin
188 end
189
190 test "All statuses unset" do
191 user = insert(:user, info: %{is_moderator: true, locked: true, is_admin: true})
192
193 Mix.Tasks.Pleroma.User.run([
194 "set",
195 user.nickname,
196 "--no-moderator",
197 "--no-admin",
198 "--no-locked"
199 ])
200
201 assert_received {:mix_shell, :info, [message]}
202 assert message =~ ~r/Moderator status .* false/
203
204 assert_received {:mix_shell, :info, [message]}
205 assert message =~ ~r/Locked status .* false/
206
207 assert_received {:mix_shell, :info, [message]}
208 assert message =~ ~r/Admin status .* false/
209
210 user = User.get_cached_by_nickname(user.nickname)
211 refute user.info.is_moderator
212 refute user.info.locked
213 refute user.info.is_admin
214 end
215
216 test "no user to set status" do
217 Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])
218
219 assert_received {:mix_shell, :error, [message]}
220 assert message =~ "No local user"
221 end
222 end
223
224 describe "running reset_password" do
225 test "password reset token is generated" do
226 user = insert(:user)
227
228 assert capture_io(fn ->
229 Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
230 end) =~ "URL:"
231
232 assert_received {:mix_shell, :info, [message]}
233 assert message =~ "Generated"
234 end
235
236 test "no user to reset password" do
237 Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
238
239 assert_received {:mix_shell, :error, [message]}
240 assert message =~ "No local user"
241 end
242 end
243
244 describe "running invite" do
245 test "invite token is generated" do
246 assert capture_io(fn ->
247 Mix.Tasks.Pleroma.User.run(["invite"])
248 end) =~ "http"
249
250 assert_received {:mix_shell, :info, [message]}
251 assert message =~ "Generated user invite token one time"
252 end
253
254 test "token is generated with expires_at" do
255 assert capture_io(fn ->
256 Mix.Tasks.Pleroma.User.run([
257 "invite",
258 "--expires-at",
259 Date.to_string(Date.utc_today())
260 ])
261 end)
262
263 assert_received {:mix_shell, :info, [message]}
264 assert message =~ "Generated user invite token date limited"
265 end
266
267 test "token is generated with max use" do
268 assert capture_io(fn ->
269 Mix.Tasks.Pleroma.User.run([
270 "invite",
271 "--max-use",
272 "5"
273 ])
274 end)
275
276 assert_received {:mix_shell, :info, [message]}
277 assert message =~ "Generated user invite token reusable"
278 end
279
280 test "token is generated with max use and expires date" do
281 assert capture_io(fn ->
282 Mix.Tasks.Pleroma.User.run([
283 "invite",
284 "--max-use",
285 "5",
286 "--expires-at",
287 Date.to_string(Date.utc_today())
288 ])
289 end)
290
291 assert_received {:mix_shell, :info, [message]}
292 assert message =~ "Generated user invite token reusable date limited"
293 end
294 end
295
296 describe "running invites" do
297 test "invites are listed" do
298 {:ok, invite} = Pleroma.UserInviteToken.create_invite()
299
300 {:ok, invite2} =
301 Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})
302
303 # assert capture_io(fn ->
304 Mix.Tasks.Pleroma.User.run([
305 "invites"
306 ])
307
308 # end)
309
310 assert_received {:mix_shell, :info, [message]}
311 assert_received {:mix_shell, :info, [message2]}
312 assert_received {:mix_shell, :info, [message3]}
313 assert message =~ "Invites list:"
314 assert message2 =~ invite.invite_type
315 assert message3 =~ invite2.invite_type
316 end
317 end
318
319 describe "running revoke_invite" do
320 test "invite is revoked" do
321 {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
322
323 assert capture_io(fn ->
324 Mix.Tasks.Pleroma.User.run([
325 "revoke_invite",
326 invite.token
327 ])
328 end)
329
330 assert_received {:mix_shell, :info, [message]}
331 assert message =~ "Invite for token #{invite.token} was revoked."
332 end
333
334 test "it prints an error message when invite is not exist" do
335 Mix.Tasks.Pleroma.User.run(["revoke_invite", "foo"])
336
337 assert_received {:mix_shell, :error, [message]}
338 assert message =~ "No invite found"
339 end
340 end
341
342 describe "running delete_activities" do
343 test "activities are deleted" do
344 %{nickname: nickname} = insert(:user)
345
346 assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
347 assert_received {:mix_shell, :info, [message]}
348 assert message == "User #{nickname} statuses deleted."
349 end
350
351 test "it prints an error message when user is not exist" do
352 Mix.Tasks.Pleroma.User.run(["delete_activities", "foo"])
353
354 assert_received {:mix_shell, :error, [message]}
355 assert message =~ "No local user"
356 end
357 end
358
359 describe "running toggle_confirmed" do
360 test "user is confirmed" do
361 %{id: id, nickname: nickname} = insert(:user, info: %{confirmation_pending: false})
362
363 assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
364 assert_received {:mix_shell, :info, [message]}
365 assert message == "#{nickname} needs confirmation."
366
367 user = Repo.get(User, id)
368 assert user.info.confirmation_pending
369 assert user.info.confirmation_token
370 end
371
372 test "user is not confirmed" do
373 %{id: id, nickname: nickname} =
374 insert(:user, info: %{confirmation_pending: true, confirmation_token: "some token"})
375
376 assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
377 assert_received {:mix_shell, :info, [message]}
378 assert message == "#{nickname} doesn't need confirmation."
379
380 user = Repo.get(User, id)
381 refute user.info.confirmation_pending
382 refute user.info.confirmation_token
383 end
384
385 test "it prints an error message when user is not exist" do
386 Mix.Tasks.Pleroma.User.run(["toggle_confirmed", "foo"])
387
388 assert_received {:mix_shell, :error, [message]}
389 assert message =~ "No local user"
390 end
391 end
392
393 describe "search" do
394 test "it returns users matching" do
395 user = insert(:user)
396 moon = insert(:user, nickname: "moon", name: "fediverse expert moon")
397 moot = insert(:user, nickname: "moot")
398 kawen = insert(:user, nickname: "kawen", name: "fediverse expert moon")
399
400 {:ok, user} = User.follow(user, kawen)
401
402 assert [moon.id, kawen.id] == User.Search.search("moon") |> Enum.map(& &1.id)
403 res = User.search("moo") |> Enum.map(& &1.id)
404 assert moon.id in res
405 assert moot.id in res
406 assert kawen.id in res
407 assert [moon.id, kawen.id] == User.Search.search("moon fediverse") |> Enum.map(& &1.id)
408
409 assert [kawen.id, moon.id] ==
410 User.Search.search("moon fediverse", for_user: user) |> Enum.map(& &1.id)
411 end
412 end
413
414 describe "signing out" do
415 test "it deletes all user's tokens and authorizations" do
416 user = insert(:user)
417 insert(:oauth_token, user: user)
418 insert(:oauth_authorization, user: user)
419
420 assert Repo.get_by(Token, user_id: user.id)
421 assert Repo.get_by(Authorization, user_id: user.id)
422
423 :ok = Mix.Tasks.Pleroma.User.run(["sign_out", user.nickname])
424
425 refute Repo.get_by(Token, user_id: user.id)
426 refute Repo.get_by(Authorization, user_id: user.id)
427 end
428
429 test "it prints an error message when user is not exist" do
430 Mix.Tasks.Pleroma.User.run(["sign_out", "foo"])
431
432 assert_received {:mix_shell, :error, [message]}
433 assert message =~ "No local user"
434 end
435 end
436
437 describe "tagging" do
438 test "it add tags to a user" do
439 user = insert(:user)
440
441 :ok = Mix.Tasks.Pleroma.User.run(["tag", user.nickname, "pleroma"])
442
443 user = User.get_cached_by_nickname(user.nickname)
444 assert "pleroma" in user.tags
445 end
446
447 test "it prints an error message when user is not exist" do
448 Mix.Tasks.Pleroma.User.run(["tag", "foo"])
449
450 assert_received {:mix_shell, :error, [message]}
451 assert message =~ "Could not change user tags"
452 end
453 end
454
455 describe "untagging" do
456 test "it deletes tags from a user" do
457 user = insert(:user, tags: ["pleroma"])
458 assert "pleroma" in user.tags
459
460 :ok = Mix.Tasks.Pleroma.User.run(["untag", user.nickname, "pleroma"])
461
462 user = User.get_cached_by_nickname(user.nickname)
463 assert Enum.empty?(user.tags)
464 end
465
466 test "it prints an error message when user is not exist" do
467 Mix.Tasks.Pleroma.User.run(["untag", "foo"])
468
469 assert_received {:mix_shell, :error, [message]}
470 assert message =~ "Could not change user tags"
471 end
472 end
473 end