No OneTemporary
Actions

Authored By

Unknown

Size

187 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/config/config_db.ex b/lib/pleroma/config/config_db.ex
	index 102e26773..91a1aa0cc 100644
	--- a/lib/pleroma/config/config_db.ex
	+++ b/lib/pleroma/config/config_db.ex
	@@ -1,424 +1,422 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConfigDB do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query
	import Pleroma.Web.Gettext

	alias __MODULE__
	alias Pleroma.Repo

	@type t :: %__MODULE__{}

	@full_key_update [
	{:pleroma, :ecto_repos},
	{:quack, :meta},
	{:mime, :types},
	{:cors_plug, [:max_age, :methods, :expose, :headers]},
	{:auto_linker, :opts},
	{:swarm, :node_blacklist},
	{:logger, :backends}
	]

	@full_subkey_update [
	{:pleroma, :assets, :mascots},
	{:pleroma, :emoji, :groups},
	{:pleroma, :workers, :retries},
	{:pleroma, :mrf_subchain, :match_actor},
	{:pleroma, :mrf_keyword, :replace}
	]

	@regex ~r/^~r(?'delimiter'[\/\|"'([{<]{1})(?'pattern'.+)[\/\|"')\]}>]{1}(?'modifier'[uismxfU]*)/u

	@delimiters ["/", "\|", "\"", "'", {"(", ")"}, {"[", "]"}, {"{", "}"}, {"<", ">"}]

	schema "config" do
	field(:key, :string)
	field(:group, :string)
	field(:value, :binary)
	field(:db, {:array, :string}, virtual: true, default: [])

	timestamps()
	end

	@spec get_all_as_keyword() :: keyword()
	def get_all_as_keyword do
	ConfigDB
	\|> select([c], {c.group, c.key, c.value})
	\|> Repo.all()
	\|> Enum.reduce([], fn {group, key, value}, acc ->
	group = ConfigDB.from_string(group)
	key = ConfigDB.from_string(key)
	value = from_binary(value)

	Keyword.update(acc, group, [{key, value}], &Keyword.merge(&1, [{key, value}]))
	end)
	end

	@spec get_by_params(map()) :: ConfigDB.t() \| nil
	def get_by_params(params), do: Repo.get_by(ConfigDB, params)

	@spec changeset(ConfigDB.t(), map()) :: Changeset.t()
	def changeset(config, params \\ %{}) do
	params = Map.put(params, :value, transform(params[:value]))

	config
	\|> cast(params, [:key, :group, :value])
	\|> validate_required([:key, :group, :value])
	\|> unique_constraint(:key, name: :config_group_key_index)
	end

	@spec create(map()) :: {:ok, ConfigDB.t()} \| {:error, Changeset.t()}
	def create(params) do
	%ConfigDB{}
	\|> changeset(params)
	\|> Repo.insert()
	end

	@spec update(ConfigDB.t(), map()) :: {:ok, ConfigDB.t()} \| {:error, Changeset.t()}
	def update(%ConfigDB{} = config, %{value: value}) do
	config
	\|> changeset(%{value: value})
	\|> Repo.update()
	end

	@spec get_db_keys(ConfigDB.t()) :: [String.t()]
	def get_db_keys(%ConfigDB{} = config) do
	config.value
	\|> ConfigDB.from_binary()
	\|> get_db_keys(config.key)
	end

	@spec get_db_keys(keyword(), any()) :: [String.t()]
	def get_db_keys(value, key) do
	if Keyword.keyword?(value) do
	value \|> Keyword.keys() \|> Enum.map(&convert(&1))
	else
	[convert(key)]
	end
	end

	@spec merge_group(atom(), atom(), keyword(), keyword()) :: keyword()
	def merge_group(group, key, old_value, new_value) do
	new_keys = to_map_set(new_value)

	intersect_keys =
	old_value \|> to_map_set() \|> MapSet.intersection(new_keys) \|> MapSet.to_list()

	merged_value = ConfigDB.merge(old_value, new_value)

	@full_subkey_update
	\|> Enum.map(fn
	{g, k, subkey} when g == group and k == key ->
	if subkey in intersect_keys, do: subkey, else: []

	_ ->
	[]
	end)
	\|> List.flatten()
	\|> Enum.reduce(merged_value, fn subkey, acc ->
	Keyword.put(acc, subkey, new_value[subkey])
	end)
	end

	defp to_map_set(keyword) do
	keyword
	\|> Keyword.keys()
	\|> MapSet.new()
	end

	@spec sub_key_full_update?(atom(), atom(), [Keyword.key()]) :: boolean()
	def sub_key_full_update?(group, key, subkeys) do
	Enum.any?(@full_subkey_update, fn {g, k, subkey} ->
	g == group and k == key and subkey in subkeys
	end)
	end

	@spec merge(keyword(), keyword()) :: keyword()
	def merge(config1, config2) when is_list(config1) and is_list(config2) do
	Keyword.merge(config1, config2, fn _, app1, app2 ->
	if Keyword.keyword?(app1) and Keyword.keyword?(app2) do
	Keyword.merge(app1, app2, &deep_merge/3)
	else
	app2
	end
	end)
	end

	defp deep_merge(_key, value1, value2) do
	if Keyword.keyword?(value1) and Keyword.keyword?(value2) do
	Keyword.merge(value1, value2, &deep_merge/3)
	else
	value2
	end
	end

	@spec update_or_create(map()) :: {:ok, ConfigDB.t()} \| {:error, Changeset.t()}
	def update_or_create(params) do
	search_opts = Map.take(params, [:group, :key])

	with %ConfigDB{} = config <- ConfigDB.get_by_params(search_opts),
	{:partial_update, true, config} <-
	{:partial_update, can_be_partially_updated?(config), config},
	old_value <- from_binary(config.value),
	transformed_value <- do_transform(params[:value]),
	{:can_be_merged, true, config} <- {:can_be_merged, is_list(transformed_value), config},
	new_value <-
	merge_group(
	ConfigDB.from_string(config.group),
	ConfigDB.from_string(config.key),
	old_value,
	transformed_value
	) do
	ConfigDB.update(config, %{value: new_value})
	else
	{reason, false, config} when reason in [:partial_update, :can_be_merged] ->
	ConfigDB.update(config, params)

	nil ->
	ConfigDB.create(params)
	end
	end

	defp can_be_partially_updated?(%ConfigDB{} = config), do: not only_full_update?(config)

	defp only_full_update?(%ConfigDB{} = config) do
	config_group = ConfigDB.from_string(config.group)
	config_key = ConfigDB.from_string(config.key)

	Enum.any?(@full_key_update, fn
	{group, key} when is_list(key) ->
	config_group == group and config_key in key

	{group, key} ->
	config_group == group and config_key == key
	end)
	end

	- @spec delete(map()) :: {:ok, ConfigDB.t()} \| {:error, Changeset.t()} \| {:ok, nil}
	+ @spec delete(map()) :: {:ok, ConfigDB.t()} \| {:error, Changeset.t()}
	def delete(params) do
	search_opts = Map.delete(params, :subkeys)

	with %ConfigDB{} = config <- ConfigDB.get_by_params(search_opts),
	{config, sub_keys} when is_list(sub_keys) <- {config, params[:subkeys]},
	old_value <- from_binary(config.value),
	keys <- Enum.map(sub_keys, &do_transform_string(&1)),
	{:partial_remove, config, new_value} when new_value != [] <-
	{:partial_remove, config, Keyword.drop(old_value, keys)} do
	ConfigDB.update(config, %{value: new_value})
	else
	{:partial_remove, config, []} ->
	Repo.delete(config)
	- {:ok, nil}

	{config, nil} ->
	Repo.delete(config)
	- {:ok, nil}

	nil ->
	err =
	dgettext("errors", "Config with params %{params} not found", params: inspect(params))

	{:error, err}
	end
	end

	@spec from_binary(binary()) :: term()
	def from_binary(binary), do: :erlang.binary_to_term(binary)

	@spec from_binary_with_convert(binary()) :: any()
	def from_binary_with_convert(binary) do
	binary
	\|> from_binary()
	\|> do_convert()
	end

	@spec from_string(String.t()) :: atom() \| no_return()
	def from_string(":" <> entity), do: String.to_existing_atom(entity)

	def from_string(entity) when is_binary(entity) do
	if is_module_name?(entity) do
	String.to_existing_atom("Elixir.#{entity}")
	else
	entity
	end
	end

	@spec convert(any()) :: any()
	def convert(entity), do: do_convert(entity)

	defp do_convert(entity) when is_list(entity) do
	for v <- entity, into: [], do: do_convert(v)
	end

	defp do_convert(%Regex{} = entity), do: inspect(entity)

	defp do_convert(entity) when is_map(entity) do
	for {k, v} <- entity, into: %{}, do: {do_convert(k), do_convert(v)}
	end

	defp do_convert({:proxy_url, {type, :localhost, port}}) do
	%{"tuple" => [":proxy_url", %{"tuple" => [do_convert(type), "localhost", port]}]}
	end

	defp do_convert({:proxy_url, {type, host, port}}) when is_tuple(host) do
	ip =
	host
	\|> :inet_parse.ntoa()
	\|> to_string()

	%{
	"tuple" => [
	":proxy_url",
	%{"tuple" => [do_convert(type), ip, port]}
	]
	}
	end

	defp do_convert({:proxy_url, {type, host, port}}) do
	%{
	"tuple" => [
	":proxy_url",
	%{"tuple" => [do_convert(type), to_string(host), port]}
	]
	}
	end

	defp do_convert({:partial_chain, entity}), do: %{"tuple" => [":partial_chain", inspect(entity)]}

	defp do_convert(entity) when is_tuple(entity) do
	value =
	entity
	\|> Tuple.to_list()
	\|> do_convert()

	%{"tuple" => value}
	end

	defp do_convert(entity) when is_boolean(entity) or is_number(entity) or is_nil(entity) do
	entity
	end

	defp do_convert(entity)
	when is_atom(entity) and entity in [:"tlsv1.1", :"tlsv1.2", :"tlsv1.3"] do
	":#{entity}"
	end

	defp do_convert(entity) when is_atom(entity), do: inspect(entity)

	defp do_convert(entity) when is_binary(entity), do: entity

	@spec transform(any()) :: binary() \| no_return()
	def transform(entity) when is_binary(entity) or is_map(entity) or is_list(entity) do
	entity
	\|> do_transform()
	\|> to_binary()
	end

	def transform(entity), do: to_binary(entity)

	@spec transform_with_out_binary(any()) :: any()
	def transform_with_out_binary(entity), do: do_transform(entity)

	@spec to_binary(any()) :: binary()
	def to_binary(entity), do: :erlang.term_to_binary(entity)

	defp do_transform(%Regex{} = entity), do: entity

	defp do_transform(%{"tuple" => [":proxy_url", %{"tuple" => [type, host, port]}]}) do
	{:proxy_url, {do_transform_string(type), parse_host(host), port}}
	end

	defp do_transform(%{"tuple" => [":partial_chain", entity]}) do
	{partial_chain, []} =
	entity
	\|> String.replace(~r/[^\w\|^{:,[\|^,\|^[\|^\]^}\|^\/\|^\.\|^"]^\s/, "")
	\|> Code.eval_string()

	{:partial_chain, partial_chain}
	end

	defp do_transform(%{"tuple" => entity}) do
	Enum.reduce(entity, {}, fn val, acc -> Tuple.append(acc, do_transform(val)) end)
	end

	defp do_transform(entity) when is_map(entity) do
	for {k, v} <- entity, into: %{}, do: {do_transform(k), do_transform(v)}
	end

	defp do_transform(entity) when is_list(entity) do
	for v <- entity, into: [], do: do_transform(v)
	end

	defp do_transform(entity) when is_binary(entity) do
	entity
	\|> String.trim()
	\|> do_transform_string()
	end

	defp do_transform(entity), do: entity

	defp parse_host("localhost"), do: :localhost

	defp parse_host(host) do
	charlist = to_charlist(host)

	case :inet.parse_address(charlist) do
	{:error, :einval} ->
	charlist

	{:ok, ip} ->
	ip
	end
	end

	defp find_valid_delimiter([], _string, _) do
	raise(ArgumentError, message: "valid delimiter for Regex expression not found")
	end

	defp find_valid_delimiter([{leading, closing} = delimiter \| others], pattern, regex_delimiter)
	when is_tuple(delimiter) do
	if String.contains?(pattern, closing) do
	find_valid_delimiter(others, pattern, regex_delimiter)
	else
	{:ok, {leading, closing}}
	end
	end

	defp find_valid_delimiter([delimiter \| others], pattern, regex_delimiter) do
	if String.contains?(pattern, delimiter) do
	find_valid_delimiter(others, pattern, regex_delimiter)
	else
	{:ok, {delimiter, delimiter}}
	end
	end

	defp do_transform_string("~r" <> _pattern = regex) do
	with %{"modifier" => modifier, "pattern" => pattern, "delimiter" => regex_delimiter} <-
	Regex.named_captures(@regex, regex),
	{:ok, {leading, closing}} <- find_valid_delimiter(@delimiters, pattern, regex_delimiter),
	{result, _} <- Code.eval_string("~r#{leading}#{pattern}#{closing}#{modifier}") do
	result
	end
	end

	defp do_transform_string(":" <> atom), do: String.to_atom(atom)

	defp do_transform_string(value) do
	if is_module_name?(value) do
	String.to_existing_atom("Elixir." <> value)
	else
	value
	end
	end

	@spec is_module_name?(String.t()) :: boolean()
	def is_module_name?(string) do
	Regex.match?(~r/^(Pleroma\|Phoenix\|Tesla\|Quack\|Ueberauth)\./, string) or
	string in ["Oban", "Ueberauth", "ExSyslogger"]
	end
	end
	diff --git a/lib/pleroma/config/transfer_task.ex b/lib/pleroma/config/transfer_task.ex
	index 00c8790f8..d54f38ee4 100644
	--- a/lib/pleroma/config/transfer_task.ex
	+++ b/lib/pleroma/config/transfer_task.ex
	@@ -1,96 +1,114 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.TransferTask do
	use Task

	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	require Logger

	def start_link(_) do
	load_and_update_env()
	if Pleroma.Config.get(:env) == :test, do: Ecto.Adapters.SQL.Sandbox.checkin(Repo)
	:ignore
	end

	- def load_and_update_env do
	+ @spec load_and_update_env([ConfigDB.t()]) :: :ok \| false
	+ def load_and_update_env(deleted \\ []) do
	with true <- Pleroma.Config.get(:configurable_from_database),
	true <- Ecto.Adapters.SQL.table_exists?(Repo, "config"),
	started_applications <- Application.started_applications() do
	# We need to restart applications for loaded settings take effect
	- ConfigDB
	- \|> Repo.all()
	- \|> Enum.map(&update_env(&1))
	+ in_db = Repo.all(ConfigDB)
	+
	+ with_deleted = in_db ++ deleted
	+
	+ with_deleted
	+ \|> Enum.map(&merge_and_update(&1))
	\|> Enum.uniq()
	# TODO: some problem with prometheus after restart!
	\|> Enum.reject(&(&1 in [:pleroma, nil, :prometheus]))
	\|> Enum.each(&restart(started_applications, &1))
	+
	+ :ok
	end
	end

	- defp update_env(setting) do
	+ defp merge_and_update(setting) do
	try do
	key = ConfigDB.from_string(setting.key)
	group = ConfigDB.from_string(setting.group)
	- value = ConfigDB.from_binary(setting.value)

	default = Pleroma.Config.Holder.config(group, key)
	+ merged_value = merge_value(setting, default, group, key)

	- merged_value =
	- if can_be_merged?(default, value) do
	- ConfigDB.merge_group(group, key, default, value)
	- else
	- value
	- end
	-
	- :ok = Application.put_env(group, key, merged_value)
	+ :ok = update_env(group, key, merged_value)

	if group != :logger do
	group
	else
	# change logger configuration in runtime, without restart
	if Keyword.keyword?(merged_value) and
	key not in [:compile_time_application, :backends, :compile_time_purge_matching] do
	Logger.configure_backend(key, merged_value)
	else
	Logger.configure([{key, merged_value}])
	end

	nil
	end
	rescue
	- e ->
	- Logger.warn(
	- "updating env causes error, group: #{inspect(setting.group)}, key: #{
	- inspect(setting.key)
	- }, value: #{inspect(ConfigDB.from_binary(setting.value))}, error: #{inspect(e)}"
	- )
	+ error ->
	+ error_msg =
	+ "updating env causes error, group: " <>
	+ inspect(setting.group) <>
	+ " key: " <>
	+ inspect(setting.key) <>
	+ " value: " <>
	+ inspect(ConfigDB.from_binary(setting.value)) <> " error: " <> inspect(error)
	+
	+ Logger.warn(error_msg)

	nil
	end
	end

	+ defp merge_value(%{__meta__: %{state: :deleted}}, default, _group, _key), do: default
	+
	+ defp merge_value(setting, default, group, key) do
	+ value = ConfigDB.from_binary(setting.value)
	+
	+ if can_be_merged?(default, value) do
	+ ConfigDB.merge_group(group, key, default, value)
	+ else
	+ value
	+ end
	+ end
	+
	+ defp update_env(group, key, nil), do: Application.delete_env(group, key)
	+ defp update_env(group, key, value), do: Application.put_env(group, key, value)
	+
	defp restart(started_applications, app) do
	with {^app, _, _} <- List.keyfind(started_applications, app, 0),
	:ok <- Application.stop(app) do
	:ok = Application.start(app)
	else
	nil ->
	Logger.warn("#{app} is not started.")

	error ->
	error
	\|> inspect()
	\|> Logger.warn()
	end
	end

	defp can_be_merged?(val1, val2) when is_list(val1) and is_list(val2) do
	Keyword.keyword?(val1) and Keyword.keyword?(val2)
	end

	defp can_be_merged?(_val1, _val2), do: false
	end
	diff --git a/lib/pleroma/web/admin_api/admin_api_controller.ex b/lib/pleroma/web/admin_api/admin_api_controller.ex
	index 1b09d137b..2314d3274 100644
	--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
	+++ b/lib/pleroma/web/admin_api/admin_api_controller.ex
	@@ -1,997 +1,997 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper, only: [json_response: 3]

	alias Pleroma.Activity
	alias Pleroma.ConfigDB
	alias Pleroma.ModerationLog
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.ReportNote
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.AdminAPI.ConfigView
	alias Pleroma.Web.AdminAPI.ModerationLogView
	alias Pleroma.Web.AdminAPI.Report
	alias Pleroma.Web.AdminAPI.ReportView
	alias Pleroma.Web.AdminAPI.Search
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.Router

	require Logger

	@descriptions_json Pleroma.Docs.JSON.compile()
	@users_page_size 50

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:accounts"], admin: true}
	when action in [:list_users, :user_show, :right_get]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:accounts"], admin: true}
	when action in [
	:get_password_reset,
	:user_delete,
	:users_create,
	:user_toggle_activation,
	:user_activate,
	:user_deactivate,
	:tag_users,
	:untag_users,
	:right_add,
	:right_delete
	]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:invites"], admin: true} when action == :invites)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:invites"], admin: true}
	when action in [:create_invite_token, :revoke_invite, :email_invite]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:follows"], admin: true}
	when action in [:user_follow, :user_unfollow, :relay_follow, :relay_unfollow]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:reports"], admin: true}
	when action in [:list_reports, :report_show]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:reports"], admin: true}
	when action in [:reports_update]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:statuses"], admin: true}
	when action == :list_user_statuses
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:statuses"], admin: true}
	when action in [:status_update, :status_delete]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read"], admin: true}
	when action in [:config_show, :migrate_from_db, :list_log]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write"], admin: true}
	when action == :config_update
	)

	action_fallback(:errors)

	def user_delete(%{assigns: %{user: admin}} = conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)
	User.delete(user)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: [user],
	action: "delete"
	})

	conn
	\|> json(nickname)
	end

	def user_delete(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)
	User.delete(users)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "delete"
	})

	conn
	\|> json(nicknames)
	end

	def user_follow(%{assigns: %{user: admin}} = conn, %{
	"follower" => follower_nick,
	"followed" => followed_nick
	}) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.follow(follower, followed)

	ModerationLog.insert_log(%{
	actor: admin,
	followed: followed,
	follower: follower,
	action: "follow"
	})
	end

	conn
	\|> json("ok")
	end

	def user_unfollow(%{assigns: %{user: admin}} = conn, %{
	"follower" => follower_nick,
	"followed" => followed_nick
	}) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.unfollow(follower, followed)

	ModerationLog.insert_log(%{
	actor: admin,
	followed: followed,
	follower: follower,
	action: "unfollow"
	})
	end

	conn
	\|> json("ok")
	end

	def users_create(%{assigns: %{user: admin}} = conn, %{"users" => users}) do
	changesets =
	Enum.map(users, fn %{"nickname" => nickname, "email" => email, "password" => password} ->
	user_data = %{
	nickname: nickname,
	name: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	bio: "."
	}

	User.register_changeset(%User{}, user_data, need_confirmation: false)
	end)
	\|> Enum.reduce(Ecto.Multi.new(), fn changeset, multi ->
	Ecto.Multi.insert(multi, Ecto.UUID.generate(), changeset)
	end)

	case Pleroma.Repo.transaction(changesets) do
	{:ok, users} ->
	res =
	users
	\|> Map.values()
	\|> Enum.map(fn user ->
	{:ok, user} = User.post_register_action(user)

	user
	end)
	\|> Enum.map(&AccountView.render("created.json", %{user: &1}))

	ModerationLog.insert_log(%{
	actor: admin,
	subjects: Map.values(users),
	action: "create"
	})

	conn
	\|> json(res)

	{:error, id, changeset, _} ->
	res =
	Enum.map(changesets.operations, fn
	{current_id, {:changeset, _current_changeset, _}} when current_id == id ->
	AccountView.render("create-error.json", %{changeset: changeset})

	{_, {:changeset, current_changeset, _}} ->
	AccountView.render("create-error.json", %{changeset: current_changeset})
	end)

	conn
	\|> put_status(:conflict)
	\|> json(res)
	end
	end

	def user_show(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname) do
	conn
	\|> put_view(AccountView)
	\|> render("show.json", %{user: user})
	else
	_ -> {:error, :not_found}
	end
	end

	def list_instance_statuses(conn, %{"instance" => instance} = params) do
	{page, page_size} = page_params(params)

	activities =
	ActivityPub.fetch_instance_activities(%{
	"instance" => instance,
	"limit" => page_size,
	"offset" => (page - 1) * page_size
	})

	conn
	\|> put_view(Pleroma.Web.AdminAPI.StatusView)
	\|> render("index.json", %{activities: activities, as: :activity})
	end

	def list_user_statuses(conn, %{"nickname" => nickname} = params) do
	godmode = params["godmode"] == "true" \|\| params["godmode"] == true

	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname) do
	{_, page_size} = page_params(params)

	activities =
	ActivityPub.fetch_user_activities(user, nil, %{
	"limit" => page_size,
	"godmode" => godmode
	})

	conn
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, as: :activity})
	else
	_ -> {:error, :not_found}
	end
	end

	def user_toggle_activation(%{assigns: %{user: admin}} = conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)

	{:ok, updated_user} = User.deactivate(user, !user.deactivated)

	action = if user.deactivated, do: "activate", else: "deactivate"

	ModerationLog.insert_log(%{
	actor: admin,
	subject: [user],
	action: action
	})

	conn
	\|> put_view(AccountView)
	\|> render("show.json", %{user: updated_user})
	end

	def user_activate(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.deactivate(users, false)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "activate"
	})

	conn
	\|> put_view(AccountView)
	\|> render("index.json", %{users: Keyword.values(updated_users)})
	end

	def user_deactivate(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.deactivate(users, true)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "deactivate"
	})

	conn
	\|> put_view(AccountView)
	\|> render("index.json", %{users: Keyword.values(updated_users)})
	end

	def tag_users(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.tag(nicknames, tags) do
	ModerationLog.insert_log(%{
	actor: admin,
	nicknames: nicknames,
	tags: tags,
	action: "tag"
	})

	json_response(conn, :no_content, "")
	end
	end

	def untag_users(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.untag(nicknames, tags) do
	ModerationLog.insert_log(%{
	actor: admin,
	nicknames: nicknames,
	tags: tags,
	action: "untag"
	})

	json_response(conn, :no_content, "")
	end
	end

	def list_users(conn, params) do
	{page, page_size} = page_params(params)
	filters = maybe_parse_filters(params["filters"])

	search_params = %{
	query: params["query"],
	page: page,
	page_size: page_size,
	tags: params["tags"],
	name: params["name"],
	email: params["email"]
	}

	with {:ok, users, count} <- Search.user(Map.merge(search_params, filters)),
	{:ok, users, count} <- filter_service_users(users, count),
	do:
	conn
	\|> json(
	AccountView.render("index.json",
	users: users,
	count: count,
	page_size: page_size
	)
	)
	end

	defp filter_service_users(users, count) do
	filtered_users = Enum.reject(users, &service_user?/1)
	count = if Enum.any?(users, &service_user?/1), do: length(filtered_users), else: count

	{:ok, filtered_users, count}
	end

	defp service_user?(user) do
	String.match?(user.ap_id, ~r/.*\/relay$/) or
	String.match?(user.ap_id, ~r/.*\/internal\/fetch$/)
	end

	@filters ~w(local external active deactivated is_admin is_moderator)

	@spec maybe_parse_filters(String.t()) :: %{required(String.t()) => true} \| %{}
	defp maybe_parse_filters(filters) when is_nil(filters) or filters == "", do: %{}

	defp maybe_parse_filters(filters) do
	filters
	\|> String.split(",")
	\|> Enum.filter(&Enum.member?(@filters, &1))
	\|> Enum.map(&String.to_atom(&1))
	\|> Enum.into(%{}, &{&1, true})
	end

	def right_add_multiple(%{assigns: %{user: admin}} = conn, %{
	"permission_group" => permission_group,
	"nicknames" => nicknames
	})
	when permission_group in ["moderator", "admin"] do
	update = %{:"is_#{permission_group}" => true}

	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	for u <- users, do: User.admin_api_update(u, update)

	ModerationLog.insert_log(%{
	action: "grant",
	actor: admin,
	subject: users,
	permission: permission_group
	})

	json(conn, update)
	end

	def right_add_multiple(conn, _) do
	render_error(conn, :not_found, "No such permission_group")
	end

	def right_add(%{assigns: %{user: admin}} = conn, %{
	"permission_group" => permission_group,
	"nickname" => nickname
	})
	when permission_group in ["moderator", "admin"] do
	fields = %{:"is_#{permission_group}" => true}

	{:ok, user} =
	nickname
	\|> User.get_cached_by_nickname()
	\|> User.admin_api_update(fields)

	ModerationLog.insert_log(%{
	action: "grant",
	actor: admin,
	subject: [user],
	permission: permission_group
	})

	json(conn, fields)
	end

	def right_add(conn, _) do
	render_error(conn, :not_found, "No such permission_group")
	end

	def right_get(conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)

	conn
	\|> json(%{
	is_moderator: user.is_moderator,
	is_admin: user.is_admin
	})
	end

	def right_delete_multiple(
	%{assigns: %{user: %{nickname: admin_nickname} = admin}} = conn,
	%{
	"permission_group" => permission_group,
	"nicknames" => nicknames
	}
	)
	when permission_group in ["moderator", "admin"] do
	with false <- Enum.member?(nicknames, admin_nickname) do
	update = %{:"is_#{permission_group}" => false}

	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	for u <- users, do: User.admin_api_update(u, update)

	ModerationLog.insert_log(%{
	action: "revoke",
	actor: admin,
	subject: users,
	permission: permission_group
	})

	json(conn, update)
	else
	_ -> render_error(conn, :forbidden, "You can't revoke your own admin/moderator status.")
	end
	end

	def right_delete_multiple(conn, _) do
	render_error(conn, :not_found, "No such permission_group")
	end

	def right_delete(
	%{assigns: %{user: admin}} = conn,
	%{
	"permission_group" => permission_group,
	"nickname" => nickname
	}
	)
	when permission_group in ["moderator", "admin"] do
	fields = %{:"is_#{permission_group}" => false}

	{:ok, user} =
	nickname
	\|> User.get_cached_by_nickname()
	\|> User.admin_api_update(fields)

	ModerationLog.insert_log(%{
	action: "revoke",
	actor: admin,
	subject: [user],
	permission: permission_group
	})

	json(conn, fields)
	end

	def right_delete(%{assigns: %{user: %{nickname: nickname}}} = conn, %{"nickname" => nickname}) do
	render_error(conn, :forbidden, "You can't revoke your own admin status.")
	end

	def relay_list(conn, _params) do
	with {:ok, list} <- Relay.list() do
	json(conn, %{relays: list})
	else
	_ ->
	conn
	\|> put_status(500)
	end
	end

	def relay_follow(%{assigns: %{user: admin}} = conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.follow(target) do
	ModerationLog.insert_log(%{
	action: "relay_follow",
	actor: admin,
	target: target
	})

	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	def relay_unfollow(%{assigns: %{user: admin}} = conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.unfollow(target) do
	ModerationLog.insert_log(%{
	action: "relay_unfollow",
	actor: admin,
	target: target
	})

	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	@doc "Sends registration invite via email"
	def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params) do
	with true <-
	Pleroma.Config.get([:instance, :invites_enabled]) &&
	!Pleroma.Config.get([:instance, :registrations_open]),
	{:ok, invite_token} <- UserInviteToken.create_invite(),
	email <-
	Pleroma.Emails.UserEmail.user_invitation_email(
	user,
	invite_token,
	email,
	params["name"]
	),
	{:ok, _} <- Pleroma.Emails.Mailer.deliver(email) do
	json_response(conn, :no_content, "")
	end
	end

	@doc "Create an account registration invite token"
	def create_invite_token(conn, params) do
	opts = %{}

	opts =
	if params["max_use"],
	do: Map.put(opts, :max_use, params["max_use"]),
	else: opts

	opts =
	if params["expires_at"],
	do: Map.put(opts, :expires_at, params["expires_at"]),
	else: opts

	{:ok, invite} = UserInviteToken.create_invite(opts)

	json(conn, AccountView.render("invite.json", %{invite: invite}))
	end

	@doc "Get list of created invites"
	def invites(conn, _params) do
	invites = UserInviteToken.list_invites()

	conn
	\|> put_view(AccountView)
	\|> render("invites.json", %{invites: invites})
	end

	@doc "Revokes invite by token"
	def revoke_invite(conn, %{"token" => token}) do
	with {:ok, invite} <- UserInviteToken.find_by_token(token),
	{:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true}) do
	conn
	\|> put_view(AccountView)
	\|> render("invite.json", %{invite: updated_invite})
	else
	nil -> {:error, :not_found}
	end
	end

	@doc "Get a password reset token (base64 string) for given nickname"
	def get_password_reset(conn, %{"nickname" => nickname}) do
	(%User{local: true} = user) = User.get_cached_by_nickname(nickname)
	{:ok, token} = Pleroma.PasswordResetToken.create_token(user)

	conn
	\|> json(%{
	token: token.token,
	link: Router.Helpers.reset_password_url(Endpoint, :reset, token.token)
	})
	end

	@doc "Force password reset for a given user"
	def force_password_reset(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	Enum.each(users, &User.force_password_reset_async/1)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "force_password_reset"
	})

	json_response(conn, :no_content, "")
	end

	def list_reports(conn, params) do
	{page, page_size} = page_params(params)

	reports = Utils.get_reports(params, page, page_size)

	conn
	\|> put_view(ReportView)
	\|> render("index.json", %{reports: reports})
	end

	def list_grouped_reports(conn, _params) do
	statuses = Utils.get_reported_activities()

	conn
	\|> put_view(ReportView)
	\|> render("index_grouped.json", Utils.get_reports_grouped_by_status(statuses))
	end

	def report_show(conn, %{"id" => id}) do
	with %Activity{} = report <- Activity.get_by_id(id) do
	conn
	\|> put_view(ReportView)
	\|> render("show.json", Report.extract_report_info(report))
	else
	_ -> {:error, :not_found}
	end
	end

	def reports_update(%{assigns: %{user: admin}} = conn, %{"reports" => reports}) do
	result =
	reports
	\|> Enum.map(fn report ->
	with {:ok, activity} <- CommonAPI.update_report_state(report["id"], report["state"]) do
	ModerationLog.insert_log(%{
	action: "report_update",
	actor: admin,
	subject: activity
	})

	activity
	else
	{:error, message} -> %{id: report["id"], error: message}
	end
	end)

	case Enum.any?(result, &Map.has_key?(&1, :error)) do
	true -> json_response(conn, :bad_request, result)
	false -> json_response(conn, :no_content, "")
	end
	end

	def report_notes_create(%{assigns: %{user: user}} = conn, %{
	"id" => report_id,
	"content" => content
	}) do
	with {:ok, _} <- ReportNote.create(user.id, report_id, content) do
	ModerationLog.insert_log(%{
	action: "report_note",
	actor: user,
	subject: Activity.get_by_id(report_id),
	text: content
	})

	json_response(conn, :no_content, "")
	else
	_ -> json_response(conn, :bad_request, "")
	end
	end

	def report_notes_delete(%{assigns: %{user: user}} = conn, %{
	"id" => note_id,
	"report_id" => report_id
	}) do
	with {:ok, note} <- ReportNote.destroy(note_id) do
	ModerationLog.insert_log(%{
	action: "report_note_delete",
	actor: user,
	subject: Activity.get_by_id(report_id),
	text: note.content
	})

	json_response(conn, :no_content, "")
	else
	_ -> json_response(conn, :bad_request, "")
	end
	end

	def status_update(%{assigns: %{user: admin}} = conn, %{"id" => id} = params) do
	with {:ok, activity} <- CommonAPI.update_activity_scope(id, params) do
	{:ok, sensitive} = Ecto.Type.cast(:boolean, params["sensitive"])

	ModerationLog.insert_log(%{
	action: "status_update",
	actor: admin,
	subject: activity,
	sensitive: sensitive,
	visibility: params["visibility"]
	})

	conn
	\|> put_view(StatusView)
	\|> render("show.json", %{activity: activity})
	end
	end

	def status_delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	ModerationLog.insert_log(%{
	action: "status_delete",
	actor: user,
	subject_id: id
	})

	json(conn, %{})
	end
	end

	def list_log(conn, params) do
	{page, page_size} = page_params(params)

	log =
	ModerationLog.get_all(%{
	page: page,
	page_size: page_size,
	start_date: params["start_date"],
	end_date: params["end_date"],
	user_id: params["user_id"],
	search: params["search"]
	})

	conn
	\|> put_view(ModerationLogView)
	\|> render("index.json", %{log: log})
	end

	def config_descriptions(conn, _params) do
	conn
	\|> Plug.Conn.put_resp_content_type("application/json")
	\|> Plug.Conn.send_resp(200, @descriptions_json)
	end

	def migrate_from_db(conn, _params) do
	with :ok <- configurable_from_database(conn) do
	Mix.Tasks.Pleroma.Config.run([
	"migrate_from_db",
	"--env",
	to_string(Pleroma.Config.get(:env)),
	"-d"
	])

	json(conn, %{})
	end
	end

	def config_show(conn, %{"only_db" => true}) do
	with :ok <- configurable_from_database(conn) do
	configs = Pleroma.Repo.all(ConfigDB)

	if configs == [] do
	errors(
	conn,
	{:error, "To use configuration from database migrate your settings to database."}
	)
	else
	conn
	\|> put_view(ConfigView)
	\|> render("index.json", %{configs: configs})
	end
	end
	end

	def config_show(conn, _params) do
	with :ok <- configurable_from_database(conn) do
	configs = ConfigDB.get_all_as_keyword()

	if configs == [] do
	errors(
	conn,
	{:error, "To use configuration from database migrate your settings to database."}
	)
	else
	merged =
	Pleroma.Config.Holder.config()
	\|> ConfigDB.merge(configs)
	\|> Enum.map(fn {group, values} ->
	Enum.map(values, fn {key, value} ->
	db =
	if configs[group][key] do
	ConfigDB.get_db_keys(configs[group][key], key)
	end

	db_value = configs[group][key]

	merged_value =
	if !is_nil(db_value) and Keyword.keyword?(db_value) and
	ConfigDB.sub_key_full_update?(group, key, Keyword.keys(db_value)) do
	ConfigDB.merge_group(group, key, value, db_value)
	else
	value
	end

	setting = %{
	group: ConfigDB.convert(group),
	key: ConfigDB.convert(key),
	value: ConfigDB.convert(merged_value)
	}

	if db, do: Map.put(setting, :db, db), else: setting
	end)
	end)
	\|> List.flatten()

	json(conn, %{configs: merged})
	end
	end
	end

	def config_update(conn, %{"configs" => configs}) do
	with :ok <- configurable_from_database(conn) do
	- updated =
	+ {_errors, results} =
	Enum.map(configs, fn
	%{"group" => group, "key" => key, "delete" => true} = params ->
	- with {:ok, config} <-
	- ConfigDB.delete(%{group: group, key: key, subkeys: params["subkeys"]}) do
	- config
	- end
	+ ConfigDB.delete(%{group: group, key: key, subkeys: params["subkeys"]})

	%{"group" => group, "key" => key, "value" => value} ->
	- with {:ok, config} <-
	- ConfigDB.update_or_create(%{group: group, key: key, value: value}) do
	- config
	- end
	+ ConfigDB.update_or_create(%{group: group, key: key, value: value})
	end)
	- \|> Enum.reject(&is_nil(&1))
	- \|> Enum.map(fn config ->
	+ \|> Enum.split_with(fn result -> elem(result, 0) == :error end)
	+
	+ {deleted, updated} =
	+ results
	+ \|> Enum.map(fn {:ok, config} ->
	Map.put(config, :db, ConfigDB.get_db_keys(config))
	end)
	+ \|> Enum.split_with(fn config ->
	+ Ecto.get_meta(config, :state) == :deleted
	+ end)

	- Pleroma.Config.TransferTask.load_and_update_env()
	+ Pleroma.Config.TransferTask.load_and_update_env(deleted)

	Mix.Tasks.Pleroma.Config.run([
	"migrate_from_db",
	"--env",
	to_string(Pleroma.Config.get(:env))
	])

	conn
	\|> put_view(ConfigView)
	\|> render("index.json", %{configs: updated})
	end
	end

	defp configurable_from_database(conn) do
	if Pleroma.Config.get(:configurable_from_database) do
	:ok
	else
	errors(
	conn,
	{:error, "To use this endpoint you need to enable configuration from database."}
	)
	end
	end

	def reload_emoji(conn, _params) do
	Pleroma.Emoji.reload()

	conn \|> json("ok")
	end

	def confirm_email(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	User.toggle_confirmation(users)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "confirm_email"
	})

	conn \|> json("")
	end

	def resend_confirmation_email(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	User.try_send_confirmation_email(users)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "resend_confirmation_email"
	})

	conn \|> json("")
	end

	def errors(conn, {:error, :not_found}) do
	conn
	\|> put_status(:not_found)
	\|> json(dgettext("errors", "Not found"))
	end

	def errors(conn, {:error, reason}) do
	conn
	\|> put_status(:bad_request)
	\|> json(reason)
	end

	def errors(conn, {:param_cast, _}) do
	conn
	\|> put_status(:bad_request)
	\|> json(dgettext("errors", "Invalid parameters"))
	end

	def errors(conn, _) do
	conn
	\|> put_status(:internal_server_error)
	\|> json(dgettext("errors", "Something went wrong"))
	end

	defp page_params(params) do
	{get_page(params["page"]), get_page_size(params["page_size"])}
	end

	defp get_page(page_string) when is_nil(page_string), do: 1

	defp get_page(page_string) do
	case Integer.parse(page_string) do
	{page, _} -> page
	:error -> 1
	end
	end

	defp get_page_size(page_size_string) when is_nil(page_size_string), do: @users_page_size

	defp get_page_size(page_size_string) do
	case Integer.parse(page_size_string) do
	{page_size, _} -> page_size
	:error -> @users_page_size
	end
	end
	end
	diff --git a/test/config/config_db_test.exs b/test/config/config_db_test.exs
	index 19619620e..61a0b1d5d 100644
	--- a/test/config/config_db_test.exs
	+++ b/test/config/config_db_test.exs
	@@ -1,667 +1,704 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConfigDBTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.ConfigDB

	test "get_by_key/1" do
	config = insert(:config)
	insert(:config)

	assert config == ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end

	test "create/1" do
	{:ok, config} = ConfigDB.create(%{group: ":pleroma", key: ":some_key", value: "some_value"})
	assert config == ConfigDB.get_by_params(%{group: ":pleroma", key: ":some_key"})
	end

	test "update/1" do
	config = insert(:config)
	{:ok, updated} = ConfigDB.update(config, %{value: "some_value"})
	loaded = ConfigDB.get_by_params(%{group: config.group, key: config.key})
	assert loaded == updated
	end

	test "get_all_as_keyword/0" do
	- insert(:config)
	+ saved = insert(:config)
	insert(:config, group: ":quack", key: ":level", value: ConfigDB.to_binary(:info))
	insert(:config, group: ":quack", key: ":meta", value: ConfigDB.to_binary([:none]))

	insert(:config,
	group: ":quack",
	key: ":webhook_url",
	value: ConfigDB.to_binary("https://hooks.slack.com/services/KEY/some_val")
	)

	- assert [
	- pleroma: [{_, %{another: _, another_key: _}}],
	- quack: [
	- level: :info,
	- meta: [:none],
	- webhook_url: "https://hooks.slack.com/services/KEY/some_val"
	- ]
	- ] = ConfigDB.get_all_as_keyword()
	+ config = ConfigDB.get_all_as_keyword()
	+
	+ assert config[:pleroma] == [
	+ {ConfigDB.from_string(saved.key), ConfigDB.from_binary(saved.value)}
	+ ]
	+
	+ assert config[:quack] == [
	+ level: :info,
	+ meta: [:none],
	+ webhook_url: "https://hooks.slack.com/services/KEY/some_val"
	+ ]
	end

	describe "update_or_create/1" do
	test "common" do
	config = insert(:config)
	key2 = "another_key"

	params = [
	%{group: "pleroma", key: key2, value: "another_value"},
	%{group: config.group, key: config.key, value: "new_value"}
	]

	assert Repo.all(ConfigDB) \|> length() == 1

	Enum.each(params, &ConfigDB.update_or_create(&1))

	assert Repo.all(ConfigDB) \|> length() == 2

	config1 = ConfigDB.get_by_params(%{group: config.group, key: config.key})
	config2 = ConfigDB.get_by_params(%{group: "pleroma", key: key2})

	assert config1.value == ConfigDB.transform("new_value")
	assert config2.value == ConfigDB.transform("another_value")
	end

	test "partial update" do
	config = insert(:config, value: ConfigDB.to_binary(key1: "val1", key2: :val2))

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: [key1: :val1, key3: :val3]
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	value = ConfigDB.from_binary(updated.value)
	assert length(value) == 3
	assert value[:key1] == :val1
	assert value[:key2] == :val2
	assert value[:key3] == :val3
	end

	test "deep merge" do
	config = insert(:config, value: ConfigDB.to_binary(key1: "val1", key2: [k1: :v1, k2: "v2"]))

	{:ok, config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: [key1: :val1, key2: [k2: :v2, k3: :v3], key3: :val3]
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert config.value == updated.value

	value = ConfigDB.from_binary(updated.value)
	assert value[:key1] == :val1
	assert value[:key2] == [k1: :v1, k2: :v2, k3: :v3]
	assert value[:key3] == :val3
	end

	test "only full update for some keys" do
	config1 = insert(:config, key: ":ecto_repos", value: ConfigDB.to_binary(repo: Pleroma.Repo))

	config2 =
	insert(:config, group: ":cors_plug", key: ":max_age", value: ConfigDB.to_binary(18))

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config1.group,
	key: config1.key,
	value: [another_repo: [Pleroma.Repo]]
	})

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config2.group,
	key: config2.key,
	value: 777
	})

	updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
	updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})

	assert ConfigDB.from_binary(updated1.value) == [another_repo: [Pleroma.Repo]]
	assert ConfigDB.from_binary(updated2.value) == 777
	end

	test "full update if value is not keyword" do
	config =
	insert(:config,
	group: ":tesla",
	key: ":adapter",
	value: ConfigDB.to_binary(Tesla.Adapter.Hackney)
	)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: Tesla.Adapter.Httpc
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert ConfigDB.from_binary(updated.value) == Tesla.Adapter.Httpc
	end

	test "only full update for some subkeys" do
	config1 =
	insert(:config,
	key: ":emoji",
	value: ConfigDB.to_binary(groups: [a: 1, b: 2], key: [a: 1])
	)

	config2 =
	insert(:config,
	key: ":assets",
	value: ConfigDB.to_binary(mascots: [a: 1, b: 2], key: [a: 1])
	)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config1.group,
	key: config1.key,
	value: [groups: [c: 3, d: 4], key: [b: 2]]
	})

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config2.group,
	key: config2.key,
	value: [mascots: [c: 3, d: 4], key: [b: 2]]
	})

	updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
	updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})

	assert ConfigDB.from_binary(updated1.value) == [groups: [c: 3, d: 4], key: [a: 1, b: 2]]
	assert ConfigDB.from_binary(updated2.value) == [mascots: [c: 3, d: 4], key: [a: 1, b: 2]]
	end
	end

	- test "delete/1" do
	- config = insert(:config)
	- {:ok, _} = ConfigDB.delete(%{key: config.key, group: config.group})
	- refute ConfigDB.get_by_params(%{key: config.key, group: config.group})
	+ describe "delete/1" do
	+ test "error on deleting non existing setting" do
	+ {:error, error} = ConfigDB.delete(%{group: ":pleroma", key: ":key"})
	+ assert error =~ "Config with params %{group: \":pleroma\", key: \":key\"} not found"
	+ end
	+
	+ test "full delete" do
	+ config = insert(:config)
	+ {:ok, deleted} = ConfigDB.delete(%{group: config.group, key: config.key})
	+ assert Ecto.get_meta(deleted, :state) == :deleted
	+ refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
	+ end
	+
	+ test "partial subkeys delete" do
	+ config = insert(:config, value: ConfigDB.to_binary(groups: [a: 1, b: 2], key: [a: 1]))
	+
	+ {:ok, deleted} =
	+ ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})
	+
	+ assert Ecto.get_meta(deleted, :state) == :loaded
	+
	+ assert deleted.value == ConfigDB.to_binary(key: [a: 1])
	+
	+ updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})
	+
	+ assert updated.value == deleted.value
	+ end
	+
	+ test "full delete if remaining value after subkeys deletion is empty list" do
	+ config = insert(:config, value: ConfigDB.to_binary(groups: [a: 1, b: 2]))
	+
	+ {:ok, deleted} =
	+ ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})
	+
	+ assert Ecto.get_meta(deleted, :state) == :deleted
	+
	+ refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
	+ end
	end

	describe "transform/1" do
	test "string" do
	binary = ConfigDB.transform("value as string")
	assert binary == :erlang.term_to_binary("value as string")
	assert ConfigDB.from_binary(binary) == "value as string"
	end

	test "boolean" do
	binary = ConfigDB.transform(false)
	assert binary == :erlang.term_to_binary(false)
	assert ConfigDB.from_binary(binary) == false
	end

	test "nil" do
	binary = ConfigDB.transform(nil)
	assert binary == :erlang.term_to_binary(nil)
	assert ConfigDB.from_binary(binary) == nil
	end

	test "integer" do
	binary = ConfigDB.transform(150)
	assert binary == :erlang.term_to_binary(150)
	assert ConfigDB.from_binary(binary) == 150
	end

	test "atom" do
	binary = ConfigDB.transform(":atom")
	assert binary == :erlang.term_to_binary(:atom)
	assert ConfigDB.from_binary(binary) == :atom
	end

	test "ssl options" do
	binary = ConfigDB.transform([":tlsv1", ":tlsv1.1", ":tlsv1.2"])
	assert binary == :erlang.term_to_binary([:tlsv1, :"tlsv1.1", :"tlsv1.2"])
	assert ConfigDB.from_binary(binary) == [:tlsv1, :"tlsv1.1", :"tlsv1.2"]
	end

	test "pleroma module" do
	binary = ConfigDB.transform("Pleroma.Bookmark")
	assert binary == :erlang.term_to_binary(Pleroma.Bookmark)
	assert ConfigDB.from_binary(binary) == Pleroma.Bookmark
	end

	test "pleroma string" do
	binary = ConfigDB.transform("Pleroma")
	assert binary == :erlang.term_to_binary("Pleroma")
	assert ConfigDB.from_binary(binary) == "Pleroma"
	end

	test "phoenix module" do
	binary = ConfigDB.transform("Phoenix.Socket.V1.JSONSerializer")
	assert binary == :erlang.term_to_binary(Phoenix.Socket.V1.JSONSerializer)
	assert ConfigDB.from_binary(binary) == Phoenix.Socket.V1.JSONSerializer
	end

	test "tesla module" do
	binary = ConfigDB.transform("Tesla.Adapter.Hackney")
	assert binary == :erlang.term_to_binary(Tesla.Adapter.Hackney)
	assert ConfigDB.from_binary(binary) == Tesla.Adapter.Hackney
	end

	test "ExSyslogger module" do
	binary = ConfigDB.transform("ExSyslogger")
	assert binary == :erlang.term_to_binary(ExSyslogger)
	assert ConfigDB.from_binary(binary) == ExSyslogger
	end

	test "Quack.Logger module" do
	binary = ConfigDB.transform("Quack.Logger")
	assert binary == :erlang.term_to_binary(Quack.Logger)
	assert ConfigDB.from_binary(binary) == Quack.Logger
	end

	test "sigil" do
	binary = ConfigDB.transform("~r[comp[lL][aA][iI][nN]er]")
	assert binary == :erlang.term_to_binary(~r/comp[lL][aA][iI][nN]er/)
	assert ConfigDB.from_binary(binary) == ~r/comp[lL][aA][iI][nN]er/
	end

	test "link sigil" do
	binary = ConfigDB.transform("~r/https:\/\/example.com/")
	assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/)
	assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/
	end

	test "link sigil with um modifiers" do
	binary = ConfigDB.transform("~r/https:\/\/example.com/um")
	assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/um)
	assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/um
	end

	test "link sigil with i modifier" do
	binary = ConfigDB.transform("~r/https:\/\/example.com/i")
	assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/i)
	assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/i
	end

	test "link sigil with s modifier" do
	binary = ConfigDB.transform("~r/https:\/\/example.com/s")
	assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/s)
	assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/s
	end

	test "raise if valid delimiter not found" do
	assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
	ConfigDB.transform("~r/https://[]{}<>\"'()\|example.com/s")
	end
	end

	test "2 child tuple" do
	binary = ConfigDB.transform(%{"tuple" => ["v1", ":v2"]})
	assert binary == :erlang.term_to_binary({"v1", :v2})
	assert ConfigDB.from_binary(binary) == {"v1", :v2}
	end

	test "proxy tuple with localhost" do
	binary =
	ConfigDB.transform(%{
	"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
	})

	assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, :localhost, 1234}})
	assert ConfigDB.from_binary(binary) == {:proxy_url, {:socks5, :localhost, 1234}}
	end

	test "proxy tuple with domain" do
	binary =
	ConfigDB.transform(%{
	"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
	})

	assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, 'domain.com', 1234}})
	assert ConfigDB.from_binary(binary) == {:proxy_url, {:socks5, 'domain.com', 1234}}
	end

	test "proxy tuple with ip" do
	binary =
	ConfigDB.transform(%{
	"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
	})

	assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}})
	assert ConfigDB.from_binary(binary) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
	end

	test "tuple with n childs" do
	binary =
	ConfigDB.transform(%{
	"tuple" => [
	"v1",
	":v2",
	"Pleroma.Bookmark",
	150,
	false,
	"Phoenix.Socket.V1.JSONSerializer"
	]
	})

	assert binary ==
	:erlang.term_to_binary(
	{"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
	)

	assert ConfigDB.from_binary(binary) ==
	{"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
	end

	test "map with string key" do
	binary = ConfigDB.transform(%{"key" => "value"})
	assert binary == :erlang.term_to_binary(%{"key" => "value"})
	assert ConfigDB.from_binary(binary) == %{"key" => "value"}
	end

	test "map with atom key" do
	binary = ConfigDB.transform(%{":key" => "value"})
	assert binary == :erlang.term_to_binary(%{key: "value"})
	assert ConfigDB.from_binary(binary) == %{key: "value"}
	end

	test "list of strings" do
	binary = ConfigDB.transform(["v1", "v2", "v3"])
	assert binary == :erlang.term_to_binary(["v1", "v2", "v3"])
	assert ConfigDB.from_binary(binary) == ["v1", "v2", "v3"]
	end

	test "list of modules" do
	binary = ConfigDB.transform(["Pleroma.Repo", "Pleroma.Activity"])
	assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
	assert ConfigDB.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
	end

	test "list of atoms" do
	binary = ConfigDB.transform([":v1", ":v2", ":v3"])
	assert binary == :erlang.term_to_binary([:v1, :v2, :v3])
	assert ConfigDB.from_binary(binary) == [:v1, :v2, :v3]
	end

	test "list of mixed values" do
	binary =
	ConfigDB.transform([
	"v1",
	":v2",
	"Pleroma.Repo",
	"Phoenix.Socket.V1.JSONSerializer",
	15,
	false
	])

	assert binary ==
	:erlang.term_to_binary([
	"v1",
	:v2,
	Pleroma.Repo,
	Phoenix.Socket.V1.JSONSerializer,
	15,
	false
	])

	assert ConfigDB.from_binary(binary) == [
	"v1",
	:v2,
	Pleroma.Repo,
	Phoenix.Socket.V1.JSONSerializer,
	15,
	false
	]
	end

	test "simple keyword" do
	binary = ConfigDB.transform([%{"tuple" => [":key", "value"]}])
	assert binary == :erlang.term_to_binary([{:key, "value"}])
	assert ConfigDB.from_binary(binary) == [{:key, "value"}]
	assert ConfigDB.from_binary(binary) == [key: "value"]
	end

	test "keyword with partial_chain key" do
	binary =
	ConfigDB.transform([%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}])

	assert binary == :erlang.term_to_binary(partial_chain: &:hackney_connect.partial_chain/1)
	assert ConfigDB.from_binary(binary) == [partial_chain: &:hackney_connect.partial_chain/1]
	end

	test "keyword" do
	binary =
	ConfigDB.transform([
	%{"tuple" => [":types", "Pleroma.PostgresTypes"]},
	%{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
	%{"tuple" => [":migration_lock", nil]},
	%{"tuple" => [":key1", 150]},
	%{"tuple" => [":key2", "string"]}
	])

	assert binary ==
	:erlang.term_to_binary(
	types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	migration_lock: nil,
	key1: 150,
	key2: "string"
	)

	assert ConfigDB.from_binary(binary) == [
	types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	migration_lock: nil,
	key1: 150,
	key2: "string"
	]
	end

	test "complex keyword with nested mixed childs" do
	binary =
	ConfigDB.transform([
	%{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
	%{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
	%{"tuple" => [":link_name", true]},
	%{"tuple" => [":proxy_remote", false]},
	%{"tuple" => [":common_map", %{":key" => "value"}]},
	%{
	"tuple" => [
	":proxy_opts",
	[
	%{"tuple" => [":redirect_on_failure", false]},
	%{"tuple" => [":max_body_length", 1_048_576]},
	%{
	"tuple" => [
	":http",
	[%{"tuple" => [":follow_redirect", true]}, %{"tuple" => [":pool", ":upload"]}]
	]
	}
	]
	]
	}
	])

	assert binary ==
	:erlang.term_to_binary(
	uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	proxy_remote: false,
	common_map: %{key: "value"},
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 1_048_576,
	http: [
	follow_redirect: true,
	pool: :upload
	]
	]
	)

	assert ConfigDB.from_binary(binary) ==
	[
	uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	proxy_remote: false,
	common_map: %{key: "value"},
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 1_048_576,
	http: [
	follow_redirect: true,
	pool: :upload
	]
	]
	]
	end

	test "common keyword" do
	binary =
	ConfigDB.transform([
	%{"tuple" => [":level", ":warn"]},
	%{"tuple" => [":meta", [":all"]]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":val", nil]},
	%{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
	])

	assert binary ==
	:erlang.term_to_binary(
	level: :warn,
	meta: [:all],
	path: "",
	val: nil,
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	)

	assert ConfigDB.from_binary(binary) == [
	level: :warn,
	meta: [:all],
	path: "",
	val: nil,
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	]
	end

	test "complex keyword with sigil" do
	binary =
	ConfigDB.transform([
	%{"tuple" => [":federated_timeline_removal", []]},
	%{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
	%{"tuple" => [":replace", []]}
	])

	assert binary ==
	:erlang.term_to_binary(
	federated_timeline_removal: [],
	reject: [~r/comp[lL][aA][iI][nN]er/],
	replace: []
	)

	assert ConfigDB.from_binary(binary) ==
	[federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
	end

	test "complex keyword with tuples with more than 2 values" do
	binary =
	ConfigDB.transform([
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key1",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	])

	assert binary ==
	:erlang.term_to_binary(
	http: [
	key1: [
	_: [
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]
	]
	]
	)

	assert ConfigDB.from_binary(binary) == [
	http: [
	key1: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	]
	]
	]
	end
	end
	end
	diff --git a/test/config/transfer_task_test.exs b/test/config/transfer_task_test.exs
	index 20dc06863..b9072e0fc 100644
	--- a/test/config/transfer_task_test.exs
	+++ b/test/config/transfer_task_test.exs
	@@ -1,121 +1,121 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.TransferTaskTest do
	use Pleroma.DataCase

	alias Pleroma.Config.TransferTask
	alias Pleroma.ConfigDB

	clear_config(:configurable_from_database) do
	Pleroma.Config.put(:configurable_from_database, true)
	end

	test "transfer config values from db to env" do
	refute Application.get_env(:pleroma, :test_key)
	refute Application.get_env(:idna, :test_key)
	refute Application.get_env(:quack, :test_key)

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":test_key",
	value: [live: 2, com: 3]
	})

	ConfigDB.create(%{
	group: ":idna",
	key: ":test_key",
	value: [live: 15, com: 35]
	})

	ConfigDB.create(%{
	group: ":quack",
	key: ":test_key",
	value: [:test_value1, :test_value2]
	})

	TransferTask.start_link([])

	assert Application.get_env(:pleroma, :test_key) == [live: 2, com: 3]
	assert Application.get_env(:idna, :test_key) == [live: 15, com: 35]
	assert Application.get_env(:quack, :test_key) == [:test_value1, :test_value2]

	on_exit(fn ->
	Application.delete_env(:pleroma, :test_key)
	Application.delete_env(:idna, :test_key)
	Application.delete_env(:quack, :test_key)
	end)
	end

	test "transfer config values for 1 group and some keys" do
	level = Application.get_env(:quack, :level)
	meta = Application.get_env(:quack, :meta)

	ConfigDB.create(%{
	group: ":quack",
	key: ":level",
	value: :info
	})

	ConfigDB.create(%{
	group: ":quack",
	key: ":meta",
	value: [:none]
	})

	TransferTask.start_link([])

	assert Application.get_env(:quack, :level) == :info
	assert Application.get_env(:quack, :meta) == [:none]
	default = Pleroma.Config.Holder.config(:quack, :webhook_url)
	assert Application.get_env(:quack, :webhook_url) == default

	on_exit(fn ->
	Application.put_env(:quack, :level, level)
	Application.put_env(:quack, :meta, meta)
	end)
	end

	test "transfer config values with full subkey update" do
	emoji = Application.get_env(:pleroma, :emoji)
	assets = Application.get_env(:pleroma, :assets)

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":emoji",
	value: [groups: [a: 1, b: 2]]
	})

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":assets",
	value: [mascots: [a: 1, b: 2]]
	})

	TransferTask.start_link([])

	emoji_env = Application.get_env(:pleroma, :emoji)
	assert emoji_env[:groups] == [a: 1, b: 2]
	assets_env = Application.get_env(:pleroma, :assets)
	assert assets_env[:mascots] == [a: 1, b: 2]

	on_exit(fn ->
	Application.put_env(:pleroma, :emoji, emoji)
	Application.put_env(:pleroma, :assets, assets)
	end)
	end

	test "non existing atom" do
	ConfigDB.create(%{
	group: ":pleroma",
	key: ":undefined_atom_key",
	value: [live: 2, com: 3]
	})

	assert ExUnit.CaptureLog.capture_log(fn ->
	TransferTask.start_link([])
	end) =~
	- "updating env causes error, group: \":pleroma\", key: \":undefined_atom_key\", value: [live: 2, com: 3], error: %ArgumentError{message: \"argument error\"}"
	+ "updating env causes error, group: \":pleroma\" key: \":undefined_atom_key\" value: [live: 2, com: 3] error: %ArgumentError{message: \"argument error\"}"
	end
	end
	diff --git a/test/web/admin_api/admin_api_controller_test.exs b/test/web/admin_api/admin_api_controller_test.exs
	index f4cdaebf9..5c767219a 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,3458 +1,3491 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.ConfigDB
	alias Pleroma.HTML
	alias Pleroma.ModerationLog
	alias Pleroma.Repo
	alias Pleroma.ReportNote
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	:ok
	end

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "with [:auth, :enforce_oauth_admin_scope_usage]," do
	clear_config([:auth, :enforce_oauth_admin_scope_usage]) do
	Pleroma.Config.put([:auth, :enforce_oauth_admin_scope_usage], true)
	end

	test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
	%{admin: admin} do
	user = insert(:user)
	url = "/api/pleroma/admin/users/#{user.nickname}"

	good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
	good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])

	bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
	bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
	bad_token3 = nil

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, 200)
	end

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, nil)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end

	for bad_token <- [bad_token1, bad_token2, bad_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, bad_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end
	end
	end

	describe "unless [:auth, :enforce_oauth_admin_scope_usage]," do
	clear_config([:auth, :enforce_oauth_admin_scope_usage]) do
	Pleroma.Config.put([:auth, :enforce_oauth_admin_scope_usage], false)
	end

	test "GET /api/pleroma/admin/users/:nickname requires " <>
	"read:accounts or admin:read:accounts or broader scope",
	%{admin: admin} do
	user = insert(:user)
	url = "/api/pleroma/admin/users/#{user.nickname}"

	good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
	good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])
	good_token4 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
	good_token5 = insert(:oauth_token, user: admin, scopes: ["read"])

	good_tokens = [good_token1, good_token2, good_token3, good_token4, good_token5]

	bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts:partial"])
	bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
	bad_token3 = nil

	for good_token <- good_tokens do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, 200)
	end

	for good_token <- good_tokens do
	conn =
	build_conn()
	\|> assign(:user, nil)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end

	for bad_token <- [bad_token1, bad_token2, bad_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, bad_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end
	end
	end

	describe "DELETE /api/pleroma/admin/users" do
	test "single user", %{admin: admin, conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user.nickname}"

	assert json_response(conn, 200) == user.nickname
	end

	test "multiple users", %{admin: admin, conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user_one.nickname}, @#{user_two.nickname}"

	response = json_response(conn, 200)
	assert response -- [user_one.nickname, user_two.nickname] == []
	end
	end

	describe "/api/pleroma/admin/users" do
	test "Create", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	},
	%{
	"nickname" => "lain2",
	"email" => "lain2@example.org",
	"password" => "test"
	}
	]
	})

	response = json_response(conn, 200) \|> Enum.map(&Map.get(&1, "type"))
	assert response == ["success", "success"]

	log_entry = Repo.one(ModerationLog)

	assert ["lain", "lain2"] -- Enum.map(log_entry.data["subjects"], & &1["nickname"]) == []
	end

	test "Cannot create user with existing email", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	}
	]
	end

	test "Cannot create user with existing nickname", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => user.nickname,
	"email" => "someuser@plerama.social",
	"password" => "test"
	}
	]
	})

	assert json_response(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => "someuser@plerama.social",
	"nickname" => user.nickname
	},
	"error" => "nickname has already been taken",
	"type" => "error"
	}
	]
	end

	test "Multiple user creation works in transaction", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "newuser",
	"email" => "newuser@pleroma.social",
	"password" => "test"
	},
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	},
	%{
	"code" => 409,
	"data" => %{
	"email" => "newuser@pleroma.social",
	"nickname" => "newuser"
	},
	"error" => "",
	"type" => "error"
	}
	]

	assert User.get_by_nickname("newuser") === nil
	end
	end

	describe "/api/pleroma/admin/users/:nickname" do
	test "Show", %{conn: conn} do
	user = insert(:user)

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")

	expected = %{
	"deactivated" => false,
	"id" => to_string(user.id),
	"local" => true,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}

	assert expected == json_response(conn, 200)
	end

	test "when the user doesn't exist", %{conn: conn} do
	user = build(:user)

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")

	assert "Not found" == json_response(conn, 404)
	end
	end

	describe "/api/pleroma/admin/users/follow" do
	test "allows to force-follow another user", %{admin: admin, conn: conn} do
	user = insert(:user)
	follower = insert(:user)

	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/follow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, user)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} follow @#{user.nickname}"
	end
	end

	describe "/api/pleroma/admin/users/unfollow" do
	test "allows to force-unfollow another user", %{admin: admin, conn: conn} do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/unfollow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} unfollow @#{user.nickname}"
	end
	end

	describe "PUT /api/pleroma/admin/users/tag" do
	setup %{conn: conn} do
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> put(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
	"#{user2.nickname}&tags[]=foo&tags[]=bar"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it appends specified tags to users with specified nicknames", %{
	conn: conn,
	admin: admin,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
	assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]

	log_entry = Repo.one(ModerationLog)

	users =
	[user1.nickname, user2.nickname]
	\|> Enum.map(&"@#{&1}")
	\|> Enum.join(", ")

	tags = ["foo", "bar"] \|> Enum.join(", ")

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} added tags: #{tags} to users: #{users}"
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "DELETE /api/pleroma/admin/users/tag" do
	setup %{conn: conn} do
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y", "z"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=" <>
	"#{user2.nickname}&tags[]=x&tags[]=z"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it removes specified tags from users with specified nicknames", %{
	conn: conn,
	admin: admin,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == []
	assert User.get_cached_by_id(user2.id).tags == ["y"]

	log_entry = Repo.one(ModerationLog)

	users =
	[user1.nickname, user2.nickname]
	\|> Enum.map(&"@#{&1}")
	\|> Enum.join(", ")

	tags = ["x", "z"] \|> Enum.join(", ")

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} removed tags: #{tags} from users: #{users}"
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "/api/pleroma/admin/users/:nickname/permission_group" do
	test "GET is giving user_info", %{admin: admin, conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")

	assert json_response(conn, 200) == %{
	"is_admin" => true,
	"is_moderator" => false
	}
	end

	test "/:right POST, can add to a permission group", %{admin: admin, conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => true
	}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{user.nickname} admin"
	end

	test "/:right POST, can add to a permission group (multiple)", %{admin: admin, conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/permission_group/admin", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})

	assert json_response(conn, 200) == %{"is_admin" => true}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{user_one.nickname}, @#{user_two.nickname} admin"
	end

	test "/:right DELETE, can remove from a permission group", %{admin: admin, conn: conn} do
	user = insert(:user, is_admin: true)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")

	assert json_response(conn, 200) == %{"is_admin" => false}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} revoked admin role from @#{user.nickname}"
	end

	test "/:right DELETE, can remove from a permission group (multiple)", %{
	admin: admin,
	conn: conn
	} do
	user_one = insert(:user, is_admin: true)
	user_two = insert(:user, is_admin: true)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/permission_group/admin", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})

	assert json_response(conn, 200) == %{"is_admin" => false}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} revoked admin role from @#{user_one.nickname}, @#{
	user_two.nickname
	}"
	end
	end

	describe "POST /api/pleroma/admin/email_invite, with valid config" do
	clear_config([:instance, :registrations_open]) do
	Pleroma.Config.put([:instance, :registrations_open], false)
	end

	clear_config([:instance, :invites_enabled]) do
	Pleroma.Config.put([:instance, :invites_enabled], true)
	end

	test "sends invitation and returns 204", %{admin: admin, conn: conn} do
	recipient_email = "foo@bar.com"
	recipient_name = "J. D."

	conn =
	post(
	conn,
	"/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
	)

	assert json_response(conn, :no_content)

	token_record = List.last(Repo.all(Pleroma.UserInviteToken))
	assert token_record
	refute token_record.used

	notify_email = Pleroma.Config.get([:instance, :notify_email])
	instance_name = Pleroma.Config.get([:instance, :name])

	email =
	Pleroma.Emails.UserEmail.user_invitation_email(
	admin,
	token_record,
	recipient_email,
	recipient_name
	)

	Swoosh.TestAssertions.assert_email_sent(
	from: {instance_name, notify_email},
	to: {recipient_name, recipient_email},
	html_body: email.html_body
	)
	end

	test "it returns 403 if requested by a non-admin" do
	non_admin_user = insert(:user)
	token = insert(:oauth_token, user: non_admin_user)

	conn =
	build_conn()
	\|> assign(:user, non_admin_user)
	\|> assign(:token, token)
	\|> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :forbidden)
	end
	end

	describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
	clear_config([:instance, :registrations_open])
	clear_config([:instance, :invites_enabled])

	test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn} do
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], false)

	conn = post(conn, "/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end

	test "it returns 500 if `registrations_open` is enabled", %{conn: conn} do
	Pleroma.Config.put([:instance, :registrations_open], true)
	Pleroma.Config.put([:instance, :invites_enabled], true)

	conn = post(conn, "/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end
	end

	test "/api/pleroma/admin/users/:nickname/password_reset", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")

	resp = json_response(conn, 200)

	assert Regex.match?(~r/(http:\/\/\|https:\/\/)/, resp["link"])
	end

	describe "GET /api/pleroma/admin/users" do
	test "renders users array for the first page", %{conn: conn, admin: admin} do
	user = insert(:user, local: false, tags: ["foo", "bar"])
	conn = get(conn, "/api/pleroma/admin/users?page=1")

	users =
	[
	%{
	"deactivated" => admin.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname),
	"confirmation_pending" => false
	},
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => false,
	"tags" => ["foo", "bar"],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "renders empty array for the second page", %{conn: conn} do
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?page=2")

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => []
	}
	end

	test "regular search", %{conn: conn} do
	user = insert(:user, nickname: "bob")

	conn = get(conn, "/api/pleroma/admin/users?query=bo")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "search by domain", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=domain.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "search by full nickname", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "search by display name", %{conn: conn} do
	user = insert(:user, name: "Display name")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?name=display")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "search by email", %{conn: conn} do
	user = insert(:user, email: "email@example.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "regular search with page size", %{conn: conn} do
	user = insert(:user, nickname: "aalice")
	user2 = insert(:user, nickname: "alice")

	conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")

	assert json_response(conn1, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}
	]
	}

	conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")

	assert json_response(conn2, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [
	%{
	"deactivated" => user2.deactivated,
	"id" => user2.id,
	"nickname" => user2.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user2) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user2.name \|\| user2.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "only local users" do
	admin = insert(:user, is_admin: true, nickname: "john")
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/users?query=bo&filters=local")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "only local users with no query", %{conn: conn, admin: old_admin} do
	admin = insert(:user, is_admin: true, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn = get(conn, "/api/pleroma/admin/users?filters=local")

	users =
	[
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	},
	%{
	"deactivated" => admin.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname),
	"confirmation_pending" => false
	},
	%{
	"deactivated" => false,
	"id" => old_admin.id,
	"local" => true,
	"nickname" => old_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"tags" => [],
	"avatar" => User.avatar_url(old_admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(old_admin.name \|\| old_admin.nickname),
	"confirmation_pending" => false
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only admins", %{conn: conn, admin: admin} do
	second_admin = insert(:user, is_admin: true)
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")

	users =
	[
	%{
	"deactivated" => false,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => admin.local,
	"tags" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname),
	"confirmation_pending" => false
	},
	%{
	"deactivated" => false,
	"id" => second_admin.id,
	"nickname" => second_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => second_admin.local,
	"tags" => [],
	"avatar" => User.avatar_url(second_admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(second_admin.name \|\| second_admin.nickname),
	"confirmation_pending" => false
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only moderators", %{conn: conn} do
	moderator = insert(:user, is_moderator: true)
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => false,
	"id" => moderator.id,
	"nickname" => moderator.nickname,
	"roles" => %{"admin" => false, "moderator" => true},
	"local" => moderator.local,
	"tags" => [],
	"avatar" => User.avatar_url(moderator) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(moderator.name \|\| moderator.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "load users with tags list", %{conn: conn} do
	user1 = insert(:user, tags: ["first"])
	user2 = insert(:user, tags: ["second"])
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")

	users =
	[
	%{
	"deactivated" => false,
	"id" => user1.id,
	"nickname" => user1.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user1.local,
	"tags" => ["first"],
	"avatar" => User.avatar_url(user1) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user1.name \|\| user1.nickname),
	"confirmation_pending" => false
	},
	%{
	"deactivated" => false,
	"id" => user2.id,
	"nickname" => user2.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user2.local,
	"tags" => ["second"],
	"avatar" => User.avatar_url(user2) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user2.name \|\| user2.nickname),
	"confirmation_pending" => false
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "it works with multiple filters" do
	admin = insert(:user, nickname: "john", is_admin: true)
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob", local: false, deactivated: true)

	insert(:user, nickname: "ken", local: true, deactivated: true)
	insert(:user, nickname: "bobb", local: false, deactivated: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/users?filters=deactivated,external")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user.local,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "it omits relay user", %{admin: admin, conn: conn} do
	assert %User{} = Relay.get_actor()

	conn = get(conn, "/api/pleroma/admin/users")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => admin.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname),
	"confirmation_pending" => false
	}
	]
	}
	end
	end

	test "PATCH /api/pleroma/admin/users/activate", %{admin: admin, conn: conn} do
	user_one = insert(:user, deactivated: true)
	user_two = insert(:user, deactivated: true)

	conn =
	patch(
	conn,
	"/api/pleroma/admin/users/activate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response(conn, 200)
	assert Enum.map(response["users"], & &1["deactivated"]) == [false, false]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} activated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/deactivate", %{admin: admin, conn: conn} do
	user_one = insert(:user, deactivated: false)
	user_two = insert(:user, deactivated: false)

	conn =
	patch(
	conn,
	"/api/pleroma/admin/users/deactivate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response(conn, 200)
	assert Enum.map(response["users"], & &1["deactivated"]) == [true, true]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation", %{admin: admin, conn: conn} do
	user = insert(:user)

	conn = patch(conn, "/api/pleroma/admin/users/#{user.nickname}/toggle_activation")

	assert json_response(conn, 200) ==
	%{
	"deactivated" => !user.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"confirmation_pending" => false
	}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user.nickname}"
	end

	describe "POST /api/pleroma/admin/users/invite_token" do
	test "without options", %{conn: conn} do
	conn = post(conn, "/api/pleroma/admin/users/invite_token")

	invite_json = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(invite_json["token"])
	refute invite.used
	refute invite.expires_at
	refute invite.max_use
	assert invite.invite_type == "one_time"
	end

	test "with expires_at", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/users/invite_token", %{
	"expires_at" => Date.to_string(Date.utc_today())
	})

	invite_json = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(invite_json["token"])

	refute invite.used
	assert invite.expires_at == Date.utc_today()
	refute invite.max_use
	assert invite.invite_type == "date_limited"
	end

	test "with max_use", %{conn: conn} do
	conn = post(conn, "/api/pleroma/admin/users/invite_token", %{"max_use" => 150})

	invite_json = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(invite_json["token"])
	refute invite.used
	refute invite.expires_at
	assert invite.max_use == 150
	assert invite.invite_type == "reusable"
	end

	test "with max use and expires_at", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/users/invite_token", %{
	"max_use" => 150,
	"expires_at" => Date.to_string(Date.utc_today())
	})

	invite_json = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(invite_json["token"])
	refute invite.used
	assert invite.expires_at == Date.utc_today()
	assert invite.max_use == 150
	assert invite.invite_type == "reusable_date_limited"
	end
	end

	describe "GET /api/pleroma/admin/users/invites" do
	test "no invites", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/users/invites")

	assert json_response(conn, 200) == %{"invites" => []}
	end

	test "with invite", %{conn: conn} do
	{:ok, invite} = UserInviteToken.create_invite()

	conn = get(conn, "/api/pleroma/admin/users/invites")

	assert json_response(conn, 200) == %{
	"invites" => [
	%{
	"expires_at" => nil,
	"id" => invite.id,
	"invite_type" => "one_time",
	"max_use" => nil,
	"token" => invite.token,
	"used" => false,
	"uses" => 0
	}
	]
	}
	end
	end

	describe "POST /api/pleroma/admin/users/revoke_invite" do
	test "with token", %{conn: conn} do
	{:ok, invite} = UserInviteToken.create_invite()

	conn = post(conn, "/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})

	assert json_response(conn, 200) == %{
	"expires_at" => nil,
	"id" => invite.id,
	"invite_type" => "one_time",
	"max_use" => nil,
	"token" => invite.token,
	"used" => true,
	"uses" => 0
	}
	end

	test "with invalid token", %{conn: conn} do
	conn = post(conn, "/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})

	assert json_response(conn, :not_found) == "Not found"
	end
	end

	describe "GET /api/pleroma/admin/reports/:id" do
	test "returns report by its id", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> get("/api/pleroma/admin/reports/#{report_id}")
	\|> json_response(:ok)

	assert response["id"] == report_id
	end

	test "returns 404 when report id is invalid", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/reports/test")

	assert json_response(conn, :not_found) == "Not found"
	end
	end

	describe "PATCH /api/pleroma/admin/reports" do
	setup do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, %{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel very offended",
	"status_ids" => [activity.id]
	})

	%{
	id: report_id,
	second_report_id: second_report_id
	}
	end

	test "requires admin:write:reports scope", %{conn: conn, id: id, admin: admin} do
	read_token = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	write_token = insert(:oauth_token, user: admin, scopes: ["admin:write:reports"])

	response =
	conn
	\|> assign(:token, read_token)
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [%{"state" => "resolved", "id" => id}]
	})
	\|> json_response(403)

	assert response == %{
	"error" => "Insufficient permissions: admin:write:reports."
	}

	conn
	\|> assign(:token, write_token)
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [%{"state" => "resolved", "id" => id}]
	})
	\|> json_response(:no_content)
	end

	test "mark report as resolved", %{conn: conn, id: id, admin: admin} do
	conn
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "resolved", "id" => id}
	]
	})
	\|> json_response(:no_content)

	activity = Activity.get_by_id(id)
	assert activity.data["state"] == "resolved"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated report ##{id} with 'resolved' state"
	end

	test "closes report", %{conn: conn, id: id, admin: admin} do
	conn
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "closed", "id" => id}
	]
	})
	\|> json_response(:no_content)

	activity = Activity.get_by_id(id)
	assert activity.data["state"] == "closed"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated report ##{id} with 'closed' state"
	end

	test "returns 400 when state is unknown", %{conn: conn, id: id} do
	conn =
	conn
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "test", "id" => id}
	]
	})

	assert hd(json_response(conn, :bad_request))["error"] == "Unsupported state"
	end

	test "returns 404 when report is not exist", %{conn: conn} do
	conn =
	conn
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "closed", "id" => "test"}
	]
	})

	assert hd(json_response(conn, :bad_request))["error"] == "not_found"
	end

	test "updates state of multiple reports", %{
	conn: conn,
	id: id,
	admin: admin,
	second_report_id: second_report_id
	} do
	conn
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "resolved", "id" => id},
	%{"state" => "closed", "id" => second_report_id}
	]
	})
	\|> json_response(:no_content)

	activity = Activity.get_by_id(id)
	second_activity = Activity.get_by_id(second_report_id)
	assert activity.data["state"] == "resolved"
	assert second_activity.data["state"] == "closed"

	[first_log_entry, second_log_entry] = Repo.all(ModerationLog)

	assert ModerationLog.get_log_entry_message(first_log_entry) ==
	"@#{admin.nickname} updated report ##{id} with 'resolved' state"

	assert ModerationLog.get_log_entry_message(second_log_entry) ==
	"@#{admin.nickname} updated report ##{second_report_id} with 'closed' state"
	end
	end

	describe "GET /api/pleroma/admin/reports" do
	test "returns empty response when no reports created", %{conn: conn} do
	response =
	conn
	\|> get("/api/pleroma/admin/reports")
	\|> json_response(:ok)

	assert Enum.empty?(response["reports"])
	assert response["total"] == 0
	end

	test "returns reports", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> get("/api/pleroma/admin/reports")
	\|> json_response(:ok)

	[report] = response["reports"]

	assert length(response["reports"]) == 1
	assert report["id"] == report_id

	assert response["total"] == 1
	end

	test "returns reports with specified state", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, %{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I don't like this user"
	})

	CommonAPI.update_report_state(second_report_id, "closed")

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "open"
	})
	\|> json_response(:ok)

	[open_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert open_report["id"] == first_report_id

	assert response["total"] == 1

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "closed"
	})
	\|> json_response(:ok)

	[closed_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert closed_report["id"] == second_report_id

	assert response["total"] == 1

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "resolved"
	})
	\|> json_response(:ok)

	assert Enum.empty?(response["reports"])
	assert response["total"] == 0
	end

	test "returns 403 when requested by a non-admin" do
	user = insert(:user)
	token = insert(:oauth_token, user: user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/reports")

	assert json_response(conn, :forbidden) ==
	%{"error" => "User is not an admin or OAuth admin scope is not granted."}
	end

	test "returns 403 when requested by anonymous" do
	conn = get(build_conn(), "/api/pleroma/admin/reports")

	assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
	end
	end

	describe "GET /api/pleroma/admin/grouped_reports" do
	setup do
	[reporter, target_user] = insert_pair(:user)

	date1 = (DateTime.to_unix(DateTime.utc_now()) + 1000) \|> DateTime.from_unix!()
	date2 = (DateTime.to_unix(DateTime.utc_now()) + 2000) \|> DateTime.from_unix!()
	date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) \|> DateTime.from_unix!()

	first_status =
	insert(:note_activity, user: target_user, data_attrs: %{"published" => date1})

	second_status =
	insert(:note_activity, user: target_user, data_attrs: %{"published" => date2})

	third_status =
	insert(:note_activity, user: target_user, data_attrs: %{"published" => date3})

	{:ok, first_report} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"status_ids" => [first_status.id, second_status.id, third_status.id]
	})

	{:ok, second_report} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"status_ids" => [first_status.id, second_status.id]
	})

	{:ok, third_report} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"status_ids" => [first_status.id]
	})

	%{
	first_status: Activity.get_by_ap_id_with_object(first_status.data["id"]),
	second_status: Activity.get_by_ap_id_with_object(second_status.data["id"]),
	third_status: Activity.get_by_ap_id_with_object(third_status.data["id"]),
	first_report: first_report,
	first_status_reports: [first_report, second_report, third_report],
	second_status_reports: [first_report, second_report],
	third_status_reports: [first_report],
	target_user: target_user,
	reporter: reporter
	}
	end

	test "returns reports grouped by status", %{
	conn: conn,
	first_status: first_status,
	second_status: second_status,
	third_status: third_status,
	first_status_reports: first_status_reports,
	second_status_reports: second_status_reports,
	third_status_reports: third_status_reports,
	target_user: target_user,
	reporter: reporter
	} do
	response =
	conn
	\|> get("/api/pleroma/admin/grouped_reports")
	\|> json_response(:ok)

	assert length(response["reports"]) == 3

	first_group = Enum.find(response["reports"], &(&1["status"]["id"] == first_status.id))

	second_group = Enum.find(response["reports"], &(&1["status"]["id"] == second_status.id))

	third_group = Enum.find(response["reports"], &(&1["status"]["id"] == third_status.id))

	assert length(first_group["reports"]) == 3
	assert length(second_group["reports"]) == 2
	assert length(third_group["reports"]) == 1

	assert first_group["date"] ==
	Enum.max_by(first_status_reports, fn act ->
	NaiveDateTime.from_iso8601!(act.data["published"])
	end).data["published"]

	assert first_group["status"] ==
	Map.put(
	stringify_keys(StatusView.render("show.json", %{activity: first_status})),
	"deleted",
	false
	)

	assert(first_group["account"]["id"] == target_user.id)

	assert length(first_group["actors"]) == 1
	assert hd(first_group["actors"])["id"] == reporter.id

	assert Enum.map(first_group["reports"], & &1["id"]) --
	Enum.map(first_status_reports, & &1.id) == []

	assert second_group["date"] ==
	Enum.max_by(second_status_reports, fn act ->
	NaiveDateTime.from_iso8601!(act.data["published"])
	end).data["published"]

	assert second_group["status"] ==
	Map.put(
	stringify_keys(StatusView.render("show.json", %{activity: second_status})),
	"deleted",
	false
	)

	assert second_group["account"]["id"] == target_user.id

	assert length(second_group["actors"]) == 1
	assert hd(second_group["actors"])["id"] == reporter.id

	assert Enum.map(second_group["reports"], & &1["id"]) --
	Enum.map(second_status_reports, & &1.id) == []

	assert third_group["date"] ==
	Enum.max_by(third_status_reports, fn act ->
	NaiveDateTime.from_iso8601!(act.data["published"])
	end).data["published"]

	assert third_group["status"] ==
	Map.put(
	stringify_keys(StatusView.render("show.json", %{activity: third_status})),
	"deleted",
	false
	)

	assert third_group["account"]["id"] == target_user.id

	assert length(third_group["actors"]) == 1
	assert hd(third_group["actors"])["id"] == reporter.id

	assert Enum.map(third_group["reports"], & &1["id"]) --
	Enum.map(third_status_reports, & &1.id) == []
	end

	test "reopened report renders status data", %{
	conn: conn,
	first_report: first_report,
	first_status: first_status
	} do
	{:ok, _} = CommonAPI.update_report_state(first_report.id, "resolved")

	response =
	conn
	\|> get("/api/pleroma/admin/grouped_reports")
	\|> json_response(:ok)

	first_group = Enum.find(response["reports"], &(&1["status"]["id"] == first_status.id))

	assert first_group["status"] ==
	Map.put(
	stringify_keys(StatusView.render("show.json", %{activity: first_status})),
	"deleted",
	false
	)
	end

	test "reopened report does not render status data if status has been deleted", %{
	conn: conn,
	first_report: first_report,
	first_status: first_status,
	target_user: target_user
	} do
	{:ok, _} = CommonAPI.update_report_state(first_report.id, "resolved")
	{:ok, _} = CommonAPI.delete(first_status.id, target_user)

	refute Activity.get_by_ap_id(first_status.id)

	response =
	conn
	\|> get("/api/pleroma/admin/grouped_reports")
	\|> json_response(:ok)

	assert Enum.find(response["reports"], &(&1["status"]["deleted"] == true))["status"][
	"deleted"
	] == true

	assert length(Enum.filter(response["reports"], &(&1["status"]["deleted"] == false))) == 2
	end

	test "account not empty if status was deleted", %{
	conn: conn,
	first_report: first_report,
	first_status: first_status,
	target_user: target_user
	} do
	{:ok, _} = CommonAPI.update_report_state(first_report.id, "resolved")
	{:ok, _} = CommonAPI.delete(first_status.id, target_user)

	refute Activity.get_by_ap_id(first_status.id)

	response =
	conn
	\|> get("/api/pleroma/admin/grouped_reports")
	\|> json_response(:ok)

	assert Enum.find(response["reports"], &(&1["status"]["deleted"] == true))["account"]
	end
	end

	describe "PUT /api/pleroma/admin/statuses/:id" do
	setup do
	activity = insert(:note_activity)

	%{id: activity.id}
	end

	test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
	\|> json_response(:ok)

	assert response["sensitive"]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
	\|> json_response(:ok)

	refute response["sensitive"]
	end

	test "change visibility flag", %{conn: conn, id: id, admin: admin} do
	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
	\|> json_response(:ok)

	assert response["visibility"] == "public"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated status ##{id}, set visibility: 'public'"

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
	\|> json_response(:ok)

	assert response["visibility"] == "private"

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
	\|> json_response(:ok)

	assert response["visibility"] == "unlisted"
	end

	test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
	conn = put(conn, "/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})

	assert json_response(conn, :bad_request) == "Unsupported visibility"
	end
	end

	describe "DELETE /api/pleroma/admin/statuses/:id" do
	setup do
	activity = insert(:note_activity)

	%{id: activity.id}
	end

	test "deletes status", %{conn: conn, id: id, admin: admin} do
	conn
	\|> delete("/api/pleroma/admin/statuses/#{id}")
	\|> json_response(:ok)

	refute Activity.get_by_id(id)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted status ##{id}"
	end

	test "returns error when status is not exist", %{conn: conn} do
	conn = delete(conn, "/api/pleroma/admin/statuses/test")

	assert json_response(conn, :bad_request) == "Could not delete"
	end
	end

	describe "GET /api/pleroma/admin/config" do
	clear_config(:configurable_from_database) do
	Pleroma.Config.put(:configurable_from_database, true)
	end

	test "when configuration from database is off", %{conn: conn} do
	initial = Pleroma.Config.get(:configurable_from_database)
	Pleroma.Config.put(:configurable_from_database, false)
	on_exit(fn -> Pleroma.Config.put(:configurable_from_database, initial) end)
	conn = get(conn, "/api/pleroma/admin/config")

	assert json_response(conn, 400) ==
	"To use this endpoint you need to enable configuration from database."
	end

	test "without any settings in db", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/config")

	assert json_response(conn, 400) ==
	"To use configuration from database migrate your settings to database."
	end

	test "with settings only in db", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	conn = get(conn, "/api/pleroma/admin/config", %{"only_db" => true})

	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => key1,
	"value" => _
	},
	%{
	"group" => ":pleroma",
	"key" => key2,
	"value" => _
	}
	]
	} = json_response(conn, 200)

	assert key1 == config1.key
	assert key2 == config2.key
	end

	test "db is added to settings that are in db", %{conn: conn} do
	_config = insert(:config, key: ":instance", value: ConfigDB.to_binary(name: "Some name"))

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response(200)

	[instance_config] =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key == ":instance"
	end)

	assert instance_config["db"] == [":name"]
	end

	test "merged default setting with db settings", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	config3 =
	insert(:config,
	value: ConfigDB.to_binary(k1: :v1, k2: :v2)
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response(200)

	assert length(configs) > 3

	received_configs =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in [config1.key, config2.key, config3.key]
	end)

	assert length(received_configs) == 3

	db_keys =
	config3.value
	\|> ConfigDB.from_binary()
	\|> Keyword.keys()
	\|> ConfigDB.convert()

	Enum.each(received_configs, fn %{"value" => value, "db" => db} ->
	assert db in [[config1.key], [config2.key], db_keys]

	assert value in [
	ConfigDB.from_binary_with_convert(config1.value),
	ConfigDB.from_binary_with_convert(config2.value),
	ConfigDB.from_binary_with_convert(config3.value)
	]
	end)
	end

	test "subkeys with full update right merge", %{conn: conn} do
	config1 =
	insert(:config,
	key: ":emoji",
	value: ConfigDB.to_binary(groups: [a: 1, b: 2], key: [a: 1])
	)

	config2 =
	insert(:config,
	key: ":assets",
	value: ConfigDB.to_binary(mascots: [a: 1, b: 2], key: [a: 1])
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response(200)

	vals =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in [config1.key, config2.key]
	end)

	emoji = Enum.find(vals, fn %{"key" => key} -> key == ":emoji" end)
	assets = Enum.find(vals, fn %{"key" => key} -> key == ":assets" end)

	emoji_val = ConfigDB.transform_with_out_binary(emoji["value"])
	assets_val = ConfigDB.transform_with_out_binary(assets["value"])

	assert emoji_val[:groups] == [a: 1, b: 2]
	assert assets_val[:mascots] == [a: 1, b: 2]
	end
	end

	test "POST /api/pleroma/admin/config error", %{conn: conn} do
	conn = post(conn, "/api/pleroma/admin/config", %{"configs" => []})

	assert json_response(conn, 400) ==
	"To use this endpoint you need to enable configuration from database."
	end

	describe "POST /api/pleroma/admin/config" do
	setup do
	http = Application.get_env(:pleroma, :http)

	on_exit(fn ->
	Application.delete_env(:pleroma, :key1)
	Application.delete_env(:pleroma, :key2)
	Application.delete_env(:pleroma, :key3)
	Application.delete_env(:pleroma, :key4)
	Application.delete_env(:pleroma, :keyaa1)
	Application.delete_env(:pleroma, :keyaa2)
	Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
	Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
	Application.put_env(:pleroma, :http, http)
	Application.put_env(:tesla, :adapter, Tesla.Mock)
	:ok = File.rm("config/test.exported_from_db.secret.exs")
	end)
	end

	clear_config(:configurable_from_database) do
	Pleroma.Config.put(:configurable_from_database, true)
	end

	@tag capture_log: true
	test "create new config setting in db", %{conn: conn} do
	+ ueberauth = Application.get_env(:ueberauth, Ueberauth)
	+ on_exit(fn -> Application.put_env(:ueberauth, Ueberauth, ueberauth) end)
	+
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
	},
	%{
	group: ":pleroma",
	key: ":key2",
	value: %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	}
	},
	%{
	group: ":pleroma",
	key: ":key3",
	value: [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]
	},
	%{
	group: ":pleroma",
	key: ":key4",
	value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
	},
	%{
	group: ":idna",
	key: ":key5",
	value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => "value1",
	"db" => [":key1"]
	},
	%{
	"group" => ":ueberauth",
	"key" => "Ueberauth",
	"value" => [%{"tuple" => [":consumer_secret", "aaaa"]}],
	"db" => [":consumer_secret"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key2",
	"value" => %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	},
	"db" => [":key2"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key3",
	"value" => [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	],
	"db" => [":key3"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key4",
	"value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"},
	"db" => [":key4"]
	},
	%{
	"group" => ":idna",
	"key" => ":key5",
	"value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]},
	"db" => [":key5"]
	}
	]
	}

	assert Application.get_env(:pleroma, :key1) == "value1"

	assert Application.get_env(:pleroma, :key2) == %{
	nested_1: "nested_value1",
	nested_2: [
	%{nested_22: "nested_value222"},
	%{nested_33: %{nested_44: "nested_444"}}
	]
	}

	assert Application.get_env(:pleroma, :key3) == [
	%{"nested_3" => :nested_3, "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]

	assert Application.get_env(:pleroma, :key4) == %{
	"endpoint" => "https://example.com",
	nested_5: :upload
	}

	assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
	end

	test "save config setting without key", %{conn: conn} do
	level = Application.get_env(:quack, :level)
	meta = Application.get_env(:quack, :meta)
	webhook_url = Application.get_env(:quack, :webhook_url)

	on_exit(fn ->
	Application.put_env(:quack, :level, level)
	Application.put_env(:quack, :meta, meta)
	Application.put_env(:quack, :webhook_url, webhook_url)
	end)

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":quack",
	key: ":level",
	value: ":info"
	},
	%{
	group: ":quack",
	key: ":meta",
	value: [":none"]
	},
	%{
	group: ":quack",
	key: ":webhook_url",
	value: "https://hooks.slack.com/services/KEY"
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":quack",
	"key" => ":level",
	"value" => ":info",
	"db" => [":level"]
	},
	%{
	"group" => ":quack",
	"key" => ":meta",
	"value" => [":none"],
	"db" => [":meta"]
	},
	%{
	"group" => ":quack",
	"key" => ":webhook_url",
	"value" => "https://hooks.slack.com/services/KEY",
	"db" => [":webhook_url"]
	}
	]
	}

	assert Application.get_env(:quack, :level) == :info
	assert Application.get_env(:quack, :meta) == [:none]
	assert Application.get_env(:quack, :webhook_url) == "https://hooks.slack.com/services/KEY"
	end

	test "saving config with partial update", %{conn: conn} do
	config = insert(:config, key: ":key1", value: :erlang.term_to_binary(key1: 1, key2: 2))

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{group: config.group, key: config.key, value: [%{"tuple" => [":key3", 3]}]}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key2", 2]},
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key1", ":key2", ":key3"]
	}
	]
	}
	end

	test "saving config with nested merge", %{conn: conn} do
	config =
	insert(:config, key: ":key1", value: :erlang.term_to_binary(key1: 1, key2: [k1: 1, k2: 2]))

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: config.group,
	key: config.key,
	value: [
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k1", 1]},
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	],
	"db" => [":key1", ":key3", ":key2"]
	}
	]
	}
	end

	test "saving special atoms", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	],
	"db" => [":ssl_options"]
	}
	]
	}

	assert Application.get_env(:pleroma, :key1) == [
	ssl_options: [versions: [:tlsv1, :"tlsv1.1", :"tlsv1.2"]]
	]
	end

	test "saving full setting if value is in full_key_update list", %{conn: conn} do
	backends = Application.get_env(:logger, :backends)
	on_exit(fn -> Application.put_env(:logger, :backends, backends) end)

	config =
	insert(:config,
	group: ":logger",
	key: ":backends",
	value: :erlang.term_to_binary([])
	)

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: config.group,
	key: config.key,
	value: [":console", %{"tuple" => ["ExSyslogger", ":ex_syslogger"]}]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":logger",
	"key" => ":backends",
	"value" => [
	":console",
	%{"tuple" => ["ExSyslogger", ":ex_syslogger"]}
	],
	"db" => [":backends"]
	}
	]
	}

	assert Application.get_env(:logger, :backends) == [
	:console,
	{ExSyslogger, :ex_syslogger}
	]

	ExUnit.CaptureLog.capture_log(fn ->
	require Logger
	Logger.warn("Ooops...")
	end) =~ "Ooops..."
	end

	test "saving full setting if value is not keyword", %{conn: conn} do
	config =
	insert(:config,
	group: ":tesla",
	key: ":adapter",
	value: :erlang.term_to_binary(Tesla.Adapter.Hackey)
	)

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{group: config.group, key: config.key, value: "Tesla.Adapter.Httpc"}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":tesla",
	"key" => ":adapter",
	"value" => "Tesla.Adapter.Httpc",
	"db" => [":adapter"]
	}
	]
	}
	end

	- test "update config setting & delete", %{conn: conn} do
	+ test "update config setting & delete with fallback to default value", %{
	+ conn: conn,
	+ admin: admin,
	+ token: token
	+ } do
	+ ueberauth = Application.get_env(:ueberauth, Ueberauth)
	config1 = insert(:config, key: ":keyaa1")
	config2 = insert(:config, key: ":keyaa2")

	- insert(:config,
	- group: "ueberauth",
	- key: "Ueberauth.Strategy.Microsoft.OAuth"
	- )
	+ config3 =
	+ insert(:config,
	+ group: ":ueberauth",
	+ key: "Ueberauth"
	+ )

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{group: config1.group, key: config1.key, value: "another_value"},
	- %{group: config2.group, key: config2.key, delete: true},
	- %{
	- group: "ueberauth",
	- key: "Ueberauth.Strategy.Microsoft.OAuth",
	- delete: true
	- }
	+ %{group: config2.group, key: config2.key, value: "another_value"}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => config1.key,
	"value" => "another_value",
	"db" => [":keyaa1"]
	+ },
	+ %{
	+ "group" => ":pleroma",
	+ "key" => config2.key,
	+ "value" => "another_value",
	+ "db" => [":keyaa2"]
	}
	]
	}

	assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	- refute Application.get_env(:pleroma, :keyaa2)
	+ assert Application.get_env(:pleroma, :keyaa2) == "another_value"
	+ assert Application.get_env(:ueberauth, Ueberauth) == ConfigDB.from_binary(config3.value)
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> assign(:token, token)
	+ \|> post("/api/pleroma/admin/config", %{
	+ configs: [
	+ %{group: config2.group, key: config2.key, delete: true},
	+ %{
	+ group: ":ueberauth",
	+ key: "Ueberauth",
	+ delete: true
	+ }
	+ ]
	+ })
	+
	+ assert json_response(conn, 200) == %{
	+ "configs" => []
	+ }
	+
	+ assert Application.get_env(:ueberauth, Ueberauth) == ueberauth
	+ refute Keyword.has_key?(Application.get_all_env(:pleroma), :keyaa2)
	end

	test "common config example", %{conn: conn} do
	adapter = Application.get_env(:tesla, :adapter)
	on_exit(fn -> Application.put_env(:tesla, :adapter, adapter) end)

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	]
	},
	%{
	"group" => ":tesla",
	"key" => ":adapter",
	"value" => "Tesla.Adapter.Httpc"
	}
	]
	})

	assert Application.get_env(:tesla, :adapter) == Tesla.Adapter.Httpc
	assert Pleroma.Config.get([Pleroma.Captcha.NotReal, :name]) == "Pleroma"

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	],
	"db" => [
	":enabled",
	":method",
	":seconds_valid",
	":path",
	":key1",
	":partial_chain",
	":regex1",
	":regex2",
	":regex3",
	":regex4",
	":name"
	]
	},
	%{
	"group" => ":tesla",
	"key" => ":adapter",
	"value" => "Tesla.Adapter.Httpc",
	"db" => [":adapter"]
	}
	]
	}
	end

	test "tuples with more than two values", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	],
	"db" => [":http"]
	}
	]
	}
	end

	test "settings with nesting map", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000,
	"nested" => %{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000
	}
	}
	]
	}
	]
	}
	]
	})

	assert json_response(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0,
	"nested" => %{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0
	}
	}
	]
	}
	],
	"db" => [":key2", ":key3"]
	}
	]
	}
	end

	test "value as map", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"}
	}
	]
	})

	assert json_response(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"},
	"db" => [":key1"]
	}
	]
	}
	end

	test "queues key as atom", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	],
	"db" => [
	":federator_incoming",
	":federator_outgoing",
	":web_push",
	":mailer",
	":transmogrifier",
	":scheduled_activities",
	":background"
	]
	}
	]
	}
	end

	test "delete part of settings by atom subkeys", %{conn: conn} do
	config =
	insert(:config,
	key: ":keyaa1",
	value: :erlang.term_to_binary(subkey1: "val1", subkey2: "val2", subkey3: "val3")
	)

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: config.group,
	key: config.key,
	subkeys: [":subkey1", ":subkey3"],
	delete: true
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => [%{"tuple" => [":subkey2", "val2"]}],
	"db" => [":subkey2"]
	}
	]
	}
	end

	test "proxy tuple localhost", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]},
	%{"tuple" => [":send_user_agent", false]}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]},
	%{"tuple" => [":send_user_agent", false]}
	],
	"db" => [":proxy_url", ":send_user_agent"]
	}
	]
	}
	end

	test "proxy tuple domain", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]},
	%{"tuple" => [":send_user_agent", false]}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]},
	%{"tuple" => [":send_user_agent", false]}
	],
	"db" => [":proxy_url", ":send_user_agent"]
	}
	]
	}
	end

	test "proxy tuple ip", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]},
	%{"tuple" => [":send_user_agent", false]}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]},
	%{"tuple" => [":send_user_agent", false]}
	],
	"db" => [":proxy_url", ":send_user_agent"]
	}
	]
	}
	end
	end

	describe "config mix tasks run" do
	setup do
	Mix.shell(Mix.Shell.Quiet)

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

	:ok
	end

	clear_config(:configurable_from_database) do
	Pleroma.Config.put(:configurable_from_database, true)
	end

	clear_config([:feed, :post_title]) do
	Pleroma.Config.put([:feed, :post_title], %{max_length: 100, omission: "…"})
	end

	test "transfer settings to DB and to file", %{conn: conn} do
	assert Repo.all(Pleroma.ConfigDB) == []
	Mix.Tasks.Pleroma.Config.migrate_to_db("test/fixtures/config/temp.secret.exs")
	assert Repo.aggregate(Pleroma.ConfigDB, :count, :id) > 0

	conn = get(conn, "/api/pleroma/admin/config/migrate_from_db")

	assert json_response(conn, 200) == %{}
	assert Repo.all(Pleroma.ConfigDB) == []
	end

	test "returns error if configuration from database is off", %{conn: conn} do
	initial = Pleroma.Config.get(:configurable_from_database)
	on_exit(fn -> Pleroma.Config.put(:configurable_from_database, initial) end)
	Pleroma.Config.put(:configurable_from_database, false)

	conn = get(conn, "/api/pleroma/admin/config/migrate_from_db")

	assert json_response(conn, 400) ==
	"To use this endpoint you need to enable configuration from database."

	assert Repo.all(Pleroma.ConfigDB) == []
	end
	end

	describe "GET /api/pleroma/admin/users/:nickname/statuses" do
	setup do
	user = insert(:user)

	date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) \|> DateTime.from_unix!()
	date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) \|> DateTime.from_unix!()
	date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) \|> DateTime.from_unix!()

	insert(:note_activity, user: user, published: date1)
	insert(:note_activity, user: user, published: date2)
	insert(:note_activity, user: user, published: date3)

	%{user: user}
	end

	test "renders user's statuses", %{conn: conn, user: user} do
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")

	assert json_response(conn, 200) \|> length() == 3
	end

	test "renders user's statuses with a limit", %{conn: conn, user: user} do
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")

	assert json_response(conn, 200) \|> length() == 2
	end

	test "doesn't return private statuses by default", %{conn: conn, user: user} do
	{:ok, _private_status} =
	CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})

	{:ok, _public_status} =
	CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")

	assert json_response(conn, 200) \|> length() == 4
	end

	test "returns private statuses with godmode on", %{conn: conn, user: user} do
	{:ok, _private_status} =
	CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})

	{:ok, _public_status} =
	CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")

	assert json_response(conn, 200) \|> length() == 5
	end
	end

	describe "GET /api/pleroma/admin/moderation_log" do
	setup do
	moderator = insert(:user, is_moderator: true)

	%{moderator: moderator}
	end

	test "returns the log", %{conn: conn, admin: admin} do
	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
	})

	conn = get(conn, "/api/pleroma/admin/moderation_log")

	response = json_response(conn, 200)
	[first_entry, second_entry] = response["items"]

	assert response["total"] == 2
	assert first_entry["data"]["action"] == "relay_unfollow"

	assert first_entry["message"] ==
	"@#{admin.nickname} unfollowed relay: https://example.org/relay"

	assert second_entry["data"]["action"] == "relay_follow"

	assert second_entry["message"] ==
	"@#{admin.nickname} followed relay: https://example.org/relay"
	end

	test "returns the log with pagination", %{conn: conn, admin: admin} do
	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
	})

	conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 2
	assert response1["items"] \|> length() == 1
	assert first_entry["data"]["action"] == "relay_unfollow"

	assert first_entry["message"] ==
	"@#{admin.nickname} unfollowed relay: https://example.org/relay"

	conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")

	response2 = json_response(conn2, 200)
	[second_entry] = response2["items"]

	assert response2["total"] == 2
	assert response2["items"] \|> length() == 1
	assert second_entry["data"]["action"] == "relay_follow"

	assert second_entry["message"] ==
	"@#{admin.nickname} followed relay: https://example.org/relay"
	end

	test "filters log by date", %{conn: conn, admin: admin} do
	first_date = "2017-08-15T15:47:06Z"
	second_date = "2017-08-20T15:47:06Z"

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.from_iso8601!(first_date)
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.from_iso8601!(second_date)
	})

	conn1 =
	get(
	conn,
	"/api/pleroma/admin/moderation_log?start_date=#{second_date}"
	)

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 1
	assert first_entry["data"]["action"] == "relay_unfollow"

	assert first_entry["message"] ==
	"@#{admin.nickname} unfollowed relay: https://example.org/relay"
	end

	test "returns log filtered by user", %{conn: conn, admin: admin, moderator: moderator} do
	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	}
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => moderator.id,
	"nickname" => moderator.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	}
	})

	conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 1
	assert get_in(first_entry, ["data", "actor", "id"]) == moderator.id
	end

	test "returns log filtered by search", %{conn: conn, moderator: moderator} do
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "relay_follow",
	target: "https://example.org/relay"
	})

	ModerationLog.insert_log(%{
	actor: moderator,
	action: "relay_unfollow",
	target: "https://example.org/relay"
	})

	conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 1

	assert get_in(first_entry, ["data", "message"]) ==
	"@#{moderator.nickname} unfollowed relay: https://example.org/relay"
	end
	end

	describe "PATCH /users/:nickname/force_password_reset" do
	test "sets password_reset_pending to true", %{conn: conn} do
	user = insert(:user)
	assert user.password_reset_pending == false

	conn =
	patch(conn, "/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})

	assert json_response(conn, 204) == ""

	ObanHelpers.perform_all()

	assert User.get_by_id(user.id).password_reset_pending == true
	end
	end

	describe "relays" do
	test "POST /relay", %{conn: conn, admin: admin} do
	conn =
	post(conn, "/api/pleroma/admin/relay", %{
	relay_url: "http://mastodon.example.org/users/admin"
	})

	assert json_response(conn, 200) == "http://mastodon.example.org/users/admin"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} followed relay: http://mastodon.example.org/users/admin"
	end

	test "GET /relay", %{conn: conn} do
	relay_user = Pleroma.Web.ActivityPub.Relay.get_actor()

	["http://mastodon.example.org/users/admin", "https://mstdn.io/users/mayuutann"]
	\|> Enum.each(fn ap_id ->
	{:ok, user} = User.get_or_fetch_by_ap_id(ap_id)
	User.follow(relay_user, user)
	end)

	conn = get(conn, "/api/pleroma/admin/relay")

	assert json_response(conn, 200)["relays"] -- ["mastodon.example.org", "mstdn.io"] == []
	end

	test "DELETE /relay", %{conn: conn, admin: admin} do
	post(conn, "/api/pleroma/admin/relay", %{
	relay_url: "http://mastodon.example.org/users/admin"
	})

	conn =
	delete(conn, "/api/pleroma/admin/relay", %{
	relay_url: "http://mastodon.example.org/users/admin"
	})

	assert json_response(conn, 200) == "http://mastodon.example.org/users/admin"

	[log_entry_one, log_entry_two] = Repo.all(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry_one) ==
	"@#{admin.nickname} followed relay: http://mastodon.example.org/users/admin"

	assert ModerationLog.get_log_entry_message(log_entry_two) ==
	"@#{admin.nickname} unfollowed relay: http://mastodon.example.org/users/admin"
	end
	end

	describe "instances" do
	test "GET /instances/:instance/statuses", %{conn: conn} do
	user = insert(:user, local: false, nickname: "archaeme@archae.me")
	user2 = insert(:user, local: false, nickname: "test@test.com")
	insert_pair(:note_activity, user: user)
	insert(:note_activity, user: user2)

	ret_conn = get(conn, "/api/pleroma/admin/instances/archae.me/statuses")

	response = json_response(ret_conn, 200)

	assert length(response) == 2

	ret_conn = get(conn, "/api/pleroma/admin/instances/test.com/statuses")

	response = json_response(ret_conn, 200)

	assert length(response) == 1

	ret_conn = get(conn, "/api/pleroma/admin/instances/nonexistent.com/statuses")

	response = json_response(ret_conn, 200)

	assert Enum.empty?(response)
	end
	end

	describe "PATCH /confirm_email" do
	test "it confirms emails of two users", %{conn: conn, admin: admin} do
	[first_user, second_user] = insert_pair(:user, confirmation_pending: true)

	assert first_user.confirmation_pending == true
	assert second_user.confirmation_pending == true

	ret_conn =
	patch(conn, "/api/pleroma/admin/users/confirm_email", %{
	nicknames: [
	first_user.nickname,
	second_user.nickname
	]
	})

	assert ret_conn.status == 200

	assert first_user.confirmation_pending == true
	assert second_user.confirmation_pending == true

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} confirmed email for users: @#{first_user.nickname}, @#{
	second_user.nickname
	}"
	end
	end

	describe "PATCH /resend_confirmation_email" do
	test "it resend emails for two users", %{conn: conn, admin: admin} do
	[first_user, second_user] = insert_pair(:user, confirmation_pending: true)

	ret_conn =
	patch(conn, "/api/pleroma/admin/users/resend_confirmation_email", %{
	nicknames: [
	first_user.nickname,
	second_user.nickname
	]
	})

	assert ret_conn.status == 200

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} re-sent confirmation email for users: @#{first_user.nickname}, @#{
	second_user.nickname
	}"
	end
	end

	describe "POST /reports/:id/notes" do
	setup %{conn: conn, admin: admin} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	post(conn, "/api/pleroma/admin/reports/#{report_id}/notes", %{
	content: "this is disgusting!"
	})

	post(conn, "/api/pleroma/admin/reports/#{report_id}/notes", %{
	content: "this is disgusting2!"
	})

	%{
	admin_id: admin.id,
	report_id: report_id
	}
	end

	test "it creates report note", %{admin_id: admin_id, report_id: report_id} do
	[note, _] = Repo.all(ReportNote)

	assert %{
	activity_id: ^report_id,
	content: "this is disgusting!",
	user_id: ^admin_id
	} = note
	end

	test "it returns reports with notes", %{conn: conn, admin: admin} do
	conn = get(conn, "/api/pleroma/admin/reports")

	response = json_response(conn, 200)
	notes = hd(response["reports"])["notes"]
	[note, _] = notes

	assert note["user"]["nickname"] == admin.nickname
	assert note["content"] == "this is disgusting!"
	assert note["created_at"]
	assert response["total"] == 1
	end

	test "it deletes the note", %{conn: conn, report_id: report_id} do
	assert ReportNote \|> Repo.all() \|> length() == 2

	[note, _] = Repo.all(ReportNote)

	delete(conn, "/api/pleroma/admin/reports/#{report_id}/notes/#{note.id}")

	assert ReportNote \|> Repo.all() \|> length() == 1
	end
	end

	test "GET /api/pleroma/admin/config/descriptions", %{conn: conn} do
	admin = insert(:user, is_admin: true)

	conn =
	assign(conn, :user, admin)
	\|> get("/api/pleroma/admin/config/descriptions")

	assert [child \| _others] = json_response(conn, 200)

	assert child["children"]
	assert child["key"]
	assert String.starts_with?(child["group"], ":")
	assert child["description"]
	end
	end

	# Needed for testing
	defmodule Pleroma.Web.Endpoint.NotReal do
	end

	defmodule Pleroma.Captcha.NotReal do
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 2, 8:42 AM (3 h, 11 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803949
Default Alt Text: (187 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions