No OneTemporary
Actions

Authored By

Unknown

Size

28 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 a389252ac..d160ce533 100644
	--- a/lib/mix/tasks/pleroma/config.ex
	+++ b/lib/mix/tasks/pleroma/config.ex
	@@ -1,547 +1,555 @@
	# 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_keys))
	+ \|> 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_keys) do
	- Enum.member?(blacklisted_keys, {group, key})
	+ 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/test/mix/tasks/pleroma/config_test.exs b/test/mix/tasks/pleroma/config_test.exs
	index 3ae6e7f16..b35e0aed8 100644
	--- a/test/mix/tasks/pleroma/config_test.exs
	+++ b/test/mix/tasks/pleroma/config_test.exs
	@@ -1,408 +1,410 @@
	# 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}
	+ {: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},
	] = 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

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 31, 12:22 AM (16 h, 39 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1800809
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions