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