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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 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, :prompt, "Y"})
  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, :prompt, [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, :prompt, "N"})
  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, :prompt, [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 %{is_active: false} = 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, fetch: false)
 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, fetch: false)
 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 %{is_active: false} = 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 deactivate" do
 161     test "user is unsubscribed" do
 162       followed = insert(:user)
 163       remote_followed = insert(:user, local: false)
 164       user = insert(:user)
 165
 166       User.follow(user, followed, :follow_accept)
 167       User.follow(user, remote_followed, :follow_accept)
 168
 169       Mix.Tasks.Pleroma.User.run(["deactivate", user.nickname])
 170
 171       assert_received {:mix_shell, :info, [message]}
 172       assert message =~ "Deactivating"
 173
 174       # Note that the task has delay :timer.sleep(500)
 175       assert_received {:mix_shell, :info, [message]}
 176       assert message =~ "Successfully unsubscribed"
 177
 178       user = User.get_cached_by_nickname(user.nickname)
 179       assert Enum.empty?(Enum.filter(User.get_friends(user), & &1.local))
 180       refute user.is_active
 181     end
 182
 183     test "no user to deactivate" do
 184       Mix.Tasks.Pleroma.User.run(["deactivate", "nonexistent"])
 185
 186       assert_received {:mix_shell, :error, [message]}
 187       assert message =~ "No user"
 188     end
 189   end
 190
 191   describe "running set" do
 192     test "All statuses set" do
 193       user = insert(:user)
 194
 195       Mix.Tasks.Pleroma.User.run([
 196         "set",
 197         user.nickname,
 198         "--admin",
 199         "--confirmed",
 200         "--locked",
 201         "--moderator"
 202       ])
 203
 204       assert_received {:mix_shell, :info, [message]}
 205       assert message =~ ~r/Admin status .* true/
 206
 207       assert_received {:mix_shell, :info, [message]}
 208       assert message =~ ~r/Confirmation status.* true/
 209
 210       assert_received {:mix_shell, :info, [message]}
 211       assert message =~ ~r/Locked status .* true/
 212
 213       assert_received {:mix_shell, :info, [message]}
 214       assert message =~ ~r/Moderator status .* true/
 215
 216       user = User.get_cached_by_nickname(user.nickname)
 217       assert user.is_moderator
 218       assert user.is_locked
 219       assert user.is_admin
 220       assert user.is_confirmed
 221     end
 222
 223     test "All statuses unset" do
 224       user =
 225         insert(:user,
 226           is_locked: true,
 227           is_moderator: true,
 228           is_admin: true,
 229           is_confirmed: false
 230         )
 231
 232       Mix.Tasks.Pleroma.User.run([
 233         "set",
 234         user.nickname,
 235         "--no-admin",
 236         "--no-confirmed",
 237         "--no-locked",
 238         "--no-moderator"
 239       ])
 240
 241       assert_received {:mix_shell, :info, [message]}
 242       assert message =~ ~r/Admin status .* false/
 243
 244       assert_received {:mix_shell, :info, [message]}
 245       assert message =~ ~r/Confirmation status.* false/
 246
 247       assert_received {:mix_shell, :info, [message]}
 248       assert message =~ ~r/Locked status .* false/
 249
 250       assert_received {:mix_shell, :info, [message]}
 251       assert message =~ ~r/Moderator status .* false/
 252
 253       user = User.get_cached_by_nickname(user.nickname)
 254       refute user.is_moderator
 255       refute user.is_locked
 256       refute user.is_admin
 257       refute user.is_confirmed
 258     end
 259
 260     test "no user to set status" do
 261       Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])
 262
 263       assert_received {:mix_shell, :error, [message]}
 264       assert message =~ "No local user"
 265     end
 266   end
 267
 268   describe "running reset_password" do
 269     test "password reset token is generated" do
 270       user = insert(:user)
 271
 272       assert capture_io(fn ->
 273                Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
 274              end) =~ "URL:"
 275
 276       assert_received {:mix_shell, :info, [message]}
 277       assert message =~ "Generated"
 278     end
 279
 280     test "no user to reset password" do
 281       Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
 282
 283       assert_received {:mix_shell, :error, [message]}
 284       assert message =~ "No local user"
 285     end
 286   end
 287
 288   describe "running reset_mfa" do
 289     test "disables MFA" do
 290       user =
 291         insert(:user,
 292           multi_factor_authentication_settings: %MFA.Settings{
 293             enabled: true,
 294             totp: %MFA.Settings.TOTP{secret: "xx", confirmed: true}
 295           }
 296         )
 297
 298       Mix.Tasks.Pleroma.User.run(["reset_mfa", user.nickname])
 299
 300       assert_received {:mix_shell, :info, [message]}
 301       assert message == "Multi-Factor Authentication disabled for #{user.nickname}"
 302
 303       assert %{enabled: false, totp: false} ==
 304                user.nickname
 305                |> User.get_cached_by_nickname()
 306                |> MFA.mfa_settings()
 307     end
 308
 309     test "no user to reset MFA" do
 310       Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
 311
 312       assert_received {:mix_shell, :error, [message]}
 313       assert message =~ "No local user"
 314     end
 315   end
 316
 317   describe "running invite" do
 318     test "invite token is generated" do
 319       assert capture_io(fn ->
 320                Mix.Tasks.Pleroma.User.run(["invite"])
 321              end) =~ "http"
 322
 323       assert_received {:mix_shell, :info, [message]}
 324       assert message =~ "Generated user invite token one time"
 325     end
 326
 327     test "token is generated with expires_at" do
 328       assert capture_io(fn ->
 329                Mix.Tasks.Pleroma.User.run([
 330                  "invite",
 331                  "--expires-at",
 332                  Date.to_string(Date.utc_today())
 333                ])
 334              end)
 335
 336       assert_received {:mix_shell, :info, [message]}
 337       assert message =~ "Generated user invite token date limited"
 338     end
 339
 340     test "token is generated with max use" do
 341       assert capture_io(fn ->
 342                Mix.Tasks.Pleroma.User.run([
 343                  "invite",
 344                  "--max-use",
 345                  "5"
 346                ])
 347              end)
 348
 349       assert_received {:mix_shell, :info, [message]}
 350       assert message =~ "Generated user invite token reusable"
 351     end
 352
 353     test "token is generated with max use and expires date" do
 354       assert capture_io(fn ->
 355                Mix.Tasks.Pleroma.User.run([
 356                  "invite",
 357                  "--max-use",
 358                  "5",
 359                  "--expires-at",
 360                  Date.to_string(Date.utc_today())
 361                ])
 362              end)
 363
 364       assert_received {:mix_shell, :info, [message]}
 365       assert message =~ "Generated user invite token reusable date limited"
 366     end
 367   end
 368
 369   describe "running invites" do
 370     test "invites are listed" do
 371       {:ok, invite} = Pleroma.UserInviteToken.create_invite()
 372
 373       {:ok, invite2} =
 374         Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})
 375
 376       # assert capture_io(fn ->
 377       Mix.Tasks.Pleroma.User.run([
 378         "invites"
 379       ])
 380
 381       #  end)
 382
 383       assert_received {:mix_shell, :info, [message]}
 384       assert_received {:mix_shell, :info, [message2]}
 385       assert_received {:mix_shell, :info, [message3]}
 386       assert message =~ "Invites list:"
 387       assert message2 =~ invite.invite_type
 388       assert message3 =~ invite2.invite_type
 389     end
 390   end
 391
 392   describe "running revoke_invite" do
 393     test "invite is revoked" do
 394       {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
 395
 396       assert capture_io(fn ->
 397                Mix.Tasks.Pleroma.User.run([
 398                  "revoke_invite",
 399                  invite.token
 400                ])
 401              end)
 402
 403       assert_received {:mix_shell, :info, [message]}
 404       assert message =~ "Invite for token #{invite.token} was revoked."
 405     end
 406   end
 407
 408   describe "running delete_activities" do
 409     test "activities are deleted" do
 410       %{nickname: nickname} = insert(:user)
 411
 412       assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
 413       assert_received {:mix_shell, :info, [message]}
 414       assert message == "User #{nickname} statuses deleted."
 415     end
 416
 417     test "it prints an error message when user is not exist" do
 418       Mix.Tasks.Pleroma.User.run(["delete_activities", "foo"])
 419
 420       assert_received {:mix_shell, :error, [message]}
 421       assert message =~ "No local user"
 422     end
 423   end
 424
 425   describe "running confirm" do
 426     test "user is confirmed" do
 427       %{id: id, nickname: nickname} = insert(:user, is_confirmed: true)
 428
 429       assert :ok = Mix.Tasks.Pleroma.User.run(["confirm", nickname])
 430       assert_received {:mix_shell, :info, [message]}
 431       assert message == "#{nickname} doesn't need confirmation."
 432
 433       user = Repo.get(User, id)
 434       assert user.is_confirmed
 435       refute user.confirmation_token
 436     end
 437
 438     test "user is not confirmed" do
 439       %{id: id, nickname: nickname} =
 440         insert(:user, is_confirmed: false, confirmation_token: "some token")
 441
 442       assert :ok = Mix.Tasks.Pleroma.User.run(["confirm", nickname])
 443       assert_received {:mix_shell, :info, [message]}
 444       assert message == "#{nickname} doesn't need confirmation."
 445
 446       user = Repo.get(User, id)
 447       assert user.is_confirmed
 448       refute user.confirmation_token
 449     end
 450
 451     test "it prints an error message when user is not exist" do
 452       Mix.Tasks.Pleroma.User.run(["confirm", "foo"])
 453
 454       assert_received {:mix_shell, :error, [message]}
 455       assert message =~ "No local user"
 456     end
 457   end
 458
 459   describe "running activate" do
 460     test "user is activated" do
 461       %{id: id, nickname: nickname} = insert(:user, is_active: true)
 462
 463       assert :ok = Mix.Tasks.Pleroma.User.run(["activate", nickname])
 464       assert_received {:mix_shell, :info, [message]}
 465       assert message == "User #{nickname} already activated"
 466
 467       user = Repo.get(User, id)
 468       assert user.is_active
 469     end
 470
 471     test "user is not activated" do
 472       %{id: id, nickname: nickname} = insert(:user, is_active: false)
 473
 474       assert :ok = Mix.Tasks.Pleroma.User.run(["activate", nickname])
 475       assert_received {:mix_shell, :info, [message]}
 476       assert message == "Successfully activated #{nickname}"
 477
 478       user = Repo.get(User, id)
 479       assert user.is_active
 480     end
 481
 482     test "it prints an error message when user is not exist" do
 483       Mix.Tasks.Pleroma.User.run(["activate", "foo"])
 484
 485       assert_received {:mix_shell, :error, [message]}
 486       assert message =~ "No user"
 487     end
 488   end
 489
 490   describe "search" do
 491     test "it returns users matching" do
 492       user = insert(:user)
 493       moon = insert(:user, nickname: "moon", name: "fediverse expert moon")
 494       moot = insert(:user, nickname: "moot")
 495       kawen = insert(:user, nickname: "kawen", name: "fediverse expert moon")
 496
 497       {:ok, user, moon} = User.follow(user, moon)
 498
 499       assert [moon.id, kawen.id] == User.Search.search("moon") |> Enum.map(& &1.id)
 500
 501       res = User.search("moo") |> Enum.map(& &1.id)
 502       assert Enum.sort([moon.id, moot.id, kawen.id]) == Enum.sort(res)
 503
 504       assert [kawen.id, moon.id] == User.Search.search("expert fediverse") |> Enum.map(& &1.id)
 505
 506       assert [moon.id, kawen.id] ==
 507                User.Search.search("expert fediverse", for_user: user) |> Enum.map(& &1.id)
 508     end
 509   end
 510
 511   describe "signing out" do
 512     test "it deletes all user's tokens and authorizations" do
 513       user = insert(:user)
 514       insert(:oauth_token, user: user)
 515       insert(:oauth_authorization, user: user)
 516
 517       assert Repo.get_by(Token, user_id: user.id)
 518       assert Repo.get_by(Authorization, user_id: user.id)
 519
 520       :ok = Mix.Tasks.Pleroma.User.run(["sign_out", user.nickname])
 521
 522       refute Repo.get_by(Token, user_id: user.id)
 523       refute Repo.get_by(Authorization, user_id: user.id)
 524     end
 525
 526     test "it prints an error message when user is not exist" do
 527       Mix.Tasks.Pleroma.User.run(["sign_out", "foo"])
 528
 529       assert_received {:mix_shell, :error, [message]}
 530       assert message =~ "No local user"
 531     end
 532   end
 533
 534   describe "tagging" do
 535     test "it add tags to a user" do
 536       user = insert(:user)
 537
 538       :ok = Mix.Tasks.Pleroma.User.run(["tag", user.nickname, "pleroma"])
 539
 540       user = User.get_cached_by_nickname(user.nickname)
 541       assert "pleroma" in user.tags
 542     end
 543
 544     test "it prints an error message when user is not exist" do
 545       Mix.Tasks.Pleroma.User.run(["tag", "foo"])
 546
 547       assert_received {:mix_shell, :error, [message]}
 548       assert message =~ "Could not change user tags"
 549     end
 550   end
 551
 552   describe "untagging" do
 553     test "it deletes tags from a user" do
 554       user = insert(:user, tags: ["pleroma"])
 555       assert "pleroma" in user.tags
 556
 557       :ok = Mix.Tasks.Pleroma.User.run(["untag", user.nickname, "pleroma"])
 558
 559       user = User.get_cached_by_nickname(user.nickname)
 560       assert Enum.empty?(user.tags)
 561     end
 562
 563     test "it prints an error message when user is not exist" do
 564       Mix.Tasks.Pleroma.User.run(["untag", "foo"])
 565
 566       assert_received {:mix_shell, :error, [message]}
 567       assert message =~ "Could not change user tags"
 568     end
 569   end
 570
 571   describe "bulk confirm and unconfirm" do
 572     test "confirm all" do
 573       user1 = insert(:user, is_confirmed: false)
 574       user2 = insert(:user, is_confirmed: false)
 575
 576       refute user1.is_confirmed
 577       refute user2.is_confirmed
 578
 579       Mix.Tasks.Pleroma.User.run(["confirm_all"])
 580
 581       user1 = User.get_cached_by_nickname(user1.nickname)
 582       user2 = User.get_cached_by_nickname(user2.nickname)
 583
 584       assert user1.is_confirmed
 585       assert user2.is_confirmed
 586     end
 587
 588     test "unconfirm all" do
 589       user1 = insert(:user, is_confirmed: true)
 590       user2 = insert(:user, is_confirmed: true)
 591       admin = insert(:user, is_admin: true, is_confirmed: true)
 592       mod = insert(:user, is_moderator: true, is_confirmed: true)
 593
 594       assert user1.is_confirmed
 595       assert user2.is_confirmed
 596
 597       Mix.Tasks.Pleroma.User.run(["unconfirm_all"])
 598
 599       user1 = User.get_cached_by_nickname(user1.nickname)
 600       user2 = User.get_cached_by_nickname(user2.nickname)
 601       admin = User.get_cached_by_nickname(admin.nickname)
 602       mod = User.get_cached_by_nickname(mod.nickname)
 603
 604       refute user1.is_confirmed
 605       refute user2.is_confirmed
 606       assert admin.is_confirmed
 607       assert mod.is_confirmed
 608     end
 609   end
 610 end