git.squeep.com Git - akkoma/blob - 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.is_moderator
  62       assert user.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.deactivated
 117     end
 118
 119     test "user is activated" do
 120       user = insert(:user, 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.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)
 143       User.follow(user, followed, "accept")
 144
 145       Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname])
 146
 147       assert_received {:mix_shell, :info, [message]}
 148       assert message =~ "Deactivating"
 149
 150       assert_received {:mix_shell, :info, [message]}
 151       assert message =~ "Unsubscribing"
 152
 153       # Note that the task has delay :timer.sleep(500)
 154       assert_received {:mix_shell, :info, [message]}
 155       assert message =~ "Successfully unsubscribed"
 156
 157       user = User.get_cached_by_nickname(user.nickname)
 158       assert Enum.empty?(User.get_friends(user))
 159       assert user.deactivated
 160     end
 161
 162     test "no user to unsubscribe" do
 163       Mix.Tasks.Pleroma.User.run(["unsubscribe", "nonexistent"])
 164
 165       assert_received {:mix_shell, :error, [message]}
 166       assert message =~ "No user"
 167     end
 168   end
 169
 170   describe "running set" do
 171     test "All statuses set" do
 172       user = insert(:user)
 173
 174       Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])
 175
 176       assert_received {:mix_shell, :info, [message]}
 177       assert message =~ ~r/Moderator status .* true/
 178
 179       assert_received {:mix_shell, :info, [message]}
 180       assert message =~ ~r/Locked status .* true/
 181
 182       assert_received {:mix_shell, :info, [message]}
 183       assert message =~ ~r/Admin status .* true/
 184
 185       user = User.get_cached_by_nickname(user.nickname)
 186       assert user.is_moderator
 187       assert user.locked
 188       assert user.is_admin
 189     end
 190
 191     test "All statuses unset" do
 192       user = insert(:user, locked: true, is_moderator: true, is_admin: true)
 193
 194       Mix.Tasks.Pleroma.User.run([
 195         "set",
 196         user.nickname,
 197         "--no-moderator",
 198         "--no-admin",
 199         "--no-locked"
 200       ])
 201
 202       assert_received {:mix_shell, :info, [message]}
 203       assert message =~ ~r/Moderator status .* false/
 204
 205       assert_received {:mix_shell, :info, [message]}
 206       assert message =~ ~r/Locked status .* false/
 207
 208       assert_received {:mix_shell, :info, [message]}
 209       assert message =~ ~r/Admin status .* false/
 210
 211       user = User.get_cached_by_nickname(user.nickname)
 212       refute user.is_moderator
 213       refute user.locked
 214       refute user.is_admin
 215     end
 216
 217     test "no user to set status" do
 218       Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])
 219
 220       assert_received {:mix_shell, :error, [message]}
 221       assert message =~ "No local user"
 222     end
 223   end
 224
 225   describe "running reset_password" do
 226     test "password reset token is generated" do
 227       user = insert(:user)
 228
 229       assert capture_io(fn ->
 230                Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
 231              end) =~ "URL:"
 232
 233       assert_received {:mix_shell, :info, [message]}
 234       assert message =~ "Generated"
 235     end
 236
 237     test "no user to reset password" do
 238       Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
 239
 240       assert_received {:mix_shell, :error, [message]}
 241       assert message =~ "No local user"
 242     end
 243   end
 244
 245   describe "running invite" do
 246     test "invite token is generated" do
 247       assert capture_io(fn ->
 248                Mix.Tasks.Pleroma.User.run(["invite"])
 249              end) =~ "http"
 250
 251       assert_received {:mix_shell, :info, [message]}
 252       assert message =~ "Generated user invite token one time"
 253     end
 254
 255     test "token is generated with expires_at" do
 256       assert capture_io(fn ->
 257                Mix.Tasks.Pleroma.User.run([
 258                  "invite",
 259                  "--expires-at",
 260                  Date.to_string(Date.utc_today())
 261                ])
 262              end)
 263
 264       assert_received {:mix_shell, :info, [message]}
 265       assert message =~ "Generated user invite token date limited"
 266     end
 267
 268     test "token is generated with max use" do
 269       assert capture_io(fn ->
 270                Mix.Tasks.Pleroma.User.run([
 271                  "invite",
 272                  "--max-use",
 273                  "5"
 274                ])
 275              end)
 276
 277       assert_received {:mix_shell, :info, [message]}
 278       assert message =~ "Generated user invite token reusable"
 279     end
 280
 281     test "token is generated with max use and expires date" do
 282       assert capture_io(fn ->
 283                Mix.Tasks.Pleroma.User.run([
 284                  "invite",
 285                  "--max-use",
 286                  "5",
 287                  "--expires-at",
 288                  Date.to_string(Date.utc_today())
 289                ])
 290              end)
 291
 292       assert_received {:mix_shell, :info, [message]}
 293       assert message =~ "Generated user invite token reusable date limited"
 294     end
 295   end
 296
 297   describe "running invites" do
 298     test "invites are listed" do
 299       {:ok, invite} = Pleroma.UserInviteToken.create_invite()
 300
 301       {:ok, invite2} =
 302         Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})
 303
 304       # assert capture_io(fn ->
 305       Mix.Tasks.Pleroma.User.run([
 306         "invites"
 307       ])
 308
 309       #  end)
 310
 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
 317     end
 318   end
 319
 320   describe "running revoke_invite" do
 321     test "invite is revoked" do
 322       {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
 323
 324       assert capture_io(fn ->
 325                Mix.Tasks.Pleroma.User.run([
 326                  "revoke_invite",
 327                  invite.token
 328                ])
 329              end)
 330
 331       assert_received {:mix_shell, :info, [message]}
 332       assert message =~ "Invite for token #{invite.token} was revoked."
 333     end
 334
 335     test "it prints an error message when invite is not exist" do
 336       Mix.Tasks.Pleroma.User.run(["revoke_invite", "foo"])
 337
 338       assert_received {:mix_shell, :error, [message]}
 339       assert message =~ "No invite found"
 340     end
 341   end
 342
 343   describe "running delete_activities" do
 344     test "activities are deleted" do
 345       %{nickname: nickname} = insert(:user)
 346
 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."
 350     end
 351
 352     test "it prints an error message when user is not exist" do
 353       Mix.Tasks.Pleroma.User.run(["delete_activities", "foo"])
 354
 355       assert_received {:mix_shell, :error, [message]}
 356       assert message =~ "No local user"
 357     end
 358   end
 359
 360   describe "running toggle_confirmed" do
 361     test "user is confirmed" do
 362       %{id: id, nickname: nickname} = insert(:user, confirmation_pending: false)
 363
 364       assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
 365       assert_received {:mix_shell, :info, [message]}
 366       assert message == "#{nickname} needs confirmation."
 367
 368       user = Repo.get(User, id)
 369       assert user.confirmation_pending
 370       assert user.confirmation_token
 371     end
 372
 373     test "user is not confirmed" do
 374       %{id: id, nickname: nickname} =
 375         insert(:user, confirmation_pending: true, confirmation_token: "some token")
 376
 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."
 380
 381       user = Repo.get(User, id)
 382       refute user.confirmation_pending
 383       refute user.confirmation_token
 384     end
 385
 386     test "it prints an error message when user is not exist" do
 387       Mix.Tasks.Pleroma.User.run(["toggle_confirmed", "foo"])
 388
 389       assert_received {:mix_shell, :error, [message]}
 390       assert message =~ "No local user"
 391     end
 392   end
 393
 394   describe "search" do
 395     test "it returns users matching" do
 396       user = insert(:user)
 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")
 400
 401       {:ok, user} = User.follow(user, kawen)
 402
 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)
 409
 410       assert [kawen.id, moon.id] ==
 411                User.Search.search("moon fediverse", for_user: user) |> Enum.map(& &1.id)
 412     end
 413   end
 414
 415   describe "signing out" do
 416     test "it deletes all user's tokens and authorizations" do
 417       user = insert(:user)
 418       insert(:oauth_token, user: user)
 419       insert(:oauth_authorization, user: user)
 420
 421       assert Repo.get_by(Token, user_id: user.id)
 422       assert Repo.get_by(Authorization, user_id: user.id)
 423
 424       :ok = Mix.Tasks.Pleroma.User.run(["sign_out", user.nickname])
 425
 426       refute Repo.get_by(Token, user_id: user.id)
 427       refute Repo.get_by(Authorization, user_id: user.id)
 428     end
 429
 430     test "it prints an error message when user is not exist" do
 431       Mix.Tasks.Pleroma.User.run(["sign_out", "foo"])
 432
 433       assert_received {:mix_shell, :error, [message]}
 434       assert message =~ "No local user"
 435     end
 436   end
 437
 438   describe "tagging" do
 439     test "it add tags to a user" do
 440       user = insert(:user)
 441
 442       :ok = Mix.Tasks.Pleroma.User.run(["tag", user.nickname, "pleroma"])
 443
 444       user = User.get_cached_by_nickname(user.nickname)
 445       assert "pleroma" in user.tags
 446     end
 447
 448     test "it prints an error message when user is not exist" do
 449       Mix.Tasks.Pleroma.User.run(["tag", "foo"])
 450
 451       assert_received {:mix_shell, :error, [message]}
 452       assert message =~ "Could not change user tags"
 453     end
 454   end
 455
 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
 460
 461       :ok = Mix.Tasks.Pleroma.User.run(["untag", user.nickname, "pleroma"])
 462
 463       user = User.get_cached_by_nickname(user.nickname)
 464       assert Enum.empty?(user.tags)
 465     end
 466
 467     test "it prints an error message when user is not exist" do
 468       Mix.Tasks.Pleroma.User.run(["untag", "foo"])
 469
 470       assert_received {:mix_shell, :error, [message]}
 471       assert message =~ "Could not change user tags"
 472     end
 473   end
 474 end