config versioningfeature/config-versioning

- added DynamicSupervisor, which starts Pleroma deps and restarts config dependent deps
- added versioning for in database config. New version is created from
changes which are passed to config update/delete endpoint. Every version
contains backup with all changes added through update. Versioning
supports rollbacks with N steps. With a rollback, all versions that
come after the version on which the rollback was made are deleted.

14 files changed, 2066 insertions, 836 deletions

diff --git a/test/fixtures/config/temp.secret.exs b/test/fixtures/config/temp.secret.exs
index 4b3af39ec..077b99923 100644
--- a/test/fixtures/config/temp.secret.exs
+++ b/test/fixtures/config/temp.secret.exs
@@ -12,6 +12,28 @@ config :quack, level: :info
 
 config :pleroma, Pleroma.Repo, pool: Ecto.Adapters.SQL.Sandbox
 
-config :postgrex, :json_library, Poison
+config :pleroma, Pleroma.Web.Endpoint, key: :val
+
+config :pleroma, env: :test
 
 config :pleroma, :database, rum_enabled: true
+
+config :pleroma, configurable_from_database: false
+
+config :pleroma, ecto_repos: [Pleroma.Repo]
+
+config :pleroma, Pleroma.Gun, Pleroma.GunMock
+
+config :pleroma, Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.Client
+
+config :postgrex, :json_library, Poison
+
+config :tesla, adapter: Tesla.Mock
+
+config :tzdata, http_client: Pleroma.HTTP
+
+config :http_signatures, key: :val
+
+config :web_push_encryption, key: :val
+
+config :floki, key: :val
diff --git a/test/mix/tasks/pleroma/config_test.exs b/test/mix/tasks/pleroma/config_test.exs
index 3ed1e94b8..6fcef232c 100644
--- a/test/mix/tasks/pleroma/config_test.exs
+++ b/test/mix/tasks/pleroma/config_test.exs
@@ -29,24 +29,56 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
     |> Enum.sort()
   end
 
-  defp insert_config_record(group, key, value) do
+  defp insert_config_record(group \\ nil, key, value) do
     insert(:config,
-      group: group,
+      group: group || :pleroma,
       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")
+    MixTask.run([
+      "migrate_to_db",
+      "--config",
+      "config/not_existance_config_file.exs"
+    ])
 
     msg =
-      "To migrate settings, you must define custom settings in config/non_existent_config_file.exs."
+      "ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."
 
-    assert_receive {:mix_shell, :info, [^msg]}, 15
+    assert_receive {:mix_shell, :error, [^msg]}, 15
   end
 
-  describe "migrate_to_db/1" do
+  test "migrate_to_db error if configurable_from_database is not enabled" do
+    clear_config(:configurable_from_database, false)
+
+    MixTask.run([
+      "migrate_to_db",
+      "--config",
+      "test/fixtures/config/temp.secret.exs"
+    ])
+
+    assert_received {:mix_shell, :error, [message]}
+
+    assert message =~
+             "ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."
+  end
+
+  test "migrate_from_db error if configurable_from_database is not enabled" do
+    clear_config(:configurable_from_database, false)
+
+    MixTask.run([
+      "migrate_from_db"
+    ])
+
+    assert_received {:mix_shell, :error, [message]}
+
+    assert message =~
+             "ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."
+  end
+
+  describe "migrate_to_db task" do
     setup do
       clear_config(:configurable_from_database, true)
       clear_config([:quack, :level])
@@ -57,7 +89,11 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
       clear_config([:media_proxy, :whitelist], ["domain_without_scheme.com"])
       assert config_records() == []
 
-      MixTask.migrate_to_db("test/fixtures/config/temp.secret.exs")
+      MixTask.run([
+        "migrate_to_db",
+        "--config",
+        "test/fixtures/config/temp.secret.exs"
+      ])
 
       assert_received {:mix_shell, :error, [message]}
 
@@ -68,25 +104,45 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
     test "filtered settings are migrated to db" do
       assert config_records() == []
 
-      MixTask.migrate_to_db("test/fixtures/config/temp.secret.exs")
+      MixTask.run([
+        "migrate_to_db",
+        "--config",
+        "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"})
-      config3 = ConfigDB.get_by_params(%{group: ":quack", key: ":level"})
-      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"})
+      config1 = ConfigDB.get_by_params(%{group: :pleroma, key: :first_setting})
+      config2 = ConfigDB.get_by_params(%{group: :pleroma, key: :second_setting})
+      config3 = ConfigDB.get_by_params(%{group: :quack})
+      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"]]
-      assert config3.value == :info
+      assert config3.value == [level: :info]
+
+      assert Repo.aggregate(ConfigDB, :count) == 3
+
+      [version] = Repo.all(Pleroma.Config.Version)
+
+      assert version.backup == [
+               pleroma: [
+                 second_setting: [key: "value2", key2: ["Activity"]],
+                 first_setting: [key: "value", key2: [Pleroma.Repo]]
+               ],
+               quack: [level: :info]
+             ]
     end
 
     test "config table is truncated before migration" do
-      insert_config_record(:pleroma, :first_setting, key: "value", key2: ["Activity"])
+      insert_config_record(:first_setting, key: "value", key2: ["Activity"])
       assert length(config_records()) == 1
 
-      MixTask.migrate_to_db("test/fixtures/config/temp.secret.exs")
+      MixTask.run([
+        "migrate_to_db",
+        "--config",
+        "test/fixtures/config/temp.secret.exs"
+      ])
 
       config = ConfigDB.get_by_params(%{group: ":pleroma", key: ":first_setting"})
       assert config.value == [key: "value", key2: [Repo]]
@@ -106,9 +162,9 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
     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])
-      insert_config_record(:quack, :level, :info)
+      insert_config_record(:setting_first, key: "value", key2: ["Activity"])
+      insert_config_record(:setting_second, key: "value2", key2: [Repo])
+      insert_config_record(:quack, nil, level: :info)
 
       MixTask.run(["migrate_from_db", "--env", "temp", "-d"])
 
@@ -117,7 +173,20 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
       file = File.read!(temp_file)
       assert file =~ "config :pleroma, :setting_first,"
       assert file =~ "config :pleroma, :setting_second,"
-      assert file =~ "config :quack, :level, :info"
+      assert file =~ "config :quack, level: :info"
+    end
+
+    test "migrate_from_db with config path in env", %{temp_file: temp_file} do
+      clear_config(:release, true)
+      clear_config(:config_path, "config/temp.exported_from_db.secret.exs")
+
+      insert_config_record(:setting_first, key: "value", key2: ["Activity"])
+
+      MixTask.run(["migrate_from_db", "--env", "temp", "-d"])
+
+      assert Repo.all(ConfigDB) == []
+      file = File.read!(temp_file)
+      assert file =~ "config :pleroma, :setting_first,"
     end
 
     test "load a settings with large values and pass to file", %{temp_file: temp_file} do
@@ -206,7 +275,7 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
     setup do
       insert_config_record(:pleroma, :setting_first, key: "value", key2: ["Activity"])
       insert_config_record(:pleroma, :setting_second, key: "value2", key2: [Repo])
-      insert_config_record(:quack, :level, :info)
+      insert_config_record(:quack, nil, level: :info)
 
       path = "test/instance_static"
       file_path = Path.join(path, "temp.exported_from_db.secret.exs")
@@ -222,7 +291,7 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
       file = File.read!(file_path)
       assert file =~ "config :pleroma, :setting_first,"
       assert file =~ "config :pleroma, :setting_second,"
-      assert file =~ "config :quack, :level, :info"
+      assert file =~ "config :quack, level: :info"
     end
 
     test "release", %{file_path: file_path} do
@@ -234,7 +303,7 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
       file = File.read!(file_path)
       assert file =~ "config :pleroma, :setting_first,"
       assert file =~ "config :pleroma, :setting_second,"
-      assert file =~ "config :quack, :level, :info"
+      assert file =~ "config :quack, level: :info"
     end
   end
 
@@ -242,7 +311,7 @@ defmodule Mix.Tasks.Pleroma.ConfigTest 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(:instance, name: "Pleroma Test")
 
       insert_config_record(:web_push_encryption, :vapid_details,
         subject: "mailto:administrator@example.com",
@@ -272,8 +341,8 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
     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)
+      insert_config_record(:instance, name: "Pleroma Test")
+      insert_config_record(Pleroma.Captcha, enabled: false)
 
       MixTask.run(["dump", "pleroma", "Pleroma.Captcha"])
 
@@ -285,8 +354,8 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
     end
 
     test "dumps all configuration successfully" do
-      insert_config_record(:pleroma, :instance, name: "Pleroma Test")
-      insert_config_record(:pleroma, Pleroma.Captcha, enabled: false)
+      insert_config_record(:instance, name: "Pleroma Test")
+      insert_config_record(Pleroma.Captcha, enabled: false)
 
       MixTask.run(["dump"])
 
@@ -302,7 +371,7 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
     test "refuses to dump" do
       clear_config(:configurable_from_database, false)
 
-      insert_config_record(:pleroma, :instance, name: "Pleroma Test")
+      insert_config_record(:instance, name: "Pleroma Test")
 
       MixTask.run(["dump"])
 
@@ -317,8 +386,8 @@ defmodule Mix.Tasks.Pleroma.ConfigTest 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(:instance, name: "Pleroma Test")
+      insert_config_record(Pleroma.Captcha, enabled: false)
       insert_config_record(:pleroma2, :key2, z: 1)
 
       assert length(config_records()) == 3
@@ -347,4 +416,55 @@ defmodule Mix.Tasks.Pleroma.ConfigTest do
       assert config_records() == []
     end
   end
+
+  describe "rollback/1" do
+    setup do: clear_config(:configurable_from_database, true)
+
+    test "configuration from database is not configured" do
+      clear_config(:configurable_from_database, false)
+
+      MixTask.run(["rollback"])
+
+      assert_received {:mix_shell, :error, [message]}
+
+      assert message =~
+               "ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."
+    end
+
+    test "error" do
+      MixTask.run(["rollback"])
+
+      assert_receive {:mix_shell, :error,
+                      [
+                        "No version to rollback"
+                      ]},
+                     15
+    end
+
+    test "success rollback" do
+      insert(:config_version,
+        backup: [pleroma: [instance: [name: "First name", email: "email@example.com"]]]
+      )
+
+      insert(:config_version, current: true)
+
+      MixTask.run(["rollback"])
+
+      assert_received {:mix_shell, :info, ["Success rollback"]}
+
+      [config] = Repo.all(ConfigDB)
+
+      assert config.value == [name: "First name", email: "email@example.com"]
+    end
+
+    test "rollback not possible error" do
+      insert(:config_version, current: true)
+
+      MixTask.run(["rollback", "-s", "2"])
+
+      assert_received {:mix_shell, :error, [message]}
+
+      assert message =~ "Rollback not possible. Incorrect steps value."
+    end
+  end
 end
diff --git a/test/pleroma/application/config_dependent_deps_test.exs b/test/pleroma/application/config_dependent_deps_test.exs
new file mode 100644
index 000000000..620da16d9
--- /dev/null
+++ b/test/pleroma/application/config_dependent_deps_test.exs
@@ -0,0 +1,149 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Application.ConfigDependentDepsTest do
+  use ExUnit.Case
+
+  alias Pleroma.Application.ConfigDependentDeps
+
+  setup do
+    {:ok, _} =
+      DynamicSupervisor.start_link(
+        strategy: :one_for_one,
+        name: Pleroma.Application.DynamicSupervisorTest
+      )
+
+    {:ok, pid} =
+      Pleroma.Application.ConfigDependentDeps.start_link(
+        dynamic_supervisor: Pleroma.Application.DynamicSupervisorTest,
+        name: Pleroma.Application.ConfigDependentDepsTesting,
+        relations: [
+          {{:pleroma, :dummy_module1}, Pleroma.DummyModule1},
+          {{:pleroma, :dummy_module2}, Pleroma.DummyModule2},
+          {:dummy_group1, :dummy_group1},
+          {:ex_aws, :ex_aws},
+          {:not_started_app, :not_started_app}
+        ]
+      )
+
+    [pid: pid]
+  end
+
+  test "start_dependency/2", %{pid: pid} do
+    {:ok, pid} = ConfigDependentDeps.start_dependency(Pleroma.DummyModule1, pid)
+    assert Process.alive?(pid)
+  end
+
+  describe "need_reboot?/1" do
+    test "apps and paths", %{pid: pid} do
+      changes = [
+        %Pleroma.ConfigDB{group: :dummy_group1},
+        %Pleroma.ConfigDB{group: :pleroma, key: :dummy_module1}
+      ]
+
+      assert ConfigDependentDeps.save_config_paths_for_restart(changes, pid) == [
+               {:pleroma, :dummy_module1},
+               :dummy_group1
+             ]
+
+      assert ConfigDependentDeps.need_reboot?(pid)
+    end
+
+    test "app and path are not duplicated", %{pid: pid} do
+      changes = [
+        %Pleroma.ConfigDB{group: :dummy_group1},
+        %Pleroma.ConfigDB{group: :dummy_group1},
+        %Pleroma.ConfigDB{group: :pleroma, key: :dummy_module1},
+        %Pleroma.ConfigDB{group: :pleroma, key: :dummy_module1}
+      ]
+
+      assert ConfigDependentDeps.save_config_paths_for_restart(changes, pid) == [
+               {:pleroma, :dummy_module1},
+               :dummy_group1
+             ]
+
+      assert ConfigDependentDeps.need_reboot?(pid)
+    end
+  end
+
+  describe "restart_dependencies/1" do
+    test "started dependency", %{pid: pid} do
+      {:ok, dummy_pid} = ConfigDependentDeps.start_dependency(Pleroma.DummyModule1, pid)
+
+      changes = [
+        %Pleroma.ConfigDB{group: :ex_aws},
+        %Pleroma.ConfigDB{group: :pleroma, key: :dummy_module1}
+      ]
+
+      assert ConfigDependentDeps.save_config_paths_for_restart(changes, pid) == [
+               {:pleroma, :dummy_module1},
+               :ex_aws
+             ]
+
+      assert :ok == ConfigDependentDeps.restart_dependencies(pid)
+
+      restarted = Process.whereis(Pleroma.DummyModule1)
+
+      refute dummy_pid == restarted
+    end
+
+    test "not started process and app", %{pid: pid} do
+      changes = [
+        %Pleroma.ConfigDB{group: :pleroma, key: :dummy_module1},
+        %Pleroma.ConfigDB{group: :not_started_app}
+      ]
+
+      assert ConfigDependentDeps.save_config_paths_for_restart(changes, pid) == [
+               :not_started_app,
+               {:pleroma, :dummy_module1}
+             ]
+
+      assert :ok == ConfigDependentDeps.restart_dependencies(pid)
+
+      started = Process.whereis(Pleroma.DummyModule1)
+
+      assert Process.alive?(started)
+    end
+
+    test "ignored dependency", %{pid: pid} do
+      changes = [
+        %Pleroma.ConfigDB{group: :pleroma, key: :dummy_module2}
+      ]
+
+      assert ConfigDependentDeps.save_config_paths_for_restart(changes, pid) == [
+               {:pleroma, :dummy_module2}
+             ]
+
+      assert :ok == ConfigDependentDeps.restart_dependencies(pid)
+
+      refute Process.whereis(Pleroma.DummyModule2)
+    end
+  end
+
+  test "process goes down", %{pid: pid} do
+    {:ok, dummy_pid} = ConfigDependentDeps.start_dependency(Pleroma.DummyModule1, pid)
+
+    Process.exit(dummy_pid, :kill)
+
+    Process.sleep(10)
+    restarted = Process.whereis(Pleroma.DummyModule1)
+    refute restarted == dummy_pid
+  end
+end
+
+defmodule Pleroma.DummyModule1 do
+  use Agent
+
+  def start_link(_) do
+    Agent.start_link(fn -> nil end, name: __MODULE__)
+  end
+end
+
+defmodule Pleroma.DummyModule2 do
+  use Agent
+
+  def start_link(_) do
+    :ignore
+  end
+end
diff --git a/test/pleroma/application/environment_test.exs b/test/pleroma/application/environment_test.exs
new file mode 100644
index 000000000..2ad27ebd8
--- /dev/null
+++ b/test/pleroma/application/environment_test.exs
@@ -0,0 +1,248 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Application.EnvironmentTest do
+  use Pleroma.DataCase
+
+  import Pleroma.Factory
+
+  alias Pleroma.Application.Environment
+
+  setup do: clear_config(:configurable_from_database, true)
+
+  describe "load_from_db_and_update/0" do
+    test "transfer config values from db to env" do
+      refute Application.get_env(:pleroma, :test_key)
+      refute Application.get_env(:idna, :test_key)
+      refute Application.get_env(:quack, :test_key)
+      refute Application.get_env(:postgrex, :test_key)
+      initial = Application.get_env(:logger, :level)
+
+      insert(:config, key: :test_key, value: [live: 2, com: 3])
+      insert(:config, group: :idna, key: :test_key, value: [live: 15, com: 35])
+
+      insert(:config,
+        group: :quack,
+        key: nil,
+        value: [test_key: [key1: :test_value1, key2: :test_value2]]
+      )
+
+      insert(:config, group: :logger, key: nil, value: [level: :debug])
+
+      Environment.load_from_db_and_update()
+
+      assert Application.get_env(:pleroma, :test_key) == [live: 2, com: 3]
+      assert Application.get_env(:idna, :test_key) == [live: 15, com: 35]
+      assert Application.get_env(:quack, :test_key) == [key1: :test_value1, key2: :test_value2]
+      assert Application.get_env(:logger, :level) == :debug
+
+      on_exit(fn ->
+        Application.delete_env(:pleroma, :test_key)
+        Application.delete_env(:idna, :test_key)
+        Application.delete_env(:quack, :test_key)
+        Application.delete_env(:postgrex, :test_key)
+        Application.put_env(:logger, :level, initial)
+      end)
+    end
+
+    test "transfer config values for 1 group and some keys" do
+      quack_env = Application.get_all_env(:quack)
+
+      insert(:config, group: :quack, key: nil, value: [level: :info, meta: [:none]])
+
+      Environment.load_from_db_and_update()
+
+      assert Application.get_env(:quack, :level) == :info
+      assert Application.get_env(:quack, :meta) == [:none]
+      default = Pleroma.Config.Holder.default_config(:quack, :webhook_url)
+      assert Application.get_env(:quack, :webhook_url) == default
+
+      on_exit(fn ->
+        Application.put_all_env(quack: quack_env)
+      end)
+    end
+
+    test "transfer config values with full subkey update" do
+      clear_config(:emoji)
+      clear_config(:assets)
+
+      insert(:config, key: :emoji, value: [groups: [a: 1, b: 2]])
+      insert(:config, key: :assets, value: [mascots: [a: 1, b: 2]])
+
+      Environment.load_from_db_and_update()
+
+      emoji_env = Application.get_env(:pleroma, :emoji)
+      assert emoji_env[:groups] == [a: 1, b: 2]
+      assets_env = Application.get_env(:pleroma, :assets)
+      assert assets_env[:mascots] == [a: 1, b: 2]
+    end
+  end
+
+  describe "update/2 :ex_syslogger" do
+    setup do
+      initial = Application.get_env(:logger, :ex_syslogger)
+
+      config =
+        insert(:config,
+          group: :logger,
+          key: nil,
+          value: [
+            ex_syslogger: [
+              level: :warn,
+              ident: "pleroma",
+              format: "$metadata[$level] $message",
+              metadata: [:request_id, :key]
+            ]
+          ]
+        )
+
+      on_exit(fn -> Application.put_env(:logger, :ex_syslogger, initial) end)
+      [config: config, initial: initial]
+    end
+
+    test "changing", %{config: config} do
+      assert Environment.update([config]) == :ok
+
+      env = Application.get_env(:logger, :ex_syslogger)
+      assert env[:level] == :warn
+      assert env[:metadata] == [:request_id, :key]
+    end
+
+    test "deletion", %{config: config, initial: initial} do
+      assert Environment.update([config]) == :ok
+
+      {:ok, config} = Pleroma.ConfigDB.delete(config)
+      assert Environment.update([config]) == :ok
+
+      env = Application.get_env(:logger, :ex_syslogger)
+
+      assert env == initial
+    end
+  end
+
+  describe "update/2 :console" do
+    setup do
+      initial = Application.get_env(:logger, :console)
+
+      config =
+        insert(:config,
+          group: :logger,
+          key: nil,
+          value: [
+            console: [
+              level: :info,
+              format: "$time $metadata[$level]",
+              metadata: [:request_id, :key]
+            ]
+          ]
+        )
+
+      on_exit(fn -> Application.put_env(:logger, :console, initial) end)
+      [config: config, initial: initial]
+    end
+
+    test "change", %{config: config} do
+      assert Environment.update([config]) == :ok
+      env = Application.get_env(:logger, :console)
+      assert env[:level] == :info
+      assert env[:format] == "$time $metadata[$level]"
+      assert env[:metadata] == [:request_id, :key]
+    end
+
+    test "deletion", %{config: config, initial: initial} do
+      assert Environment.update([config]) == :ok
+      {:ok, config} = Pleroma.ConfigDB.delete(config)
+      assert Environment.update([config]) == :ok
+
+      env = Application.get_env(:logger, :console)
+      assert env == initial
+    end
+  end
+
+  describe "update/2 :backends" do
+    setup do
+      initial = Application.get_all_env(:logger)
+
+      config =
+        insert(:config, group: :logger, key: nil, value: [backends: [:console, :ex_syslogger]])
+
+      on_exit(fn -> Application.put_all_env(logger: initial) end)
+
+      [config: config, initial: initial]
+    end
+
+    test "change", %{config: config} do
+      assert Environment.update([config]) == :ok
+      env = Application.get_all_env(:logger)
+      assert env[:backends] == [:console, :ex_syslogger]
+    end
+
+    test "deletion", %{config: config, initial: initial} do
+      assert Environment.update([config]) == :ok
+      {:ok, config} = Pleroma.ConfigDB.delete(config)
+      assert Environment.update([config])
+
+      env = Application.get_all_env(:logger)
+      assert env == initial
+    end
+  end
+
+  describe "update/2 logger settings" do
+    setup do
+      initial = Application.get_all_env(:logger)
+
+      config =
+        insert(:config,
+          group: :logger,
+          key: nil,
+          value: [
+            console: [
+              level: :info,
+              format: "$time $metadata[$level]",
+              metadata: [:request_id, :key]
+            ],
+            ex_syslogger: [
+              level: :warn,
+              ident: "pleroma",
+              format: "$metadata[$level] $message",
+              metadata: [:request_id, :key]
+            ],
+            backends: [:console, :ex_syslogger]
+          ]
+        )
+
+      on_exit(fn -> Application.put_all_env(logger: initial) end)
+      [config: config]
+    end
+
+    test "change", %{config: config} do
+      assert Environment.update([config]) == :ok
+
+      env =
+        :logger
+        |> Application.get_all_env()
+        |> Keyword.take([:backends, :console, :ex_syslogger])
+
+      assert env[:console] == config.value[:console]
+      assert env[:ex_syslogger] == config.value[:ex_syslogger]
+      assert env[:backends] == config.value[:backends]
+    end
+  end
+
+  test "update/2 for change without key :cors_plug" do
+    config =
+      insert(:config,
+        group: :cors_plug,
+        key: nil,
+        value: [max_age: 300, methods: ["GET"]]
+      )
+
+    assert Environment.update([config]) == :ok
+
+    env = Application.get_all_env(:cors_plug)
+
+    assert env[:max_age] == 300
+    assert env[:methods] == ["GET"]
+  end
+end
diff --git a/test/pleroma/application_requirements_test.exs b/test/pleroma/application/requirements_test.exs
index a54c37968..c4ce045cc 100644
--- a/test/pleroma/application_requirements_test.exs
+++ b/test/pleroma/application/requirements_test.exs
@@ -2,24 +2,24 @@
 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 
-defmodule Pleroma.ApplicationRequirementsTest do
+defmodule Pleroma.Application.RequirementsTest do
   use Pleroma.DataCase
 
   import ExUnit.CaptureLog
   import Mock
 
-  alias Pleroma.ApplicationRequirements
-  alias Pleroma.Repo
+  alias Pleroma.Application.Requirements
+  alias Pleroma.Emails.Mailer
 
   describe "check_repo_pool_size!/1" do
     test "raises if the pool size is unexpected" do
       clear_config([Pleroma.Repo, :pool_size], 11)
       clear_config([:dangerzone, :override_repo_pool_size], false)
 
-      assert_raise Pleroma.ApplicationRequirements.VerifyError,
+      assert_raise Requirements.VerifyError,
                    "Repo.pool_size different than recommended value.",
                    fn ->
-                     capture_log(&Pleroma.ApplicationRequirements.verify!/0)
+                     capture_log(&Requirements.verify!/0)
                    end
     end
 
@@ -27,27 +27,27 @@ defmodule Pleroma.ApplicationRequirementsTest do
       clear_config([Pleroma.Repo, :pool_size], 11)
       clear_config([:dangerzone, :override_repo_pool_size], true)
 
-      assert Pleroma.ApplicationRequirements.verify!() == :ok
+      assert Requirements.verify!() == :ok
     end
   end
 
   describe "check_welcome_message_config!/1" do
     setup do: clear_config([:welcome])
-    setup do: clear_config([Pleroma.Emails.Mailer])
+    setup do: clear_config([Mailer])
 
     test "warns if welcome email enabled but mail disabled" do
       clear_config([:welcome, :email, :enabled], true)
