No OneTemporary
Actions

Size

89 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/mix/tasks/pleroma/config.ex b/lib/mix/tasks/pleroma/config.ex
	index d160ce533..bfdd01c70 100644
	--- a/lib/mix/tasks/pleroma/config.ex
	+++ b/lib/mix/tasks/pleroma/config.ex
	@@ -1,555 +1,556 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Config do
	use Mix.Task

	import Ecto.Query
	import Mix.Pleroma

	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	@shortdoc "Manages the location of the config"
	@moduledoc File.read!("docs/administration/CLI_tasks/config.md")

	def run(["migrate_to_db"]) do
	check_configdb(fn ->
	start_pleroma()
	migrate_to_db()
	end)
	end

	def run(["migrate_from_db" \| options]) do
	check_configdb(fn ->
	start_pleroma()

	{opts, _} =
	OptionParser.parse!(options,
	strict: [env: :string, delete: :boolean, path: :string],
	aliases: [d: :delete]
	)

	migrate_from_db(opts)
	end)
	end

	def run(["dump"]) do
	check_configdb(fn ->
	start_pleroma()

	header = config_header()

	settings =
	ConfigDB
	\|> Repo.all()
	\|> Enum.sort()

	unless settings == [] do
	shell_info("#{header}")

	Enum.each(settings, &dump(&1))
	else
	shell_error("No settings in ConfigDB.")
	end
	end)
	end

	def run(["dump", group, key]) do
	check_configdb(fn ->
	start_pleroma()

	group = maybe_atomize(group)
	key = maybe_atomize(key)

	group
	\|> ConfigDB.get_by_group_and_key(key)
	\|> dump()
	end)
	end

	def run(["dump", group]) do
	check_configdb(fn ->
	start_pleroma()

	group = maybe_atomize(group)

	dump_group(group)
	end)
	end

	def run(["groups"]) do
	check_configdb(fn ->
	start_pleroma()

	groups =
	ConfigDB
	\|> distinct([c], true)
	\|> select([c], c.group)
	\|> Repo.all()

	if length(groups) > 0 do
	shell_info("The following configuration groups are set in ConfigDB:\r\n")
	groups \|> Enum.each(fn x -> shell_info("- #{x}") end)
	shell_info("\r\n")
	end
	end)
	end

	def run(["reset", "--force"]) do
	check_configdb(fn ->
	start_pleroma()
	truncatedb()
	shell_info("The ConfigDB settings have been removed from the database.")
	end)
	end

	def run(["reset"]) do
	check_configdb(fn ->
	start_pleroma()

	shell_info("The following settings will be permanently removed:")

	ConfigDB
	\|> Repo.all()
	\|> Enum.sort()
	\|> Enum.each(&dump(&1))

	shell_error("\nTHIS CANNOT BE UNDONE!")

	if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
	truncatedb()

	shell_info("The ConfigDB settings have been removed from the database.")
	else
	shell_error("No changes made.")
	end
	end)
	end

	def run(["delete", "--force", group, key]) do
	start_pleroma()

	group = maybe_atomize(group)
	key = maybe_atomize(key)

	with true <- key_exists?(group, key) do
	shell_info("The following settings will be removed from ConfigDB:\n")

	group
	\|> ConfigDB.get_by_group_and_key(key)
	\|> dump()

	delete_key(group, key)
	else
	_ ->
	shell_error("No settings in ConfigDB for #{inspect(group)}, #{inspect(key)}. Aborting.")
	end
	end

	def run(["delete", "--force", group]) do
	start_pleroma()

	group = maybe_atomize(group)

	with true <- group_exists?(group) do
	shell_info("The following settings will be removed from ConfigDB:\n")
	dump_group(group)
	delete_group(group)
	else
	_ -> shell_error("No settings in ConfigDB for #{inspect(group)}. Aborting.")
	end
	end

	def run(["delete", group, key]) do
	start_pleroma()

	group = maybe_atomize(group)
	key = maybe_atomize(key)

	with true <- key_exists?(group, key) do
	shell_info("The following settings will be removed from ConfigDB:\n")

	group
	\|> ConfigDB.get_by_group_and_key(key)
	\|> dump()

	if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
	delete_key(group, key)
	else
	shell_error("No changes made.")
	end
	else
	_ ->
	shell_error("No settings in ConfigDB for #{inspect(group)}, #{inspect(key)}. Aborting.")
	end
	end

	def run(["delete", group]) do
	start_pleroma()

	group = maybe_atomize(group)

	with true <- group_exists?(group) do
	shell_info("The following settings will be removed from ConfigDB:\n")
	dump_group(group)

	if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
	delete_group(group)
	else
	shell_error("No changes made.")
	end
	else
	_ -> shell_error("No settings in ConfigDB for #{inspect(group)}. Aborting.")
	end
	end

	# Removes any policies that are not a real module
	# as they will prevent the server from starting
	def run(["fix_mrf_policies"]) do
	check_configdb(fn ->
	start_pleroma()

	group = :pleroma
	key = :mrf

	%{value: value} =
	group
	\|> ConfigDB.get_by_group_and_key(key)

	policies =
	Keyword.get(value, :policies, [])
	\|> Enum.filter(&is_atom(&1))
	\|> Enum.filter(fn mrf ->
	case Code.ensure_compiled(mrf) do
	{:module, _} -> true
	{:error, _} -> false
	end
	end)

	value = Keyword.put(value, :policies, policies)

	ConfigDB.update_or_create(%{group: group, key: key, value: value})
	end)
	end

	# Removes non-whitelisted configuration sections
	def run(["filter_whitelisted" \| rest]) do
	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [force: :boolean],
	aliases: [f: :force]
	)

	force = Keyword.get(options, :force, false)

	start_pleroma()

	whitelisted_configs = Pleroma.Config.get(:database_config_whitelist)

	if whitelisted_configs in [nil, false] do
	shell_error("No unwanted settings in ConfigDB. No changes made.")
	else
	whitelisted_groups =
	whitelisted_configs
	\|> Enum.filter(fn
	{_group} -> true
	_ -> false
	end)
	\|> Enum.map(fn {group} -> group end)

	whitelisted_keys =
	whitelisted_configs
	\|> Enum.filter(fn
	{_group, _key} -> true
	_ -> false
	end)

	filtered =
	from(c in ConfigDB)
	\|> Repo.all()
	\|> Enum.filter(&not_whitelisted?(&1, whitelisted_groups, whitelisted_keys))

	if not Enum.empty?(filtered) do
	shell_info("The following settings will be removed from ConfigDB:\n")
	Enum.each(filtered, &dump(&1))

	if force or shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
	filtered_ids = Enum.map(filtered, fn %{id: id} -> id end)

	Repo.delete_all(from(c in ConfigDB, where: c.id in ^filtered_ids))
	else
	shell_error("No changes made.")
	end
	else
	shell_error("No unwanted settings in ConfigDB. No changes made.")
	end
	end
	end

	# Removes blacklisted configuration sections
	def run(["filter_blacklisted" \| rest]) do
	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [force: :boolean],
	aliases: [f: :force]
	)

	force = Keyword.get(options, :force, false)

	start_pleroma()

	blacklisted_configs = Pleroma.Config.get(:database_config_blacklist)

	if blacklisted_configs in [nil, false] do
	shell_error("No unwanted settings in ConfigDB. No changes made.")
	else
	blacklisted_groups =
	blacklisted_configs
	\|> Enum.filter(fn
	{_group} -> true
	_ -> false
	end)

	blacklisted_keys =
	blacklisted_configs
	\|> Enum.filter(fn
	{_group, _key} -> true
	_ -> false
	end)

	filtered =
	from(c in ConfigDB)
	\|> Repo.all()
	\|> Enum.filter(&blacklisted?(&1, blacklisted_groups, blacklisted_keys))

	if not Enum.empty?(filtered) do
	shell_info("The following settings will be removed from ConfigDB:\n")
	Enum.each(filtered, &dump(&1))

	if force or shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
	filtered_ids = Enum.map(filtered, fn %{id: id} -> id end)

	Repo.delete_all(from(c in ConfigDB, where: c.id in ^filtered_ids))
	else
	shell_error("No changes made.")
	end
	else
	shell_error("No unwanted settings in ConfigDB. No changes made.")
	end
	end
	end
	+
	@spec migrate_to_db(Path.t() \| nil) :: any()
	def migrate_to_db(file_path \\ nil) do
	with :ok <- Pleroma.Config.DeprecationWarnings.warn() do
	config_file =
	if file_path do
	file_path
	else
	if Pleroma.Config.get(:release) do
	Pleroma.Config.get(:config_path)
	else
	"config/#{Pleroma.Config.get(:env)}.secret.exs"
	end
	end

	do_migrate_to_db(config_file)
	else
	_ ->
	shell_error("Migration is not allowed until all deprecation warnings have been resolved.")
	end
	end

	defp do_migrate_to_db(config_file) do
	if File.exists?(config_file) do
	shell_info("Migrating settings from file: #{Path.expand(config_file)}")
	truncatedb()

	custom_config =
	config_file
	\|> read_file()
	\|> elem(0)

	custom_config
	\|> Keyword.keys()
	\|> Enum.each(&create(&1, custom_config))
	else
	shell_info("To migrate settings, you must define custom settings in #{config_file}.")
	end
	end

	defp create(group, settings) do
	group
	\|> Pleroma.Config.Loader.filter_group(settings)
	\|> Enum.each(fn {key, value} ->
	{:ok, _} = ConfigDB.update_or_create(%{group: group, key: key, value: value})

	shell_info("Settings for key #{key} migrated.")
	end)

	shell_info("Settings for group #{inspect(group)} migrated.")
	end

	defp migrate_from_db(opts) do
	env = opts[:env] \|\| Pleroma.Config.get(:env)

	filename = "#{env}.exported_from_db.secret.exs"

	config_path =
	cond do
	opts[:path] ->
	opts[:path]

	Pleroma.Config.get(:release) ->
	:config_path
	\|> Pleroma.Config.get()
	\|> Path.dirname()

	true ->
	"config"
	end
	\|> Path.join(filename)

	with {:ok, file} <- File.open(config_path, [:write, :utf8]) do
	write_config(file, config_path, opts)
	shell_info("Database configuration settings have been exported to #{config_path}")
	else
	_ ->
	shell_error("Impossible to save settings to this directory #{Path.dirname(config_path)}")
	tmp_config_path = Path.join(System.tmp_dir!(), filename)
	file = File.open!(tmp_config_path)

	shell_info(
	"Saving database configuration settings to #{tmp_config_path}. Copy it to the #{Path.dirname(config_path)} manually."
	)

	write_config(file, tmp_config_path, opts)
	end
	end

	defp write_config(file, path, opts) do
	IO.write(file, config_header())

	ConfigDB
	\|> Repo.all()
	\|> Enum.each(&write_and_delete(&1, file, opts[:delete]))

	:ok = File.close(file)

	# Ensure `mix format` runs in the same env as the current task and doesn't
	# emit config-time stderr noise (e.g. dev secret warnings) into `mix test`.
	System.cmd("mix", ["format", path],
	env: [{"MIX_ENV", to_string(Mix.env())}],
	stderr_to_stdout: true
	)
	end

	defp config_header, do: "import Config\r\n\r\n"
	defp read_file(config_file), do: Config.Reader.read_imports!(config_file)

	defp write_and_delete(config, file, delete?) do
	config
	\|> write(file)
	\|> delete(delete?)
	end

	defp write(config, file) do
	value = inspect(config.value, limit: :infinity)

	IO.write(file, "config #{inspect(config.group)}, #{inspect(config.key)}, #{value}\r\n\r\n")

	config
	end

	defp delete(config, true) do
	{:ok, _} = Repo.delete(config)

	shell_info(
	"config #{inspect(config.group)}, #{inspect(config.key)} was deleted from the ConfigDB."
	)
	end

	defp delete(_config, _), do: :ok

	defp dump(%ConfigDB{} = config) do
	value = inspect(config.value, limit: :infinity)

	shell_info("config #{inspect(config.group)}, #{inspect(config.key)}, #{value}\r\n\r\n")
	end

	defp dump(_), do: :noop

	defp dump_group(group) when is_atom(group) do
	group
	\|> ConfigDB.get_all_by_group()
	\|> Enum.each(&dump/1)
	end

	defp group_exists?(group) do
	group
	\|> ConfigDB.get_all_by_group()
	\|> Enum.any?()
	end

	defp key_exists?(group, key) do
	group
	\|> ConfigDB.get_by_group_and_key(key)
	\|> is_nil
	\|> Kernel.!()
	end

	defp maybe_atomize(arg) when is_atom(arg), do: arg

	defp maybe_atomize(":" <> arg), do: maybe_atomize(arg)

	defp maybe_atomize(arg) when is_binary(arg) do
	if ConfigDB.module_name?(arg) do
	String.to_existing_atom("Elixir." <> arg)
	else
	String.to_atom(arg)
	end
	end

	defp check_configdb(callback) do
	with true <- Pleroma.Config.get([:configurable_from_database]) do
	callback.()
	else
	_ ->
	shell_error(
	"ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."
	)
	end
	end

	defp delete_key(group, key) do
	check_configdb(fn ->
	ConfigDB.delete(%{group: group, key: key})
	end)
	end

	defp delete_group(group) do
	check_configdb(fn ->
	group
	\|> ConfigDB.get_all_by_group()
	\|> Enum.each(&ConfigDB.delete/1)
	end)
	end

	defp truncatedb do
	Ecto.Adapters.SQL.query!(Repo, "TRUNCATE config;")
	Ecto.Adapters.SQL.query!(Repo, "ALTER SEQUENCE config_id_seq RESTART;")
	end

	defp not_whitelisted?(%{group: group, key: key}, whitelisted_groups, whitelisted_keys) do
	not Enum.member?(whitelisted_groups, group) and
	not Enum.member?(whitelisted_keys, {group, key})
	end

	defp blacklisted?(%{group: group, key: key}, blacklisted_groups, blacklisted_keys) do
	Enum.member?(blacklisted_groups, {group}) or
	Enum.member?(blacklisted_keys, {group, key})
	end
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/config_controller.ex b/lib/pleroma/web/admin_api/controllers/config_controller.ex
	index 503fbc14d..78c798a3b 100644
	--- a/lib/pleroma/web/admin_api/controllers/config_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/config_controller.ex
	@@ -1,228 +1,228 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Config
	alias Pleroma.ConfigDB
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)
	plug(OAuthScopesPlug, %{scopes: ["admin:write"]} when action == :update)

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:read"]}
	when action in [:show, :descriptions]
	)

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

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

	defp translate_descriptions(descriptions, path \\ []) do
	Enum.map(descriptions, fn desc -> translate_item(desc, path) end)
	end

	defp translate_string(str, path, type) do
	Gettext.dpgettext(
	Pleroma.Web.Gettext,
	"config_descriptions",
	Pleroma.Docs.Translator.Compiler.msgctxt_for(path, type),
	str
	)
	end

	defp maybe_put_translated(item, key, path) do
	if item[key] do
	Map.put(
	item,
	key,
	translate_string(
	item[key],
	path ++ [Pleroma.Docs.Translator.Compiler.key_for(item)],
	to_string(key)
	)
	)
	else
	item
	end
	end

	defp translate_item(item, path) do
	item
	\|> maybe_put_translated(:label, path)
	\|> maybe_put_translated(:description, path)
	\|> translate_children(path)
	end

	defp translate_children(%{children: children} = item, path) when is_list(children) do
	item
	\|> Map.put(
	:children,
	translate_descriptions(children, path ++ [Pleroma.Docs.Translator.Compiler.key_for(item)])
	)
	end

	defp translate_children(item, _path) do
	item
	end

	def descriptions(conn, _params) do
	descriptions =
	Pleroma.Docs.JSON.compiled_descriptions()
	\|> Enum.filter(&whitelisted_config?/1)
	\|> Enum.reject(&blacklisted_config?/1)

	json(conn, translate_descriptions(descriptions))
	end

	def show(%{private: %{open_api_spex: %{params: %{only_db: true}}}} = conn, _) do
	with :ok <- configurable_from_database() do
	configs = Pleroma.Repo.all(ConfigDB)

	render(conn, "index.json", %{
	configs: configs,
	need_reboot: Restarter.Pleroma.need_reboot?()
	})
	end
	end

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

	merged =
	Config.Holder.default_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 not 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

	%ConfigDB{
	group: group,
	key: key,
	value: merged_value
	}
	\|> Pleroma.Maps.put_if_present(:db, db)
	end)
	end)
	\|> List.flatten()

	render(conn, "index.json", %{
	configs: merged,
	need_reboot: Restarter.Pleroma.need_reboot?()
	})
	end
	end

	def update(%{private: %{open_api_spex: %{body_params: %{configs: configs}}}} = conn, _) do
	with :ok <- configurable_from_database() do
	results =
	configs
	\|> Enum.filter(&whitelisted_config?/1)
	\|> Enum.reject(&blacklisted_config?/1)
	\|> Enum.map(fn
	%{group: group, key: key, delete: true} = params ->
	ConfigDB.delete(%{group: group, key: key, subkeys: params[:subkeys]})

	%{group: group, key: key, value: value} ->
	ConfigDB.update_or_create(%{group: group, key: key, value: value})
	end)
	\|> Enum.reject(fn {result, _} -> result == :error end)

	{deleted, updated} =
	results
	\|> Enum.map(fn {:ok, %{key: key, value: value} = config} ->
	Map.put(config, :db, ConfigDB.get_db_keys(value, key))
	end)
	\|> Enum.split_with(&(Ecto.get_meta(&1, :state) == :deleted))

	Config.TransferTask.load_and_update_env(deleted, false)

	if not Restarter.Pleroma.need_reboot?() do
	changed_reboot_settings? =
	(updated ++ deleted)
	\|> Enum.any?(&Config.TransferTask.pleroma_need_restart?(&1.group, &1.key, &1.value))

	if changed_reboot_settings?, do: Restarter.Pleroma.need_reboot()
	end

	render(conn, "index.json", %{
	configs: updated,
	need_reboot: Restarter.Pleroma.need_reboot?()
	})
	end
	end

	defp configurable_from_database do
	if Config.get(:configurable_from_database) do
	:ok
	else
	{:error, "You must enable configurable_from_database in your config file."}
	end
	end

	defp whitelisted_config?(":pleroma", ":database_config_whitelist"), do: false

	defp whitelisted_config?(group, key) do
	if whitelisted_configs = Config.get(:database_config_whitelist) do
	Enum.any?(whitelisted_configs, fn
	{whitelisted_group} ->
	group == inspect(whitelisted_group)

	{whitelisted_group, whitelisted_key} ->
	group == inspect(whitelisted_group) && key == inspect(whitelisted_key)
	end)
	else
	true
	end
	end

	defp whitelisted_config?(%{group: group, key: key}) do
	whitelisted_config?(group, key)
	end

	defp whitelisted_config?(%{group: group} = config) do
	whitelisted_config?(group, config[:key])
	end

	defp blacklisted_config?(":pleroma", ":database_config_blacklist"), do: true

	defp blacklisted_config?(group, key) do
	if blacklisted_configs = Config.get(:database_config_blacklist) do
	Enum.any?(blacklisted_configs, fn
	{blacklisted_group} ->
	group == inspect(blacklisted_group)

	{blacklisted_group, blacklisted_key} ->
	group == inspect(blacklisted_group) and key == inspect(blacklisted_key)
	- end)
	+ end)
	else
	true
	end
	end

	defp blacklisted_config?(%{group: group, key: key}) do
	blacklisted_config?(group, key)
	end

	defp blacklisted_config?(%{group: group} = config) do
	blacklisted_config?(group, config[:key])
	end
	end
	diff --git a/test/mix/tasks/pleroma/config_test.exs b/test/mix/tasks/pleroma/config_test.exs
	index b35e0aed8..7513e958e 100644
	--- a/test/mix/tasks/pleroma/config_test.exs
	+++ b/test/mix/tasks/pleroma/config_test.exs
	@@ -1,410 +1,407 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.ConfigTest do
	use Pleroma.DataCase

	import Pleroma.Factory

	alias Mix.Tasks.Pleroma.Config, as: MixTask
	alias Pleroma.ConfigDB
	alias Pleroma.Repo

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

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	Application.delete_env(:pleroma, :first_setting)
	Application.delete_env(:pleroma, :second_setting)
	end)

	:ok
	end

	defp config_records do
	ConfigDB
	\|> Repo.all()
	\|> Enum.sort()
	end

	defp insert_config_record(group, key, value) do
	insert(:config,
	group: group,
	key: key,
	value: value
	)
	end

	test "error if file with custom settings doesn't exist" do
	MixTask.migrate_to_db("config/non_existent_config_file.exs")

	msg =
	"To migrate settings, you must define custom settings in config/non_existent_config_file.exs."

	assert_receive {:mix_shell, :info, [^msg]}, 15
	end

	describe "migrate_to_db/1" do
	setup do
	clear_config(:configurable_from_database, true)
	end

	test "config migration refused when deprecated settings are found" do
	clear_config([:media_proxy, :whitelist], ["domain_without_scheme.com"])
	assert config_records() == []

	MixTask.migrate_to_db("test/fixtures/config/temp.secret.exs")

	assert_received {:mix_shell, :error, [message]}

	assert message =~
	"Migration is not allowed until all deprecation warnings have been resolved."
	end

	test "filtered settings are migrated to db" do
	assert config_records() == []

	MixTask.migrate_to_db("test/fixtures/config/temp.secret.exs")

	config1 = ConfigDB.get_by_params(%{group: ":pleroma", key: ":first_setting"})
	config2 = ConfigDB.get_by_params(%{group: ":pleroma", key: ":second_setting"})
	refute ConfigDB.get_by_params(%{group: ":pleroma", key: "Pleroma.Repo"})
	refute ConfigDB.get_by_params(%{group: ":postgrex", key: ":json_library"})
	refute ConfigDB.get_by_params(%{group: ":pleroma", key: ":database"})

	assert config1.value == [key: "value", key2: [Repo]]
	assert config2.value == [key: "value2", key2: ["Activity"]]
	end

	test "config table is truncated before migration" do
	insert_config_record(:pleroma, :first_setting, key: "value", key2: ["Activity"])
	assert length(config_records()) == 1

	MixTask.migrate_to_db("test/fixtures/config/temp.secret.exs")

	config = ConfigDB.get_by_params(%{group: ":pleroma", key: ":first_setting"})
	assert config.value == [key: "value", key2: [Repo]]
	end
	end

	describe "with deletion of temp file" do
	setup do
	clear_config(:configurable_from_database, true)
	temp_file = "config/temp.exported_from_db.secret.exs"

	on_exit(fn ->
	:ok = File.rm(temp_file)
	end)

	{:ok, temp_file: temp_file}
	end

	test "settings are migrated to file and deleted from db", %{temp_file: temp_file} do
	insert_config_record(:pleroma, :setting_first, key: "value", key2: ["Activity"])
	insert_config_record(:pleroma, :setting_second, key: "value2", key2: [Repo])

	MixTask.run(["migrate_from_db", "--env", "temp", "-d"])

	assert config_records() == []

	file = File.read!(temp_file)
	assert file =~ "config :pleroma, :setting_first,"
	assert file =~ "config :pleroma, :setting_second,"
	end

	test "load a settings with large values and pass to file", %{temp_file: temp_file} do
	insert(:config,
	key: :instance,
	value: [
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "A Pleroma instance, an alternative fediverse server",
	limit: 5_000,
	chat_limit: 5_000,
	remote_limit: 100_000,
	upload_limit: 16_000_000,
	avatar_upload_limit: 2_000_000,
	background_upload_limit: 4_000_000,
	banner_upload_limit: 4_000_000,
	poll_limits: %{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 365 * 24 * 60 * 60
	},
	registrations_open: true,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	allow_relay: true,
	public: true,
	quarantined_instances: [],
	managed_config: true,
	static_dir: "instance/static/",
	allowed_post_formats: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode",
	"text/x.misskeymarkdown"
	],
	autofollowed_nicknames: [],
	max_pinned_statuses: 1,
	attachment_links: false,
	max_report_comment_size: 1000,
	safe_dm_mentions: false,
	healthcheck: false,
	remote_post_retention_days: 90,
	skip_thread_containment: true,
	limit_to_local_content: :unauthenticated,
	user_bio_length: 5000,
	user_name_length: 100,
	max_account_fields: 10,
	max_remote_account_fields: 20,
	account_field_name_length: 512,
	account_field_value_length: 2048,
	external_user_synchronization: true,
	extended_nickname_format: true,
	multi_factor_authentication: [
	totp: [
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 2,
	length: 6
	]
	]
	]
	)

	MixTask.run(["migrate_from_db", "--env", "temp", "-d"])

	assert config_records() == []
	assert File.exists?(temp_file)
	{:ok, file} = File.read(temp_file)

	assert file =~ "import Config\n"
	assert file =~ "A Pleroma instance, an alternative fediverse server"
	end
	end

	describe "migrate_from_db/1" do
	setup do: clear_config(:configurable_from_database, true)

	setup do
	insert_config_record(:pleroma, :setting_first, key: "value", key2: ["Activity"])
	insert_config_record(:pleroma, :setting_second, key: "value2", key2: [Repo])

	path = "test/instance_static"
	file_path = Path.join(path, "temp.exported_from_db.secret.exs")

	on_exit(fn -> File.rm!(file_path) end)

	[file_path: file_path]
	end

	test "with path parameter", %{file_path: file_path} do
	MixTask.run(["migrate_from_db", "--env", "temp", "--path", Path.dirname(file_path)])

	file = File.read!(file_path)
	assert file =~ "config :pleroma, :setting_first,"
	assert file =~ "config :pleroma, :setting_second,"
	end

	test "release", %{file_path: file_path} do
	clear_config(:release, true)
	clear_config(:config_path, file_path)

	MixTask.run(["migrate_from_db", "--env", "temp"])

	file = File.read!(file_path)
	assert file =~ "config :pleroma, :setting_first,"
	assert file =~ "config :pleroma, :setting_second,"
	end
	end

	describe "operations on database config" do
	setup do: clear_config(:configurable_from_database, true)

	test "dumping a specific group" do
	insert_config_record(:pleroma, :instance, name: "Pleroma Test")

	insert_config_record(:web_push_encryption, :vapid_details,
	subject: "mailto:administrator@example.com",
	public_key:
	"BOsPL-_KjNnjj_RMvLeR3dTOrcndi4TbMR0cu56gLGfGaT5m1gXxSfRHOcC4Dd78ycQL1gdhtx13qgKHmTM5xAI",
	private_key: "Ism6FNdS31nLCA94EfVbJbDdJXCxAZ8cZiB1JQPN_t4"
	)

	MixTask.run(["dump", "pleroma"])

	assert_receive {:mix_shell, :info,
	["config :pleroma, :instance, [name: \"Pleroma Test\"]\r\n\r\n"]}

	refute_receive {
	:mix_shell,
	:info,
	[
	"config :web_push_encryption, :vapid_details, [subject: \"mailto:administrator@example.com\", public_key: \"BOsPL-_KjNnjj_RMvLeR3dTOrcndi4TbMR0cu56gLGfGaT5m1gXxSfRHOcC4Dd78ycQL1gdhtx13qgKHmTM5xAI\", private_key: \"Ism6FNdS31nLCA94EfVbJbDdJXCxAZ8cZiB1JQPN_t4\"]\r\n\r\n"
	]
	}

	# Ensure operations work when using atom syntax
	MixTask.run(["dump", ":pleroma"])

	assert_receive {:mix_shell, :info,
	["config :pleroma, :instance, [name: \"Pleroma Test\"]\r\n\r\n"]}
	end

	test "dumping a specific key in a group" do
	insert_config_record(:pleroma, :instance, name: "Pleroma Test")
	insert_config_record(:pleroma, Pleroma.Captcha, enabled: false)

	MixTask.run(["dump", "pleroma", "Pleroma.Captcha"])

	refute_receive {:mix_shell, :info,
	["config :pleroma, :instance, [name: \"Pleroma Test\"]\r\n\r\n"]}

	assert_receive {:mix_shell, :info,
	["config :pleroma, Pleroma.Captcha, [enabled: false]\r\n\r\n"]}
	end

	test "dumps all configuration successfully" do
	insert_config_record(:pleroma, :instance, name: "Pleroma Test")
	insert_config_record(:pleroma, Pleroma.Captcha, enabled: false)

	MixTask.run(["dump"])

	assert_receive {:mix_shell, :info,
	["config :pleroma, :instance, [name: \"Pleroma Test\"]\r\n\r\n"]}

	assert_receive {:mix_shell, :info,
	["config :pleroma, Pleroma.Captcha, [enabled: false]\r\n\r\n"]}
	end
	end

	describe "when configdb disabled" do
	test "refuses to dump" do
	clear_config(:configurable_from_database, false)

	insert_config_record(:pleroma, :instance, name: "Pleroma Test")

	MixTask.run(["dump"])

	msg =
	"ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."

	assert_receive {:mix_shell, :error, [^msg]}
	end
	end

	describe "destructive operations" do
	setup do: clear_config(:configurable_from_database, true)

	setup do
	insert_config_record(:pleroma, :instance, name: "Pleroma Test")
	insert_config_record(:pleroma, Pleroma.Captcha, enabled: false)
	insert_config_record(:pleroma2, :key2, z: 1)

	assert length(config_records()) == 3

	:ok
	end

	test "deletes group of settings" do
	MixTask.run(["delete", "--force", "pleroma"])

	assert [%ConfigDB{group: :pleroma2, key: :key2}] = config_records()
	end

	test "deletes specified key" do
	MixTask.run(["delete", "--force", "pleroma", "Pleroma.Captcha"])

	assert [
	%ConfigDB{group: :pleroma, key: :instance},
	%ConfigDB{group: :pleroma2, key: :key2}
	] = config_records()
	end

	test "resets entire config" do
	MixTask.run(["reset", "--force"])

	assert config_records() == []
	end

	test "filters non-whitelisted settings" do
	clear_config(:database_config_whitelist, [
	{:pleroma},
	{:web_push_encryption, :vapid_details}
	])

	insert_config_record(:web_push_encryption, :non_whitelisted_key, a: 1)
	insert_config_record(:web_push_encryption, :vapid_details, b: 1)

	MixTask.run(["filter_whitelisted", "--force"])

	assert [
	%ConfigDB{group: :pleroma, key: :instance},
	%ConfigDB{group: :pleroma, key: Pleroma.Captcha},
	%ConfigDB{group: :web_push_encryption, key: :vapid_details}
	] = config_records()
	end

	test "filter_whitelisted doesn't crash when whitelist is unset" do
	clear_config(:database_config_whitelist, nil)

	existing = config_records()
	MixTask.run(["filter_whitelisted", "--force"])
	assert config_records() == existing
	end

	test "filter_whitelisted doesn't crash when whitelist is disabled" do
	clear_config(:database_config_whitelist, false)

	existing = config_records()
	MixTask.run(["filter_whitelisted", "--force"])
	assert config_records() == existing
	end

	test "filters blacklisted settings" do
	clear_config(:database_config_whitelist, [{:pleroma}])
	- clear_config(:database_config_blacklist, [
	- {:pleroma, :logger},
	- {:blacklisted_group}
	- ])
	+ clear_config(:database_config_blacklist, [{:pleroma, :logger}, {:blacklisted_group}])

	insert_config_record(:pleroma, :logger, backends: :console)
	insert_config_record(:web_push_encryption, :vapid_details, a: 1)
	insert_config_record(:blacklisted_group, :anything, a: 1)

	MixTask.run(["filter_blacklisted", "--force"])

	assert [
	%ConfigDB{group: :pleroma, key: :instance},
	%ConfigDB{group: :pleroma, key: Pleroma.Captcha},
	%ConfigDB{group: :pleroma2, key: :key2},
	- %ConfigDB{group: :web_push_encryption, key: :vapid_details},
	+ %ConfigDB{group: :web_push_encryption, key: :vapid_details}
	] = config_records()
	end

	test "filter_blacklisted doesn't crash when blacklist is unset" do
	clear_config(:database_config_blacklist, nil)

	existing = config_records()
	MixTask.run(["filter_blacklisted", "--force"])
	assert config_records() == existing
	end

	test "filter_blacklisted doesn't crash when blacklist is disabled" do
	clear_config(:database_config_blacklist, false)

	existing = config_records()
	MixTask.run(["filter_blacklisted", "--force"])
	assert config_records() == existing
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/config_controller_test.exs b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	index 047662d39..902b30cdd 100644
	--- a/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	@@ -1,1590 +1,1600 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
	use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.ConfigDB

	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 "GET /api/pleroma/admin/config" do
	setup do: clear_config(:configurable_from_database, true)

	test "when configuration from database is off", %{conn: conn} do
	clear_config(:configurable_from_database, false)
	conn = get(conn, "/api/pleroma/admin/config")

	assert json_response_and_validate_schema(conn, 400) ==
	%{
	"error" => "You must enable configurable_from_database in your config file."
	}
	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_and_validate_schema(conn, 200)

	assert key1 == inspect(config1.key)
	assert key2 == inspect(config2.key)
	end

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

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(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: [k1: :v1, k2: :v2]
	)

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

	assert length(configs) > 3

	saved_configs = [config1, config2, config3]
	keys = Enum.map(saved_configs, &inspect(&1.key))

	received_configs =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in keys
	end)

	assert length(received_configs) == 3

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

	keys = Enum.map(saved_configs -- [config3], &inspect(&1.key))

	values = Enum.map(saved_configs, &ConfigDB.to_json_types(&1.value))

	mapset_keys = MapSet.new(keys ++ db_keys)

	Enum.each(received_configs, fn %{"value" => value, "db" => db} ->
	db = MapSet.new(db)
	assert MapSet.subset?(db, mapset_keys)

	assert value in values
	end)
	end

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

	insert(:config,
	key: ":assets",
	value: [mascots: [a: 1, b: 2], key: [a: 1]]
	)

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

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

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

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

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

	test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	clear_config([:admin_token], "password123")

	build_conn()
	\|> get("/api/pleroma/admin/config?admin_token=password123")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "POST /api/pleroma/admin/config with configdb disabled", %{conn: conn} do
	clear_config(:configurable_from_database, false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => []})

	assert json_response_and_validate_schema(conn, 400) ==
	%{"error" => "You must enable configurable_from_database in your config file."}
	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)
	Restarter.Pleroma.refresh()
	end)
	end

	setup do: clear_config(:configurable_from_database, true)

	setup do:
	clear_config(:database_config_whitelist, [
	{:pleroma},
	{:http},
	{:idna},
	{:oban},
	{:tesla},
	{:ueberauth}
	])

	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 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/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_and_validate_schema(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"]
	}
	],
	"need_reboot" => false
	}

	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 configs setting without explicit key", %{conn: conn} do
	adapter = Application.get_env(:http, :adapter)
	send_user_agent = Application.get_env(:http, :send_user_agent)
	user_agent = Application.get_env(:http, :user_agent)

	on_exit(fn ->
	Application.put_env(:http, :adapter, adapter)
	Application.put_env(:http, :send_user_agent, send_user_agent)
	Application.put_env(:http, :user_agent, user_agent)
	end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":http",
	key: ":adapter",
	value: [":someval"]
	},
	%{
	group: ":http",
	key: ":send_user_agent",
	value: true
	},
	%{
	group: ":http",
	key: ":user_agent",
	value: [":default"]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":http",
	"key" => ":adapter",
	"value" => [":someval"],
	"db" => [":adapter"]
	},
	%{
	"group" => ":http",
	"key" => ":send_user_agent",
	"value" => true,
	"db" => [":send_user_agent"]
	},
	%{
	"group" => ":http",
	"key" => ":user_agent",
	"value" => [":default"],
	"db" => [":user_agent"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:http, :adapter) == [:someval]
	assert Application.get_env(:http, :send_user_agent) == true
	assert Application.get_env(:http, :user_agent) == [:default]
	end

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})

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

	test "saving config which need pleroma reboot", %{conn: conn} do
	clear_config([:shout, :enabled], true)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":shout", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":shout",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"]

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "update setting which need reboot, don't change reboot flag until reboot", %{conn: conn} do
	clear_config([:shout, :enabled], true)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":shout", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":shout",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key3"]
	}
	],
	"need_reboot" => true
	}

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":key1",
	value: [
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(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"]
	}
	],
	"need_reboot" => false
	}
	end

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

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

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

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":tesla", key: ":adapter", value: "Tesla.Adapter.Httpc"}
	]
	})

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

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

	config3 =
	insert(:config,
	group: :ueberauth,
	key: Ueberauth
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa1", value: "another_value"},
	%{group: ":pleroma", key: ":keyaa2", value: "another_value"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => "another_value",
	"db" => [":keyaa1"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":keyaa2",
	"value" => "another_value",
	"db" => [":keyaa2"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	assert Application.get_env(:pleroma, :keyaa2) == "another_value"
	assert Application.get_env(:ueberauth, Ueberauth) == config3.value

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa2", delete: true},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [],
	"need_reboot" => false
	}

	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
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/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"]}
	]
	}
	]
	})

	assert Config.get([Pleroma.Captcha.NotReal, :name]) == "Pleroma"

	assert json_response_and_validate_schema(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"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "tuples with more than two values", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/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",
	":sth",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Plug.Cowboy.Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(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",
	":sth",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Plug.Cowboy.Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	],
	"db" => [":http"]
	}
	],
	"need_reboot" => false
	}
	end

	test "settings with nesting map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/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_and_validate_schema(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"]
	}
	],
	"need_reboot" => false
	}
	end

	test "value as map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"}
	}
	]
	})

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

	test "queues key as atom", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/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_and_validate_schema(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"
	]
	}
	],
	"need_reboot" => false
	}
	end

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":keyaa1",
	subkeys: [":subkey1", ":subkey3"],
	delete: true
	}
	]
	})

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

	test "proxy tuple localhost", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple domain", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple ip", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "doesn't set keys not in the whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :key1},
	{:pleroma, :key2},
	{:pleroma, Pleroma.Captcha.NotReal},
	{:not_real}
	])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{group: ":pleroma", key: ":key2", value: "value2"},
	%{group: ":pleroma", key: ":key3", value: "value3"},
	%{group: ":pleroma", key: "Pleroma.Web.Endpoint.NotReal", value: "value4"},
	%{group: ":pleroma", key: "Pleroma.Captcha.NotReal", value: "value5"},
	%{group: ":not_real", key: ":anything", value: "value6"}
	]
	})

	assert Application.get_env(:pleroma, :key1) == "value1"
	assert Application.get_env(:pleroma, :key2) == "value2"
	assert Application.get_env(:pleroma, :key3) == nil
	assert Application.get_env(:pleroma, Pleroma.Web.Endpoint.NotReal) == nil
	assert Application.get_env(:pleroma, Pleroma.Captcha.NotReal) == "value5"
	assert Application.get_env(:not_real, :anything) == "value6"
	end

	test "doesn't allow updating the database_config_whitelist itself", %{conn: conn} do
	original_whitelist = Pleroma.Config.get(:database_config_whitelist)

	refute ConfigDB.get_by_group_and_key(:pleroma, :database_config_whitelist)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":database_config_whitelist",
	value: [%{"tuple" => [":pleroma", ":key1"]}]
	}
	]
	})

	%{"configs" => configs} = json_response_and_validate_schema(conn, 200)

	assert configs == []
	assert Pleroma.Config.get(:database_config_whitelist) == original_whitelist
	refute ConfigDB.get_by_group_and_key(:pleroma, :database_config_whitelist)
	end

	test "doesn't set keys in the blacklist", %{conn: conn} do
	- clear_config(:database_config_blacklist, [{:pleroma, :logger}, {:pleroma, :key2}, {:pleroma, Pleroma.Captcha.NotReal}, {:blacklisted_group}])
	+ clear_config(:database_config_blacklist, [
	+ {:pleroma, :logger},
	+ {:pleroma, :key2},
	+ {:pleroma, Pleroma.Captcha.NotReal},
	+ {:blacklisted_group}
	+ ])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":logger", value: "logconf"},
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{group: ":pleroma", key: ":key2", value: "value2"},
	%{group: ":not_real", key: ":anything", value: "value3"},
	%{group: ":blacklisted_group", key: ":anything", value: "value4"}
	]
	})

	assert Application.get_env(:pleroma, :logger) == nil
	assert Application.get_env(:pleroma, :key1) == "value1"
	assert Application.get_env(:pleroma, :key2) == nil
	assert Application.get_env(:pleroma, Pleroma.Captcha.NotReal) == nil
	assert Application.get_env(:blacklisted_group, :anything) == nil
	end

	test "doesn't allow updating the database_config_blacklist itself", %{conn: conn} do
	original_blacklist = Pleroma.Config.get(:database_config_blacklist)

	refute ConfigDB.get_by_group_and_key(:pleroma, :database_config_blacklist)

	%{"configs" => configs} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":database_config_blacklist",
	value: [%{"tuple" => [":pleroma", ":key1"]}]
	}
	]
	})
	\|> json_response_and_validate_schema(200)

	assert configs == []
	assert Pleroma.Config.get(:database_config_blacklist) == original_blacklist
	refute ConfigDB.get_by_group_and_key(:pleroma, :database_config_blacklist)
	end

	test "args for Pleroma.Upload.Filter.Mogrify with custom tuples", %{conn: conn} do
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	]
	}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	config = Config.get(Pleroma.Upload.Filter.Mogrify)
	assert {:args, ["auto-orient", "strip"]} in config

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	]
	}
	]
	})
	\|> json_response(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	config = Config.get(Pleroma.Upload.Filter.Mogrify)

	assert {:args, ["auto-orient", "strip", {"implode", "1"}, {"resize", "3840x1080>"}]} in config
	end

	test "enables the welcome messages", %{conn: conn} do
	clear_config([:welcome])

	params = %{
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => [
	%{
	"tuple" => [
	":direct_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":chat_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":email",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":sender", %{"tuple" => ["pleroma@dev.dev", "Pleroma"]}]},
	%{"tuple" => [":subject", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":html", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":text", "Welcome to <%= instance_name %>!"]}
	]
	]
	}
	]
	}

	refute Pleroma.User.WelcomeEmail.enabled?()
	refute Pleroma.User.WelcomeMessage.enabled?()
	refute Pleroma.User.WelcomeChatMessage.enabled?()

	res =
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200)

	assert Pleroma.User.WelcomeEmail.enabled?()
	assert Pleroma.User.WelcomeMessage.enabled?()
	assert Pleroma.User.WelcomeChatMessage.enabled?()

	assert res == %{
	"configs" => [
	%{
	"db" => [":direct_message", ":chat_message", ":email"],
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => params["value"]
	}
	],
	"need_reboot" => false
	}
	end

	test "custom instance thumbnail", %{conn: conn} do
	clear_config([:instance])

	params = %{
	"group" => ":pleroma",
	"key" => ":instance",
	"value" => [
	%{
	"tuple" => [
	":instance_thumbnail",
	"https://example.com/media/new_thumbnail.jpg"
	]
	}
	]
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200) ==
	%{
	"configs" => [
	%{
	"db" => [":instance_thumbnail"],
	"group" => ":pleroma",
	"key" => ":instance",
	"value" => params["value"]
	}
	],
	"need_reboot" => false
	}

	assert conn
	\|> get("/api/v1/instance")
	\|> json_response_and_validate_schema(200)
	\|> Map.take(["thumbnail"]) ==
	%{"thumbnail" => "https://example.com/media/new_thumbnail.jpg"}
	end

	test "Concurrent Limiter", %{conn: conn} do
	clear_config([ConcurrentLimiter])

	params = %{
	"group" => ":pleroma",
	"key" => "ConcurrentLimiter",
	"value" => [
	%{
	"tuple" => [
	"Pleroma.Web.RichMedia.Helpers",
	[
	%{"tuple" => [":max_running", 6]},
	%{"tuple" => [":max_waiting", 6]}
	]
	]
	},
	%{
	"tuple" => [
	"Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy",
	[
	%{"tuple" => [":max_running", 7]},
	%{"tuple" => [":max_waiting", 7]}
	]
	]
	}
	]
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "GET /api/pleroma/admin/config/descriptions" do
	test "structure", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	assert [child \| _others] = json_response_and_validate_schema(conn, 200)

	assert child["children"]
	assert child["key"]
	assert String.starts_with?(child["group"], ":")
	assert child["description"]
	end

	test "filters by database configuration whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :instance},
	{:pleroma, :activitypub},
	{:pleroma, Pleroma.Upload}
	])

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

	children = json_response_and_validate_schema(conn, 200)

	assert length(children) == 3

	assert Enum.count(children, fn c -> c["group"] == ":pleroma" end) == 3

	instance = Enum.find(children, fn c -> c["key"] == ":instance" end)
	assert instance["children"]

	activitypub = Enum.find(children, fn c -> c["key"] == ":activitypub" end)
	assert activitypub["children"]

	web_endpoint = Enum.find(children, fn c -> c["key"] == "Pleroma.Upload" end)
	assert web_endpoint["children"]
	end

	test "all keys from description are whitelisted", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	assert response = json_response_and_validate_schema(conn, 200)

	assert length(response) == length(Pleroma.Docs.JSON.compiled_descriptions())
	end

	test "filters by database configuration blacklist and whitelist", %{conn: conn} do
	- clear_config(:database_config_whitelist, [{:pleroma, :instance}, {:pleroma, :activitypub}, {:pleroma, Pleroma.Upload}])
	+ clear_config(:database_config_whitelist, [
	+ {:pleroma, :instance},
	+ {:pleroma, :activitypub},
	+ {:pleroma, Pleroma.Upload}
	+ ])
	+
	clear_config(:database_config_blacklist, [
	- {:pleroma, Pleroma.Upload},
	+ {:pleroma, Pleroma.Upload}
	])

	children =
	conn
	\|> get("/api/pleroma/admin/config/descriptions")
	\|> json_response_and_validate_schema(200)

	assert length(children) == 2

	assert Enum.count(children, fn c -> c["group"] == ":pleroma" end) == 2

	instance = Enum.find(children, fn c -> c["key"] == ":instance" end)
	assert instance["children"]

	activitypub = Enum.find(children, fn c -> c["key"] == ":activitypub" end)
	assert activitypub["children"]

	web_endpoint = Enum.find(children, fn c -> c["key"] == "Pleroma.Upload" end)
	refute web_endpoint["children"]
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Aug 28, 4:04 PM (58 m, 14 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1736504
Default Alt Text: (89 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions