No OneTemporary
Actions

Authored By

Unknown

Size

28 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/database-config-whitelist.add b/changelog.d/database-config-whitelist.add
	new file mode 100644
	index 000000000..a78960c98
	--- /dev/null
	+++ b/changelog.d/database-config-whitelist.add
	@@ -0,0 +1 @@
	+Add reasonable defaults for :database_config_whitelist
	\ No newline at end of file
	diff --git a/docs/administration/CLI_tasks/config.md b/docs/administration/CLI_tasks/config.md
	index 13d671a7e..35e02145e 100644
	--- a/docs/administration/CLI_tasks/config.md
	+++ b/docs/administration/CLI_tasks/config.md
	@@ -1,172 +1,186 @@
	# Transferring the config to/from the database

	{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	## Transfer config from file to DB.

	!!! note
	You need to add the following to your config before executing this command:

	```elixir
	config :pleroma, configurable_from_database: true
	```

	=== "OTP"

	```sh
	./bin/pleroma_ctl config migrate_to_db
	```

	=== "From Source"

	```sh
	mix pleroma.config migrate_to_db
	```

	## Transfer config from DB to `config/env.exported_from_db.secret.exs`

	!!! note
	In-Database configuration will still be applied after executing this command unless you set the following in your config:

	```elixir
	config :pleroma, configurable_from_database: false
	```

	Options:

	- `<path>` - where to save migrated config. E.g. `--path=/tmp`. If file saved into non-standard folder, you must manually copy file into directory where Pleroma can read it. For OTP install path will be `PLEROMA_CONFIG_PATH` or `/etc/pleroma`. For installation from source - `config` directory in the pleroma folder.
	- `<env>` - environment, for which is migrated config. By default is `prod`.
	- To delete transferred settings from database optional flag `-d` can be used

	=== "OTP"
	```sh
	./bin/pleroma_ctl config migrate_from_db [--env=<env>] [-d] [--path=<path>]
	```

	=== "From Source"
	```sh
	mix pleroma.config migrate_from_db [--env=<env>] [-d] [--path=<path>]
	```

	## Dump all of the config settings defined in the database

	=== "OTP"

	```sh
	./bin/pleroma_ctl config dump
	```

	=== "From Source"

	```sh
	mix pleroma.config dump
	```

	## List individual configuration groups in the database

	=== "OTP"

	```sh
	./bin/pleroma_ctl config groups
	```

	=== "From Source"

	```sh
	mix pleroma.config groups
	```

	## Dump the saved configuration values for a specific group or key

	e.g., this shows all the settings under `config :pleroma`

	=== "OTP"

	```sh
	./bin/pleroma_ctl config dump pleroma
	```

	=== "From Source"

	```sh
	mix pleroma.config dump pleroma
	```

	To get values under a specific key:

	e.g., this shows all the settings under `config :pleroma, :instance`

	=== "OTP"

	```sh
	./bin/pleroma_ctl config dump pleroma instance
	```

	=== "From Source"

	```sh
	mix pleroma.config dump pleroma instance
	```

	## Delete the saved configuration values for a specific group or key

	e.g., this deletes all the settings under `config :tesla`

	=== "OTP"

	```sh
	./bin/pleroma_ctl config delete [--force] tesla
	```

	=== "From Source"

	```sh
	mix pleroma.config delete [--force] tesla
	```

	To delete values under a specific key:

	e.g., this deletes all the settings under `config :phoenix, :stacktrace_depth`

	=== "OTP"

	```sh
	./bin/pleroma_ctl config delete [--force] phoenix stacktrace_depth
	```

	=== "From Source"

	```sh
	mix pleroma.config delete [--force] phoenix stacktrace_depth
	```

	## Remove all settings from the database

	This forcibly removes all saved values in the database.

	=== "OTP"

	```sh
	./bin/pleroma_ctl config [--force] reset
	```

	=== "From Source"

	```sh
	mix pleroma.config [--force] reset

	```

	## Remove invalid MRF modules from the database

	This forcibly removes any enabled MRF that does not exist and will fix the ability of the instance to start.

	=== "OTP"
	```sh
	./bin/pleroma_ctl config fix_mrf_policies
	```

	=== "From Source"
	```sh
	mix pleroma.config fix_mrf_policies
	- ```
	\ No newline at end of file
	+ ```
	+
	+## Remove non-whitelisted configs from the database
	+
	+This removes any configuration value that is not explicitly whitelisted by `:pleroma, :database_config_whitelist`. Might be useful after updating the whitelist.
	+
	+=== "OTP"
	+ ```sh
	+ ./bin/pleroma_ctl config filter_whitelisted
	+ ```
	+
	+=== "From Source"
	+ ```sh
	+ mix pleroma.config filter_whitelisted
	+ ```
	diff --git a/lib/mix/tasks/pleroma/config.ex b/lib/mix/tasks/pleroma/config.ex
	index 834b4fe14..fc6982ea8 100644
	--- a/lib/mix/tasks/pleroma/config.ex
	+++ b/lib/mix/tasks/pleroma/config.ex
	@@ -1,437 +1,493 @@
	# 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)
	+
	+ 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
	+
	@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
	end
	diff --git a/test/mix/tasks/pleroma/config_test.exs b/test/mix/tasks/pleroma/config_test.exs
	index 942cfa83d..3b1037f0a 100644
	--- a/test/mix/tasks/pleroma/config_test.exs
	+++ b/test/mix/tasks/pleroma/config_test.exs
	@@ -1,333 +1,351 @@
	# 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"],
	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
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 11:07 AM (9 h, 29 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802966
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions