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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 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   use Pleroma.DataCase
   9
  10   import Pleroma.Factory
  11   import ExUnit.CaptureIO
  12
  13   setup_all do
  14     Mix.shell(Mix.Shell.Process)
  15
  16     on_exit(fn ->
  17       Mix.shell(Mix.Shell.IO)
  18     end)
  19
  20     :ok
  21   end
  22
  23   describe "running new" do
  24     test "user is created" do
  25       # just get random data
  26       unsaved = build(:user)
  27
  28       # prepare to answer yes
  29       send(self(), {:mix_shell_input, :yes?, true})
  30
  31       Mix.Tasks.Pleroma.User.run([
  32         "new",
  33         unsaved.nickname,
  34         unsaved.email,
  35         "--name",
  36         unsaved.name,
  37         "--bio",
  38         unsaved.bio,
  39         "--password",
  40         "test",
  41         "--moderator",
  42         "--admin"
  43       ])
  44
  45       assert_received {:mix_shell, :info, [message]}
  46       assert message =~ "user will be created"
  47
  48       assert_received {:mix_shell, :yes?, [message]}
  49       assert message =~ "Continue"
  50
  51       assert_received {:mix_shell, :info, [message]}
  52       assert message =~ "created"
  53
  54       user = User.get_cached_by_nickname(unsaved.nickname)
  55       assert user.name == unsaved.name
  56       assert user.email == unsaved.email
  57       assert user.bio == unsaved.bio
  58       assert user.info.is_moderator
  59       assert user.info.is_admin
  60     end
  61
  62     test "user is not created" do
  63       unsaved = build(:user)
  64
  65       # prepare to answer no
  66       send(self(), {:mix_shell_input, :yes?, false})
  67
  68       Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])
  69
  70       assert_received {:mix_shell, :info, [message]}
  71       assert message =~ "user will be created"
  72
  73       assert_received {:mix_shell, :yes?, [message]}
  74       assert message =~ "Continue"
  75
  76       assert_received {:mix_shell, :info, [message]}
  77       assert message =~ "will not be created"
  78
  79       refute User.get_cached_by_nickname(unsaved.nickname)
  80     end
  81   end
  82
  83   describe "running rm" do
  84     test "user is deleted" do
  85       user = insert(:user)
  86
  87       Mix.Tasks.Pleroma.User.run(["rm", user.nickname])
  88
  89       assert_received {:mix_shell, :info, [message]}
  90       assert message =~ " deleted"
  91
  92       user = User.get_cached_by_nickname(user.nickname)
  93       assert user.info.deactivated
  94     end
  95
  96     test "no user to delete" do
  97       Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])
  98
  99       assert_received {:mix_shell, :error, [message]}
 100       assert message =~ "No local user"
 101     end
 102   end
 103
 104   describe "running toggle_activated" do
 105     test "user is deactivated" do
 106       user = insert(:user)
 107
 108       Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
 109
 110       assert_received {:mix_shell, :info, [message]}
 111       assert message =~ " deactivated"
 112
 113       user = User.get_cached_by_nickname(user.nickname)
 114       assert user.info.deactivated
 115     end
 116
 117     test "user is activated" do
 118       user = insert(:user, info: %{deactivated: true})
 119
 120       Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])
 121
 122       assert_received {:mix_shell, :info, [message]}
 123       assert message =~ " activated"
 124
 125       user = User.get_cached_by_nickname(user.nickname)
 126       refute user.info.deactivated
 127     end
 128
 129     test "no user to toggle" do
 130       Mix.Tasks.Pleroma.User.run(["toggle_activated", "nonexistent"])
 131
 132       assert_received {:mix_shell, :error, [message]}
 133       assert message =~ "No user"
 134     end
 135   end
 136
 137   describe "running unsubscribe" do
 138     test "user is unsubscribed" do
 139       followed = insert(:user)
 140       user = insert(:user, %{following: [User.ap_followers(followed)]})
 141
 142       Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname])
 143
 144       assert_received {:mix_shell, :info, [message]}
 145       assert message =~ "Deactivating"
 146
 147       assert_received {:mix_shell, :info, [message]}
 148       assert message =~ "Unsubscribing"
 149
 150       # Note that the task has delay :timer.sleep(500)
 151       assert_received {:mix_shell, :info, [message]}
 152       assert message =~ "Successfully unsubscribed"
 153
 154       user = User.get_cached_by_nickname(user.nickname)
 155       assert Enum.empty?(user.following)
 156       assert user.info.deactivated
 157     end
 158
 159     test "no user to unsubscribe" do
 160       Mix.Tasks.Pleroma.User.run(["unsubscribe", "nonexistent"])
 161
 162       assert_received {:mix_shell, :error, [message]}
 163       assert message =~ "No user"
 164     end
 165   end
 166
 167   describe "running set" do
 168     test "All statuses set" do
 169       user = insert(:user)
 170
 171       Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])
 172
 173       assert_received {:mix_shell, :info, [message]}
 174       assert message =~ ~r/Moderator status .* true/
 175
 176       assert_received {:mix_shell, :info, [message]}
 177       assert message =~ ~r/Locked status .* true/
 178
 179       assert_received {:mix_shell, :info, [message]}
 180       assert message =~ ~r/Admin status .* true/
 181
 182       user = User.get_cached_by_nickname(user.nickname)
 183       assert user.info.is_moderator
 184       assert user.info.locked
 185       assert user.info.is_admin
 186     end
 187
 188     test "All statuses unset" do
 189       user = insert(:user, info: %{is_moderator: true, locked: true, is_admin: true})
 190
 191       Mix.Tasks.Pleroma.User.run([
 192         "set",
 193         user.nickname,
 194         "--no-moderator",
 195         "--no-admin",
 196         "--no-locked"
 197       ])
 198
 199       assert_received {:mix_shell, :info, [message]}
 200       assert message =~ ~r/Moderator status .* false/
 201
 202       assert_received {:mix_shell, :info, [message]}
 203       assert message =~ ~r/Locked status .* false/
 204
 205       assert_received {:mix_shell, :info, [message]}
 206       assert message =~ ~r/Admin status .* false/
 207
 208       user = User.get_cached_by_nickname(user.nickname)
 209       refute user.info.is_moderator
 210       refute user.info.locked
 211       refute user.info.is_admin
 212     end
 213
 214     test "no user to set status" do
 215       Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])
 216
 217       assert_received {:mix_shell, :error, [message]}
 218       assert message =~ "No local user"
 219     end
 220   end
 221
 222   describe "running reset_password" do
 223     test "password reset token is generated" do
 224       user = insert(:user)
 225
 226       assert capture_io(fn ->
 227                Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
 228              end) =~ "URL:"
 229
 230       assert_received {:mix_shell, :info, [message]}
 231       assert message =~ "Generated"
 232     end
 233
 234     test "no user to reset password" do
 235       Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])
 236
 237       assert_received {:mix_shell, :error, [message]}
 238       assert message =~ "No local user"
 239     end
 240   end
 241
 242   describe "running invite" do
 243     test "invite token is generated" do
 244       assert capture_io(fn ->
 245                Mix.Tasks.Pleroma.User.run(["invite"])
 246              end) =~ "http"
 247
 248       assert_received {:mix_shell, :info, [message]}
 249       assert message =~ "Generated user invite token one time"
 250     end
 251
 252     test "token is generated with expires_at" do
 253       assert capture_io(fn ->
 254                Mix.Tasks.Pleroma.User.run([
 255                  "invite",
 256                  "--expires-at",
 257                  Date.to_string(Date.utc_today())
 258                ])
 259              end)
 260
 261       assert_received {:mix_shell, :info, [message]}
 262       assert message =~ "Generated user invite token date limited"
 263     end
 264
 265     test "token is generated with max use" do
 266       assert capture_io(fn ->
 267                Mix.Tasks.Pleroma.User.run([
 268                  "invite",
 269                  "--max-use",
 270                  "5"
 271                ])
 272              end)
 273
 274       assert_received {:mix_shell, :info, [message]}
 275       assert message =~ "Generated user invite token reusable"
 276     end
 277
 278     test "token is generated with max use and expires date" do
 279       assert capture_io(fn ->
 280                Mix.Tasks.Pleroma.User.run([
 281                  "invite",
 282                  "--max-use",
 283                  "5",
 284                  "--expires-at",
 285                  Date.to_string(Date.utc_today())
 286                ])
 287              end)
 288
 289       assert_received {:mix_shell, :info, [message]}
 290       assert message =~ "Generated user invite token reusable date limited"
 291     end
 292   end
 293
 294   describe "running invites" do
 295     test "invites are listed" do
 296       {:ok, invite} = Pleroma.UserInviteToken.create_invite()
 297
 298       {:ok, invite2} =
 299         Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})
 300
 301       # assert capture_io(fn ->
 302       Mix.Tasks.Pleroma.User.run([
 303         "invites"
 304       ])
 305
 306       #  end)
 307
 308       assert_received {:mix_shell, :info, [message]}
 309       assert_received {:mix_shell, :info, [message2]}
 310       assert_received {:mix_shell, :info, [message3]}
 311       assert message =~ "Invites list:"
 312       assert message2 =~ invite.invite_type
 313       assert message3 =~ invite2.invite_type
 314     end
 315   end
 316
 317   describe "running revoke_invite" do
 318     test "invite is revoked" do
 319       {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
 320
 321       assert capture_io(fn ->
 322                Mix.Tasks.Pleroma.User.run([
 323                  "revoke_invite",
 324                  invite.token
 325                ])
 326              end)
 327
 328       assert_received {:mix_shell, :info, [message]}
 329       assert message =~ "Invite for token #{invite.token} was revoked."
 330     end
 331   end
 332
 333   describe "running delete_activities" do
 334     test "activities are deleted" do
 335       %{nickname: nickname} = insert(:user)
 336
 337       assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
 338       assert_received {:mix_shell, :info, [message]}
 339       assert message == "User #{nickname} statuses deleted."
 340     end
 341   end
 342
 343   describe "running toggle_confirmed" do
 344     test "user is confirmed" do
 345       %{id: id, nickname: nickname} = insert(:user, info: %{confirmation_pending: false})
 346
 347       assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
 348       assert_received {:mix_shell, :info, [message]}
 349       assert message == "#{nickname} needs confirmation."
 350
 351       user = Repo.get(User, id)
 352       assert user.info.confirmation_pending
 353       assert user.info.confirmation_token
 354     end
 355
 356     test "user is not confirmed" do
 357       %{id: id, nickname: nickname} =
 358         insert(:user, info: %{confirmation_pending: true, confirmation_token: "some token"})
 359
 360       assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
 361       assert_received {:mix_shell, :info, [message]}
 362       assert message == "#{nickname} doesn't need confirmation."
 363
 364       user = Repo.get(User, id)
 365       refute user.info.confirmation_pending
 366       refute user.info.confirmation_token
 367     end
 368   end
 369
 370   describe "search" do
 371     test "it returns users matching" do
 372       user = insert(:user)
 373       moon = insert(:user, nickname: "moon", name: "fediverse expert moon")
 374       moot = insert(:user, nickname: "moot")
 375       kawen = insert(:user, nickname: "kawen", name: "fediverse expert moon")
 376
 377       {:ok, user} = User.follow(user, kawen)
 378
 379       assert [moon.id, kawen.id] == User.Search.search("moon") |> Enum.map(& &1.id)
 380       res = User.search("moo") |> Enum.map(& &1.id)
 381       assert moon.id in res
 382       assert moot.id in res
 383       assert kawen.id in res
 384       assert [moon.id, kawen.id] == User.Search.search("moon fediverse") |> Enum.map(& &1.id)
 385
 386       assert [kawen.id, moon.id] ==
 387                User.Search.search("moon fediverse", for_user: user) |> Enum.map(& &1.id)
 388     end
 389   end
 390 end