user_test.exs
No OneTemporary
Actions

Size

11 KB

Referenced Files

None

Subscribers

None

user_test.exs
View Options

	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.UserTest do
	alias Pleroma.Repo
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory
	import ExUnit.CaptureIO

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "running new" do
	test "user is created" do
	# just get random data
	unsaved = build(:user)

	# prepare to answer yes
	send(self(), {:mix_shell_input, :yes?, true})

	Mix.Tasks.Pleroma.User.run([
	"new",
	unsaved.nickname,
	unsaved.email,
	"--name",
	unsaved.name,
	"--bio",
	unsaved.bio,
	"--password",
	"test",
	"--moderator",
	"--admin"
	])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_received {:mix_shell, :yes?, [message]}
	assert message =~ "Continue"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "created"

	user = User.get_cached_by_nickname(unsaved.nickname)
	assert user.name == unsaved.name
	assert user.email == unsaved.email
	assert user.bio == unsaved.bio
	assert user.info.is_moderator
	assert user.info.is_admin
	end

	test "user is not created" do
	unsaved = build(:user)

	# prepare to answer no
	send(self(), {:mix_shell_input, :yes?, false})

	Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_received {:mix_shell, :yes?, [message]}
	assert message =~ "Continue"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "will not be created"

	refute User.get_cached_by_nickname(unsaved.nickname)
	end
	end

	describe "running rm" do
	test "user is deleted" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["rm", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " deleted"

	refute User.get_by_nickname(user.nickname)
	end

	test "no user to delete" do
	Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running toggle_activated" do
	test "user is deactivated" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " deactivated"

	user = User.get_cached_by_nickname(user.nickname)
	assert user.info.deactivated
	end

	test "user is activated" do
	user = insert(:user, info: %{deactivated: true})

	Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " activated"

	user = User.get_cached_by_nickname(user.nickname)
	refute user.info.deactivated
	end

	test "no user to toggle" do
	Mix.Tasks.Pleroma.User.run(["toggle_activated", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "running unsubscribe" do
	test "user is unsubscribed" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Deactivating"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Unsubscribing"

	# Note that the task has delay :timer.sleep(500)
	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Successfully unsubscribed"

	user = User.get_cached_by_nickname(user.nickname)
	assert Enum.empty?(user.following)
	assert user.info.deactivated
	end

	test "no user to unsubscribe" do
	Mix.Tasks.Pleroma.User.run(["unsubscribe", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "running set" do
	test "All statuses set" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* true/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* true/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* true/

	user = User.get_cached_by_nickname(user.nickname)
	assert user.info.is_moderator
	assert user.info.locked
	assert user.info.is_admin
	end

	test "All statuses unset" do
	user = insert(:user, info: %{is_moderator: true, locked: true, is_admin: true})

	Mix.Tasks.Pleroma.User.run([
	"set",
	user.nickname,
	"--no-moderator",
	"--no-admin",
	"--no-locked"
	])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* false/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* false/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* false/

	user = User.get_cached_by_nickname(user.nickname)
	refute user.info.is_moderator
	refute user.info.locked
	refute user.info.is_admin
	end

	test "no user to set status" do
	Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running reset_password" do
	test "password reset token is generated" do
	user = insert(:user)

	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
	end) =~ "URL:"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated"
	end

	test "no user to reset password" do
	Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running invite" do
	test "invite token is generated" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["invite"])
	end) =~ "http"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token one time"
	end

	test "token is generated with expires_at" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite",
	"--expires-at",
	Date.to_string(Date.utc_today())
	])
	end)

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token date limited"
	end

	test "token is generated with max use" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite",
	"--max-use",
	"5"
	])
	end)

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token reusable"
	end

	test "token is generated with max use and expires date" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite",
	"--max-use",
	"5",
	"--expires-at",
	Date.to_string(Date.utc_today())
	])
	end)

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token reusable date limited"
	end
	end

	describe "running invites" do
	test "invites are listed" do
	{:ok, invite} = Pleroma.UserInviteToken.create_invite()

	{:ok, invite2} =
	Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})

	# assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invites"
	])

	# end)

	assert_received {:mix_shell, :info, [message]}
	assert_received {:mix_shell, :info, [message2]}
	assert_received {:mix_shell, :info, [message3]}
	assert message =~ "Invites list:"
	assert message2 =~ invite.invite_type
	assert message3 =~ invite2.invite_type
	end
	end

	describe "running revoke_invite" do
	test "invite is revoked" do
	{:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})

	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"revoke_invite",
	invite.token
	])
	end)

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Invite for token #{invite.token} was revoked."
	end
	end

	describe "running delete_activities" do
	test "activities are deleted" do
	%{nickname: nickname} = insert(:user)

	assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
	assert_received {:mix_shell, :info, [message]}
	assert message == "User #{nickname} statuses deleted."
	end
	end

	describe "running toggle_confirmed" do
	test "user is confirmed" do
	%{id: id, nickname: nickname} = insert(:user, info: %{confirmation_pending: false})

	assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
	assert_received {:mix_shell, :info, [message]}
	assert message == "#{nickname} needs confirmation."

	user = Repo.get(User, id)
	assert user.info.confirmation_pending
	assert user.info.confirmation_token
	end

	test "user is not confirmed" do
	%{id: id, nickname: nickname} =
	insert(:user, info: %{confirmation_pending: true, confirmation_token: "some token"})

	assert :ok = Mix.Tasks.Pleroma.User.run(["toggle_confirmed", nickname])
	assert_received {:mix_shell, :info, [message]}
	assert message == "#{nickname} doesn't need confirmation."

	user = Repo.get(User, id)
	refute user.info.confirmation_pending
	refute user.info.confirmation_token
	end
	end

	describe "search" do
	test "it returns users matching" do
	user = insert(:user)
	moon = insert(:user, nickname: "moon", name: "fediverse expert moon")
	moot = insert(:user, nickname: "moot")
	kawen = insert(:user, nickname: "kawen", name: "fediverse expert moon")

	{:ok, user} = User.follow(user, kawen)

	assert [moon.id, kawen.id] == User.Search.search("moon") \|> Enum.map(& &1.id)
	res = User.search("moo") \|> Enum.map(& &1.id)
	assert moon.id in res
	assert moot.id in res
	assert kawen.id in res
	assert [moon.id, kawen.id] == User.Search.search("moon fediverse") \|> Enum.map(& &1.id)

	assert [kawen.id, moon.id] ==
	User.Search.search("moon fediverse", for_user: user) \|> Enum.map(& &1.id)
	end
	end
	end

File Metadata

Mime Type: text/plain
Expires: Thu, Oct 2, 4:44 AM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 487314
Default Alt Text: user_test.exs (11 KB)

user_test.exsNo OneTemporaryActions

user_test.exsView Options

File Metadata

Event Timeline

user_test.exs
No OneTemporary
Actions

user_test.exs
View Options