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