No OneTemporary
Actions

Size

29 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex b/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex
	index bc54f1915..879b2227e 100644
	--- a/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex
	@@ -1,228 +1,237 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.TwitterUtilOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def emoji_operation do
	%Operation{
	tags: ["Emojis"],
	summary: "List all custom emojis",
	operationId: "UtilController.emoji",
	parameters: [],
	responses: %{
	200 =>
	Operation.response("List", "application/json", %Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :object,
	properties: %{
	image_url: %Schema{type: :string},
	tags: %Schema{type: :array, items: %Schema{type: :string}}
	}
	},
	example: %{
	"firefox" => %{
	"image_url" => "/emoji/firefox.png",
	"tag" => ["Fun"]
	}
	}
	})
	}
	}
	end

	def frontend_configurations_operation do
	%Operation{
	tags: ["Configuration"],
	summary: "Dump frontend configurations",
	operationId: "UtilController.frontend_configurations",
	parameters: [],
	responses: %{
	200 =>
	Operation.response("List", "application/json", %Schema{
	type: :object,
	additionalProperties: %Schema{type: :object}
	})
	}
	}
	end

	def change_password_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Change account password",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.change_password",
	requestBody: request_body("Parameters", change_password_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp change_password_request do
	%Schema{
	title: "ChangePasswordRequest",
	description: "POST body for changing the account's passowrd",
	type: :object,
	required: [:password, :new_password, :new_password_confirmation],
	properties: %{
	password: %Schema{type: :string, description: "Current password"},
	new_password: %Schema{type: :string, description: "New password"},
	new_password_confirmation: %Schema{
	type: :string,
	description: "New password, confirmation"
	}
	}
	}
	end

	def change_email_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Change account email",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.change_email",
	- parameters: [
	- Operation.parameter(:password, :query, :string, "Current password", required: true),
	- Operation.parameter(:email, :query, :string, "New email", required: true)
	- ],
	- requestBody: nil,
	+ requestBody: request_body("Parameters", change_email_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	+ defp change_email_request do
	+ %Schema{
	+ title: "ChangeEmailRequest",
	+ description: "POST body for changing the account's email",
	+ type: :object,
	+ required: [:email, :password],
	+ properties: %{
	+ email: %Schema{type: :string, description: "New email"},
	+ password: %Schema{type: :string, description: "Current password"}
	+ }
	+ }
	+ end
	+
	def update_notificaton_settings_operation do
	%Operation{
	tags: ["Accounts"],
	summary: "Update Notification Settings",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.update_notificaton_settings",
	parameters: [
	Operation.parameter(
	:block_from_strangers,
	:query,
	BooleanLike,
	"blocks notifications from accounts you do not follow"
	),
	Operation.parameter(
	:hide_notification_contents,
	:query,
	BooleanLike,
	"removes the contents of a message from the push notification"
	)
	],
	requestBody: nil,
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def disable_account_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Disable Account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.disable_account",
	parameters: [
	Operation.parameter(:password, :query, :string, "Password")
	],
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def delete_account_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Delete Account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.delete_account",
	parameters: [
	Operation.parameter(:password, :query, :string, "Password")
	],
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def captcha_operation do
	%Operation{
	summary: "Get a captcha",
	operationId: "UtilController.captcha",
	parameters: [],
	responses: %{
	200 => Operation.response("Success", "application/json", %Schema{type: :object})
	}
	}
	end

	def healthcheck_operation do
	%Operation{
	tags: ["Accounts"],
	summary: "Quick status check on the instance",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.healthcheck",
	parameters: [],
	responses: %{
	200 => Operation.response("Healthy", "application/json", %Schema{type: :object}),
	503 =>
	Operation.response("Disabled or Unhealthy", "application/json", %Schema{type: :object})
	}
	}
	end

	def remote_subscribe_operation do
	%Operation{
	tags: ["Accounts"],
	summary: "Remote Subscribe",
	operationId: "UtilController.remote_subscribe",
	parameters: [],
	responses: %{200 => Operation.response("Web Page", "test/html", %Schema{type: :string})}
	}
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index 58a733258..ef43f7682 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,172 +1,172 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.UtilController do
	use Pleroma.Web, :controller

	require Logger

	alias Pleroma.Config
	alias Pleroma.Emoji
	alias Pleroma.Healthcheck
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.WebFinger

	plug(Pleroma.Web.ApiSpec.CastAndValidate when action != :remote_subscribe)
	plug(Pleroma.Web.Plugs.FederatingPlug when action == :remote_subscribe)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:accounts"]}
	when action in [
	:change_email,
	:change_password,
	:delete_account,
	:update_notificaton_settings,
	:disable_account
	]
	)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.TwitterUtilOperation

	def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
	with %User{} = user <- User.get_cached_by_nickname(nick),
	avatar = User.avatar_url(user) do
	conn
	\|> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error: "Could not find user"
	})
	end
	end

	def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error: "Something went wrong."
	})
	end
	end

	def frontend_configurations(conn, _params) do
	render(conn, "frontend_configurations.json")
	end

	def emoji(conn, _params) do
	emoji =
	Enum.reduce(Emoji.get_all(), %{}, fn {code, %Emoji{file: file, tags: tags}}, acc ->
	Map.put(acc, code, %{image_url: file, tags: tags})
	end)

	json(conn, emoji)
	end

	def update_notificaton_settings(%{assigns: %{user: user}} = conn, params) do
	with {:ok, _} <- User.update_notification_settings(user, params) do
	json(conn, %{status: "success"})
	end
	end

	def change_password(%{assigns: %{user: user}, body_params: body_params} = conn, %{}) do
	case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	with {:ok, _user} <-
	User.reset_password(user, %{
	password: body_params.new_password,
	password_confirmation: body_params.new_password_confirmation
	}) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "New password #{error}."})

	_ ->
	json(conn, %{error: "Unable to change password."})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	- def change_email(%{assigns: %{user: user}} = conn, %{password: password, email: email}) do
	- case CommonAPI.Utils.confirm_current_password(user, password) do
	+ def change_email(%{assigns: %{user: user}, body_params: body_params} = conn, %{}) do
	+ case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	- with {:ok, _user} <- User.change_email(user, email) do
	+ with {:ok, _user} <- User.change_email(user, body_params.email) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "Email #{error}."})

	_ ->
	json(conn, %{error: "Unable to change email."})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def delete_account(%{assigns: %{user: user}} = conn, params) do
	password = params[:password] \|\| ""

	case CommonAPI.Utils.confirm_current_password(user, password) do
	{:ok, user} ->
	User.delete(user)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def disable_account(%{assigns: %{user: user}} = conn, params) do
	case CommonAPI.Utils.confirm_current_password(user, params[:password]) do
	{:ok, user} ->
	User.set_activation_async(user, false)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def captcha(conn, _params) do
	json(conn, Pleroma.Captcha.new())
	end

	def healthcheck(conn, _params) do
	with true <- Config.get([:instance, :healthcheck]),
	%{healthy: true} = info <- Healthcheck.system_info() do
	json(conn, info)
	else
	%{healthy: false} = info ->
	service_unavailable(conn, info)

	_ ->
	service_unavailable(conn, %{})
	end
	end

	defp service_unavailable(conn, info) do
	conn
	\|> put_status(:service_unavailable)
	\|> json(info)
	end
	end
	diff --git a/test/pleroma/web/twitter_api/util_controller_test.exs b/test/pleroma/web/twitter_api/util_controller_test.exs
	index fe3d99272..f030483d8 100644
	--- a/test/pleroma/web/twitter_api/util_controller_test.exs
	+++ b/test/pleroma/web/twitter_api/util_controller_test.exs
	@@ -1,476 +1,467 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User

	import Pleroma.Factory
	import Mock

	setup do
	Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance])
	setup do: clear_config([:frontend_configurations, :pleroma_fe])

	describe "PUT /api/pleroma/notification_settings" do
	setup do: oauth_access(["write:accounts"])

	test "it updates notification settings", %{user: user, conn: conn} do
	conn
	\|> put(
	"/api/pleroma/notification_settings?#{
	URI.encode_query(%{
	block_from_strangers: true
	})
	}"
	)
	\|> json_response_and_validate_schema(:ok)

	user = refresh_record(user)

	assert %Pleroma.User.NotificationSetting{
	block_from_strangers: true,
	hide_notification_contents: false
	} == user.notification_settings
	end

	test "it updates notification settings to enable hiding contents", %{user: user, conn: conn} do
	conn
	\|> put(
	"/api/pleroma/notification_settings?#{
	URI.encode_query(%{
	hide_notification_contents: 1
	})
	}"
	)
	\|> json_response_and_validate_schema(:ok)

	user = refresh_record(user)

	assert %Pleroma.User.NotificationSetting{
	block_from_strangers: false,
	hide_notification_contents: true
	} == user.notification_settings
	end
	end

	describe "GET /api/pleroma/frontend_configurations" do
	test "returns everything in :pleroma, :frontend_configurations", %{conn: conn} do
	config = [
	frontend_a: %{
	x: 1,
	y: 2
	},
	frontend_b: %{
	z: 3
	}
	]

	clear_config(:frontend_configurations, config)

	response =
	conn
	\|> get("/api/pleroma/frontend_configurations")
	\|> json_response_and_validate_schema(:ok)

	assert response == Jason.encode!(config \|> Enum.into(%{})) \|> Jason.decode!()
	end
	end

	describe "/api/pleroma/emoji" do
	test "returns json with custom emoji with tags", %{conn: conn} do
	emoji =
	conn
	\|> get("/api/pleroma/emoji")
	\|> json_response_and_validate_schema(200)

	assert Enum.all?(emoji, fn
	{_key,
	%{
	"image_url" => url,
	"tags" => tags
	}} ->
	is_binary(url) and is_list(tags)
	end)
	end
	end

	describe "GET /api/pleroma/healthcheck" do
	setup do: clear_config([:instance, :healthcheck])

	test "returns 503 when healthcheck disabled", %{conn: conn} do
	clear_config([:instance, :healthcheck], false)

	response =
	conn
	\|> get("/api/pleroma/healthcheck")
	\|> json_response_and_validate_schema(503)

	assert response == %{}
	end

	test "returns 200 when healthcheck enabled and all ok", %{conn: conn} do
	clear_config([:instance, :healthcheck], true)

	with_mock Pleroma.Healthcheck,
	system_info: fn -> %Pleroma.Healthcheck{healthy: true} end do
	response =
	conn
	\|> get("/api/pleroma/healthcheck")
	\|> json_response_and_validate_schema(200)

	assert %{
	"active" => _,
	"healthy" => true,
	"idle" => _,
	"memory_used" => _,
	"pool_size" => _
	} = response
	end
	end

	test "returns 503 when healthcheck enabled and health is false", %{conn: conn} do
	clear_config([:instance, :healthcheck], true)

	with_mock Pleroma.Healthcheck,
	system_info: fn -> %Pleroma.Healthcheck{healthy: false} end do
	response =
	conn
	\|> get("/api/pleroma/healthcheck")
	\|> json_response_and_validate_schema(503)

	assert %{
	"active" => _,
	"healthy" => false,
	"idle" => _,
	"memory_used" => _,
	"pool_size" => _
	} = response
	end
	end
	end

	describe "POST /api/pleroma/disable_account" do
	setup do: oauth_access(["write:accounts"])

	test "with valid permissions and password, it disables the account", %{conn: conn, user: user} do
	response =
	conn
	\|> post("/api/pleroma/disable_account?password=test")
	\|> json_response_and_validate_schema(:ok)

	assert response == %{"status" => "success"}
	ObanHelpers.perform_all()

	user = User.get_cached_by_id(user.id)

	refute user.is_active
	end

	test "with valid permissions and invalid password, it returns an error", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post("/api/pleroma/disable_account?password=test1")
	\|> json_response_and_validate_schema(:ok)

	assert response == %{"error" => "Invalid password."}
	user = User.get_cached_by_id(user.id)

	assert user.is_active
	end
	end

	describe "POST /main/ostatus - remote_subscribe/2" do
	setup do: clear_config([:instance, :federating], true)

	test "renders subscribe form", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post("/main/ostatus", %{"nickname" => user.nickname, "profile" => ""})
	\|> response(:ok)

	refute response =~ "Could not find user"
	assert response =~ "Remotely follow #{user.nickname}"
	end

	test "renders subscribe form with error when user not found", %{conn: conn} do
	response =
	conn
	\|> post("/main/ostatus", %{"nickname" => "nickname", "profile" => ""})
	\|> response(:ok)

	assert response =~ "Could not find user"
	refute response =~ "Remotely follow"
	end

	test "it redirect to webfinger url", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	conn =
	conn
	\|> post("/main/ostatus", %{
	"user" => %{"nickname" => user.nickname, "profile" => user2.ap_id}
	})

	assert redirected_to(conn) ==
	"https://social.heldscal.la/main/ostatussub?profile=#{user.ap_id}"
	end

	test "it renders form with error when user not found", %{conn: conn} do
	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	response =
	conn
	\|> post("/main/ostatus", %{"user" => %{"nickname" => "jimm", "profile" => user2.ap_id}})
	\|> response(:ok)

	assert response =~ "Something went wrong."
	end
	end

	test "it returns new captcha", %{conn: conn} do
	with_mock Pleroma.Captcha,
	new: fn -> "test_captcha" end do
	resp =
	conn
	\|> get("/api/pleroma/captcha")
	\|> response(200)

	assert resp == "\"test_captcha\""
	assert called(Pleroma.Captcha.new())
	end
	end

	describe "POST /api/pleroma/change_email" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	- \|> post(
	- "/api/pleroma/change_email?#{
	- URI.encode_query(%{password: "hi", email: "test@test.com"})
	- }"
	- )
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/change_email", %{password: "hi", email: "test@test.com"})

	assert json_response_and_validate_schema(conn, 403) == %{
	"error" => "Insufficient permissions: write:accounts."
	}
	end

	test "with proper permissions and invalid password", %{conn: conn} do
	conn =
	- post(
	- conn,
	- "/api/pleroma/change_email?#{
	- URI.encode_query(%{password: "hi", email: "test@test.com"})
	- }"
	- )
	+ conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/change_email", %{password: "hi", email: "test@test.com"})

	assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with proper permissions, valid password and invalid email", %{
	conn: conn
	} do
	conn =
	- post(
	- conn,
	- "/api/pleroma/change_email?#{URI.encode_query(%{password: "test", email: "foobar"})}"
	- )
	+ conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/change_email", %{password: "test", email: "foobar"})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "Email has invalid format."
	}
	end

	test "with proper permissions, valid password and no email", %{
	conn: conn
	} do
	- conn = post(conn, "/api/pleroma/change_email?#{URI.encode_query(%{password: "test"})}")
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/change_email", %{password: "test"})

	assert %{"error" => "Missing field: email."} = json_response_and_validate_schema(conn, 400)
	end

	test "with proper permissions, valid password and blank email", %{
	conn: conn
	} do
	conn =
	- post(
	- conn,
	- "/api/pleroma/change_email?#{URI.encode_query(%{password: "test", email: ""})}"
	- )
	+ conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/change_email", %{password: "test", email: ""})

	assert json_response_and_validate_schema(conn, 200) == %{"error" => "Email can't be blank."}
	end

	test "with proper permissions, valid password and non unique email", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	- post(
	- conn,
	- "/api/pleroma/change_email?#{URI.encode_query(%{password: "test", email: user.email})}"
	- )
	+ conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/change_email", %{password: "test", email: user.email})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "Email has already been taken."
	}
	end

	test "with proper permissions, valid password and valid email", %{
	conn: conn
	} do
	conn =
	- post(
	- conn,
	- "/api/pleroma/change_email?#{
	- URI.encode_query(%{password: "test", email: "cofe@foobar.com"})
	- }"
	- )
	+ conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/change_email", %{password: "test", email: "cofe@foobar.com"})

	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
	end
	end

	describe "POST /api/pleroma/change_password" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response_and_validate_schema(conn, 403) == %{
	"error" => "Insufficient permissions: write:accounts."
	}
	end

	test "with proper permissions and invalid password", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response_and_validate_schema(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with proper permissions, valid password and new password and confirmation not matching",
	%{
	conn: conn
	} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "notnewpass"
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "New password does not match confirmation."
	}
	end

	test "with proper permissions, valid password and invalid new password", %{
	conn: conn
	} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/change_password", %{
	password: "test",
	new_password: "",
	new_password_confirmation: ""
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"error" => "New password can't be blank."
	}
	end

	test "with proper permissions, valid password and matching new password and confirmation", %{
	conn: conn,
	user: user
	} do
	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/change_password",
	%{
	password: "test",
	new_password: "newpass",
	new_password_confirmation: "newpass"
	}
	)

	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}
	fetched_user = User.get_cached_by_id(user.id)
	assert Pleroma.Password.Pbkdf2.verify_pass("newpass", fetched_user.password_hash) == true
	end
	end

	describe "POST /api/pleroma/delete_account" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> post("/api/pleroma/delete_account")

	assert json_response_and_validate_schema(conn, 403) ==
	%{"error" => "Insufficient permissions: write:accounts."}
	end

	test "with proper permissions and wrong or missing password", %{conn: conn} do
	for params <- [%{"password" => "hi"}, %{}] do
	ret_conn = post(conn, "/api/pleroma/delete_account", params)

	assert json_response_and_validate_schema(ret_conn, 200) == %{
	"error" => "Invalid password."
	}
	end
	end

	test "with proper permissions and valid password", %{conn: conn, user: user} do
	conn = post(conn, "/api/pleroma/delete_account?password=test")
	ObanHelpers.perform_all()
	assert json_response_and_validate_schema(conn, 200) == %{"status" => "success"}

	user = User.get_by_id(user.id)
	refute user.is_active
	assert user.name == nil
	assert user.bio == ""
	assert user.password_hash == nil
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 12:19 PM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723175
Default Alt Text: (29 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions