git.squeep.com Git - akkoma/blob - test/tasks/user_test.exs

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