-      clear_config([Pleroma.Emails.Mailer, :enabled], false)
+      clear_config([Mailer, :enabled], false)
 
       assert capture_log(fn ->
-               assert Pleroma.ApplicationRequirements.verify!() == :ok
+               assert Requirements.verify!() == :ok
              end) =~ "Welcome emails will NOT be sent"
     end
   end
 
   describe "check_confirmation_accounts!" do
     setup_with_mocks([
-      {Pleroma.ApplicationRequirements, [:passthrough],
+      {Requirements, [:passthrough],
        [
          check_migrations_applied!: fn _ -> :ok end
        ]}
@@ -59,30 +59,29 @@ defmodule Pleroma.ApplicationRequirementsTest do
 
     test "warns if account confirmation is required but mailer isn't enabled" do
       clear_config([:instance, :account_activation_required], true)
-      clear_config([Pleroma.Emails.Mailer, :enabled], false)
+      clear_config([Mailer, :enabled], false)
 
       assert capture_log(fn ->
-               assert Pleroma.ApplicationRequirements.verify!() == :ok
+               assert Requirements.verify!() == :ok
              end) =~ "Users will NOT be able to confirm their accounts"
     end
 
     test "doesn't do anything if account confirmation is disabled" do
       clear_config([:instance, :account_activation_required], false)
-      clear_config([Pleroma.Emails.Mailer, :enabled], false)
-      assert Pleroma.ApplicationRequirements.verify!() == :ok
+      clear_config([Mailer, :enabled], false)
+      assert Requirements.verify!() == :ok
     end
 
     test "doesn't do anything if account confirmation is required and mailer is enabled" do
       clear_config([:instance, :account_activation_required], true)
-      clear_config([Pleroma.Emails.Mailer, :enabled], true)
-      assert Pleroma.ApplicationRequirements.verify!() == :ok
+      clear_config([Mailer, :enabled], true)
+      assert Requirements.verify!() == :ok
     end
   end
 
   describe "check_rum!" do
     setup_with_mocks([
-      {Pleroma.ApplicationRequirements, [:passthrough],
-       [check_migrations_applied!: fn _ -> :ok end]}
+      {Requirements, [:passthrough], [check_migrations_applied!: fn _ -> :ok end]}
     ]) do
       :ok
     end
@@ -93,10 +92,10 @@ defmodule Pleroma.ApplicationRequirementsTest do
       clear_config([:database, :rum_enabled], true)
 
       with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
-        assert_raise ApplicationRequirements.VerifyError,
+        assert_raise Requirements.VerifyError,
                      "Unapplied RUM Migrations detected",
                      fn ->
-                       capture_log(&ApplicationRequirements.verify!/0)
+                       capture_log(&Requirements.verify!/0)
                      end
       end
     end
@@ -105,10 +104,10 @@ defmodule Pleroma.ApplicationRequirementsTest do
       clear_config([:database, :rum_enabled], false)
 
       with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
-        assert_raise ApplicationRequirements.VerifyError,
+        assert_raise Requirements.VerifyError,
                      "RUM Migrations detected",
                      fn ->
-                       capture_log(&ApplicationRequirements.verify!/0)
+                       capture_log(&Requirements.verify!/0)
                      end
       end
     end
@@ -117,7 +116,7 @@ defmodule Pleroma.ApplicationRequirementsTest do
       clear_config([:database, :rum_enabled], true)
 
       with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
-        assert ApplicationRequirements.verify!() == :ok
+        assert Requirements.verify!() == :ok
       end
     end
 
@@ -125,12 +124,12 @@ defmodule Pleroma.ApplicationRequirementsTest do
       clear_config([:database, :rum_enabled], false)
 
       with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
-        assert ApplicationRequirements.verify!() == :ok
+        assert Requirements.verify!() == :ok
       end
     end
   end
 
-  describe "check_migrations_applied!" do
+  describe "check_migrations_applied" do
     setup_with_mocks([
       {Ecto.Migrator, [],
        [
@@ -150,17 +149,17 @@ defmodule Pleroma.ApplicationRequirementsTest do
     setup do: clear_config([:i_am_aware_this_may_cause_data_loss, :disable_migration_check])
 
     test "raises if it detects unapplied migrations" do
-      assert_raise ApplicationRequirements.VerifyError,
+      assert_raise Requirements.VerifyError,
                    "Unapplied Migrations detected",
                    fn ->
-                     capture_log(&ApplicationRequirements.verify!/0)
+                     capture_log(&Requirements.verify!/0)
                    end
     end
 
     test "doesn't do anything if disabled" do
       clear_config([:i_am_aware_this_may_cause_data_loss, :disable_migration_check], true)
 
-      assert :ok == ApplicationRequirements.verify!()
+      assert :ok == Requirements.verify!()
     end
   end
 end
diff --git a/test/pleroma/config/converter_test.exs b/test/pleroma/config/converter_test.exs
new file mode 100644
index 000000000..a1ffab5be
--- /dev/null
+++ b/test/pleroma/config/converter_test.exs
@@ -0,0 +1,432 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Config.ConverterTest do
+  use ExUnit.Case, async: true
+
+  alias Pleroma.Config.Converter
+
+  describe "to_elixir_types/1" do
+    test "string" do
+      assert Converter.to_elixir_types("value as string") == "value as string"
+    end
+
+    test "boolean" do
+      assert Converter.to_elixir_types(false) == false
+    end
+
+    test "nil" do
+      assert Converter.to_elixir_types(nil) == nil
+    end
+
+    test "integer" do
+      assert Converter.to_elixir_types(150) == 150
+    end
+
+    test "atom" do
+      assert Converter.to_elixir_types(":atom") == :atom
+    end
+
+    test "ssl options" do
+      assert Converter.to_elixir_types([":tlsv1", ":tlsv1.1", ":tlsv1.2"]) == [
+               :tlsv1,
+               :"tlsv1.1",
+               :"tlsv1.2"
+             ]
+    end
+
+    test "pleroma module" do
+      assert Converter.to_elixir_types("Pleroma.Bookmark") == Pleroma.Bookmark
+    end
+
+    test "pleroma string" do
+      assert Converter.to_elixir_types("Pleroma") == "Pleroma"
+    end
+
+    test "phoenix module" do
+      assert Converter.to_elixir_types("Phoenix.Socket.V1.JSONSerializer") ==
+               Phoenix.Socket.V1.JSONSerializer
+    end
+
+    test "tesla module" do
+      assert Converter.to_elixir_types("Tesla.Adapter.Hackney") == Tesla.Adapter.Hackney
+    end
+
+    test "ExSyslogger module" do
+      assert Converter.to_elixir_types("ExSyslogger") == ExSyslogger
+    end
+
+    test "Quack.Logger module" do
+      assert Converter.to_elixir_types("Quack.Logger") == Quack.Logger
+    end
+
+    test "Swoosh.Adapters modules" do
+      assert Converter.to_elixir_types("Swoosh.Adapters.SMTP") == Swoosh.Adapters.SMTP
+      assert Converter.to_elixir_types("Swoosh.Adapters.AmazonSES") == Swoosh.Adapters.AmazonSES
+    end
+
+    test "sigil" do
+      assert Converter.to_elixir_types("~r[comp[lL][aA][iI][nN]er]") == ~r/comp[lL][aA][iI][nN]er/
+    end
+
+    test "link sigil" do
+      assert Converter.to_elixir_types("~r/https:\/\/example.com/") == ~r/https:\/\/example.com/
+    end
+
+    test "link sigil with um modifiers" do
+      assert Converter.to_elixir_types("~r/https:\/\/example.com/um") ==
+               ~r/https:\/\/example.com/um
+    end
+
+    test "link sigil with i modifier" do
+      assert Converter.to_elixir_types("~r/https:\/\/example.com/i") == ~r/https:\/\/example.com/i
+    end
+
+    test "link sigil with s modifier" do
+      assert Converter.to_elixir_types("~r/https:\/\/example.com/s") == ~r/https:\/\/example.com/s
+    end
+
+    test "raise if valid delimiter not found" do
+      assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
+        Converter.to_elixir_types("~r/https://[]{}<>\"'()|example.com/s")
+      end
+    end
+
+    test "2 child tuple" do
+      assert Converter.to_elixir_types(%{"tuple" => ["v1", ":v2"]}) == {"v1", :v2}
+    end
+
+    test "proxy tuple with localhost" do
+      assert Converter.to_elixir_types(%{
+               "tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
+             }) == {:proxy_url, {:socks5, :localhost, 1234}}
+    end
+
+    test "proxy tuple with domain" do
+      assert Converter.to_elixir_types(%{
+               "tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
+             }) == {:proxy_url, {:socks5, 'domain.com', 1234}}
+    end
+
+    test "proxy tuple with ip" do
+      assert Converter.to_elixir_types(%{
+               "tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
+             }) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
+    end
+
+    test "tuple with n childs" do
+      assert Converter.to_elixir_types(%{
+               "tuple" => [
+                 "v1",
+                 ":v2",
+                 "Pleroma.Bookmark",
+                 150,
+                 false,
+                 "Phoenix.Socket.V1.JSONSerializer"
+               ]
+             }) == {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
+    end
+
+    test "map with string key" do
+      assert Converter.to_elixir_types(%{"key" => "value"}) == %{"key" => "value"}
+    end
+
+    test "map with atom key" do
+      assert Converter.to_elixir_types(%{":key" => "value"}) == %{key: "value"}
+    end
+
+    test "list of strings" do
+      assert Converter.to_elixir_types(["v1", "v2", "v3"]) == ["v1", "v2", "v3"]
+    end
+
+    test "list of modules" do
+      assert Converter.to_elixir_types(["Pleroma.Repo", "Pleroma.Activity"]) == [
+               Pleroma.Repo,
+               Pleroma.Activity
+             ]
+    end
+
+    test "list of atoms" do
+      assert Converter.to_elixir_types([":v1", ":v2", ":v3"]) == [:v1, :v2, :v3]
+    end
+
+    test "list of mixed values" do
+      assert Converter.to_elixir_types([
+               "v1",
+               ":v2",
+               "Pleroma.Repo",
+               "Phoenix.Socket.V1.JSONSerializer",
+               15,
+               false
+             ]) == [
+               "v1",
+               :v2,
+               Pleroma.Repo,
+               Phoenix.Socket.V1.JSONSerializer,
+               15,
+               false
+             ]
+    end
+
+    test "simple keyword" do
+      assert Converter.to_elixir_types([%{"tuple" => [":key", "value"]}]) == [key: "value"]
+    end
+
+    test "keyword" do
+      assert Converter.to_elixir_types([
+               %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
+               %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
+               %{"tuple" => [":migration_lock", nil]},
+               %{"tuple" => [":key1", 150]},
+               %{"tuple" => [":key2", "string"]}
+             ]) == [
+               types: Pleroma.PostgresTypes,
+               telemetry_event: [Pleroma.Repo.Instrumenter],
+               migration_lock: nil,
+               key1: 150,
+               key2: "string"
+             ]
+    end
+
+    test "trandformed keyword" do
+      assert Converter.to_elixir_types(a: 1, b: 2, c: "string") == [a: 1, b: 2, c: "string"]
+    end
+
+    test "complex keyword with nested mixed childs" do
+      assert Converter.to_elixir_types([
+               %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
+               %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
+               %{"tuple" => [":link_name", true]},
+               %{"tuple" => [":proxy_remote", false]},
+               %{"tuple" => [":common_map", %{":key" => "value"}]},
+               %{
+                 "tuple" => [
+                   ":proxy_opts",
+                   [
+                     %{"tuple" => [":redirect_on_failure", false]},
+                     %{"tuple" => [":max_body_length", 1_048_576]},
+                     %{
+                       "tuple" => [
+                         ":http",
+                         [
+                           %{"tuple" => [":follow_redirect", true]},
+                           %{"tuple" => [":pool", ":upload"]}
+                         ]
+                       ]
+                     }
+                   ]
+                 ]
+               }
+             ]) == [
+               uploader: Pleroma.Uploaders.Local,
+               filters: [Pleroma.Upload.Filter.Dedupe],
+               link_name: true,
+               proxy_remote: false,
+               common_map: %{key: "value"},
+               proxy_opts: [
+                 redirect_on_failure: false,
+                 max_body_length: 1_048_576,
+                 http: [
+                   follow_redirect: true,
+                   pool: :upload
+                 ]
+               ]
+             ]
+    end
+
+    test "common keyword" do
+      assert Converter.to_elixir_types([
+               %{"tuple" => [":level", ":warn"]},
+               %{"tuple" => [":meta", [":all"]]},
+               %{"tuple" => [":path", ""]},
+               %{"tuple" => [":val", nil]},
+               %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
+             ]) == [
+               level: :warn,
+               meta: [:all],
+               path: "",
+               val: nil,
+               webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
+             ]
+    end
+
+    test "complex keyword with sigil" do
+      assert Converter.to_elixir_types([
+               %{"tuple" => [":federated_timeline_removal", []]},
+               %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
+               %{"tuple" => [":replace", []]}
+             ]) == [
+               federated_timeline_removal: [],
+               reject: [~r/comp[lL][aA][iI][nN]er/],
+               replace: []
+             ]
+    end
+
+    test "complex keyword with tuples with more than 2 values" do
+      assert Converter.to_elixir_types([
+               %{
+                 "tuple" => [
+                   ":http",
+                   [
+                     %{
+                       "tuple" => [
+                         ":key1",
+                         [
+                           %{
+                             "tuple" => [
+                               ":_",
+                               [
+                                 %{
+                                   "tuple" => [
+                                     "/api/v1/streaming",
+                                     "Pleroma.Web.MastodonAPI.WebsocketHandler",
+                                     []
+                                   ]
+                                 },
+                                 %{
+                                   "tuple" => [
+                                     "/websocket",
+                                     "Phoenix.Endpoint.CowboyWebSocket",
+                                     %{
+                                       "tuple" => [
+                                         "Phoenix.Transports.WebSocket",
+                                         %{
+                                           "tuple" => [
+                                             "Pleroma.Web.Endpoint",
+                                             "Pleroma.Web.UserSocket",
+                                             []
+                                           ]
+                                         }
+                                       ]
+                                     }
+                                   ]
+                                 },
+                                 %{
+                                   "tuple" => [
+                                     ":_",
+                                     "Phoenix.Endpoint.Cowboy2Handler",
+                                     %{"tuple" => ["Pleroma.Web.Endpoint", []]}
+                                   ]
+                                 }
+                               ]
+                             ]
+                           }
+                         ]
+                       ]
+                     }
+                   ]
+                 ]
+               }
+             ]) == [
+               http: [
+                 key1: [
+                   {:_,
+                    [
+                      {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
+                      {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
+                       {Phoenix.Transports.WebSocket,
+                        {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
+                      {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
+                    ]}
+                 ]
+               ]
+             ]
+    end
+  end
+
+  describe "to_json_types" do
+    test "list" do
+      assert Converter.to_json_types(["0", 1, true, :atom, Pleroma.Upload]) == [
+               "0",
+               1,
+               true,
+               ":atom",
+               "Pleroma.Upload"
+             ]
+    end
+
+    test "regex" do
+      assert Converter.to_json_types(~r/regex/i) == "~r/regex/i"
+    end
+
+    test "map" do
+      assert Converter.to_json_types(%{"a" => "b", "c" => 1, "d" => true, "e" => :atom}) == %{
+               "a" => "b",
+               "c" => 1,
+               "d" => true,
+               "e" => ":atom"
+             }
+    end
+
+    test ":args list" do
+      assert Converter.to_json_types({:args, [{1, "a"}, "string"]}) == %{
+               "tuple" => [":args", ["{1, \"a\"}", "string"]]
+             }
+    end
+
+    test ":proxy_url tuple with localhost" do
+      assert Converter.to_json_types({:proxy_url, {:socks, :localhost, 1234}}) == %{
+               "tuple" => [":proxy_url", %{"tuple" => [":socks", "localhost", 1234]}]
+             }
+    end
+
+    test ":proxy_url tuple" do
+      assert Converter.to_json_types({:proxy_url, {:socks, {127, 0, 0, 1}, 1234}}) == %{
+               "tuple" => [":proxy_url", %{"tuple" => [":socks", "127.0.0.1", 1234]}]
+             }
+    end
+
+    test ":proxy_url tuple domain" do
+      assert Converter.to_json_types({:proxy_url, {:socks5, "domain.com", 1234}}) == %{
+               "tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
+             }
+    end
+
+    test "tuple" do
+      assert Converter.to_json_types({1, "a"}) == %{"tuple" => [1, "a"]}
+    end
+
+    test "string" do
+      assert Converter.to_json_types("string") == "string"
+    end
+
+    test "boolean" do
+      assert Converter.to_json_types(true) == true
+    end
+
+    test "integer" do
+      assert Converter.to_json_types(123) == 123
+    end
+
+    test "nil" do
+      assert Converter.to_json_types(nil) == nil
+    end
+
+    test "ssl type" do
+      assert Converter.to_json_types(:"tlsv1.1") == ":tlsv1.1"
+    end
+
+    test "atom" do
+      assert Converter.to_json_types(:atom) == ":atom"
+    end
+  end
+
+  describe "string_to_elixir_types!/1" do
+    test "atom" do
+      assert Converter.string_to_elixir_types!(":localhost") == :localhost
+    end
+
+    test "module" do
+      assert Converter.string_to_elixir_types!("Pleroma.Upload") == Pleroma.Upload
+    end
+
+    test "regex" do
+      assert Converter.string_to_elixir_types!("~r/regex/i") == ~r/regex/i
+    end
+
+    test "string" do
+      assert Converter.string_to_elixir_types!("string") == "string"
+    end
+  end
+end
diff --git a/test/pleroma/config/loader_test.exs b/test/pleroma/config/loader_test.exs
index b34fd70da..5eb29946d 100644
--- a/test/pleroma/config/loader_test.exs
+++ b/test/pleroma/config/loader_test.exs
@@ -8,22 +8,38 @@ defmodule Pleroma.Config.LoaderTest do
   alias Pleroma.Config.Loader
 
   test "read/1" do
-    config = Loader.read("test/fixtures/config/temp.secret.exs")
+    config = Loader.read!("test/fixtures/config/temp.secret.exs")
     assert config[:pleroma][:first_setting][:key] == "value"
     assert config[:pleroma][:first_setting][:key2] == [Pleroma.Repo]
     assert config[:quack][:level] == :info
   end
 
-  test "filter_group/2" do
-    assert Loader.filter_group(:pleroma,
-             pleroma: [
-               {Pleroma.Repo, [a: 1, b: 2]},
-               {Pleroma.Upload, [a: 1, b: 2]},
-               {Pleroma.Web.Endpoint, []},
-               env: :test,
-               configurable_from_database: true,
-               database: []
-             ]
-           ) == [{Pleroma.Upload, [a: 1, b: 2]}]
+  test "filter/1" do
+    config = Loader.read!("test/fixtures/config/temp.secret.exs")
+
+    filtered_config = Loader.filter(config)
+
+    refute filtered_config[:postgrex]
+    refute filtered_config[:tesla]
+    refute filtered_config[:phoenix]
+    refute filtered_config[:tz_data]
+    refute filtered_config[:http_signatures]
+    refute filtered_config[:web_push_encryption]
+    refute filtered_config[:floki]
+
+    refute filtered_config[:pleroma][Pleroma.Repo]
+    refute filtered_config[:pleroma][Pleroma.Web.Endpoint]
+    refute filtered_config[:pleroma][:env]
+    refute filtered_config[:pleroma][:configurable_from_database]
+    refute filtered_config[:pleroma][:database]
+    refute filtered_config[:pleroma][:ecto_repos]
+    refute filtered_config[:pleroma][Pleroma.Gun]
+    refute filtered_config[:pleroma][Pleroma.ReverseProxy.Client]
+
+    assert config[:pleroma][:first_setting][:key] == "value"
+    assert config[:pleroma][:first_setting][:key2] == [Pleroma.Repo]
+    assert config[:quack][:level] == :info
+    assert config[:pleroma][:second_setting][:key] == "value2"
+    assert config[:pleroma][:second_setting][:key2] == ["Activity"]
   end
 end
diff --git a/test/pleroma/config/transfer_task_test.exs b/test/pleroma/config/transfer_task_test.exs
deleted file mode 100644
index 8ae5d3b81..000000000
--- a/test/pleroma/config/transfer_task_test.exs
+++ /dev/null
@@ -1,120 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Config.TransferTaskTest do
-  use Pleroma.DataCase
-
-  import ExUnit.CaptureLog
-  import Pleroma.Factory
-
-  alias Pleroma.Config.TransferTask
-
-  setup do: clear_config(:configurable_from_database, true)
-
-  test "transfer config values from db to env" do
-    refute Application.get_env(:pleroma, :test_key)
-    refute Application.get_env(:idna, :test_key)
-    refute Application.get_env(:quack, :test_key)
-    refute Application.get_env(:postgrex, :test_key)
-    initial = Application.get_env(:logger, :level)
-
-    insert(:config, key: :test_key, value: [live: 2, com: 3])
-    insert(:config, group: :idna, key: :test_key, value: [live: 15, com: 35])
-    insert(:config, group: :quack, key: :test_key, value: [:test_value1, :test_value2])
-    insert(:config, group: :postgrex, key: :test_key, value: :value)
-    insert(:config, group: :logger, key: :level, value: :debug)
-
-    TransferTask.start_link([])
-
-    assert Application.get_env(:pleroma, :test_key) == [live: 2, com: 3]
-    assert Application.get_env(:idna, :test_key) == [live: 15, com: 35]
-    assert Application.get_env(:quack, :test_key) == [:test_value1, :test_value2]
-    assert Application.get_env(:logger, :level) == :debug
-    assert Application.get_env(:postgrex, :test_key) == :value
-
-    on_exit(fn ->
-      Application.delete_env(:pleroma, :test_key)
-      Application.delete_env(:idna, :test_key)
-      Application.delete_env(:quack, :test_key)
-      Application.delete_env(:postgrex, :test_key)
-      Application.put_env(:logger, :level, initial)
-    end)
-  end
-
-  test "transfer config values for 1 group and some keys" do
-    level = Application.get_env(:quack, :level)
-    meta = Application.get_env(:quack, :meta)
-
-    insert(:config, group: :quack, key: :level, value: :info)
-    insert(:config, group: :quack, key: :meta, value: [:none])
-
-    TransferTask.start_link([])
-
-    assert Application.get_env(:quack, :level) == :info
-    assert Application.get_env(:quack, :meta) == [:none]
-    default = Pleroma.Config.Holder.default_config(:quack, :webhook_url)
-    assert Application.get_env(:quack, :webhook_url) == default
-
-    on_exit(fn ->
-      Application.put_env(:quack, :level, level)
-      Application.put_env(:quack, :meta, meta)
-    end)
-  end
-
-  test "transfer config values with full subkey update" do
-    clear_config(:emoji)
-    clear_config(:assets)
-
-    insert(:config, key: :emoji, value: [groups: [a: 1, b: 2]])
-    insert(:config, key: :assets, value: [mascots: [a: 1, b: 2]])
-
-    TransferTask.start_link([])
-
-    emoji_env = Application.get_env(:pleroma, :emoji)
-    assert emoji_env[:groups] == [a: 1, b: 2]
-    assets_env = Application.get_env(:pleroma, :assets)
-    assert assets_env[:mascots] == [a: 1, b: 2]
-  end
-
-  describe "pleroma restart" do
-    setup do
-      on_exit(fn -> Restarter.Pleroma.refresh() end)
-    end
-
-    test "don't restart if no reboot time settings were changed" do
-      clear_config(:emoji)
-      insert(:config, key: :emoji, value: [groups: [a: 1, b: 2]])
-
-      refute String.contains?(
-               capture_log(fn -> TransferTask.start_link([]) end),
-               "pleroma restarted"
-             )
-    end
-
-    test "on reboot time key" do
-      clear_config(:chat)
-      insert(:config, key: :chat, value: [enabled: false])
-      assert capture_log(fn -> TransferTask.start_link([]) end) =~ "pleroma restarted"
-    end
-
-    test "on reboot time subkey" do
-      clear_config(Pleroma.Captcha)
-      insert(:config, key: Pleroma.Captcha, value: [seconds_valid: 60])
-      assert capture_log(fn -> TransferTask.start_link([]) end) =~ "pleroma restarted"
-    end
-
-    test "don't restart pleroma on reboot time key and subkey if there is false flag" do
-      clear_config(:chat)
-      clear_config(Pleroma.Captcha)
-
-      insert(:config, key: :chat, value: [enabled: false])
-      insert(:config, key: Pleroma.Captcha, value: [seconds_valid: 60])
-
-      refute String.contains?(
-               capture_log(fn -> TransferTask.load_and_update_env([], false) end),
-               "pleroma restarted"
-             )
-    end
-  end
-end
diff --git a/test/pleroma/config/versioning_test.exs b/test/pleroma/config/versioning_test.exs
new file mode 100644
index 000000000..783952e98
--- /dev/null
+++ b/test/pleroma/config/versioning_test.exs
@@ -0,0 +1,414 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Config.VersioningTest do
+  use Pleroma.DataCase, async: true
+
+  import Pleroma.Factory
+
+  alias Pleroma.Config.Version
+  alias Pleroma.Config.Versioning
+  alias Pleroma.ConfigDB
+  alias Pleroma.Repo
+
+  @with_key %{
+    group: :pleroma,
+    key: :instance,
+    value: [name: "Instance name"]
+  }
+
+  @without_key %{
+    group: :quack,
+    key: nil,
+    value: [
+      level: :warn,
+      meta: [:all],
+      webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
+    ]
+  }
+
+  @value_not_keyword %{
+    group: :pleroma,
+    key: Pleroma.Web.Auth.Authenticator,
+    value: Pleroma.Web.Auth.PleromaAuthenticator
+  }
+
+  describe "new_version/1" do
+    test "creates version" do
+      changes = [@with_key, @without_key, @value_not_keyword]
+
+      {:ok,
+       %{
+         :insert_version => version,
+         :update_all_versions => {0, nil},
+         {:insert_or_update, :pleroma, :instance} => _,
+         {:insert_or_update, :quack, nil} => _
+       }} = Versioning.new_version(changes)
+
+      assert version.current
+      assert backup_length(version) == 2
+
+      assert version.backup[:quack] == @without_key[:value]
+
+      assert version.backup[:pleroma][:instance] == @with_key[:value]
+
+      assert version.backup[:pleroma][Pleroma.Web.Auth.Authenticator] ==
+               @value_not_keyword[:value]
+
+      assert Repo.aggregate(ConfigDB, :count) == 3
+      assert Repo.aggregate(Version, :count) == 1
+    end
+
+    test "creates several versions" do
+      change1 = [@with_key]
+
+      {:ok,
+       %{
+         :insert_version => version1,
+         :update_all_versions => {0, nil},
+         {:insert_or_update, :pleroma, :instance} => _
+       }} = Versioning.new_version(change1)
+
+      change2 = [@without_key]
+
+      {:ok,
+       %{
+         :insert_version => version2,
+         :update_all_versions => {1, nil},
+         {:insert_or_update, :quack, nil} => _
+       }} = Versioning.new_version(change2)
+
+      version1 = refresh_record(version1)
+      refute version1.current
+
+      assert backup_length(version1) == 1
+
+      version2 = refresh_record(version2)
+      assert version2.current
+
+      assert backup_length(version2) == 2
+    end
+
+    test "error on empty list" do
+      assert Versioning.new_version([]) == {:error, :empty_changes}
+    end
+
+    test "error on bad format" do
+      assert Versioning.new_version(nil) == {:error, :bad_format}
+    end
+
+    test "process changes as single map" do
+      {:ok,
+       %{
+         :insert_version => _,
+         :update_all_versions => {0, nil},
+         {:insert_or_update, :pleroma, :instance} => _
+       }} = Versioning.new_version(@with_key)
+
+      assert Repo.aggregate(ConfigDB, :count) == 1
+    end
+
+    test "error if value is not keyword" do
+      assert Versioning.new_version([
+               %{group: :pleroma, key: :key, value: %{}}
+             ]) ==
+               {:error, {:error, :pleroma, :key},
+                {:value_must_be_keyword, %{group: :pleroma, key: :key, value: %{}}}, %{}}
+    end
+
+    test "error if value is list" do
+      assert Versioning.new_version([
+               %{group: :pleroma, key: :key, value: [1]}
+             ]) ==
+               {:error, {:error, :pleroma, :key},
+                {:value_must_be_keyword, %{group: :pleroma, key: :key, value: [1]}}, %{}}
+    end
+  end
+
+  describe "rollback/1" do
+    test "bad steps format" do
+      assert Versioning.rollback(nil) == {:error, :steps_format}
+    end
+
+    test "no versions" do
+      assert Versioning.rollback() == {:error, :no_current_version}
+    end
+
+    test "rollback not possible, because there is only one version" do
+      {:ok, _} = Versioning.new_version(@with_key)
+
+      assert Versioning.rollback() == {:error, :rollback_not_possible}
+    end
+
+    test "rollbacks to previous version" do
+      {:ok, _} = Versioning.new_version(@with_key)
+
+      {:ok, _} = Versioning.new_version(@value_not_keyword)
+
+      {:ok, _} = Versioning.new_version(@without_key)
+
+      {:ok, _} = Versioning.rollback()
+
+      configs = ConfigDB.all()
+
+      Enum.each(configs, fn
+        %{key: :instance} = config ->
+          config.value == @with_key[:value]
+
+        %{key: Pleroma.Web.Auth.Authenticator} = config ->
+          config.value == @value_not_keyword[:value]
+      end)
+
+      assert Repo.aggregate(Version, :count) == 2
+
+      version = Repo.get_by(Version, current: true)
+
+      assert version.backup[:pleroma][:instance] == @with_key[:value]
+
+      assert version.backup[:pleroma][Pleroma.Web.Auth.Authenticator] ==
+               @value_not_keyword[:value]
+    end
+
+    test "rollbacks with 2 steps" do
+      {:ok, _} = Versioning.new_version(@with_key)
+
+      {:ok, _} = Versioning.new_version(@without_key)
+
+      {:ok, _} =
+        Versioning.new_version(%{
+          group: :pleroma,
+          key: :instance,
+          value: [name: "New name"]
+        })
+
+      assert Repo.aggregate(ConfigDB, :count) == 2
+      assert Repo.aggregate(Version, :count) == 3
+      {:ok, _} = Versioning.rollback(2)
+
+      assert Repo.aggregate(Version, :count) == 1
+
+      [with_key] = ConfigDB.all()
+
+      assert with_key.value == @with_key[:value]
+    end
+
+    test "rollbacks with 2 steps and creates new version for new change" do
+      {:ok, _} = Versioning.new_version(@with_key)
+
+      {:ok, _} = Versioning.new_version(@without_key)
+
+      {:ok, _} =
+        Versioning.new_version(%{
+          group: :pleroma,
+          key: :instance,
+          value: [name: "New name"]
+        })
+
+      {:ok, _} = Versioning.rollback(2)
+
+      {:ok, _} =
+        Versioning.new_version(%{
+          group: :pleroma,
+          key: :instance,
+          value: [name: "Last name"]
+        })
+
+      [with_key] = ConfigDB.all()
+      assert with_key.value == [name: "Last name"]
+    end
+
+    test "properly rollbacks with settings without keys" do
+      {:ok, _} = Versioning.new_version(@with_key)
+
+      {:ok, _} = Versioning.new_version(@without_key)
+
+      {:ok, _} =
+        Versioning.new_version(%{
+          group: :pleroma,
+          key: :instance,
+          value: [name: "New name"]
+        })
+
+      {:ok, _} = Versioning.rollback()
+
+      config = ConfigDB.get_by_params(%{group: :quack})
+      assert config.value == @without_key[:value]
+    end
+
+    test "properly rollbacks with logger settings" do
+      {:ok, _} = Versioning.new_version(@with_key)
+
+      {:ok, _} =
+        Versioning.new_version([
+          %{
+            group: :logger,
+            value: [
+              console: [
+                level: :debug,
+                format: "\n$time $metadata[$level] $message\n",
+                metadata: [:request_id]
+              ],
+              backends: [:console]
+            ]
+          }
+        ])
+
+      {:ok, _} = Versioning.new_version(@without_key)
+
+      {:ok, _} = Versioning.rollback()
+
+      logger = ConfigDB.get_by_params(%{group: :logger})
+
+      assert logger.value == [
+               console: [
+                 level: :debug,
+                 format: "\n$time $metadata[$level] $message\n",
+                 metadata: [:request_id]
+               ],
+               backends: [:console]
+             ]
+    end
+  end
+
+  describe "migrate/1" do
+    test "migrates settings from config file" do
+      {:ok, _} = Versioning.migrate("test/fixtures/config/temp.secret.exs")
+
+      assert Repo.aggregate(ConfigDB, :count) == 3
+
+      config1 = ConfigDB.get_by_params(%{group: :pleroma, key: :first_setting})
+      config2 = ConfigDB.get_by_params(%{group: :pleroma, key: :second_setting})
+      config3 = ConfigDB.get_by_params(%{group: :quack})
+
+      assert config1.value == [key: "value", key2: [Repo]]
+      assert config2.value == [key: "value2", key2: ["Activity"]]
+      assert config3.value == [level: :info]
+
+      [version] = Repo.all(Version)
+
+      assert version.backup == [
+               pleroma: [
+                 second_setting: [key: "value2", key2: ["Activity"]],
+                 first_setting: [key: "value", key2: [Repo]]
+               ],
+               quack: [level: :info]
+             ]
+    end
+
+    test "truncates table on migration" do
+      insert_list(4, :config)
+
+      assert Repo.aggregate(ConfigDB, :count) == 4
+
+      {:ok, _} = Versioning.migrate("test/fixtures/config/temp.secret.exs")
+
+      assert Repo.aggregate(ConfigDB, :count) == 3
+    end
+  end
+
+  describe "migrate_namespace/2" do
+    test "common namespace rename" do
+      value_before_migration = [name: "Name"]
+
+      {:ok, %{:insert_version => version1}} =
+        Versioning.new_version(%{
+          group: :pleroma,
+          key: :key1,
+          value: value_before_migration
+        })
+
+      {:ok, %{:insert_version => version2}} =
+        Versioning.new_version(%{
+          group: :pleroma,
+          key: :key2,
+          value: [name: "Name"]
+        })
+
+      {:ok, %{:insert_version => version3}} =
+        Versioning.new_version(%{
+          group: :pleroma,
+          key: :key3,
+          value: [name: "Name"]
+        })
+
+      {:ok, _} = Versioning.migrate_namespace({:pleroma, :key1}, {:ex_aws, :new_key})
+
+      version1 = refresh_record(version1)
+      assert version1.backup == [ex_aws: [new_key: [name: "Name"]]]
+      version2 = refresh_record(version2)
+
+      assert version2.backup == [
+               ex_aws: [new_key: [name: "Name"]],
+               pleroma: [key2: [name: "Name"]]
+             ]
+
+      version3 = refresh_record(version3)
+
+      assert version3.backup == [
+               ex_aws: [new_key: [name: "Name"]],
+               pleroma: [key2: [name: "Name"], key3: [name: "Name"]]
+             ]
+
+      assert Repo.aggregate(from(c in ConfigDB, where: c.group == ^:pleroma), :count, :id) == 2
+      config = ConfigDB.get_by_params(%{group: :ex_aws, key: :new_key})
+      assert config.value == value_before_migration
+
+      {:ok, _} = Versioning.migrate_namespace({:pleroma, :key2}, {:pleroma, :new_key})
+
+      version1 = refresh_record(version1)
+      assert version1.backup == [ex_aws: [new_key: [name: "Name"]]]
+      version2 = refresh_record(version2)
+
+      assert version2.backup == [
+               pleroma: [new_key: [name: "Name"]],
+               ex_aws: [new_key: [name: "Name"]]
+             ]
+
+      version3 = refresh_record(version3)
+
+      assert version3.backup == [
+               ex_aws: [new_key: [name: "Name"]],
+               pleroma: [new_key: [name: "Name"], key3: [name: "Name"]]
+             ]
+    end
+
+    test "old namespace exists in old backups" do
+      {:ok, %{:insert_version => version1}} =
+        Versioning.new_version(%{
+          group: :pleroma,
+          key: :key1,
+          value: [name: "Name"]
+        })
+
+      {:ok, %{:insert_version => version2}} =
+        Versioning.new_version([
+          %{
+            group: :pleroma,
+            key: :key2,
+            value: [name: "Name"]
+          },
+          %{group: :pleroma, key: :key1, delete: true}
+        ])
+
+      {:ok, _} = Versioning.migrate_namespace({:pleroma, :key1}, {:ex_aws, :new_key})
+
+      version1 = refresh_record(version1)
+      assert version1.backup == [ex_aws: [new_key: [name: "Name"]]]
+      version2 = refresh_record(version2)
+
+      assert version2.backup == [
+               pleroma: [key2: [name: "Name"]]
+             ]
+
+      assert Repo.aggregate(from(c in ConfigDB, where: c.group == ^:pleroma), :count, :id) == 1
+      refute ConfigDB.get_by_params(%{group: :ex_aws, key: :new_key})
+    end
+  end
+
+  defp backup_length(%{backup: backup}) do
+    backup
+    |> Keyword.keys()
+    |> length()
+  end
+end
diff --git a/test/pleroma/config_db_test.exs b/test/pleroma/config_db_test.exs
index d42123fb4..26704169a 100644
--- a/test/pleroma/config_db_test.exs
+++ b/test/pleroma/config_db_test.exs
@@ -14,7 +14,7 @@ defmodule Pleroma.ConfigDBTest do
     assert config == ConfigDB.get_by_params(%{group: config.group, key: config.key})
   end
 
-  test "get_all_as_keyword/0" do
+  test "all_as_keyword/0" do
     saved = insert(:config)
     insert(:config, group: ":quack", key: ":level", value: :info)
     insert(:config, group: ":quack", key: ":meta", value: [:none])
@@ -25,7 +25,7 @@ defmodule Pleroma.ConfigDBTest do
       value: "https://hooks.slack.com/services/KEY/some_val"
     )
 
-    config = ConfigDB.get_all_as_keyword()
+    config = ConfigDB.all_as_keyword()
 
     assert config[:pleroma] == [
              {saved.key, saved.value}
@@ -38,12 +38,12 @@ defmodule Pleroma.ConfigDBTest do
 
   describe "update_or_create/1" do
     test "common" do
-      config = insert(:config)
+      config1 = insert(:config, value: [])
       key2 = :another_key
 
       params = [
-        %{group: :pleroma, key: key2, value: "another_value"},
-        %{group: :pleroma, key: config.key, value: [a: 1, b: 2, c: "new_value"]}
+        %{group: :pleroma, key: config1.key, value: [a: 1, b: 2, c: "new_value"]},
+        %{group: :pleroma, key: key2, value: [new_val: "another_value"]}
       ]
 
       assert Repo.all(ConfigDB) |> length() == 1
@@ -52,11 +52,11 @@ defmodule Pleroma.ConfigDBTest do
 
       assert Repo.all(ConfigDB) |> length() == 2
 
-      config1 = ConfigDB.get_by_params(%{group: config.group, key: config.key})
+      config1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
       config2 = ConfigDB.get_by_params(%{group: :pleroma, key: key2})
 
       assert config1.value == [a: 1, b: 2, c: "new_value"]
-      assert config2.value == "another_value"
+      assert config2.value == [new_val: "another_value"]
     end
 
     test "partial update" do
@@ -95,50 +95,18 @@ defmodule Pleroma.ConfigDBTest do
       assert updated.value[:key3] == :val3
     end
 
-    test "only full update for some keys" do
-      config1 = insert(:config, key: :ecto_repos, value: [repo: Pleroma.Repo])
-
-      config2 = insert(:config, group: :cors_plug, key: :max_age, value: 18)
-
-      {:ok, _config} =
-        ConfigDB.update_or_create(%{
-          group: config1.group,
-          key: config1.key,
-          value: [another_repo: [Pleroma.Repo]]
-        })
-
-      {:ok, _config} =
-        ConfigDB.update_or_create(%{
-          group: config2.group,
-          key: config2.key,
-          value: 777
-        })
-
-      updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
-      updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})
-
-      assert updated1.value == [another_repo: [Pleroma.Repo]]
-      assert updated2.value == 777
-    end
-
-    test "full update if value is not keyword" do
-      config =
-        insert(:config,
-          group: ":tesla",
-          key: ":adapter",
-          value: Tesla.Adapter.Hackney
-        )
+    test "only full update for groups without keys" do
+      config = insert(:config, group: :cors_plug, key: nil, value: [max_age: 18])
 
       {:ok, _config} =
         ConfigDB.update_or_create(%{
           group: config.group,
-          key: config.key,
-          value: Tesla.Adapter.Httpc
+          key: nil,
+          value: [max_age: 25, credentials: true]
         })
 
       updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})
-
-      assert updated.value == Tesla.Adapter.Httpc
+      assert updated.value == [max_age: 25, credentials: true]
     end
 
     test "only full update for some subkeys" do
@@ -176,15 +144,14 @@ defmodule Pleroma.ConfigDBTest do
     end
   end
 
-  describe "delete/1" do
+  describe "delete_or_update/1" do
     test "error on deleting non existing setting" do
-      {:error, error} = ConfigDB.delete(%{group: ":pleroma", key: ":key"})
-      assert error =~ "Config with params %{group: \":pleroma\", key: \":key\"} not found"
+      assert {:ok, nil} == ConfigDB.delete_or_update(%{group: :pleroma, key: :key})
     end
 
     test "full delete" do
       config = insert(:config)
-      {:ok, deleted} = ConfigDB.delete(%{group: config.group, key: config.key})
+      {:ok, deleted} = ConfigDB.delete_or_update(%{group: config.group, key: config.key})
       assert Ecto.get_meta(deleted, :state) == :deleted
       refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
     end
@@ -193,7 +160,7 @@ defmodule Pleroma.ConfigDBTest do
       config = insert(:config, value: [groups: [a: 1, b: 2], key: [a: 1]])
 
       {:ok, deleted} =
-        ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})
+        ConfigDB.delete_or_update(%{group: config.group, key: config.key, subkeys: [:groups]})
 
       assert Ecto.get_meta(deleted, :state) == :loaded
 
@@ -208,339 +175,246 @@ defmodule Pleroma.ConfigDBTest do
       config = insert(:config, value: [groups: [a: 1, b: 2]])
 
       {:ok, deleted} =
-        ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})
+        ConfigDB.delete_or_update(%{group: config.group, key: config.key, subkeys: [:groups]})
 
       assert Ecto.get_meta(deleted, :state) == :deleted
 
       refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
     end
-  end
-
-  describe "to_elixir_types/1" do
-    test "string" do
-      assert ConfigDB.to_elixir_types("value as string") == "value as string"
-    end
-
-    test "boolean" do
-      assert ConfigDB.to_elixir_types(false) == false
-    end
 
-    test "nil" do
-      assert ConfigDB.to_elixir_types(nil) == nil
+    test "delete struct" do
+      config = insert(:config)
+      {:ok, config} = ConfigDB.delete(config)
+      assert Ecto.get_meta(config, :state) == :deleted
+      assert Pleroma.Repo.aggregate(ConfigDB, :count) == 0
     end
+  end
 
-    test "integer" do
-      assert ConfigDB.to_elixir_types(150) == 150
-    end
+  test "all/0" do
+    config = insert(:config)
 
-    test "atom" do
-      assert ConfigDB.to_elixir_types(":atom") == :atom
-    end
+    assert [^config] = ConfigDB.all()
+  end
 
-    test "ssl options" do
-      assert ConfigDB.to_elixir_types([":tlsv1", ":tlsv1.1", ":tlsv1.2"]) == [
-               :tlsv1,
-               :"tlsv1.1",
-               :"tlsv1.2"
-             ]
-    end
+  describe "reduce_defaults_and_merge_with_changes/2" do
+    test "common changes" do
+      defaults = [
+        pleroma: [
+          key1: [k1: 1, k2: 1, k3: 1],
+          key2: [k1: 2, k2: 2, k3: 2]
+        ],
+        logger: [k1: 3, k2: 3]
+      ]
 
-    test "pleroma module" do
-      assert ConfigDB.to_elixir_types("Pleroma.Bookmark") == Pleroma.Bookmark
-    end
+      config1 = insert(:config, key: :key1, value: [k1: 4, k2: 4])
+      config2 = insert(:config, key: :key2, value: [k1: 5, k2: 5])
 
-    test "pleroma string" do
-      assert ConfigDB.to_elixir_types("Pleroma") == "Pleroma"
-    end
+      {changes, [logger: [k1: 3, k2: 3]]} =
+        ConfigDB.reduce_defaults_and_merge_with_changes([config1, config2], defaults)
 
-    test "phoenix module" do
-      assert ConfigDB.to_elixir_types("Phoenix.Socket.V1.JSONSerializer") ==
-               Phoenix.Socket.V1.JSONSerializer
-    end
+      Enum.each(changes, fn
+        %{key: :key1, value: value} ->
+          assert value == [k3: 1, k1: 4, k2: 4]
 
-    test "tesla module" do
-      assert ConfigDB.to_elixir_types("Tesla.Adapter.Hackney") == Tesla.Adapter.Hackney
+        %{key: :key2, value: value} ->
+          assert value == [k3: 2, k1: 5, k2: 5]
+      end)
     end
 
-    test "ExSyslogger module" do
-      assert ConfigDB.to_elixir_types("ExSyslogger") == ExSyslogger
-    end
+    test "changes for group without key" do
+      defaults = [
+        cors_plug: [
+          max_age: 86_400,
+          methods: ["POST", "PUT", "DELETE", "GET", "PATCH", "OPTIONS"]
+        ],
+        pleroma: [key1: [k1: 1, k2: 1, k3: 1]]
+      ]
 
-    test "Quack.Logger module" do
-      assert ConfigDB.to_elixir_types("Quack.Logger") == Quack.Logger
-    end
+      config = insert(:config, group: :cors_plug, key: nil, value: [max_age: 60_000])
 
-    test "Swoosh.Adapters modules" do
-      assert ConfigDB.to_elixir_types("Swoosh.Adapters.SMTP") == Swoosh.Adapters.SMTP
-      assert ConfigDB.to_elixir_types("Swoosh.Adapters.AmazonSES") == Swoosh.Adapters.AmazonSES
-    end
+      {[change], [pleroma: [key1: [k1: 1, k2: 1, k3: 1]]]} =
+        ConfigDB.reduce_defaults_and_merge_with_changes([config], defaults)
 
-    test "sigil" do
-      assert ConfigDB.to_elixir_types("~r[comp[lL][aA][iI][nN]er]") == ~r/comp[lL][aA][iI][nN]er/
+      assert change.value == [
+               methods: ["POST", "PUT", "DELETE", "GET", "PATCH", "OPTIONS"],
+               max_age: 60_000
+             ]
     end
 
-    test "link sigil" do
-      assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/") == ~r/https:\/\/example.com/
-    end
+    test "for logger backend setting and others" do
+      defaults = [
+        logger: [
+          ex_syslogger: [k1: 1, k2: 1],
+          console: [k1: 2, k2: 2],
+          backends: [:ex_syslogger, :console],
+          key: 1
+        ],
+        pleroma: [key1: 1, key2: 2]
+      ]
 
-    test "link sigil with um modifiers" do
-      assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/um") ==
-               ~r/https:\/\/example.com/um
-    end
+      logger =
+        insert(:config,
+          group: :logger,
+          key: nil,
+          value: [ex_syslogger: [k1: 3, k2: 4], backends: [:console]]
+        )
 
-    test "link sigil with i modifier" do
-      assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/i") == ~r/https:\/\/example.com/i
-    end
+      {[change], [pleroma: [key1: 1, key2: 2]]} =
+        ConfigDB.reduce_defaults_and_merge_with_changes([logger], defaults)
 
-    test "link sigil with s modifier" do
-      assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/s") == ~r/https:\/\/example.com/s
+      assert change.value == [
+               console: [k1: 2, k2: 2],
+               key: 1,
+               ex_syslogger: [k1: 3, k2: 4],
+               backends: [:console]
+             ]
     end
 
-    test "raise if valid delimiter not found" do
-      assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
-        ConfigDB.to_elixir_types("~r/https://[]{}<>\"'()|example.com/s")
-      end
-    end
+    test "with ex_syslogger, console and backends changes" do
+      defaults = [
+        logger: [
+          ex_syslogger: [k1: 1, k2: 1],
+          console: [k1: 2, k2: 2],
+          backends: [:ex_syslogger, :console],
+          key: 1
+        ],
+        pleroma: [key1: 1, key2: 2]
+      ]
 
-    test "2 child tuple" do
-      assert ConfigDB.to_elixir_types(%{"tuple" => ["v1", ":v2"]}) == {"v1", :v2}
-    end
+      logger =
+        insert(:config,
+          group: :logger,
+          key: nil,
+          value: [console: [k1: 4, k2: 4], k1: 3, k2: 4, backends: [:console]]
+        )
 
-    test "proxy tuple with localhost" do
-      assert ConfigDB.to_elixir_types(%{
-               "tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
-             }) == {:proxy_url, {:socks5, :localhost, 1234}}
-    end
+      {[change], [pleroma: [key1: 1, key2: 2]]} =
+        ConfigDB.reduce_defaults_and_merge_with_changes([logger], defaults)
 
-    test "proxy tuple with domain" do
-      assert ConfigDB.to_elixir_types(%{
-               "tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
-             }) == {:proxy_url, {:socks5, 'domain.com', 1234}}
+      assert change.value == [
+               ex_syslogger: [k1: 1, k2: 1],
+               key: 1,
+               console: [k1: 4, k2: 4],
+               k1: 3,
+               k2: 4,
+               backends: [:console]
+             ]
     end
+  end
 
-    test "proxy tuple with ip" do
-      assert ConfigDB.to_elixir_types(%{
-               "tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
-             }) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
-    end
+  test "all_with_db/0" do
+    config = insert(:config)
+    [change] = ConfigDB.all_with_db()
+    assert change.db == Keyword.keys(config.value)
+  end
 
-    test "tuple with n childs" do
-      assert ConfigDB.to_elixir_types(%{
-               "tuple" => [
-                 "v1",
-                 ":v2",
-                 "Pleroma.Bookmark",
-                 150,
-                 false,
-                 "Phoenix.Socket.V1.JSONSerializer"
+  test "from_keyword_to_structs/2" do
+    keyword = [
+      pleroma: [
+        key1: [k1: 1, k2: 1, k3: 1],
+        key2: [k1: 2, k2: 2, k3: 2]
+      ],
+      logger: [k1: 3, k2: 3, ex_syslogger: [k1: 4, k2: 4], console: [k1: 5, k2: 5]]
+    ]
+
+    changes = ConfigDB.from_keyword_to_structs(keyword)
+
+    Enum.each(changes, fn
+      %{key: :key1} = change ->
+        assert change.group == :pleroma
+        assert change.value == [k1: 1, k2: 1, k3: 1]
+
+      %{key: :key2} = change ->
+        assert change.group == :pleroma
+        assert change.value == [k1: 2, k2: 2, k3: 2]
+
+      %{key: nil} = change ->
+        assert change.group == :logger
+
+        assert change.value == [
+                 k1: 3,
+                 k2: 3,
+                 ex_syslogger: [k1: 4, k2: 4],
+                 console: [k1: 5, k2: 5]
                ]
-             }) == {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
-    end
+    end)
+  end
 
-    test "map with string key" do
-      assert ConfigDB.to_elixir_types(%{"key" => "value"}) == %{"key" => "value"}
-    end
+  describe "merge_changes_with_defaults/2" do
+    test "with existance changes" do
+      defaults = [
+        pleroma: [
+          key1: [k1: 1, k2: 1, k3: 1],
+          key2: [k1: 2, k2: 2, k3: 2]
+        ],
+        logger: [k1: 3, k2: 3]
+      ]
 
-    test "map with atom key" do
-      assert ConfigDB.to_elixir_types(%{":key" => "value"}) == %{key: "value"}
-    end
+      config1 = insert(:config, key: :key1, value: [k1: 4, k2: 4])
+      config2 = insert(:config, key: :key2, value: [k1: 5, k2: 5])
 
-    test "list of strings" do
-      assert ConfigDB.to_elixir_types(["v1", "v2", "v3"]) == ["v1", "v2", "v3"]
-    end
+      changes = ConfigDB.merge_changes_with_defaults([config1, config2], defaults)
 
-    test "list of modules" do
-      assert ConfigDB.to_elixir_types(["Pleroma.Repo", "Pleroma.Activity"]) == [
-               Pleroma.Repo,
-               Pleroma.Activity
-             ]
+      Enum.each(changes, fn
+        %{key: :key1} = change -> assert change.value == [k3: 1, k1: 4, k2: 4]
+        %{key: :key2} = change -> assert change.value == [k3: 2, k1: 5, k2: 5]
+      end)
     end
 
-    test "list of atoms" do
-      assert ConfigDB.to_elixir_types([":v1", ":v2", ":v3"]) == [:v1, :v2, :v3]
-    end
+    test "full subkey update and deep merge" do
+      defaults = [
+        pleroma: [
+          assets: [
+            mascots: [3, 4],
+            subkey: [key1: [key: :val2, key2: :val2], key2: :val2],
+            key: 5
+          ]
+        ]
+      ]
 
-    test "list of mixed values" do
-      assert ConfigDB.to_elixir_types([
-               "v1",
-               ":v2",
-               "Pleroma.Repo",
-               "Phoenix.Socket.V1.JSONSerializer",
-               15,
-               false
-             ]) == [
-               "v1",
-               :v2,
-               Pleroma.Repo,
-               Phoenix.Socket.V1.JSONSerializer,
-               15,
-               false
-             ]
-    end
+      config =
+        insert(:config,
+          group: :pleroma,
+          key: :assets,
+          value: [mascots: [1, 2], subkey: [key1: [key: :val1, key2: :val1], key2: :val1]]
+        )
 
-    test "simple keyword" do
-      assert ConfigDB.to_elixir_types([%{"tuple" => [":key", "value"]}]) == [key: "value"]
-    end
+      [merged] = ConfigDB.merge_changes_with_defaults([config], defaults)
 
-    test "keyword" do
-      assert ConfigDB.to_elixir_types([
-               %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
-               %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
-               %{"tuple" => [":migration_lock", nil]},
-               %{"tuple" => [":key1", 150]},
-               %{"tuple" => [":key2", "string"]}
-             ]) == [
-               types: Pleroma.PostgresTypes,
-               telemetry_event: [Pleroma.Repo.Instrumenter],
-               migration_lock: nil,
-               key1: 150,
-               key2: "string"
+      assert merged.value == [
+               mascots: [1, 2],
+               key: 5,
+               subkey: [key1: [key: :val1, key2: :val1], key2: :val1]
              ]
     end
 
-    test "trandformed keyword" do
-      assert ConfigDB.to_elixir_types(a: 1, b: 2, c: "string") == [a: 1, b: 2, c: "string"]
-    end
+    test "merge for other subkeys" do
+      defaults = [pleroma: [assets: [key: 5]]]
 
-    test "complex keyword with nested mixed childs" do
-      assert ConfigDB.to_elixir_types([
-               %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
-               %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
-               %{"tuple" => [":link_name", true]},
-               %{"tuple" => [":proxy_remote", false]},
-               %{"tuple" => [":common_map", %{":key" => "value"}]},
-               %{
-                 "tuple" => [
-                   ":proxy_opts",
-                   [
-                     %{"tuple" => [":redirect_on_failure", false]},
-                     %{"tuple" => [":max_body_length", 1_048_576]},
-                     %{
-                       "tuple" => [
-                         ":http",
-                         [
-                           %{"tuple" => [":follow_redirect", true]},
-                           %{"tuple" => [":pool", ":upload"]}
-                         ]
-                       ]
-                     }
-                   ]
-                 ]
-               }
-             ]) == [
-               uploader: Pleroma.Uploaders.Local,
-               filters: [Pleroma.Upload.Filter.Dedupe],
-               link_name: true,
-               proxy_remote: false,
-               common_map: %{key: "value"},
-               proxy_opts: [
-                 redirect_on_failure: false,
-                 max_body_length: 1_048_576,
-                 http: [
-                   follow_redirect: true,
-                   pool: :upload
-                 ]
-               ]
-             ]
-    end
+      config =
+        insert(:config,
+          group: :pleroma,
+          key: :assets,
+          value: [subkey: 3, default_mascot: :test_mascot]
+        )
 
-    test "common keyword" do
-      assert ConfigDB.to_elixir_types([
-               %{"tuple" => [":level", ":warn"]},
-               %{"tuple" => [":meta", [":all"]]},
-               %{"tuple" => [":path", ""]},
-               %{"tuple" => [":val", nil]},
-               %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
-             ]) == [
-               level: :warn,
-               meta: [:all],
-               path: "",
-               val: nil,
-               webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
-             ]
+      [merged] = ConfigDB.merge_changes_with_defaults([config], defaults)
+      assert merged.value == [key: 5, subkey: 3, default_mascot: :test_mascot]
     end
 
-    test "complex keyword with sigil" do
-      assert ConfigDB.to_elixir_types([
-               %{"tuple" => [":federated_timeline_removal", []]},
-               %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
-               %{"tuple" => [":replace", []]}
-             ]) == [
-               federated_timeline_removal: [],
-               reject: [~r/comp[lL][aA][iI][nN]er/],
-               replace: []
-             ]
-    end
+    test "with change deletion" do
+      defaults = [pleroma: [assets: [key: 5]]]
 
-    test "complex keyword with tuples with more than 2 values" do
-      assert ConfigDB.to_elixir_types([
-               %{
-                 "tuple" => [
-                   ":http",
-                   [
-                     %{
-                       "tuple" => [
-                         ":key1",
-                         [
-                           %{
-                             "tuple" => [
-                               ":_",
-                               [
-                                 %{
-                                   "tuple" => [
-                                     "/api/v1/streaming",
-                                     "Pleroma.Web.MastodonAPI.WebsocketHandler",
-                                     []
-                                   ]
-                                 },
-                                 %{
-                                   "tuple" => [
-                                     "/websocket",
-                                     "Phoenix.Endpoint.CowboyWebSocket",
-                                     %{
-                                       "tuple" => [
-                                         "Phoenix.Transports.WebSocket",
-                                         %{
-                                           "tuple" => [
-                                             "Pleroma.Web.Endpoint",
-                                             "Pleroma.Web.UserSocket",
-                                             []
-                                           ]
-                                         }
-                                       ]
-                                     }
-                                   ]
-                                 },
-                                 %{
-                                   "tuple" => [
-                                     ":_",
-                                     "Phoenix.Endpoint.Cowboy2Handler",
-                                     %{"tuple" => ["Pleroma.Web.Endpoint", []]}
-                                   ]
-                                 }
-                               ]
-                             ]
-                           }
-                         ]
-                       ]
-                     }
-                   ]
-                 ]
-               }
-             ]) == [
-               http: [
-                 key1: [
-                   {:_,
-                    [
-                      {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
-                      {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
-                       {Phoenix.Transports.WebSocket,
-                        {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
-                      {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
-                    ]}
-                 ]
-               ]
-             ]
+      config =
+        insert(:config,
+          group: :pleroma,
+          key: :assets,
+          value: [subkey: 3, default_mascot: :test_mascot]
+        )
+
+      {:ok, config} = ConfigDB.delete(config)
+      [merged] = ConfigDB.merge_changes_with_defaults([config], defaults)
+      assert merged.value == [key: 5]
     end
   end
 end
diff --git a/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs b/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
index 8cd9f939b..5871f3a9e 100644
--- a/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/admin_api_controller_test.exs
@@ -6,7 +6,6 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
   use Pleroma.Web.ConnCase
   use Oban.Testing, repo: Pleroma.Repo
 
-  import ExUnit.CaptureLog
   import Pleroma.Factory
   import Swoosh.TestAssertions
 
@@ -322,28 +321,12 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
     setup do: clear_config(:configurable_from_database, true)
 
     test "pleroma restarts", %{conn: conn} do
-      capture_log(fn ->
-        assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) == %{}
-      end) =~ "pleroma restarted"
+      assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) == %{}
 
-      refute Restarter.Pleroma.need_reboot?()
+      refute Pleroma.Application.ConfigDependentDeps.need_reboot?()
     end
   end
 
-  test "need_reboot flag", %{conn: conn} do
-    assert conn
-           |> get("/api/pleroma/admin/need_reboot")
-           |> json_response(200) == %{"need_reboot" => false}
-
-    Restarter.Pleroma.need_reboot()
-
-    assert conn
-           |> get("/api/pleroma/admin/need_reboot")
-           |> json_response(200) == %{"need_reboot" => true}
-
-    on_exit(fn -> Restarter.Pleroma.refresh() end)
-  end
-
   describe "GET /api/pleroma/admin/users/:nickname/statuses" do
     setup do
       user = insert(:user)
@@ -999,10 +982,3 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
     end
   end
 end
-
-# Needed for testing
-defmodule Pleroma.Web.Endpoint.NotReal do
-end
-
-defmodule Pleroma.Captcha.NotReal do
-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 c39c1b1e1..7a2c8727a 100644
--- a/test/pleroma/web/admin_api/controllers/config_controller_test.exs
+++ b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
@@ -5,10 +5,9 @@
 defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
   use Pleroma.Web.ConnCase
 
-  import ExUnit.CaptureLog
   import Pleroma.Factory
 
-  alias Pleroma.ConfigDB
+  alias Pleroma.Config
 
   setup do
     admin = insert(:user, is_admin: true)
@@ -18,7 +17,9 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
       build_conn()
       |> assign(:user, admin)
       |> assign(:token, token)
+      |> put_req_header("content-type", "application/json")
 
+    on_exit(fn -> Pleroma.Application.ConfigDependentDeps.clear_state() end)
     {:ok, %{admin: admin, token: token, conn: conn}}
   end
 
@@ -27,9 +28,10 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
 
     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) ==
+      assert conn
+             |> get("/api/pleroma/admin/config")
+             |> json_response_and_validate_schema(400) ==
                %{
                  "error" => "You must enable configurable_from_database in your config file."
                }
@@ -61,7 +63,7 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
     end
 
     test "db is added to settings that are in db", %{conn: conn} do
-      _config = insert(:config, key: ":instance", value: [name: "Some name"])
+      _config = insert(:config, key: :instance, value: [name: "Some name"])
 
       %{"configs" => configs} =
         conn
@@ -76,6 +78,27 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
       assert instance_config["db"] == [":name"]
     end
 
+    test "setting with value not keyword", %{conn: conn} do
+      _config =
+        insert(:config,
+          key: Pleroma.Web.Auth.Authenticator,
+          value: Pleroma.Web.Auth.LDAPAuthenticator
+        )
+
+      %{"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 == "Pleroma.Web.Auth.Authenticator"
+        end)
+
+      assert instance_config["db"] == ["Pleroma.Web.Auth.Authenticator"]
+      assert instance_config["value"] == "Pleroma.Web.Auth.LDAPAuthenticator"
+    end
+
     test "merged default setting with db settings", %{conn: conn} do
       config1 = insert(:config)
       config2 = insert(:config)
@@ -94,30 +117,19 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
 
       saved_configs = [config1, config2, config3]
       keys = Enum.map(saved_configs, &inspect(&1.key))
+      values = Map.new(saved_configs, fn config -> {config.key, config.value} end)
 
-      received_configs =
-        Enum.filter(configs, fn %{"group" => group, "key" => key} ->
+      configs =
+        configs
+        |> Enum.filter(fn %{"group" => group, "key" => key} ->
           group == ":pleroma" and key in keys
         end)
+        |> Config.Converter.to_elixir_types()
 
-      assert length(received_configs) == 3
-
-      db_keys =
-        config3.value
-        |> Keyword.keys()
-        |> ConfigDB.to_json_types()
-
-      keys = Enum.map(saved_configs -- [config3], &inspect(&1.key))
+      assert length(configs) == 3
 
-      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
+      Enum.each(configs, fn %{"key" => key, "value" => value} ->
+        assert values[key] == value
       end)
     end
 
@@ -145,8 +157,8 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
       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"])
+      emoji_val = Config.Converter.to_elixir_types(emoji["value"])
+      assets_val = Config.Converter.to_elixir_types(assets["value"])
 
       assert emoji_val[:groups] == [a: 1, b: 2]
       assert assets_val[:mascots] == [a: 1, b: 2]
@@ -188,13 +200,11 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
         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)
 
-    @tag capture_log: true
     test "create new config setting in db", %{conn: conn} do
       ueberauth = Application.get_env(:ueberauth, Ueberauth)
       on_exit(fn -> Application.put_env(:ueberauth, Ueberauth, ueberauth) end)
@@ -204,7 +214,7 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
         |> put_req_header("content-type", "application/json")
         |> post("/api/pleroma/admin/config", %{
           configs: [
-            %{group: ":pleroma", key: ":key1", value: "value1"},
+            %{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key", "value1"]}]},
             %{
               group: ":ueberauth",
               key: "Ueberauth",
@@ -213,31 +223,40 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
             %{
               group: ":pleroma",
               key: ":key2",
-              value: %{
-                ":nested_1" => "nested_value1",
-                ":nested_2" => [
-                  %{":nested_22" => "nested_value222"},
-                  %{":nested_33" => %{":nested_44" => "nested_444"}}
-                ]
-              }
+              value: [
+                %{"tuple" => [":nested_1", "nested_value1"]},
+                %{
+                  "tuple" => [
+                    ":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}
+                %{"tuple" => [":key", ":nested_3"]},
+                %{"tuple" => [":nested_33", "nested_33"]},
+                %{"tuple" => [":key", true]}
               ]
             },
             %{
               group: ":pleroma",
               key: ":key4",
-              value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
+              value: [
+                %{"tuple" => [":nested_5", ":upload"]},
+                %{"tuple" => [":endpoint", "https://example.com"]}
+              ]
             },
             %{
               group: ":idna",
               key: ":key5",
-              value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
+              value: [%{"tuple" => [":string", "Pleroma.Captcha.NotReal"]}]
             }
           ]
         })
@@ -245,86 +264,92 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
       assert json_response_and_validate_schema(conn, 200) == %{
                "configs" => [
                  %{
-                   "group" => ":pleroma",
-                   "key" => ":key1",
-                   "value" => "value1",
-                   "db" => [":key1"]
-                 },
-                 %{
+                   "db" => [":consumer_secret"],
                    "group" => ":ueberauth",
                    "key" => "Ueberauth",
-                   "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}],
-                   "db" => [":consumer_secret"]
+                   "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
                  },
                  %{
+                   "db" => [":nested_5", ":endpoint"],
                    "group" => ":pleroma",
-                   "key" => ":key2",
-                   "value" => %{
-                     ":nested_1" => "nested_value1",
-                     ":nested_2" => [
-                       %{":nested_22" => "nested_value222"},
-                       %{":nested_33" => %{":nested_44" => "nested_444"}}
-                     ]
-                   },
-                   "db" => [":key2"]
+                   "key" => ":key4",
+                   "value" => [
+                     %{"tuple" => [":nested_5", ":upload"]},
+                     %{"tuple" => [":endpoint", "https://example.com"]}
+                   ]
                  },
                  %{
+                   "db" => [":key", ":nested_33", ":key"],
                    "group" => ":pleroma",
                    "key" => ":key3",
                    "value" => [
-                     %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
-                     %{"nested_4" => true}
-                   ],
-                   "db" => [":key3"]
+                     %{"tuple" => [":key", ":nested_3"]},
+                     %{"tuple" => [":nested_33", "nested_33"]},
+                     %{"tuple" => [":key", true]}
+                   ]
                  },
                  %{
+                   "db" => [":nested_1", ":nested_2"],
                    "group" => ":pleroma",
-                   "key" => ":key4",
-                   "value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"},
-                   "db" => [":key4"]
+                   "key" => ":key2",
+                   "value" => [
+                     %{"tuple" => [":nested_1", "nested_value1"]},
+                     %{
+                       "tuple" => [
+                         ":nested_2",
+                         [
+                           %{":nested_22" => "nested_value222"},
+                           %{":nested_33" => %{":nested_44" => "nested_444"}}
+                         ]
+                       ]
+                     }
+                   ]
                  },
                  %{
+                   "db" => [":key"],
+                   "group" => ":pleroma",
+                   "key" => ":key1",
+                   "value" => [%{"tuple" => [":key", "value1"]}]
+                 },
+                 %{
+                   "db" => [":string"],
                    "group" => ":idna",
                    "key" => ":key5",
-                   "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]},
-                   "db" => [":key5"]
+                   "value" => [%{"tuple" => [":string", "Pleroma.Captcha.NotReal"]}]
                  }
                ],
                "need_reboot" => false
              }
 
-      assert Application.get_env(:pleroma, :key1) == "value1"
+      assert Application.get_env(:pleroma, :key1) == [key: "value1"]
 
-      assert Application.get_env(:pleroma, :key2) == %{
+      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}
+               key: :nested_3,
+               nested_33: "nested_33",
+               key: true
              ]
 
-      assert Application.get_env(:pleroma, :key4) == %{
-               "endpoint" => "https://example.com",
-               nested_5: :upload
-             }
+      assert Application.get_env(:pleroma, :key4) == [
+               nested_5: :upload,
+               endpoint: "https://example.com"
+             ]
 
-      assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
+      assert Application.get_env(:idna, :key5) == [string: Pleroma.Captcha.NotReal]
     end
 
-    test "save configs setting without explicit key", %{conn: conn} do
-      level = Application.get_env(:quack, :level)
-      meta = Application.get_env(:quack, :meta)
-      webhook_url = Application.get_env(:quack, :webhook_url)
+    test "save configs setting without key", %{conn: conn} do
+      quack_env = Application.get_all_env(:quack)
 
       on_exit(fn ->
-        Application.put_env(:quack, :level, level)
-        Application.put_env(:quack, :meta, meta)
-        Application.put_env(:quack, :webhook_url, webhook_url)
+        Application.put_all_env(quack: quack_env)
       end)
 
       conn =
@@ -334,18 +359,11 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
           configs: [
             %{
               group: ":quack",
-              key: ":level",
-              value: ":info"
-            },
-            %{
-              group: ":quack",
-              key: ":meta",
-              value: [":none"]
-            },
-            %{
-              group: ":quack",
-              key: ":webhook_url",
-              value: "https://hooks.slack.com/services/KEY"
+              value: [
+                %{"tuple" => [":level", ":info"]},
+                %{"tuple" => [":meta", [":none"]]},
+                %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/KEY"]}
+              ]
             }
           ]
         })
@@ -354,21 +372,13 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
                "configs" => [
                  %{
                    "group" => ":quack",
-                   "key" => ":level",
-                   "value" => ":info",
-                   "db" => [":level"]
-                 },
-                 %{
-                   "group" => ":quack",
-                   "key" => ":meta",
-                   "value" => [":none"],
-                   "db" => [":meta"]
-                 },
-                 %{
-                   "group" => ":quack",
-                   "key" => ":webhook_url",
-                   "value" => "https://hooks.slack.com/services/KEY",
-                   "db" => [":webhook_url"]
+                   "key" => nil,
+                   "value" => [
+                     %{"tuple" => [":level", ":info"]},
+                     %{"tuple" => [":meta", [":none"]]},
+                     %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/KEY"]}
+                   ],
+                   "db" => [":level", ":meta", ":webhook_url"]
                  }
                ],
                "need_reboot" => false
@@ -380,7 +390,7 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
     end
 
     test "saving config with partial update", %{conn: conn} do
-      insert(:config, key: ":key1", value: :erlang.term_to_binary(key1: 1, key2: 2))
+      insert(:config, key: ":key1", value: [key1: 1, key2: 2])
 
       conn =
         conn
@@ -440,10 +450,8 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
 
       assert configs["need_reboot"]
 
-      capture_log(fn ->
-        assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) ==
-                 %{}
-      end) =~ "pleroma restarted"
+      assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) ==
+               %{}
 
       configs =
         conn
@@ -499,10 +507,8 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
                "need_reboot" => true
              }
 
-      capture_log(fn ->
-        assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) ==
-                 %{}
-      end) =~ "pleroma restarted"
+      assert conn |> get("/api/pleroma/admin/restart") |> json_response(200) ==
+               %{}
 
       configs =
         conn
@@ -610,136 +616,86 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
              ]
     end
 
-    test "saving full setting if value is in full_key_update list", %{conn: conn} do
-      backends = Application.get_env(:logger, :backends)
-      on_exit(fn -> Application.put_env(:logger, :backends, backends) end)
-
-      insert(:config,
-        group: :logger,
-        key: :backends,
-        value: []
-      )
-
-      Pleroma.Config.TransferTask.load_and_update_env([], false)
-
-      assert Application.get_env(:logger, :backends) == []
+    test "update config setting & delete with fallback to default value", %{conn: conn} do
+      ueberauth = Application.get_env(:ueberauth, Ueberauth)
+      insert(:config, key: :keyaa1, value: [key: "value"])
+      insert(:config, key: :keyaa2, value: [key: "value"])
 
-      conn =
-        conn
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/pleroma/admin/config", %{
+      resp =
+        post(conn, "/api/pleroma/admin/config", %{
           configs: [
             %{
-              group: ":logger",
-              key: ":backends",
-              value: [":console"]
+              group: ":pleroma",
+              key: ":keyaa1",
+              value: [
+                %{"tuple" => [":key", "value2"]},
+                %{"tuple" => [":key2", "value"]}
+              ]
+            },
+            %{group: ":pleroma", key: ":keyaa2", value: [%{"tuple" => [":key", "value2"]}]},
+            %{
+              group: ":ueberauth",
+              key: "Ueberauth",
+              value: [
+                %{"tuple" => [":another_key", "somevalue"]},
+                %{"tuple" => [":another", "somevalue"]}
+              ]
+            },
+            %{
+              group: ":pleroma",
+              key: "Pleroma.Uploaders.Local",
+              delete: true
             }
           ]
         })
 
-      assert json_response_and_validate_schema(conn, 200) == %{
+      assert json_response_and_validate_schema(resp, 200) == %{
                "configs" => [
                  %{
-                   "group" => ":logger",
-                   "key" => ":backends",
+                   "db" => [":another_key", ":another"],
+                   "group" => ":ueberauth",
+                   "key" => "Ueberauth",
                    "value" => [
-                     ":console"
-                   ],
-                   "db" => [":backends"]
-                 }
-               ],
-               "need_reboot" => false
-             }
-
-      assert Application.get_env(:logger, :backends) == [
-               :console
-             ]
-    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" => [
+                     %{"tuple" => [":another_key", "somevalue"]},
+                     %{"tuple" => [":another", "somevalue"]}
+                   ]
+                 },
                  %{
                    "group" => ":pleroma",
-                   "key" => ":keyaa1",
-                   "value" => "another_value",
-                   "db" => [":keyaa1"]
+                   "key" => ":keyaa2",
+                   "value" => [
+                     %{"tuple" => [":key", "value2"]}
+                   ],
+                   "db" => [":key"]
                  },
                  %{
                    "group" => ":pleroma",
-                   "key" => ":keyaa2",
-                   "value" => "another_value",
-                   "db" => [":keyaa2"]
+                   "key" => ":keyaa1",
+                   "value" => [
+                     %{"tuple" => [":key", "value2"]},
+                     %{"tuple" => [":key2", "value"]}
+                   ],
+                   "db" => [":key", ":key2"]
                  }
                ],
                "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
+      assert Application.get_env(:pleroma, :keyaa1) == [key: "value2", key2: "value"]
+      assert Application.get_env(:pleroma, :keyaa2) == [key: "value2"]
 
-      conn =
-        build_conn()
-        |> assign(:user, admin)
-        |> assign(:token, token)
-        |> put_req_header("content-type", "application/json")
-        |> post("/api/pleroma/admin/config", %{
+      assert Application.get_env(:ueberauth, Ueberauth) == [
+               base_path: "/oauth",
+               providers: [],
+               another_key: "somevalue",
+               another: "somevalue"
+             ]
+
+      resp =
+        post(conn, "/api/pleroma/admin/config", %{
           configs: [
             %{group: ":pleroma", key: ":keyaa2", delete: true},
+            %{group: ":pleroma", key: ":keyaa1", delete: true, subkeys: [":key"]},
             %{
               group: ":ueberauth",
               key: "Ueberauth",
@@ -748,8 +704,15 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
           ]
         })
 
-      assert json_response_and_validate_schema(conn, 200) == %{
-               "configs" => [],
+      assert json_response_and_validate_schema(resp, 200) == %{
+               "configs" => [
+                 %{
+                   "db" => [":key2"],
+                   "group" => ":pleroma",
+                   "key" => ":keyaa1",
+                   "value" => [%{"tuple" => [":key2", "value"]}]
+                 }
+               ],
                "need_reboot" => false
              }
 
@@ -1023,34 +986,6 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
                }
     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
@@ -1228,7 +1163,6 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
       assert ":proxy_url" in db
     end
 
-    @tag capture_log: true
     test "doesn't set keys not in the whitelist", %{conn: conn} do
       clear_config(:database_config_whitelist, [
         {:pleroma, :key1},
@@ -1241,21 +1175,29 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
       |> 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"}
+          %{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key", "value1"]}]},
+          %{group: ":pleroma", key: ":key2", value: [%{"tuple" => [":key", "value2"]}]},
+          %{group: ":pleroma", key: ":key3", value: [%{"tuple" => [":key", "value3"]}]},
+          %{
+            group: ":pleroma",
+            key: "Pleroma.Web.Endpoint.NotReal",
+            value: [%{"tuple" => [":key", "value4"]}]
+          },
+          %{
+            group: ":pleroma",
+            key: "Pleroma.Captcha.NotReal",
+            value: [%{"tuple" => [":key", "value5"]}]
+          },
+          %{group: ":not_real", key: ":anything", value: [%{"tuple" => [":key", "value6"]}]}
         ]
       })
 
-      assert Application.get_env(:pleroma, :key1) == "value1"
-      assert Application.get_env(:pleroma, :key2) == "value2"
+      assert Application.get_env(:pleroma, :key1) == [key: "value1"]
+      assert Application.get_env(:pleroma, :key2) == [key: "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"
+      assert Application.get_env(:pleroma, Pleroma.Captcha.NotReal) == [key: "value5"]
+      assert Application.get_env(:not_real, :anything) == [key: "value6"]
     end
 
     test "args for Pleroma.Upload.Filter.Mogrify with custom tuples", %{conn: conn} do
@@ -1445,14 +1387,83 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
                "need_reboot" => false
              }
 
-      _res =
-        assert conn
-               |> get("/api/v1/instance")
-               |> json_response_and_validate_schema(200)
+      assert conn
+             |> get("/api/v1/instance")
+             |> json_response_and_validate_schema(200)
 
       assert res = %{"thumbnail" => "https://example.com/media/new_thumbnail.jpg"}
     end
 
+    test "value bad format error", %{conn: conn} do
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/pleroma/admin/config", %{
+          configs: [
+            %{
+              group: ":quack",
+              value: %{}
+            }
+          ]
+        })
+
+      assert json_response_and_validate_schema(conn, 400) == %{
+               "error" =>
+                 "Updating config failed: :value_must_be_keyword, group: quack, key: , value: %{}"
+             }
+    end
+
+    test "error when value is list", %{conn: conn} do
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/pleroma/admin/config", %{
+          configs: [
+            %{
+              group: ":quack",
+              value: [1]
+            }
+          ]
+        })
+
+      assert json_response_and_validate_schema(conn, 400) == %{
+               "error" =>
+                 "Updating config failed: :value_must_be_keyword, group: quack, key: , value: [1]"
+             }
+    end
+
+    test "saving pleroma group with value not a keyword", %{conn: conn} do
+      clear_config(Pleroma.Web.Auth.Authenticator)
+
+      conn =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/pleroma/admin/config", %{
+          configs: [
+            %{
+              group: ":pleroma",
+              key: "Pleroma.Web.Auth.Authenticator",
+              value: "Pleroma.Web.Auth.LDAPAuthenticator"
+            }
+          ]
+        })
+
+      assert json_response_and_validate_schema(conn, 200) == %{
+               "configs" => [
+                 %{
+                   "db" => ["Pleroma.Web.Auth.Authenticator"],
+                   "group" => ":pleroma",
+                   "key" => "Pleroma.Web.Auth.Authenticator",
+                   "value" => "Pleroma.Web.Auth.LDAPAuthenticator"
+                 }
+               ],
+               "need_reboot" => false
+             }
+
+      assert Application.get_env(:pleroma, Pleroma.Web.Auth.Authenticator) ==
+               Pleroma.Web.Auth.LDAPAuthenticator
+    end
+
     test "Concurrent Limiter", %{conn: conn} do
       clear_config([ConcurrentLimiter])
 
@@ -1529,4 +1540,94 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
       assert esshd["children"]
     end
   end
+
+  describe "GET /api/pleroma/admin/config/versions/rollback" do
+    setup do: clear_config(:configurable_from_database, true)
+
+    test "success rollback", %{conn: conn} do
+      version = insert(:config_version)
+      insert(:config_version)
+      insert(:config_version, current: true)
+
+      conn
+      |> get("/api/pleroma/admin/config/versions/rollback/#{version.id}")
+      |> json_response_and_validate_schema(204)
+
+      [config] = Pleroma.Repo.all(Pleroma.ConfigDB)
+      assert config.value == version.backup[config.group][config.key]
+    end
+
+    test "not found error", %{conn: conn} do
+      assert conn
+             |> get("/api/pleroma/admin/config/versions/rollback/1")
+             |> json_response_and_validate_schema(404) == %{
+               "error" => "Not found"
+             }
+    end
+
+    test "on rollback to version, which is current", %{conn: conn} do
+      version = insert(:config_version, current: true)
+
+      assert conn
+             |> get("/api/pleroma/admin/config/versions/rollback/#{version.id}")
+             |> json_response_and_validate_schema(400) == %{
+               "error" => "Rollback is not possible: :version_is_already_current"
+             }
+    end
+
+    test "when configuration from database is off", %{conn: conn} do
+      clear_config(:configurable_from_database, false)
+
+      assert conn
+             |> get("/api/pleroma/admin/config/versions/rollback/1")
+             |> json_response_and_validate_schema(400) ==
+               %{
+                 "error" => "You must enable configurable_from_database in your config file."
+               }
+    end
+  end
+
+  describe "GET /api/pleroma/admin/config/versions" do
+    setup do: clear_config(:configurable_from_database, true)
+
+    test "with no versions", %{conn: conn} do
+      assert conn
+             |> get("/api/pleroma/admin/config/versions")
+             |> json_response_and_validate_schema(200) == %{"versions" => []}
+    end
+
+    test "with versions", %{conn: conn} do
+      version = insert(:config_version, current: true)
+
+      assert conn
+             |> get("/api/pleroma/admin/config/versions")
+             |> json_response_and_validate_schema(200) == %{
+               "versions" => [
+                 %{
+                   "current" => true,
+                   "id" => version.id,
+                   "inserted_at" => Pleroma.Web.CommonAPI.Utils.to_masto_date(version.inserted_at)
+                 }
+               ]
+             }
+    end
+
+    test "when configuration from database is off", %{conn: conn} do
+      clear_config(:configurable_from_database, false)
+
+      assert conn
+             |> get("/api/pleroma/admin/config/versions")
+             |> json_response_and_validate_schema(400) ==
+               %{
+                 "error" => "You must enable configurable_from_database in your config file."
+               }
+    end
+  end
+end
+
+# Needed for testing
+defmodule Pleroma.Web.Endpoint.NotReal do
+end
+
+defmodule Pleroma.Captcha.NotReal do
 end
