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