diff --git a/test/support/data_case.ex b/test/support/data_case.ex
index 0ee2aa4a2..d4998a79c 100644
--- a/test/support/data_case.ex
+++ b/test/support/data_case.ex
@@ -48,19 +48,11 @@ defmodule Pleroma.DataCase do
   end
 
   def clear_cachex do
-    Pleroma.Supervisor
-    |> Supervisor.which_children()
-    |> Enum.each(fn
-      {name, _, _, [Cachex]} ->
-        name
-        |> to_string
-        |> String.trim_leading("cachex_")
-        |> Kernel.<>("_cache")
-        |> String.to_existing_atom()
-        |> Cachex.clear()
-
-      _ ->
-        nil
+    Pleroma.Application.StartUpDependencies.cachex_deps()
+    |> Enum.each(fn {name, _} ->
+      "#{name}_cache"
+      |> String.to_existing_atom()
+      |> Cachex.clear()
     end)
   end
 
diff --git a/test/support/factory.ex b/test/support/factory.ex
index 5c4e65c81..8f0e28b64 100644
--- a/test/support/factory.ex
+++ b/test/support/factory.ex
@@ -504,7 +504,7 @@ defmodule Pleroma.Factory do
       value:
         sequence(
           :value,
-          &%{another_key: "#{&1}somevalue", another: "#{&1}somevalue"}
+          &[another_key: "#{&1}somevalue", another: "#{&1}somevalue"]
         )
     }
     |> merge_attributes(attrs)
@@ -536,4 +536,11 @@ defmodule Pleroma.Factory do
       context: ["home"]
     }
   end
+
+  def config_version_factory do
+    %Pleroma.Config.Version{
+      backup: sequence(:value, &[pleroma: [instance: [name: "Instance name #{&1}"]]]),
+      current: false
+    }
+  end
 end