Merge remote-tracking branch 'remotes/origin/develop' into feature/object-hashtags-rework

# Conflicts:
#	CHANGELOG.md

CHANGELOG.md

@@ -20,6 +20,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Emoji: Support the full Unicode 13.1 set of Emoji for reactions, plus regional indicators.
 - Admin API: Reports now ordered by newest
 - Deprecated `Pleroma.Uploaders.S3, :public_endpoint`. Now `Pleroma.Upload, :base_url` is the standard configuration key for all uploaders.
+- Improved Apache webserver support: updated sample configuration, MediaProxy cache invalidation verified with the included sample script
 - Extracted object hashtags into separate table in order to improve hashtag timeline performance (via background migration in `Pleroma.Migrators.HashtagsTableMigrator`). 
 
 ### Added
@@ -38,7 +39,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - OAuth improvements and fixes: more secure session-based authentication (by token that could be revoked anytime), ability to revoke belonging OAuth token from any client etc.
 - Ability to set ActivityPub aliases for follower migration.
 - Configurable background job limits for RichMedia (link previews) and MediaProxyWarmingPolicy
-
+- Ability to define custom HTTP headers per each frontend
 
 <details>
   <summary>API Changes</summary>
@@ -63,6 +64,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   <summary>API Changes</summary>
   - Mastodon API: Current user is now included in conversation if it's the only participant.
   - Mastodon API: Fixed last_status.account being not filled with account data.
+  - Mastodon API: Fix not being able to add or remove multiple users at once in lists.
+  - Mastodon API: Fixed own_votes being not returned with poll data.
 </details>
 
 ## Unreleased (Patch)

config/config.exs

@@ -438,7 +438,9 @@
   headers: [],
   options: []
 
-config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Script, script_path: nil
+config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Script,
+  script_path: nil,
+  url_format: nil
 
 # Note: media preview proxy depends on media proxy to be enabled
 config :pleroma, :media_preview_proxy,
@@ -725,7 +727,10 @@
       "git" => "https://git.pleroma.social/pleroma/fedi-fe",
       "build_url" =>
         "https://git.pleroma.social/pleroma/fedi-fe/-/jobs/artifacts/${ref}/download?job=build",
-      "ref" => "master"
+      "ref" => "master",
+      "custom-http-headers" => [
+        {"service-worker-allowed", "/"}
+      ]
     },
     "admin-fe" => %{
       "name" => "admin-fe",

config/description.exs

@@ -60,6 +60,12 @@
     label: "Build directory",
     type: :string,
     description: "The directory inside the zip file "
+  },
+  %{
+    key: "custom-http-headers",
+    label: "Custom HTTP headers",
+    type: {:list, :string},
+    description: "The custom HTTP headers for the frontend"
   }
 ]
 
@@ -1633,13 +1639,20 @@
     group: :pleroma,
     key: Pleroma.Web.MediaProxy.Invalidation.Script,
     type: :group,
-    description: "Script invalidate settings",
+    description: "Invalidation script settings",
     children: [
       %{
         key: :script_path,
         type: :string,
-        description: "Path to shell script. Which will run purge cache.",
+        description: "Path to executable script which will purge cached items.",
         suggestions: ["./installation/nginx-cache-purge.sh.example"]
+      },
+      %{
+        key: :url_format,
+        type: :string,
+        description:
+          "Optional URL format preprocessing. Only required for Apache's htcacheclean.",
+        suggestions: [":htcacheclean"]
       }
     ]
   },
@@ -3218,6 +3231,12 @@
         type: :string,
         description: "S3 host",
         suggestions: ["s3.eu-central-1.amazonaws.com"]
+      },
+      %{
+        key: :region,
+        type: :string,
+        description: "S3 region (for AWS)",
+        suggestions: ["us-east-1"]
       }
     ]
   },

docs/configuration/cheatsheet.md

@@ -321,9 +321,10 @@ This section describe PWA manifest instance-specific values. Currently this opti
 #### Pleroma.Web.MediaProxy.Invalidation.Script
 
 This strategy allow perform external shell script to purge cache.
-Urls of attachments pass to script as arguments.
+Urls of attachments are passed to the script as arguments.
 
-* `script_path`: path to external script.
+* `script_path`: Path to the external script.
+* `url_format`: Set to `:htcacheclean` if using Apache's htcacheclean utility.
 
 Example:
 

installation/apache-cache-purge.sh.example

@@ -0,0 +1,36 @@
+#!/bin/sh
+
+# A simple shell script to delete a media from Apache's mod_disk_cache.
+# You will likely need to setup a sudo rule like the following:
+#
+# Cmnd_Alias HTCACHECLEAN = /usr/local/sbin/htcacheclean
+# pleroma ALL=HTCACHECLEAN, NOPASSWD: HTCACHECLEAN
+#
+# Please also ensure you have enabled:
+#
+# config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Script, url_format: :htcacheclean
+#
+# which will correctly format the URLs passed to this script for the htcacheclean utility.
+#
+
+SCRIPTNAME=${0##*/}
+
+# mod_disk_cache directory
+CACHE_DIRECTORY="/tmp/pleroma-media-cache"
+
+## Removes an item via the htcacheclean utility
+## $1 - the filename, can be a pattern .
+## $2 - the cache directory.
+purge_item() {
+    sudo htcacheclean -v -p "${2}" "${1}"
+} # purge_item
+
+purge() {
+  for url in $@
+  do
+    echo "$SCRIPTNAME delete \`$url\` from cache ($CACHE_DIRECTORY)"
+    purge_item "$url" $CACHE_DIRECTORY
+  done
+}
+
+purge $@

installation/pleroma-apache.conf

@@ -1,73 +1,84 @@
-# default Apache site config for Pleroma
+# Sample Apache config for Pleroma
-#
-# needed modules: define headers proxy proxy_http proxy_wstunnel rewrite ssl
-# optional modules: cache cache_disk
 #
 # Simple installation instructions:
-# 1. Install your TLS certificate, possibly using Let's Encrypt.
+# 1. Install your TLS certificate. We recommend using Let's Encrypt via Certbot
-# 2. Replace 'example.tld' with your instance's domain wherever it appears.
+# 2. Replace 'example.tld' with your instance's domain.
-# 3. This assumes a Debian style Apache config. Copy this file to
+# 3. This assumes a Debian-style Apache config. Copy this file to
-#    /etc/apache2/sites-available/ and then add a symlink to it in
+#    /etc/apache2/sites-available/ and then activate the site by running
-#    /etc/apache2/sites-enabled/ by running 'a2ensite pleroma-apache.conf', then restart Apache.
+#    'a2ensite pleroma-apache.conf', then restart Apache.
 #
 # Optional: enable disk-based caching for the media proxy
 # For details, see https://git.pleroma.social/pleroma/pleroma/wikis/How%20to%20activate%20mediaproxy
 #
-# 1. Create the directory listed below as the CacheRoot, and make sure
+# 1. Create a directory as shown below for the CacheRoot and make sure
 #    the Apache user can write to it.
 # 2. Configure Apache's htcacheclean to clean the directory periodically.
-# 3. Run 'a2enmod cache cache_disk' and restart Apache.
+#    Your OS may provide a service you can enable to do this automatically.
 
 Define servername example.tld
 
+<IfModule !proxy_module>
+    LoadModule proxy_module libexec/apache24/mod_proxy.so
+</IfModule>
+<IfModule !proxy_http_module>
+    LoadModule proxy_http_module libexec/apache24/mod_proxy_http.so
+</IfModule>
+<IfModule !proxy_wstunnel_module>
+    LoadModule proxy_wstunnel_module libexec/apache24/mod_proxy_wstunnel.so
+</IfModule>
+<IfModule !rewrite_module>
+    LoadModule rewrite_module libexec/apache24/mod_rewrite.so
+</IfModule>
+<IfModule !ssl_module>
+    LoadModule ssl_module libexec/apache24/mod_ssl.so
+</IfModule>
+<IfModule !cache_module>
+    LoadModule cache_module libexec/apache24/mod_cache.so
+</IfModule>
+<IfModule !cache_disk_module>
+    LoadModule cache_disk_module libexec/apache24/mod_cache_disk.so
+</IfModule>
+
 ServerName ${servername}
 ServerTokens Prod
 
-ErrorLog ${APACHE_LOG_DIR}/error.log
+# If you want Pleroma-specific logs
-CustomLog ${APACHE_LOG_DIR}/access.log combined
+#ErrorLog /var/log/httpd-pleroma-error.log
+#CustomLog /var/log/httpd-pleroma-access.log combined
 
 <VirtualHost *:80>
-    Redirect permanent / https://${servername}
+    RewriteEngine on
+    RewriteCond %{SERVER_NAME} =${servername}
+    RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
 </VirtualHost>
 
 <VirtualHost *:443>
     SSLEngine on
     SSLCertificateFile      /etc/letsencrypt/live/${servername}/fullchain.pem
     SSLCertificateKeyFile   /etc/letsencrypt/live/${servername}/privkey.pem
+    # Make sure you have the certbot-apache module installed
+    Include /etc/letsencrypt/options-ssl-apache.conf
 
-    # Mozilla modern configuration, tweak to your needs
+    # Uncomment the following to enable MediaProxy caching on disk
-    SSLProtocol             all -SSLv3 -TLSv1 -TLSv1.1
+    #CacheRoot /tmp/pleroma-media-cache/
-    SSLCipherSuite          ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256
+    #CacheDirLevels 1
-    SSLHonorCipherOrder     on
+    #CacheDirLength 2
-    SSLCompression          off
+    #CacheEnable disk /proxy
-    SSLSessionTickets       off
+    #CacheLock on
-
+    #CacheHeader on
-    # uncomment the following to enable mediaproxy caching on disk
+    #CacheDetailHeader on
-    # <IfModule mod_cache_disk.c>
+    ## 16MB max filesize for caching, configure as desired
-    #     CacheRoot /var/cache/apache2/mod_cache_disk
+    #CacheMaxFileSize 16000000
-    #     CacheDirLevels 1
+    #CacheDefaultExpire 86400
-    #     CacheDirLength 2
-    #     CacheEnable disk /proxy
-    #     CacheLock on
-    # </IfModule>
 
     RewriteEngine On
     RewriteCond %{HTTP:Connection} Upgrade [NC]
     RewriteCond %{HTTP:Upgrade} websocket [NC]
-    RewriteRule /(.*) ws://localhost:4000/$1 [P,L]
+    RewriteRule /(.*) ws://127.0.0.1:4000/$1 [P,L]
 
+    #ProxyRequests must be off or you open your server to abuse as an open proxy
     ProxyRequests off
-    # this is explicitly IPv4 since Pleroma.Web.Endpoint binds on IPv4 only
-    # and `localhost.` resolves to [::0] on some systems: see issue #930
     ProxyPass / http://127.0.0.1:4000/
     ProxyPassReverse / http://127.0.0.1:4000/
-
-    RequestHeader set Host ${servername}
     ProxyPreserveHost On
 </VirtualHost>
-
-# OCSP Stapling, only in httpd 2.3.3 and later
-SSLUseStapling          on
-SSLStaplingResponderTimeout 5
-SSLStaplingReturnResponderErrors off
-SSLStaplingCache        shmcb:/var/run/ocsp(128000)

lib/pleroma/list.ex

@@ -113,11 +113,15 @@ def create(title, %User{} = creator) do
     end
   end
 
-  def follow(%Pleroma.List{following: following} = list, %User{} = followed) do
+  def follow(%Pleroma.List{id: id}, %User{} = followed) do
+    list = Repo.get(Pleroma.List, id)
+    %{following: following} = list
     update_follows(list, %{following: Enum.uniq([followed.follower_address | following])})
   end
 
-  def unfollow(%Pleroma.List{following: following} = list, %User{} = unfollowed) do
+  def unfollow(%Pleroma.List{id: id}, %User{} = unfollowed) do
+    list = Repo.get(Pleroma.List, id)
+    %{following: following} = list
     update_follows(list, %{following: List.delete(following, unfollowed.follower_address)})
   end
 

lib/pleroma/web/endpoint.ex

@@ -23,6 +23,18 @@ defmodule Pleroma.Web.Endpoint do
   # InstanceStatic needs to be before Plug.Static to be able to override shipped-static files
   # If you're adding new paths to `only:` you'll need to configure them in InstanceStatic as well
   # Cache-control headers are duplicated in case we turn off etags in the future
+  plug(
+    Pleroma.Web.Plugs.InstanceStatic,
+    at: "/",
+    from: :pleroma,
+    only: ["emoji", "images"],
+    gzip: true,
+    cache_control_for_etags: "public, max-age=1209600",
+    headers: %{
+      "cache-control" => "public, max-age=1209600"
+    }
+  )
+
   plug(Pleroma.Web.Plugs.InstanceStatic,
     at: "/",
     gzip: true,

lib/pleroma/web/mastodon_api/views/poll_view.ex

@@ -11,7 +11,7 @@ def render("show.json", %{object: object, multiple: multiple, options: options}
     {end_time, expired} = end_time_and_expired(object)
     {options, votes_count} = options_and_votes_count(options)
 
-    %{
+    poll = %{
       # Mastodon uses separate ids for polls, but an object can't have
       # more than one poll embedded so object id is fine
       id: to_string(object.id),
@@ -21,9 +21,16 @@ def render("show.json", %{object: object, multiple: multiple, options: options}
       votes_count: votes_count,
       voters_count: voters_count(object),
       options: options,
-      voted: voted?(params),
       emojis: Pleroma.Web.MastodonAPI.StatusView.build_emojis(object.data["emoji"])
     }
+
+    if params[:for] do
+      # when unauthenticated Mastodon doesn't include `voted` & `own_votes` keys in response
+      {voted, own_votes} = voted_and_own_votes(params, options)
+      Map.merge(poll, %{voted: voted, own_votes: own_votes})
+    else
+      poll
+    end
   end
 
   def render("show.json", %{object: object} = params) do
@@ -67,12 +74,29 @@ defp voters_count(%{data: %{"voters" => [_ | _] = voters}}) do
 
   defp voters_count(_), do: 0
 
-  defp voted?(%{object: object} = opts) do
+  defp voted_and_own_votes(%{object: object} = params, options) do
-    if opts[:for] do
+    if params[:for] do
-      existing_votes = Pleroma.Web.ActivityPub.Utils.get_existing_votes(opts[:for].ap_id, object)
+      existing_votes =
-      existing_votes != [] or opts[:for].ap_id == object.data["actor"]
+        Pleroma.Web.ActivityPub.Utils.get_existing_votes(params[:for].ap_id, object)
+
+      voted = existing_votes != [] or params[:for].ap_id == object.data["actor"]
+
+      own_votes =
+        if voted do
+          titles = Enum.map(options, & &1[:title])
+
+          Enum.reduce(existing_votes, [], fn vote, acc ->
+            data = vote |> Map.get(:object) |> Map.get(:data)
+            index = Enum.find_index(titles, &(&1 == data["name"]))
+            [index | acc]
+          end)
+        else
+          []
+        end
+
+      {voted, own_votes}
     else
-      false
+      {false, []}
     end
   end
 end

lib/pleroma/web/media_proxy/invalidation/script.ex

@@ -13,6 +13,7 @@ defmodule Pleroma.Web.MediaProxy.Invalidation.Script do
   def purge(urls, opts \\ []) do
     args =
       urls
+      |> maybe_format_urls(Keyword.get(opts, :url_format))
       |> List.wrap()
       |> Enum.uniq()
       |> Enum.join(" ")
@@ -40,4 +41,22 @@ defp handle_result(error, _) do
     Logger.error("Error while cache purge: #{inspect(error)}")
     {:error, inspect(error)}
   end
+
+  def maybe_format_urls(urls, :htcacheclean) do
+    urls
+    |> Enum.map(fn url ->
+      uri = URI.parse(url)
+
+      query =
+        if !is_nil(uri.query) do
+          "?" <> uri.query
+        else
+          "?"
+        end
+
+      uri.scheme <> "://" <> uri.host <> ":#{inspect(uri.port)}" <> uri.path <> query
+    end)
+  end
+
+  def maybe_format_urls(urls, _), do: urls
 end

lib/pleroma/web/plugs/http_security_plug.ex

@@ -20,9 +20,26 @@ def call(conn, _options) do
     end
   end
 
-  defp headers do
+  def primary_frontend do
+    with %{"name" => frontend} <- Config.get([:frontends, :primary]),
+         available <- Config.get([:frontends, :available]),
+         %{} = primary_frontend <- Map.get(available, frontend) do
+      {:ok, primary_frontend}
+    end
+  end
+
+  def custom_http_frontend_headers do
+    with {:ok, %{"custom-http-headers" => custom_headers}} <- primary_frontend() do
+      custom_headers
+    else
+      _ -> []
+    end
+  end
+
+  def headers do
     referrer_policy = Config.get([:http_security, :referrer_policy])
     report_uri = Config.get([:http_security, :report_uri])
+    custom_http_frontend_headers = custom_http_frontend_headers()
 
     headers = [
       {"x-xss-protection", "1; mode=block"},
@@ -34,6 +51,13 @@ defp headers do
       {"content-security-policy", csp_string()}
     ]
 
+    headers =
+      if custom_http_frontend_headers do
+        custom_http_frontend_headers ++ headers
+      else
+        headers
+      end
+
     if report_uri do
       report_group = %{
         "group" => "csp-endpoint",

test/mix/tasks/pleroma/robots_txt_test.exs

@@ -12,7 +12,7 @@ defmodule Mix.Tasks.Pleroma.RobotsTxtTest do
   test "creates new dir" do
     path = "test/fixtures/new_dir/"
     file_path = path <> "robots.txt"
-    Pleroma.Config.put([:instance, :static_dir], path)
+    clear_config([:instance, :static_dir], path)
 
     on_exit(fn ->
       {:ok, ["test/fixtures/new_dir/", "test/fixtures/new_dir/robots.txt"]} = File.rm_rf(path)
@@ -29,7 +29,7 @@ test "creates new dir" do
   test "to existance folder" do
     path = "test/fixtures/"
     file_path = path <> "robots.txt"
-    Pleroma.Config.put([:instance, :static_dir], path)
+    clear_config([:instance, :static_dir], path)
 
     on_exit(fn ->
       :ok = File.rm(file_path)

test/pleroma/activity_test.exs

@@ -168,7 +168,7 @@ test "find only local statuses for unauthenticated users", %{local_activity: loc
 
     test "find only local statuses for unauthenticated users  when `limit_to_local_content` is `:all`",
          %{local_activity: local_activity} do
-      Pleroma.Config.put([:instance, :limit_to_local_content], :all)
+      clear_config([:instance, :limit_to_local_content], :all)
       assert [^local_activity] = Activity.search(nil, "find me")
     end
 
@@ -177,7 +177,7 @@ test "find all statuses for unauthenticated users when `limit_to_local_content`
            local_activity: local_activity,
            remote_activity: remote_activity
          } do
-      Pleroma.Config.put([:instance, :limit_to_local_content], false)
+      clear_config([:instance, :limit_to_local_content], false)
 
       activities = Enum.sort_by(Activity.search(nil, "find me"), & &1.id)
 

test/pleroma/application_requirements_test.exs

@@ -9,7 +9,6 @@ defmodule Pleroma.ApplicationRequirementsTest do
   import Mock
 
   alias Pleroma.ApplicationRequirements
-  alias Pleroma.Config
   alias Pleroma.Repo
 
   describe "check_repo_pool_size!/1" do
@@ -37,8 +36,8 @@ test "doesn't raise if the pool size is unexpected but the respective flag is se
     setup do: clear_config([Pleroma.Emails.Mailer])
 
     test "raises if welcome email enabled but mail disabled" do
-      Pleroma.Config.put([:welcome, :email, :enabled], true)
+      clear_config([:welcome, :email, :enabled], true)
-      Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)
+      clear_config([Pleroma.Emails.Mailer, :enabled], false)
 
       assert_raise Pleroma.ApplicationRequirements.VerifyError, "The mail disabled.", fn ->
         capture_log(&Pleroma.ApplicationRequirements.verify!/0)
@@ -59,8 +58,8 @@ test "raises if welcome email enabled but mail disabled" do
     setup do: clear_config([:instance, :account_activation_required])
 
     test "raises if account confirmation is required but mailer isn't enable" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
-      Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)
+      clear_config([Pleroma.Emails.Mailer, :enabled], false)
 
       assert_raise Pleroma.ApplicationRequirements.VerifyError,
                    "Account activation enabled, but Mailer is disabled. Cannot send confirmation emails.",
@@ -70,14 +69,14 @@ test "raises if account confirmation is required but mailer isn't enable" do
     end
 
     test "doesn't do anything if account confirmation is disabled" do
-      Pleroma.Config.put([:instance, :account_activation_required], false)
+      clear_config([:instance, :account_activation_required], false)
-      Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)
+      clear_config([Pleroma.Emails.Mailer, :enabled], false)
       assert Pleroma.ApplicationRequirements.verify!() == :ok
     end
 
     test "doesn't do anything if account confirmation is required and mailer is enabled" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
-      Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], true)
+      clear_config([Pleroma.Emails.Mailer, :enabled], true)
       assert Pleroma.ApplicationRequirements.verify!() == :ok
     end
   end
@@ -93,7 +92,7 @@ test "doesn't do anything if account confirmation is required and mailer is enab
     setup do: clear_config([:database, :rum_enabled])
 
     test "raises if rum is enabled and detects unapplied rum migrations" do
-      Config.put([:database, :rum_enabled], true)
+      clear_config([:database, :rum_enabled], true)
 
       with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
         assert_raise ApplicationRequirements.VerifyError,
@@ -105,7 +104,7 @@ test "raises if rum is enabled and detects unapplied rum migrations" do
     end
 
     test "raises if rum is disabled and detects rum migrations" do
-      Config.put([:database, :rum_enabled], false)
+      clear_config([:database, :rum_enabled], false)
 
       with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
         assert_raise ApplicationRequirements.VerifyError,
@@ -117,7 +116,7 @@ test "raises if rum is disabled and detects rum migrations" do
     end
 
     test "doesn't do anything if rum enabled and applied migrations" do
-      Config.put([:database, :rum_enabled], true)
+      clear_config([:database, :rum_enabled], true)
 
       with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
         assert ApplicationRequirements.verify!() == :ok
@@ -125,7 +124,7 @@ test "doesn't do anything if rum enabled and applied migrations" do
     end
 
     test "doesn't do anything if rum disabled" do
-      Config.put([:database, :rum_enabled], false)
+      clear_config([:database, :rum_enabled], false)
 
       with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
         assert ApplicationRequirements.verify!() == :ok
@@ -161,7 +160,7 @@ test "raises if it detects unapplied migrations" do
     end
 
     test "doesn't do anything if disabled" do
-      Config.put([:i_am_aware_this_may_cause_data_loss, :disable_migration_check], true)
+      clear_config([:i_am_aware_this_may_cause_data_loss, :disable_migration_check], true)
 
       assert :ok == ApplicationRequirements.verify!()
     end

test/pleroma/captcha_test.exs

@@ -69,7 +69,7 @@ test "new and validate" do
 
   describe "Captcha Wrapper" do
     test "validate" do
-      Pleroma.Config.put([Pleroma.Captcha, :enabled], true)
+      clear_config([Pleroma.Captcha, :enabled], true)
 
       new = Captcha.new()
 
@@ -83,7 +83,7 @@ test "validate" do
     end
 
     test "doesn't validate invalid answer" do
-      Pleroma.Config.put([Pleroma.Captcha, :enabled], true)
+      clear_config([Pleroma.Captcha, :enabled], true)
 
       new = Captcha.new()
 
@@ -99,7 +99,7 @@ test "doesn't validate invalid answer" do
     end
 
     test "nil answer_data" do
-      Pleroma.Config.put([Pleroma.Captcha, :enabled], true)
+      clear_config([Pleroma.Captcha, :enabled], true)
 
       new = Captcha.new()
 

test/pleroma/config_test.exs

@@ -30,9 +30,9 @@ test "get/1 with a list of keys" do
 
   describe "nil values" do
     setup do
-      Pleroma.Config.put(:lorem, nil)
+      clear_config(:lorem, nil)
-      Pleroma.Config.put(:ipsum, %{dolor: [sit: nil]})
+      clear_config(:ipsum, %{dolor: [sit: nil]})
-      Pleroma.Config.put(:dolor, sit: %{amet: nil})
+      clear_config(:dolor, sit: %{amet: nil})
 
       on_exit(fn -> Enum.each(~w(lorem ipsum dolor)a, &Pleroma.Config.delete/1) end)
     end
@@ -57,9 +57,9 @@ test "get/2 with a list of keys for nil value" do
   end
 
   test "get/1 when value is false" do
-    Pleroma.Config.put([:instance, :false_test], false)
+    clear_config([:instance, :false_test], false)
-    Pleroma.Config.put([:instance, :nested], [])
+    clear_config([:instance, :nested], [])
-    Pleroma.Config.put([:instance, :nested, :false_test], false)
+    clear_config([:instance, :nested, :false_test], false)
 
     assert Pleroma.Config.get([:instance, :false_test]) == false
     assert Pleroma.Config.get([:instance, :nested, :false_test]) == false
@@ -81,40 +81,40 @@ test "get!/1" do
   end
 
   test "get!/1 when value is false" do
-    Pleroma.Config.put([:instance, :false_test], false)
+    clear_config([:instance, :false_test], false)
-    Pleroma.Config.put([:instance, :nested], [])
+    clear_config([:instance, :nested], [])
-    Pleroma.Config.put([:instance, :nested, :false_test], false)
+    clear_config([:instance, :nested, :false_test], false)
 
     assert Pleroma.Config.get!([:instance, :false_test]) == false
     assert Pleroma.Config.get!([:instance, :nested, :false_test]) == false
   end
 
   test "put/2 with a key" do
-    Pleroma.Config.put(:config_test, true)
+    clear_config(:config_test, true)
 
     assert Pleroma.Config.get(:config_test) == true
   end
 
   test "put/2 with a list of keys" do
-    Pleroma.Config.put([:instance, :config_test], true)
+    clear_config([:instance, :config_test], true)
-    Pleroma.Config.put([:instance, :config_nested_test], [])
+    clear_config([:instance, :config_nested_test], [])
-    Pleroma.Config.put([:instance, :config_nested_test, :x], true)
+    clear_config([:instance, :config_nested_test, :x], true)
 
     assert Pleroma.Config.get([:instance, :config_test]) == true
     assert Pleroma.Config.get([:instance, :config_nested_test, :x]) == true
   end
 
   test "delete/1 with a key" do
-    Pleroma.Config.put([:delete_me], :delete_me)
+    clear_config([:delete_me], :delete_me)
     Pleroma.Config.delete([:delete_me])
     assert Pleroma.Config.get([:delete_me]) == nil
   end
 
   test "delete/2 with a list of keys" do
-    Pleroma.Config.put([:delete_me], hello: "world", world: "Hello")
+    clear_config([:delete_me], hello: "world", world: "Hello")
     Pleroma.Config.delete([:delete_me, :world])
     assert Pleroma.Config.get([:delete_me]) == [hello: "world"]
-    Pleroma.Config.put([:delete_me, :delete_me], hello: "world", world: "Hello")
+    clear_config([:delete_me, :delete_me], hello: "world", world: "Hello")
     Pleroma.Config.delete([:delete_me, :delete_me, :world])
     assert Pleroma.Config.get([:delete_me, :delete_me]) == [hello: "world"]
 
@@ -123,8 +123,8 @@ test "delete/2 with a list of keys" do
   end
 
   test "fetch/1" do
-    Pleroma.Config.put([:lorem], :ipsum)
+    clear_config([:lorem], :ipsum)
-    Pleroma.Config.put([:ipsum], dolor: :sit)
+    clear_config([:ipsum], dolor: :sit)
 
     assert Pleroma.Config.fetch([:lorem]) == {:ok, :ipsum}
     assert Pleroma.Config.fetch(:lorem) == {:ok, :ipsum}

test/pleroma/gun/connection_pool_test.exs

@@ -7,7 +7,6 @@ defmodule Pleroma.Gun.ConnectionPoolTest do
 
   import Mox
   import ExUnit.CaptureLog
-  alias Pleroma.Config
   alias Pleroma.Gun.ConnectionPool
 
   defp gun_mock(_) do
@@ -49,7 +48,7 @@ test "gives the same connection to 2 concurrent requests" do
 
   test "connection limit is respected with concurrent requests" do
     clear_config([:connections_pool, :max_connections]) do
-      Config.put([:connections_pool, :max_connections], 1)
+      clear_config([:connections_pool, :max_connections], 1)
       # The supervisor needs a reboot to apply the new config setting
       Process.exit(Process.whereis(Pleroma.Gun.ConnectionPool.WorkerSupervisor), :kill)
 

test/pleroma/http/adapter_helper/gun_test.exs

@@ -8,7 +8,6 @@ defmodule Pleroma.HTTP.AdapterHelper.GunTest do
 
   import Mox
 
-  alias Pleroma.Config
   alias Pleroma.HTTP.AdapterHelper.Gun
 
   setup :verify_on_exit!
@@ -52,9 +51,7 @@ test "merges with defaul http adapter config" do
     end
 
     test "parses string proxy host & port" do
-      proxy = Config.get([:http, :proxy_url])
+      clear_config([:http, :proxy_url], "localhost:8123")
-      Config.put([:http, :proxy_url], "localhost:8123")
-      on_exit(fn -> Config.put([:http, :proxy_url], proxy) end)
 
       uri = URI.parse("https://some-domain.com")
       opts = Gun.options([receive_conn: false], uri)
@@ -62,9 +59,7 @@ test "parses string proxy host & port" do
     end
 
     test "parses tuple proxy scheme host and port" do
-      proxy = Config.get([:http, :proxy_url])
+      clear_config([:http, :proxy_url], {:socks, 'localhost', 1234})
-      Config.put([:http, :proxy_url], {:socks, 'localhost', 1234})
-      on_exit(fn -> Config.put([:http, :proxy_url], proxy) end)
 
       uri = URI.parse("https://some-domain.com")
       opts = Gun.options([receive_conn: false], uri)
@@ -72,9 +67,7 @@ test "parses tuple proxy scheme host and port" do
     end
 
     test "passed opts have more weight than defaults" do
-      proxy = Config.get([:http, :proxy_url])
+      clear_config([:http, :proxy_url], {:socks5, 'localhost', 1234})
-      Config.put([:http, :proxy_url], {:socks5, 'localhost', 1234})
-      on_exit(fn -> Config.put([:http, :proxy_url], proxy) end)
       uri = URI.parse("https://some-domain.com")
       opts = Gun.options([receive_conn: false, proxy: {'example.com', 4321}], uri)
 

test/pleroma/object/fetcher_test.exs

@@ -6,7 +6,6 @@ defmodule Pleroma.Object.FetcherTest do
   use Pleroma.DataCase
 
   alias Pleroma.Activity
-  alias Pleroma.Config
   alias Pleroma.Object
   alias Pleroma.Object.Fetcher
 
@@ -87,20 +86,20 @@ test "it works when fetching the OP actor errors out" do
     setup do: clear_config([:instance, :federation_incoming_replies_max_depth])
 
     test "it returns thread depth exceeded error if thread depth is exceeded" do
-      Config.put([:instance, :federation_incoming_replies_max_depth], 0)
+      clear_config([:instance, :federation_incoming_replies_max_depth], 0)
 
       assert {:error, "Max thread distance exceeded."} =
                Fetcher.fetch_object_from_id(@ap_id, depth: 1)
     end
 
     test "it fetches object if max thread depth is restricted to 0 and depth is not specified" do
-      Config.put([:instance, :federation_incoming_replies_max_depth], 0)
+      clear_config([:instance, :federation_incoming_replies_max_depth], 0)
 
       assert {:ok, _} = Fetcher.fetch_object_from_id(@ap_id)
     end
 
     test "it fetches object if requested depth does not exceed max thread depth" do
-      Config.put([:instance, :federation_incoming_replies_max_depth], 10)
+      clear_config([:instance, :federation_incoming_replies_max_depth], 10)
 
       assert {:ok, _} = Fetcher.fetch_object_from_id(@ap_id, depth: 10)
     end
@@ -245,7 +244,7 @@ test "it can refetch pruned objects" do
                    Pleroma.Signature,
                    [:passthrough],
                    [] do
-      Config.put([:activitypub, :sign_object_fetches], true)
+      clear_config([:activitypub, :sign_object_fetches], true)
 
       Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
 
@@ -256,7 +255,7 @@ test "it can refetch pruned objects" do
                    Pleroma.Signature,
                    [:passthrough],
                    [] do
-      Config.put([:activitypub, :sign_object_fetches], false)
+      clear_config([:activitypub, :sign_object_fetches], false)
 
       Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
 

test/pleroma/repo/migrations/autolinker_to_linkify_test.exs

@@ -37,7 +37,7 @@ test "change/0 converts auto_linker opts for Pleroma.Formatter", %{migration: mi
              strip_prefix: false
            ]
 
-    Pleroma.Config.put(Pleroma.Formatter, new_opts)
+    clear_config(Pleroma.Formatter, new_opts)
     assert new_opts == Pleroma.Config.get(Pleroma.Formatter)
 
     {text, _mentions, []} =

test/pleroma/repo/migrations/fix_malformed_formatter_config_test.exs

@@ -34,7 +34,7 @@ test "change/0 converts a map into a list", %{migration: migration} do
              strip_prefix: false
            ]
 
-    Pleroma.Config.put(Pleroma.Formatter, new_opts)
+    clear_config(Pleroma.Formatter, new_opts)
     assert new_opts == Pleroma.Config.get(Pleroma.Formatter)
 
     {text, _mentions, []} =

test/pleroma/scheduled_activity_test.exs

@@ -15,7 +15,7 @@ defmodule Pleroma.ScheduledActivityTest do
 
   describe "creation" do
     test "scheduled activities with jobs when ScheduledActivity enabled" do
-      Pleroma.Config.put([ScheduledActivity, :enabled], true)
+      clear_config([ScheduledActivity, :enabled], true)
       user = insert(:user)
 
       today =
@@ -34,7 +34,7 @@ test "scheduled activities with jobs when ScheduledActivity enabled" do
     end
 
     test "scheduled activities without jobs when ScheduledActivity disabled" do
-      Pleroma.Config.put([ScheduledActivity, :enabled], false)
+      clear_config([ScheduledActivity, :enabled], false)
       user = insert(:user)
 
       today =

test/pleroma/upload/filter/anonymize_filename_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.Upload.Filter.AnonymizeFilenameTest do
   use Pleroma.DataCase
 
-  alias Pleroma.Config
   alias Pleroma.Upload
 
   setup do
@@ -23,13 +22,13 @@ defmodule Pleroma.Upload.Filter.AnonymizeFilenameTest do
   setup do: clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text])
 
   test "it replaces filename on pre-defined text", %{upload_file: upload_file} do
-    Config.put([Upload.Filter.AnonymizeFilename, :text], "custom-file.png")
+    clear_config([Upload.Filter.AnonymizeFilename, :text], "custom-file.png")
     {:ok, :filtered, %Upload{name: name}} = Upload.Filter.AnonymizeFilename.filter(upload_file)
     assert name == "custom-file.png"
   end
 
   test "it replaces filename on pre-defined text expression", %{upload_file: upload_file} do
-    Config.put([Upload.Filter.AnonymizeFilename, :text], "custom-file.{extension}")
+    clear_config([Upload.Filter.AnonymizeFilename, :text], "custom-file.{extension}")
     {:ok, :filtered, %Upload{name: name}} = Upload.Filter.AnonymizeFilename.filter(upload_file)
     assert name == "custom-file.jpg"
   end

test/pleroma/upload/filter_test.exs

@@ -5,13 +5,12 @@
 defmodule Pleroma.Upload.FilterTest do
   use Pleroma.DataCase
 
-  alias Pleroma.Config
   alias Pleroma.Upload.Filter
 
   setup do: clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text])
 
   test "applies filters" do
-    Config.put([Pleroma.Upload.Filter.AnonymizeFilename, :text], "custom-file.png")
+    clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text], "custom-file.png")
 
     File.cp!(
       "test/fixtures/image.jpg",

test/pleroma/uploaders/s3_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.Uploaders.S3Test do
   use Pleroma.DataCase
 
-  alias Pleroma.Config
   alias Pleroma.Uploaders.S3
 
   import Mock
@@ -27,13 +26,13 @@ test "it returns path to local folder for files" do
     end
 
     test "it returns path without bucket when truncated_namespace set to ''" do
-      Config.put([Pleroma.Uploaders.S3],
+      clear_config([Pleroma.Uploaders.S3],
         bucket: "test_bucket",
         bucket_namespace: "myaccount",
         truncated_namespace: ""
       )
 
-      Config.put([Pleroma.Upload, :base_url], "https://s3.amazonaws.com")
+      clear_config([Pleroma.Upload, :base_url], "https://s3.amazonaws.com")
 
       assert S3.get_file("test_image.jpg") == {
                :ok,
@@ -42,7 +41,7 @@ test "it returns path without bucket when truncated_namespace set to ''" do
     end
 
     test "it returns path with bucket namespace when namespace is set" do
-      Config.put([Pleroma.Uploaders.S3],
+      clear_config([Pleroma.Uploaders.S3],
         bucket: "test_bucket",
         bucket_namespace: "family"
       )

test/pleroma/user/backup_test.exs

@@ -23,7 +23,7 @@ defmodule Pleroma.User.BackupTest do
   end
 
   test "it requries enabled email" do
-    Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)
+    clear_config([Pleroma.Emails.Mailer, :enabled], false)
     user = insert(:user)
     assert {:error, "Backups require enabled email"} == Backup.create(user)
   end
@@ -53,7 +53,7 @@ test "it return an error if the export limit is over" do
   end
 
   test "it process a backup record" do
-    Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
+    clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
     %{id: user_id} = user = insert(:user)
 
     assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
@@ -76,8 +76,8 @@ test "it process a backup record" do
   end
 
   test "it removes outdated backups after creating a fresh one" do
-    Pleroma.Config.put([Backup, :limit_days], -1)
+    clear_config([Backup, :limit_days], -1)
-    Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
+    clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
     user = insert(:user)
 
     assert {:ok, job1} = Backup.create(user)

test/pleroma/user/welcome_chat_message_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.User.WelcomeChatMessageTest do
   use Pleroma.DataCase
 
-  alias Pleroma.Config
   alias Pleroma.User.WelcomeChatMessage
 
   import Pleroma.Factory
@@ -17,10 +16,10 @@ test "send a chat welcome message" do
       welcome_user = insert(:user, name: "mewmew")
       user = insert(:user)
 
-      Config.put([:welcome, :chat_message, :enabled], true)
+      clear_config([:welcome, :chat_message, :enabled], true)
-      Config.put([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
+      clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
 
-      Config.put(
+      clear_config(
         [:welcome, :chat_message, :message],
         "Hello, welcome to Blob/Cat!"
       )

test/pleroma/user/welcome_email_test.exs

@@ -18,15 +18,15 @@ defmodule Pleroma.User.WelcomeEmailTest do
     test "send a welcome email" do
       user = insert(:user, name: "Jimm")
 
-      Config.put([:welcome, :email, :enabled], true)
+      clear_config([:welcome, :email, :enabled], true)
-      Config.put([:welcome, :email, :sender], "welcome@pleroma.app")
+      clear_config([:welcome, :email, :sender], "welcome@pleroma.app")
 
-      Config.put(
+      clear_config(
         [:welcome, :email, :subject],
         "Hello, welcome to pleroma: <%= instance_name %>"
       )
 
-      Config.put(
+      clear_config(
         [:welcome, :email, :html],
         "<h1>Hello <%= user.name %>.</h1> <p>Welcome to <%= instance_name %></p>"
       )
@@ -44,7 +44,7 @@ test "send a welcome email" do
         html_body: "<h1>Hello #{user.name}.</h1> <p>Welcome to #{instance_name}</p>"
       )
 
-      Config.put([:welcome, :email, :sender], {"Pleroma App", "welcome@pleroma.app"})
+      clear_config([:welcome, :email, :sender], {"Pleroma App", "welcome@pleroma.app"})
 
       {:ok, _job} = WelcomeEmail.send_email(user)
 

test/pleroma/user/welcome_message_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.User.WelcomeMessageTest do
   use Pleroma.DataCase
 
-  alias Pleroma.Config
   alias Pleroma.User.WelcomeMessage
 
   import Pleroma.Factory
@@ -17,10 +16,10 @@ test "send a direct welcome message" do
       welcome_user = insert(:user)
       user = insert(:user, name: "Jimm")
 
-      Config.put([:welcome, :direct_message, :enabled], true)
+      clear_config([:welcome, :direct_message, :enabled], true)
-      Config.put([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
+      clear_config([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
 
-      Config.put(
+      clear_config(
         [:welcome, :direct_message, :message],
         "Hello. Welcome to Pleroma"
       )

test/pleroma/user_search_test.exs

@@ -18,7 +18,7 @@ defmodule Pleroma.UserSearchTest do
     setup do: clear_config([:instance, :limit_to_local_content])
 
     test "returns a resolved user as the first result" do
-      Pleroma.Config.put([:instance, :limit_to_local_content], false)
+      clear_config([:instance, :limit_to_local_content], false)
       user = insert(:user, %{nickname: "no_relation", ap_id: "https://lain.com/users/lain"})
       _user = insert(:user, %{nickname: "com_user"})
 
@@ -199,7 +199,7 @@ test "find only local users for unauthenticated users" do
     end
 
     test "find only local users for authenticated users when `limit_to_local_content` is `:all`" do
-      Pleroma.Config.put([:instance, :limit_to_local_content], :all)
+      clear_config([:instance, :limit_to_local_content], :all)
 
       %{id: id} = insert(:user, %{name: "lain"})
       insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
@@ -209,7 +209,7 @@ test "find only local users for authenticated users when `limit_to_local_content
     end
 
     test "find all users for unauthenticated users when `limit_to_local_content` is `false`" do
-      Pleroma.Config.put([:instance, :limit_to_local_content], false)
+      clear_config([:instance, :limit_to_local_content], false)
 
       u1 = insert(:user, %{name: "lain"})
       u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})

test/pleroma/user_test.exs

@@ -311,7 +311,7 @@ test "local users do not automatically follow local locked accounts" do
     setup do: clear_config([:instance, :external_user_synchronization])
 
     test "unfollow with syncronizes external user" do
-      Pleroma.Config.put([:instance, :external_user_synchronization], true)
+      clear_config([:instance, :external_user_synchronization], true)
 
       followed =
         insert(:user,
@@ -396,7 +396,7 @@ test "it autofollows accounts that are set for it" do
       user = insert(:user)
       remote_user = insert(:user, %{local: false})
 
-      Pleroma.Config.put([:instance, :autofollowed_nicknames], [
+      clear_config([:instance, :autofollowed_nicknames], [
         user.nickname,
         remote_user.nickname
       ])
@@ -413,7 +413,7 @@ test "it adds automatic followers for new registered accounts" do
       user1 = insert(:user)
       user2 = insert(:user)
 
-      Pleroma.Config.put([:instance, :autofollowing_nicknames], [
+      clear_config([:instance, :autofollowing_nicknames], [
         user1.nickname,
         user2.nickname
       ])
@@ -428,9 +428,9 @@ test "it adds automatic followers for new registered accounts" do
 
     test "it sends a welcome message if it is set" do
       welcome_user = insert(:user)
-      Pleroma.Config.put([:welcome, :direct_message, :enabled], true)
+      clear_config([:welcome, :direct_message, :enabled], true)
-      Pleroma.Config.put([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
+      clear_config([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
-      Pleroma.Config.put([:welcome, :direct_message, :message], "Hello, this is a direct message")
+      clear_config([:welcome, :direct_message, :message], "Hello, this is a direct message")
 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)
@@ -444,9 +444,9 @@ test "it sends a welcome message if it is set" do
 
     test "it sends a welcome chat message if it is set" do
       welcome_user = insert(:user)
-      Pleroma.Config.put([:welcome, :chat_message, :enabled], true)
+      clear_config([:welcome, :chat_message, :enabled], true)
-      Pleroma.Config.put([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
+      clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
-      Pleroma.Config.put([:welcome, :chat_message, :message], "Hello, this is a chat message")
+      clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")
 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)
@@ -480,12 +480,12 @@ test "it sends a welcome chat message if it is set" do
             )
 
     test "it sends a welcome chat message when Simple policy applied to local instance" do
-      Pleroma.Config.put([:mrf_simple, :media_nsfw], ["localhost"])
+      clear_config([:mrf_simple, :media_nsfw], ["localhost"])
 
       welcome_user = insert(:user)
-      Pleroma.Config.put([:welcome, :chat_message, :enabled], true)
+      clear_config([:welcome, :chat_message, :enabled], true)
-      Pleroma.Config.put([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
+      clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
-      Pleroma.Config.put([:welcome, :chat_message, :message], "Hello, this is a chat message")
+      clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")
 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)
@@ -499,10 +499,10 @@ test "it sends a welcome chat message when Simple policy applied to local instan
 
     test "it sends a welcome email message if it is set" do
       welcome_user = insert(:user)
-      Pleroma.Config.put([:welcome, :email, :enabled], true)
+      clear_config([:welcome, :email, :enabled], true)
-      Pleroma.Config.put([:welcome, :email, :sender], welcome_user.email)
+      clear_config([:welcome, :email, :sender], welcome_user.email)
 
-      Pleroma.Config.put(
+      clear_config(
         [:welcome, :email, :subject],
         "Hello, welcome to cool site: <%= instance_name %>"
       )
@@ -522,7 +522,7 @@ test "it sends a welcome email message if it is set" do
     end
 
     test "it sends a confirm email" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)
@@ -552,7 +552,7 @@ test "sends a pending approval email" do
     end
 
     test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
 
       @full_user_data
       |> Map.keys()
@@ -565,7 +565,7 @@ test "it requires an email, name, nickname and password, bio is optional when ac
     end
 
     test "it requires an name, nickname and password, bio and email are optional when account_activation_required is disabled" do
-      Pleroma.Config.put([:instance, :account_activation_required], false)
+      clear_config([:instance, :account_activation_required], false)
 
       @full_user_data
       |> Map.keys()
@@ -1712,13 +1712,13 @@ test "User.delete() plugs any possible zombie objects" do
     setup do: clear_config([:instance, :account_activation_required])
 
     test "return confirmation_pending for unconfirm user" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
       user = insert(:user, is_confirmed: false)
       assert User.account_status(user) == :confirmation_pending
     end
 
     test "return active for confirmed user" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
       user = insert(:user, is_confirmed: true)
       assert User.account_status(user) == :active
     end
@@ -1797,7 +1797,7 @@ test "returns true when the account is itself" do
     end
 
     test "returns false when the account is unconfirmed and confirmation is required" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
 
       user = insert(:user, local: true, is_confirmed: false)
       other_user = insert(:user, local: true)
@@ -1806,7 +1806,7 @@ test "returns false when the account is unconfirmed and confirmation is required
     end
 
     test "returns true when the account is unconfirmed and confirmation is required but the account is remote" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
 
       user = insert(:user, local: false, is_confirmed: false)
       other_user = insert(:user, local: true)
@@ -1815,7 +1815,7 @@ test "returns true when the account is unconfirmed and confirmation is required
     end
 
     test "returns true when the account is unconfirmed and being viewed by a privileged account (confirmation required)" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
 
       user = insert(:user, local: true, is_confirmed: false)
       other_user = insert(:user, local: true, is_admin: true)
@@ -2072,7 +2072,7 @@ test "performs update cache if user updated" do
     setup do: clear_config([:instance, :external_user_synchronization])
 
     test "updates the counters normally on following/getting a follow when disabled" do
-      Pleroma.Config.put([:instance, :external_user_synchronization], false)
+      clear_config([:instance, :external_user_synchronization], false)
       user = insert(:user)
 
       other_user =
@@ -2093,7 +2093,7 @@ test "updates the counters normally on following/getting a follow when disabled"
     end
 
     test "syncronizes the counters with the remote instance for the followed when enabled" do
-      Pleroma.Config.put([:instance, :external_user_synchronization], false)
+      clear_config([:instance, :external_user_synchronization], false)
 
       user = insert(:user)
 
@@ -2108,14 +2108,14 @@ test "syncronizes the counters with the remote instance for the followed when en
       assert other_user.following_count == 0
       assert other_user.follower_count == 0
 
-      Pleroma.Config.put([:instance, :external_user_synchronization], true)
+      clear_config([:instance, :external_user_synchronization], true)
       {:ok, _user, other_user} = User.follow(user, other_user)
 
       assert other_user.follower_count == 437
     end
 
     test "syncronizes the counters with the remote instance for the follower when enabled" do
-      Pleroma.Config.put([:instance, :external_user_synchronization], false)
+      clear_config([:instance, :external_user_synchronization], false)
 
       user = insert(:user)
 
@@ -2130,7 +2130,7 @@ test "syncronizes the counters with the remote instance for the follower when en
       assert other_user.following_count == 0
       assert other_user.follower_count == 0
 
-      Pleroma.Config.put([:instance, :external_user_synchronization], true)
+      clear_config([:instance, :external_user_synchronization], true)
       {:ok, other_user, _user} = User.follow(other_user, user)
 
       assert other_user.following_count == 152
@@ -2177,43 +2177,43 @@ test "changes email", %{user: user} do
     test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
       remote_user: remote_user
     } do
-      Pleroma.Config.put([:instance, :limit_to_local_content], false)
+      clear_config([:instance, :limit_to_local_content], false)
       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
 
-      Pleroma.Config.put([:instance, :limit_to_local_content], true)
+      clear_config([:instance, :limit_to_local_content], true)
       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
 
-      Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
+      clear_config([:instance, :limit_to_local_content], :unauthenticated)
       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
     end
 
     test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
          %{remote_user: remote_user} do
-      Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
+      clear_config([:instance, :limit_to_local_content], :unauthenticated)
       assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
     end
 
     test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
          %{remote_user: remote_user, local_user: local_user} do
-      Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
+      clear_config([:instance, :limit_to_local_content], :unauthenticated)
       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
     end
 
     test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
          %{remote_user: remote_user} do
-      Pleroma.Config.put([:instance, :limit_to_local_content], true)
+      clear_config([:instance, :limit_to_local_content], true)
       assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
     end
 
     test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
          %{local_user: local_user} do
-      Pleroma.Config.put([:instance, :limit_to_local_content], false)
+      clear_config([:instance, :limit_to_local_content], false)
       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
 
-      Pleroma.Config.put([:instance, :limit_to_local_content], true)
+      clear_config([:instance, :limit_to_local_content], true)
       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
 
-      Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
+      clear_config([:instance, :limit_to_local_content], :unauthenticated)
       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
     end
   end

test/pleroma/web/activity_pub/activity_pub_controller_test.exs

@@ -7,7 +7,6 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
   use Oban.Testing, repo: Pleroma.Repo
 
   alias Pleroma.Activity
-  alias Pleroma.Config
   alias Pleroma.Delivery
   alias Pleroma.Instances
   alias Pleroma.Object
@@ -46,7 +45,7 @@ test "with the relay active, it returns the relay user", %{conn: conn} do
     end
 
     test "with the relay disabled, it returns 404", %{conn: conn} do
-      Config.put([:instance, :allow_relay], false)
+      clear_config([:instance, :allow_relay], false)
 
       conn
       |> get(activity_pub_path(conn, :relay))
@@ -54,7 +53,7 @@ test "with the relay disabled, it returns 404", %{conn: conn} do
     end
 
     test "on non-federating instance, it returns 404", %{conn: conn} do
-      Config.put([:instance, :federating], false)
+      clear_config([:instance, :federating], false)
       user = insert(:user)
 
       conn
@@ -75,7 +74,7 @@ test "it returns the internal fetch user", %{conn: conn} do
     end
 
     test "on non-federating instance, it returns 404", %{conn: conn} do
-      Config.put([:instance, :federating], false)
+      clear_config([:instance, :federating], false)
       user = insert(:user)
 
       conn
@@ -493,7 +492,7 @@ test "it clears `unreachable` federation status of the sender", %{conn: conn} do
     end
 
     test "accept follow activity", %{conn: conn} do
-      Pleroma.Config.put([:instance, :federating], true)
+      clear_config([:instance, :federating], true)
       relay = Relay.get_actor()
 
       assert {:ok, %Activity{} = activity} = Relay.follow("https://relay.mastodon.host/actor")
@@ -539,7 +538,7 @@ test "without valid signature, " <>
 
       conn = put_req_header(conn, "content-type", "application/activity+json")
 
-      Config.put([:instance, :federating], false)
+      clear_config([:instance, :federating], false)
 
       conn
       |> post("/inbox", data)
@@ -549,7 +548,7 @@ test "without valid signature, " <>
       |> post("/inbox", non_create_data)
       |> json_response(403)
 
-      Config.put([:instance, :federating], true)
+      clear_config([:instance, :federating], true)
 
       ret_conn = post(conn, "/inbox", data)
       assert "ok" == json_response(ret_conn, 200)
@@ -1246,7 +1245,7 @@ test "it doesn't spreads faulty attributedTo or actor fields", %{
     end
 
     test "Character limitation", %{conn: conn, activity: activity} do
-      Pleroma.Config.put([:instance, :limit], 5)
+      clear_config([:instance, :limit], 5)
       user = insert(:user)
 
       result =
@@ -1275,7 +1274,7 @@ test "it returns relay followers", %{conn: conn} do
     end
 
     test "on non-federating instance, it returns 404", %{conn: conn} do
-      Config.put([:instance, :federating], false)
+      clear_config([:instance, :federating], false)
       user = insert(:user)
 
       conn
@@ -1296,7 +1295,7 @@ test "it returns relay following", %{conn: conn} do
     end
 
     test "on non-federating instance, it returns 404", %{conn: conn} do
-      Config.put([:instance, :federating], false)
+      clear_config([:instance, :federating], false)
       user = insert(:user)
 
       conn

test/pleroma/web/activity_pub/activity_pub_test.exs

@@ -1100,15 +1100,15 @@ test "sets a description if given", %{test_file: file} do
     test "it sets the default description depending on the configuration", %{test_file: file} do
       clear_config([Pleroma.Upload, :default_description])
 
-      Pleroma.Config.put([Pleroma.Upload, :default_description], nil)
+      clear_config([Pleroma.Upload, :default_description], nil)
       {:ok, %Object{} = object} = ActivityPub.upload(file)
       assert object.data["name"] == ""
 
-      Pleroma.Config.put([Pleroma.Upload, :default_description], :filename)
+      clear_config([Pleroma.Upload, :default_description], :filename)
       {:ok, %Object{} = object} = ActivityPub.upload(file)
       assert object.data["name"] == "an_image.jpg"
 
-      Pleroma.Config.put([Pleroma.Upload, :default_description], "unnamed attachment")
+      clear_config([Pleroma.Upload, :default_description], "unnamed attachment")
       {:ok, %Object{} = object} = ActivityPub.upload(file)
       assert object.data["name"] == "unnamed attachment"
     end

test/pleroma/web/activity_pub/mrf/hellthread_policy_test.exs

@@ -34,7 +34,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicyTest do
   setup do: clear_config(:mrf_hellthread)
 
   test "doesn't die on chat messages" do
-    Pleroma.Config.put([:mrf_hellthread], %{delist_threshold: 2, reject_threshold: 0})
+    clear_config([:mrf_hellthread], %{delist_threshold: 2, reject_threshold: 0})
 
     user = insert(:user)
     other_user = insert(:user)
@@ -48,7 +48,7 @@ test "doesn't die on chat messages" do
     test "rejects the message if the recipient count is above reject_threshold", %{
       message: message
     } do
-      Pleroma.Config.put([:mrf_hellthread], %{delist_threshold: 0, reject_threshold: 2})
+      clear_config([:mrf_hellthread], %{delist_threshold: 0, reject_threshold: 2})
 
       assert {:reject, "[HellthreadPolicy] 3 recipients is over the limit of 2"} ==
                filter(message)
@@ -57,7 +57,7 @@ test "rejects the message if the recipient count is above reject_threshold", %{
     test "does not reject the message if the recipient count is below reject_threshold", %{
       message: message
     } do
-      Pleroma.Config.put([:mrf_hellthread], %{delist_threshold: 0, reject_threshold: 3})
+      clear_config([:mrf_hellthread], %{delist_threshold: 0, reject_threshold: 3})
 
       assert {:ok, ^message} = filter(message)
     end
@@ -68,7 +68,7 @@ test "delists the message if the recipient count is above delist_threshold", %{
       user: user,
       message: message
     } do
-      Pleroma.Config.put([:mrf_hellthread], %{delist_threshold: 2, reject_threshold: 0})
+      clear_config([:mrf_hellthread], %{delist_threshold: 2, reject_threshold: 0})
 
       {:ok, message} = filter(message)
       assert user.follower_address in message["to"]
@@ -78,14 +78,14 @@ test "delists the message if the recipient count is above delist_threshold", %{
     test "does not delist the message if the recipient count is below delist_threshold", %{
       message: message
     } do
-      Pleroma.Config.put([:mrf_hellthread], %{delist_threshold: 4, reject_threshold: 0})
+      clear_config([:mrf_hellthread], %{delist_threshold: 4, reject_threshold: 0})
 
       assert {:ok, ^message} = filter(message)
     end
   end
 
   test "excludes follower collection and public URI from threshold count", %{message: message} do
-    Pleroma.Config.put([:mrf_hellthread], %{delist_threshold: 0, reject_threshold: 3})
+    clear_config([:mrf_hellthread], %{delist_threshold: 0, reject_threshold: 3})
 
     assert {:ok, ^message} = filter(message)
   end

test/pleroma/web/activity_pub/mrf/keyword_policy_test.exs

@@ -10,12 +10,12 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest do
   setup do: clear_config(:mrf_keyword)
 
   setup do
-    Pleroma.Config.put([:mrf_keyword], %{reject: [], federated_timeline_removal: [], replace: []})
+    clear_config([:mrf_keyword], %{reject: [], federated_timeline_removal: [], replace: []})
   end
 
   describe "rejecting based on keywords" do
     test "rejects if string matches in content" do
-      Pleroma.Config.put([:mrf_keyword, :reject], ["pun"])
+      clear_config([:mrf_keyword, :reject], ["pun"])
 
       message = %{
         "type" => "Create",
@@ -30,7 +30,7 @@ test "rejects if string matches in content" do
     end
 
     test "rejects if string matches in summary" do
-      Pleroma.Config.put([:mrf_keyword, :reject], ["pun"])
+      clear_config([:mrf_keyword, :reject], ["pun"])
 
       message = %{
         "type" => "Create",
@@ -45,7 +45,7 @@ test "rejects if string matches in summary" do
     end
 
     test "rejects if regex matches in content" do
-      Pleroma.Config.put([:mrf_keyword, :reject], [~r/comp[lL][aA][iI][nN]er/])
+      clear_config([:mrf_keyword, :reject], [~r/comp[lL][aA][iI][nN]er/])
 
       assert true ==
                Enum.all?(["complainer", "compLainer", "compLAiNer", "compLAINer"], fn content ->
@@ -63,7 +63,7 @@ test "rejects if regex matches in content" do
     end
 
     test "rejects if regex matches in summary" do
-      Pleroma.Config.put([:mrf_keyword, :reject], [~r/comp[lL][aA][iI][nN]er/])
+      clear_config([:mrf_keyword, :reject], [~r/comp[lL][aA][iI][nN]er/])
 
       assert true ==
                Enum.all?(["complainer", "compLainer", "compLAiNer", "compLAINer"], fn content ->
@@ -83,7 +83,7 @@ test "rejects if regex matches in summary" do
 
   describe "delisting from ftl based on keywords" do
     test "delists if string matches in content" do
-      Pleroma.Config.put([:mrf_keyword, :federated_timeline_removal], ["pun"])
+      clear_config([:mrf_keyword, :federated_timeline_removal], ["pun"])
 
       message = %{
         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
@@ -100,7 +100,7 @@ test "delists if string matches in content" do
     end
 
     test "delists if string matches in summary" do
-      Pleroma.Config.put([:mrf_keyword, :federated_timeline_removal], ["pun"])
+      clear_config([:mrf_keyword, :federated_timeline_removal], ["pun"])
 
       message = %{
         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
@@ -117,7 +117,7 @@ test "delists if string matches in summary" do
     end
 
     test "delists if regex matches in content" do
-      Pleroma.Config.put([:mrf_keyword, :federated_timeline_removal], [~r/comp[lL][aA][iI][nN]er/])
+      clear_config([:mrf_keyword, :federated_timeline_removal], [~r/comp[lL][aA][iI][nN]er/])
 
       assert true ==
                Enum.all?(["complainer", "compLainer", "compLAiNer", "compLAINer"], fn content ->
@@ -138,7 +138,7 @@ test "delists if regex matches in content" do
     end
 
     test "delists if regex matches in summary" do
-      Pleroma.Config.put([:mrf_keyword, :federated_timeline_removal], [~r/comp[lL][aA][iI][nN]er/])
+      clear_config([:mrf_keyword, :federated_timeline_removal], [~r/comp[lL][aA][iI][nN]er/])
 
       assert true ==
                Enum.all?(["complainer", "compLainer", "compLAiNer", "compLAINer"], fn content ->
@@ -161,7 +161,7 @@ test "delists if regex matches in summary" do
 
   describe "replacing keywords" do
     test "replaces keyword if string matches in content" do
-      Pleroma.Config.put([:mrf_keyword, :replace], [{"opensource", "free software"}])
+      clear_config([:mrf_keyword, :replace], [{"opensource", "free software"}])
 
       message = %{
         "type" => "Create",
@@ -174,7 +174,7 @@ test "replaces keyword if string matches in content" do
     end
 
     test "replaces keyword if string matches in summary" do
-      Pleroma.Config.put([:mrf_keyword, :replace], [{"opensource", "free software"}])
+      clear_config([:mrf_keyword, :replace], [{"opensource", "free software"}])
 
       message = %{
         "type" => "Create",
@@ -187,7 +187,7 @@ test "replaces keyword if string matches in summary" do
     end
 
     test "replaces keyword if regex matches in content" do
-      Pleroma.Config.put([:mrf_keyword, :replace], [
+      clear_config([:mrf_keyword, :replace], [
         {~r/open(-|\s)?source\s?(software)?/, "free software"}
       ])
 
@@ -205,7 +205,7 @@ test "replaces keyword if regex matches in content" do
     end
 
     test "replaces keyword if regex matches in summary" do
-      Pleroma.Config.put([:mrf_keyword, :replace], [
+      clear_config([:mrf_keyword, :replace], [
         {~r/open(-|\s)?source\s?(software)?/, "free software"}
       ])
 

test/pleroma/web/activity_pub/mrf/mention_policy_test.exs

@@ -23,7 +23,7 @@ test "pass filter if allow list is empty" do
 
   describe "allow" do
     test "empty" do
-      Pleroma.Config.put([:mrf_mention], %{actors: ["https://example.com/blocked"]})
+      clear_config([:mrf_mention], %{actors: ["https://example.com/blocked"]})
 
       message = %{
         "type" => "Create"
@@ -33,7 +33,7 @@ test "empty" do
     end
 
     test "to" do
-      Pleroma.Config.put([:mrf_mention], %{actors: ["https://example.com/blocked"]})
+      clear_config([:mrf_mention], %{actors: ["https://example.com/blocked"]})
 
       message = %{
         "type" => "Create",
@@ -44,7 +44,7 @@ test "to" do
     end
 
     test "cc" do
-      Pleroma.Config.put([:mrf_mention], %{actors: ["https://example.com/blocked"]})
+      clear_config([:mrf_mention], %{actors: ["https://example.com/blocked"]})
 
       message = %{
         "type" => "Create",
@@ -55,7 +55,7 @@ test "cc" do
     end
 
     test "both" do
-      Pleroma.Config.put([:mrf_mention], %{actors: ["https://example.com/blocked"]})
+      clear_config([:mrf_mention], %{actors: ["https://example.com/blocked"]})
 
       message = %{
         "type" => "Create",
@@ -69,7 +69,7 @@ test "both" do
 
   describe "deny" do
     test "to" do
-      Pleroma.Config.put([:mrf_mention], %{actors: ["https://example.com/blocked"]})
+      clear_config([:mrf_mention], %{actors: ["https://example.com/blocked"]})
 
       message = %{
         "type" => "Create",
@@ -81,7 +81,7 @@ test "to" do
     end
 
     test "cc" do
-      Pleroma.Config.put([:mrf_mention], %{actors: ["https://example.com/blocked"]})
+      clear_config([:mrf_mention], %{actors: ["https://example.com/blocked"]})
 
       message = %{
         "type" => "Create",

test/pleroma/web/activity_pub/mrf/object_age_policy_test.exs

@@ -4,7 +4,6 @@
 
 defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest do
   use Pleroma.DataCase
-  alias Pleroma.Config
   alias Pleroma.User
   alias Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy
   alias Pleroma.Web.ActivityPub.Visibility
@@ -39,7 +38,7 @@ defp get_new_message do
 
   describe "with reject action" do
     test "works with objects with empty to or cc fields" do
-      Config.put([:mrf_object_age, :actions], [:reject])
+      clear_config([:mrf_object_age, :actions], [:reject])
 
       data =
         get_old_message()
@@ -50,7 +49,7 @@ test "works with objects with empty to or cc fields" do
     end
 
     test "it rejects an old post" do
-      Config.put([:mrf_object_age, :actions], [:reject])
+      clear_config([:mrf_object_age, :actions], [:reject])
 
       data = get_old_message()
 
@@ -58,7 +57,7 @@ test "it rejects an old post" do
     end
 
     test "it allows a new post" do
-      Config.put([:mrf_object_age, :actions], [:reject])
+      clear_config([:mrf_object_age, :actions], [:reject])
 
       data = get_new_message()
 
@@ -68,7 +67,7 @@ test "it allows a new post" do
 
   describe "with delist action" do
     test "works with objects with empty to or cc fields" do
-      Config.put([:mrf_object_age, :actions], [:delist])
+      clear_config([:mrf_object_age, :actions], [:delist])
 
       data =
         get_old_message()
@@ -83,7 +82,7 @@ test "works with objects with empty to or cc fields" do
     end
 
     test "it delists an old post" do
-      Config.put([:mrf_object_age, :actions], [:delist])
+      clear_config([:mrf_object_age, :actions], [:delist])
 
       data = get_old_message()
 
@@ -95,7 +94,7 @@ test "it delists an old post" do
     end
 
     test "it allows a new post" do
-      Config.put([:mrf_object_age, :actions], [:delist])
+      clear_config([:mrf_object_age, :actions], [:delist])
 
       data = get_new_message()
 
@@ -107,7 +106,7 @@ test "it allows a new post" do
 
   describe "with strip_followers action" do
     test "works with objects with empty to or cc fields" do
-      Config.put([:mrf_object_age, :actions], [:strip_followers])
+      clear_config([:mrf_object_age, :actions], [:strip_followers])
 
       data =
         get_old_message()
@@ -123,7 +122,7 @@ test "works with objects with empty to or cc fields" do
     end
 
     test "it strips followers collections from an old post" do
-      Config.put([:mrf_object_age, :actions], [:strip_followers])
+      clear_config([:mrf_object_age, :actions], [:strip_followers])
 
       data = get_old_message()
 
@@ -136,7 +135,7 @@ test "it strips followers collections from an old post" do
     end
 
     test "it allows a new post" do
-      Config.put([:mrf_object_age, :actions], [:strip_followers])
+      clear_config([:mrf_object_age, :actions], [:strip_followers])
 
       data = get_new_message()
 

test/pleroma/web/activity_pub/mrf/reject_non_public_test.exs

@@ -49,7 +49,7 @@ test "it's allowed when addrer of message in the follower addresses of user and
         "type" => "Create"
       }
 
-      Pleroma.Config.put([:mrf_rejectnonpublic, :allow_followersonly], true)
+      clear_config([:mrf_rejectnonpublic, :allow_followersonly], true)
       assert {:ok, _message} = RejectNonPublic.filter(message)
     end
 
@@ -63,7 +63,7 @@ test "it's rejected when addrer of message in the follower addresses of user and
         "type" => "Create"
       }
 
-      Pleroma.Config.put([:mrf_rejectnonpublic, :allow_followersonly], false)
+      clear_config([:mrf_rejectnonpublic, :allow_followersonly], false)
       assert {:reject, _} = RejectNonPublic.filter(message)
     end
   end
@@ -79,7 +79,7 @@ test "it's allows when direct messages are allow" do
         "type" => "Create"
       }
 
-      Pleroma.Config.put([:mrf_rejectnonpublic, :allow_direct], true)
+      clear_config([:mrf_rejectnonpublic, :allow_direct], true)
       assert {:ok, _message} = RejectNonPublic.filter(message)
     end
 
@@ -93,7 +93,7 @@ test "it's reject when direct messages aren't allow" do
         "type" => "Create"
       }
 
-      Pleroma.Config.put([:mrf_rejectnonpublic, :allow_direct], false)
+      clear_config([:mrf_rejectnonpublic, :allow_direct], false)
       assert {:reject, _} = RejectNonPublic.filter(message)
     end
   end

test/pleroma/web/activity_pub/mrf/simple_policy_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest do
   use Pleroma.DataCase
   import Pleroma.Factory
-  alias Pleroma.Config
   alias Pleroma.Web.ActivityPub.MRF.SimplePolicy
   alias Pleroma.Web.CommonAPI
 
@@ -25,7 +24,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest do
 
   describe "when :media_removal" do
     test "is empty" do
-      Config.put([:mrf_simple, :media_removal], [])
+      clear_config([:mrf_simple, :media_removal], [])
       media_message = build_media_message()
       local_message = build_local_message()
 
@@ -34,7 +33,7 @@ test "is empty" do
     end
 
     test "has a matching host" do
-      Config.put([:mrf_simple, :media_removal], ["remote.instance"])
+      clear_config([:mrf_simple, :media_removal], ["remote.instance"])
       media_message = build_media_message()
       local_message = build_local_message()
 
@@ -47,7 +46,7 @@ test "has a matching host" do
     end
 
     test "match with wildcard domain" do
-      Config.put([:mrf_simple, :media_removal], ["*.remote.instance"])
+      clear_config([:mrf_simple, :media_removal], ["*.remote.instance"])
       media_message = build_media_message()
       local_message = build_local_message()
 
@@ -62,7 +61,7 @@ test "match with wildcard domain" do
 
   describe "when :media_nsfw" do
     test "is empty" do
-      Config.put([:mrf_simple, :media_nsfw], [])
+      clear_config([:mrf_simple, :media_nsfw], [])
       media_message = build_media_message()
       local_message = build_local_message()
 
@@ -71,7 +70,7 @@ test "is empty" do
     end
 
     test "has a matching host" do
-      Config.put([:mrf_simple, :media_nsfw], ["remote.instance"])
+      clear_config([:mrf_simple, :media_nsfw], ["remote.instance"])
       media_message = build_media_message()
       local_message = build_local_message()
 
@@ -85,7 +84,7 @@ test "has a matching host" do
     end
 
     test "match with wildcard domain" do
-      Config.put([:mrf_simple, :media_nsfw], ["*.remote.instance"])
+      clear_config([:mrf_simple, :media_nsfw], ["*.remote.instance"])
       media_message = build_media_message()
       local_message = build_local_message()
 
@@ -113,7 +112,7 @@ defp build_media_message do
 
   describe "when :report_removal" do
     test "is empty" do
-      Config.put([:mrf_simple, :report_removal], [])
+      clear_config([:mrf_simple, :report_removal], [])
       report_message = build_report_message()
       local_message = build_local_message()
 
@@ -122,7 +121,7 @@ test "is empty" do
     end
 
     test "has a matching host" do
-      Config.put([:mrf_simple, :report_removal], ["remote.instance"])
+      clear_config([:mrf_simple, :report_removal], ["remote.instance"])
       report_message = build_report_message()
       local_message = build_local_message()
 
@@ -131,7 +130,7 @@ test "has a matching host" do
     end
 
     test "match with wildcard domain" do
-      Config.put([:mrf_simple, :report_removal], ["*.remote.instance"])
+      clear_config([:mrf_simple, :report_removal], ["*.remote.instance"])
       report_message = build_report_message()
       local_message = build_local_message()
 
@@ -149,7 +148,7 @@ defp build_report_message do
 
   describe "when :federated_timeline_removal" do
     test "is empty" do
-      Config.put([:mrf_simple, :federated_timeline_removal], [])
+      clear_config([:mrf_simple, :federated_timeline_removal], [])
       {_, ftl_message} = build_ftl_actor_and_message()
       local_message = build_local_message()
 
@@ -166,7 +165,7 @@ test "has a matching host" do
         |> URI.parse()
         |> Map.fetch!(:host)
 
-      Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
+      clear_config([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
       local_message = build_local_message()
 
       assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
@@ -187,7 +186,7 @@ test "match with wildcard domain" do
         |> URI.parse()
         |> Map.fetch!(:host)
 
-      Config.put([:mrf_simple, :federated_timeline_removal], ["*." <> ftl_message_actor_host])
+      clear_config([:mrf_simple, :federated_timeline_removal], ["*." <> ftl_message_actor_host])
       local_message = build_local_message()
 
       assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
@@ -210,7 +209,7 @@ test "has a matching host but only as:Public in to" do
 
       ftl_message = Map.put(ftl_message, "cc", [])
 
-      Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
+      clear_config([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
 
       assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
       refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
@@ -231,7 +230,7 @@ defp build_ftl_actor_and_message do
 
   describe "when :reject" do
     test "is empty" do
-      Config.put([:mrf_simple, :reject], [])
+      clear_config([:mrf_simple, :reject], [])
 
       remote_message = build_remote_message()
 
@@ -239,7 +238,7 @@ test "is empty" do
     end
 
     test "activity has a matching host" do
-      Config.put([:mrf_simple, :reject], ["remote.instance"])
+      clear_config([:mrf_simple, :reject], ["remote.instance"])
 
       remote_message = build_remote_message()
 
@@ -247,7 +246,7 @@ test "activity has a matching host" do
     end
 
     test "activity matches with wildcard domain" do
-      Config.put([:mrf_simple, :reject], ["*.remote.instance"])
+      clear_config([:mrf_simple, :reject], ["*.remote.instance"])
 
       remote_message = build_remote_message()
 
@@ -255,7 +254,7 @@ test "activity matches with wildcard domain" do
     end
 
     test "actor has a matching host" do
-      Config.put([:mrf_simple, :reject], ["remote.instance"])
+      clear_config([:mrf_simple, :reject], ["remote.instance"])
 
       remote_user = build_remote_user()
 
@@ -265,7 +264,7 @@ test "actor has a matching host" do
 
   describe "when :followers_only" do
     test "is empty" do
-      Config.put([:mrf_simple, :followers_only], [])
+      clear_config([:mrf_simple, :followers_only], [])
       {_, ftl_message} = build_ftl_actor_and_message()
       local_message = build_local_message()
 
@@ -305,7 +304,7 @@ test "has a matching host" do
         |> URI.parse()
         |> Map.fetch!(:host)
 
-      Config.put([:mrf_simple, :followers_only], [actor_domain])
+      clear_config([:mrf_simple, :followers_only], [actor_domain])
 
       assert {:ok, new_activity} = SimplePolicy.filter(activity)
       assert actor.follower_address in new_activity["cc"]
@@ -323,7 +322,7 @@ test "has a matching host" do
 
   describe "when :accept" do
     test "is empty" do
-      Config.put([:mrf_simple, :accept], [])
+      clear_config([:mrf_simple, :accept], [])
 
       local_message = build_local_message()
       remote_message = build_remote_message()
@@ -333,7 +332,7 @@ test "is empty" do
     end
 
     test "is not empty but activity doesn't have a matching host" do
-      Config.put([:mrf_simple, :accept], ["non.matching.remote"])
+      clear_config([:mrf_simple, :accept], ["non.matching.remote"])
 
       local_message = build_local_message()
       remote_message = build_remote_message()
@@ -343,7 +342,7 @@ test "is not empty but activity doesn't have a matching host" do
     end
 
     test "activity has a matching host" do
-      Config.put([:mrf_simple, :accept], ["remote.instance"])
+      clear_config([:mrf_simple, :accept], ["remote.instance"])
 
       local_message = build_local_message()
       remote_message = build_remote_message()
@@ -353,7 +352,7 @@ test "activity has a matching host" do
     end
 
     test "activity matches with wildcard domain" do
-      Config.put([:mrf_simple, :accept], ["*.remote.instance"])
+      clear_config([:mrf_simple, :accept], ["*.remote.instance"])
 
       local_message = build_local_message()
       remote_message = build_remote_message()
@@ -363,7 +362,7 @@ test "activity matches with wildcard domain" do
     end
 
     test "actor has a matching host" do
-      Config.put([:mrf_simple, :accept], ["remote.instance"])
+      clear_config([:mrf_simple, :accept], ["remote.instance"])
 
       remote_user = build_remote_user()
 
@@ -373,7 +372,7 @@ test "actor has a matching host" do
 
   describe "when :avatar_removal" do
     test "is empty" do
-      Config.put([:mrf_simple, :avatar_removal], [])
+      clear_config([:mrf_simple, :avatar_removal], [])
 
       remote_user = build_remote_user()
 
@@ -381,7 +380,7 @@ test "is empty" do
     end
 
     test "is not empty but it doesn't have a matching host" do
-      Config.put([:mrf_simple, :avatar_removal], ["non.matching.remote"])
+      clear_config([:mrf_simple, :avatar_removal], ["non.matching.remote"])
 
       remote_user = build_remote_user()
 
@@ -389,7 +388,7 @@ test "is not empty but it doesn't have a matching host" do
     end
 
     test "has a matching host" do
-      Config.put([:mrf_simple, :avatar_removal], ["remote.instance"])
+      clear_config([:mrf_simple, :avatar_removal], ["remote.instance"])
 
       remote_user = build_remote_user()
       {:ok, filtered} = SimplePolicy.filter(remote_user)
@@ -398,7 +397,7 @@ test "has a matching host" do
     end
 
     test "match with wildcard domain" do
-      Config.put([:mrf_simple, :avatar_removal], ["*.remote.instance"])
+      clear_config([:mrf_simple, :avatar_removal], ["*.remote.instance"])
 
       remote_user = build_remote_user()
       {:ok, filtered} = SimplePolicy.filter(remote_user)
@@ -409,7 +408,7 @@ test "match with wildcard domain" do
 
   describe "when :banner_removal" do
     test "is empty" do
-      Config.put([:mrf_simple, :banner_removal], [])
+      clear_config([:mrf_simple, :banner_removal], [])
 
       remote_user = build_remote_user()
 
@@ -417,7 +416,7 @@ test "is empty" do
     end
 
     test "is not empty but it doesn't have a matching host" do
-      Config.put([:mrf_simple, :banner_removal], ["non.matching.remote"])
+      clear_config([:mrf_simple, :banner_removal], ["non.matching.remote"])
 
       remote_user = build_remote_user()
 
@@ -425,7 +424,7 @@ test "is not empty but it doesn't have a matching host" do
     end
 
     test "has a matching host" do
-      Config.put([:mrf_simple, :banner_removal], ["remote.instance"])
+      clear_config([:mrf_simple, :banner_removal], ["remote.instance"])
 
       remote_user = build_remote_user()
       {:ok, filtered} = SimplePolicy.filter(remote_user)
@@ -434,7 +433,7 @@ test "has a matching host" do
     end
 
     test "match with wildcard domain" do
-      Config.put([:mrf_simple, :banner_removal], ["*.remote.instance"])
+      clear_config([:mrf_simple, :banner_removal], ["*.remote.instance"])
 
       remote_user = build_remote_user()
       {:ok, filtered} = SimplePolicy.filter(remote_user)
@@ -444,10 +443,10 @@ test "match with wildcard domain" do
   end
 
   describe "when :reject_deletes is empty" do
-    setup do: Config.put([:mrf_simple, :reject_deletes], [])
+    setup do: clear_config([:mrf_simple, :reject_deletes], [])
 
     test "it accepts deletions even from rejected servers" do
-      Config.put([:mrf_simple, :reject], ["remote.instance"])
+      clear_config([:mrf_simple, :reject], ["remote.instance"])
 
       deletion_message = build_remote_deletion_message()
 
@@ -455,7 +454,7 @@ test "it accepts deletions even from rejected servers" do
     end
 
     test "it accepts deletions even from non-whitelisted servers" do
-      Config.put([:mrf_simple, :accept], ["non.matching.remote"])
+      clear_config([:mrf_simple, :accept], ["non.matching.remote"])
 
       deletion_message = build_remote_deletion_message()
 
@@ -464,10 +463,10 @@ test "it accepts deletions even from non-whitelisted servers" do
   end
 
   describe "when :reject_deletes is not empty but it doesn't have a matching host" do
-    setup do: Config.put([:mrf_simple, :reject_deletes], ["non.matching.remote"])
+    setup do: clear_config([:mrf_simple, :reject_deletes], ["non.matching.remote"])
 
     test "it accepts deletions even from rejected servers" do
-      Config.put([:mrf_simple, :reject], ["remote.instance"])
+      clear_config([:mrf_simple, :reject], ["remote.instance"])
 
       deletion_message = build_remote_deletion_message()
 
@@ -475,7 +474,7 @@ test "it accepts deletions even from rejected servers" do
     end
 
     test "it accepts deletions even from non-whitelisted servers" do
-      Config.put([:mrf_simple, :accept], ["non.matching.remote"])
+      clear_config([:mrf_simple, :accept], ["non.matching.remote"])
 
       deletion_message = build_remote_deletion_message()
 
@@ -484,7 +483,7 @@ test "it accepts deletions even from non-whitelisted servers" do
   end
 
   describe "when :reject_deletes has a matching host" do
-    setup do: Config.put([:mrf_simple, :reject_deletes], ["remote.instance"])
+    setup do: clear_config([:mrf_simple, :reject_deletes], ["remote.instance"])
 
     test "it rejects the deletion" do
       deletion_message = build_remote_deletion_message()
@@ -494,7 +493,7 @@ test "it rejects the deletion" do
   end
 
   describe "when :reject_deletes match with wildcard domain" do
-    setup do: Config.put([:mrf_simple, :reject_deletes], ["*.remote.instance"])
+    setup do: clear_config([:mrf_simple, :reject_deletes], ["*.remote.instance"])
 
     test "it rejects the deletion" do
       deletion_message = build_remote_deletion_message()

test/pleroma/web/activity_pub/mrf/subchain_policy_test.exs

@@ -16,7 +16,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.SubchainPolicyTest do
   setup do: clear_config([:mrf_subchain, :match_actor])
 
   test "it matches and processes subchains when the actor matches a configured target" do
-    Pleroma.Config.put([:mrf_subchain, :match_actor], %{
+    clear_config([:mrf_subchain, :match_actor], %{
       ~r/^https:\/\/banned.com/s => [DropPolicy]
     })
 
@@ -24,7 +24,7 @@ test "it matches and processes subchains when the actor matches a configured tar
   end
 
   test "it doesn't match and process subchains when the actor doesn't match a configured target" do
-    Pleroma.Config.put([:mrf_subchain, :match_actor], %{
+    clear_config([:mrf_subchain, :match_actor], %{
       ~r/^https:\/\/borked.com/s => [DropPolicy]
     })
 

test/pleroma/web/activity_pub/mrf/user_allow_list_policy_test.exs

@@ -17,14 +17,14 @@ test "pass filter if allow list is empty" do
 
   test "pass filter if allow list isn't empty and user in allow list" do
     actor = insert(:user)
-    Pleroma.Config.put([:mrf_user_allowlist], %{"localhost" => [actor.ap_id, "test-ap-id"]})
+    clear_config([:mrf_user_allowlist], %{"localhost" => [actor.ap_id, "test-ap-id"]})
     message = %{"actor" => actor.ap_id}
     assert UserAllowListPolicy.filter(message) == {:ok, message}
   end
 
   test "rejected if allow list isn't empty and user not in allow list" do
     actor = insert(:user)
-    Pleroma.Config.put([:mrf_user_allowlist], %{"localhost" => ["test-ap-id"]})
+    clear_config([:mrf_user_allowlist], %{"localhost" => ["test-ap-id"]})
     message = %{"actor" => actor.ap_id}
     assert {:reject, _} = UserAllowListPolicy.filter(message)
   end

test/pleroma/web/activity_pub/mrf/vocabulary_policy_test.exs

@@ -11,7 +11,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicyTest do
     setup do: clear_config([:mrf_vocabulary, :accept])
 
     test "it accepts based on parent activity type" do
-      Pleroma.Config.put([:mrf_vocabulary, :accept], ["Like"])
+      clear_config([:mrf_vocabulary, :accept], ["Like"])
 
       message = %{
         "type" => "Like",
@@ -22,7 +22,7 @@ test "it accepts based on parent activity type" do
     end
 
     test "it accepts based on child object type" do
-      Pleroma.Config.put([:mrf_vocabulary, :accept], ["Create", "Note"])
+      clear_config([:mrf_vocabulary, :accept], ["Create", "Note"])
 
       message = %{
         "type" => "Create",
@@ -36,7 +36,7 @@ test "it accepts based on child object type" do
     end
 
     test "it does not accept disallowed child objects" do
-      Pleroma.Config.put([:mrf_vocabulary, :accept], ["Create", "Note"])
+      clear_config([:mrf_vocabulary, :accept], ["Create", "Note"])
 
       message = %{
         "type" => "Create",
@@ -50,7 +50,7 @@ test "it does not accept disallowed child objects" do
     end
 
     test "it does not accept disallowed parent types" do
-      Pleroma.Config.put([:mrf_vocabulary, :accept], ["Announce", "Note"])
+      clear_config([:mrf_vocabulary, :accept], ["Announce", "Note"])
 
       message = %{
         "type" => "Create",
@@ -68,7 +68,7 @@ test "it does not accept disallowed parent types" do
     setup do: clear_config([:mrf_vocabulary, :reject])
 
     test "it rejects based on parent activity type" do
-      Pleroma.Config.put([:mrf_vocabulary, :reject], ["Like"])
+      clear_config([:mrf_vocabulary, :reject], ["Like"])
 
       message = %{
         "type" => "Like",
@@ -79,7 +79,7 @@ test "it rejects based on parent activity type" do
     end
 
     test "it rejects based on child object type" do
-      Pleroma.Config.put([:mrf_vocabulary, :reject], ["Note"])
+      clear_config([:mrf_vocabulary, :reject], ["Note"])
 
       message = %{
         "type" => "Create",
@@ -93,7 +93,7 @@ test "it rejects based on child object type" do
     end
 
     test "it passes through objects that aren't disallowed" do
-      Pleroma.Config.put([:mrf_vocabulary, :reject], ["Like"])
+      clear_config([:mrf_vocabulary, :reject], ["Like"])
 
       message = %{
         "type" => "Announce",

test/pleroma/web/activity_pub/object_validators/chat_validation_test.exs

@@ -149,7 +149,7 @@ test "does not validate if the message has no content", %{
     test "does not validate if the message is longer than the remote_limit", %{
       valid_chat_message: valid_chat_message
     } do
-      Pleroma.Config.put([:instance, :remote_limit], 2)
+      clear_config([:instance, :remote_limit], 2)
       refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
     end
 

test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs

@@ -133,7 +133,7 @@ test "it works for follow requests when you are already followed, creating a new
     end
 
     test "it rejects incoming follow requests from blocked users when deny_follow_blocked is enabled" do
-      Pleroma.Config.put([:user, :deny_follow_blocked], true)
+      clear_config([:user, :deny_follow_blocked], true)
 
       user = insert(:user)
       {:ok, target} = User.get_or_fetch("http://mastodon.example.org/users/admin")

test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs

@@ -417,7 +417,7 @@ test "schedules background fetching of `replies` items if max thread depth limit
       data: data,
       items: items
     } do
-      Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 10)
+      clear_config([:instance, :federation_incoming_replies_max_depth], 10)
 
       {:ok, _activity} = Transmogrifier.handle_incoming(data)
 
@@ -429,7 +429,7 @@ test "schedules background fetching of `replies` items if max thread depth limit
 
     test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
          %{data: data} do
-      Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 0)
+      clear_config([:instance, :federation_incoming_replies_max_depth], 0)
 
       {:ok, _activity} = Transmogrifier.handle_incoming(data)
 
@@ -466,7 +466,7 @@ test "schedules background fetching of `replies` items if max thread depth limit
       federation_output: federation_output,
       replies_uris: replies_uris
     } do
-      Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 1)
+      clear_config([:instance, :federation_incoming_replies_max_depth], 1)
 
       {:ok, _activity} = Transmogrifier.handle_incoming(federation_output)
 
@@ -478,7 +478,7 @@ test "schedules background fetching of `replies` items if max thread depth limit
 
     test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
          %{federation_output: federation_output} do
-      Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 0)
+      clear_config([:instance, :federation_incoming_replies_max_depth], 0)
 
       {:ok, _activity} = Transmogrifier.handle_incoming(federation_output)
 
@@ -553,7 +553,7 @@ test "returns not modified object when hasn't containts inReplyTo field", %{data
     end
 
     test "returns object with inReplyTo when denied incoming reply", %{data: data} do
-      Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 0)
+      clear_config([:instance, :federation_incoming_replies_max_depth], 0)
 
       object_with_reply =
         Map.put(data["object"], "inReplyTo", "https://shitposter.club/notice/2827873")
@@ -587,7 +587,7 @@ test "returns modified object when allowed incoming reply", %{data: data} do
           "https://mstdn.io/users/mayuutann/statuses/99568293732299394"
         )
 
-      Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 5)
+      clear_config([:instance, :federation_incoming_replies_max_depth], 5)
       modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
 
       assert modified_object["inReplyTo"] ==

test/pleroma/web/admin_api/controllers/config_controller_test.exs

@@ -8,7 +8,6 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
   import ExUnit.CaptureLog
   import Pleroma.Factory
 
-  alias Pleroma.Config
   alias Pleroma.ConfigDB
 
   setup do
@@ -27,7 +26,7 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
     setup do: clear_config(:configurable_from_database, true)
 
     test "when configuration from database is off", %{conn: conn} do
-      Config.put(:configurable_from_database, false)
+      clear_config(:configurable_from_database, false)
       conn = get(conn, "/api/pleroma/admin/config")
 
       assert json_response_and_validate_schema(conn, 400) ==
@@ -410,8 +409,7 @@ test "saving config with partial update", %{conn: conn} do
     end
 
     test "saving config which need pleroma reboot", %{conn: conn} do
-      chat = Config.get(:chat)
+      clear_config([:chat, :enabled], true)
-      on_exit(fn -> Config.put(:chat, chat) end)
 
       assert conn
              |> put_req_header("content-type", "application/json")
@@ -456,8 +454,7 @@ test "saving config which need pleroma reboot", %{conn: conn} do
     end
 
     test "update setting which need reboot, don't change reboot flag until reboot", %{conn: conn} do
-      chat = Config.get(:chat)
+      clear_config([:chat, :enabled], true)
-      on_exit(fn -> Config.put(:chat, chat) end)
 
       assert conn
              |> put_req_header("content-type", "application/json")

test/pleroma/web/admin_api/controllers/invite_controller_test.exs

@@ -7,7 +7,6 @@ defmodule Pleroma.Web.AdminAPI.InviteControllerTest do
 
   import Pleroma.Factory
 
-  alias Pleroma.Config
   alias Pleroma.Repo
   alias Pleroma.UserInviteToken
 
@@ -119,8 +118,8 @@ test "email with +", %{conn: conn, admin: admin} do
     setup do: clear_config([:instance, :invites_enabled])
 
     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn} do
-      Config.put([:instance, :registrations_open], false)
+      clear_config([:instance, :registrations_open], false)
-      Config.put([:instance, :invites_enabled], false)
+      clear_config([:instance, :invites_enabled], false)
 
       conn =
         conn
@@ -138,8 +137,8 @@ test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn} do
     end
 
     test "it returns 500 if `registrations_open` is enabled", %{conn: conn} do
-      Config.put([:instance, :registrations_open], true)
+      clear_config([:instance, :registrations_open], true)
-      Config.put([:instance, :invites_enabled], true)
+      clear_config([:instance, :invites_enabled], true)
 
       conn =
         conn

test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs

@@ -21,9 +21,9 @@ defmodule Pleroma.Web.AdminAPI.MediaProxyCacheControllerTest do
       |> assign(:user, admin)
       |> assign(:token, token)
 
-    Config.put([:media_proxy, :enabled], true)
+    clear_config([:media_proxy, :enabled], true)
-    Config.put([:media_proxy, :invalidation, :enabled], true)
+    clear_config([:media_proxy, :invalidation, :enabled], true)
-    Config.put([:media_proxy, :invalidation, :provider], MediaProxy.Invalidation.Script)
+    clear_config([:media_proxy, :invalidation, :provider], MediaProxy.Invalidation.Script)
 
     {:ok, %{admin: admin, token: token, conn: conn}}
   end

test/pleroma/web/chat_channel_test.exs

@@ -33,7 +33,7 @@ test "it ignores messages of length zero", %{socket: socket} do
     end
 
     test "it ignores messages above a certain length", %{socket: socket} do
-      Pleroma.Config.put([:instance, :chat_limit], 2)
+      clear_config([:instance, :chat_limit], 2)
       push(socket, "new_msg", %{"text" => "123"})
       refute_broadcast("new_msg", %{text: "123"})
     end

test/pleroma/web/common_api_test.exs

@@ -234,7 +234,7 @@ test "it posts a chat message" do
     end
 
     test "it reject messages over the local limit" do
-      Pleroma.Config.put([:instance, :chat_limit], 2)
+      clear_config([:instance, :chat_limit], 2)
 
       author = insert(:user)
       recipient = insert(:user)
@@ -475,7 +475,7 @@ test "with the safe_dm_mention option set, it does not mention people beyond the
     jafnhar = insert(:user)
     tridi = insert(:user)
 
-    Pleroma.Config.put([:instance, :safe_dm_mentions], true)
+    clear_config([:instance, :safe_dm_mentions], true)
 
     {:ok, activity} =
       CommonAPI.post(har, %{
@@ -642,7 +642,7 @@ test "it returns error when status is empty and no attachments" do
     end
 
     test "it validates character limits are correctly enforced" do
-      Pleroma.Config.put([:instance, :limit], 5)
+      clear_config([:instance, :limit], 5)
 
       user = insert(:user)
 
@@ -793,7 +793,7 @@ test "favoriting a status twice returns ok, but without the like activity" do
 
   describe "pinned statuses" do
     setup do
-      Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
+      clear_config([:instance, :max_pinned_statuses], 1)
 
       user = insert(:user)
       {:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})

test/pleroma/web/federator_test.exs

@@ -56,7 +56,7 @@ test "with relays deactivated, it does not publish to the relay", %{
       activity: activity,
       relay_mock: relay_mock
     } do
-      Pleroma.Config.put([:instance, :allow_relay], false)
+      clear_config([:instance, :allow_relay], false)
 
       with_mocks([relay_mock]) do
         Federator.publish(activity)
@@ -155,9 +155,9 @@ test "rejects incoming AP docs with incorrect origin" do
     end
 
     test "it does not crash if MRF rejects the post" do
-      Pleroma.Config.put([:mrf_keyword, :reject], ["lain"])
+      clear_config([:mrf_keyword, :reject], ["lain"])
 
-      Pleroma.Config.put(
+      clear_config(
         [:mrf, :policies],
         Pleroma.Web.ActivityPub.MRF.KeywordPolicy
       )

test/pleroma/web/feed/tag_controller_test.exs

@@ -8,7 +8,6 @@ defmodule Pleroma.Web.Feed.TagControllerTest do
   import Pleroma.Factory
   import SweetXml
 
-  alias Pleroma.Config
   alias Pleroma.Object
   alias Pleroma.Web.CommonAPI
   alias Pleroma.Web.Feed.FeedView
@@ -16,7 +15,7 @@ defmodule Pleroma.Web.Feed.TagControllerTest do
   setup do: clear_config([:feed])
 
   test "gets a feed (ATOM)", %{conn: conn} do
-    Config.put(
+    clear_config(
       [:feed, :post_title],
       %{max_length: 25, omission: "..."}
     )
@@ -83,7 +82,7 @@ test "gets a feed (ATOM)", %{conn: conn} do
   end
 
   test "gets a feed (RSS)", %{conn: conn} do
-    Config.put(
+    clear_config(
       [:feed, :post_title],
       %{max_length: 25, omission: "..."}
     )

test/pleroma/web/feed/user_controller_test.exs

@@ -8,7 +8,6 @@ defmodule Pleroma.Web.Feed.UserControllerTest do
   import Pleroma.Factory
   import SweetXml
 
-  alias Pleroma.Config
   alias Pleroma.Object
   alias Pleroma.User
   alias Pleroma.Web.CommonAPI
@@ -20,7 +19,7 @@ defmodule Pleroma.Web.Feed.UserControllerTest do
     setup do: clear_config([:feed])
 
     setup do
-      Config.put(
+      clear_config(
         [:feed, :post_title],
         %{max_length: 15, omission: "..."}
       )
@@ -236,7 +235,7 @@ test "with non-html / non-json format, it returns error when user is not found",
     setup do: clear_config([:instance, :public])
 
     test "returns 404 for user feed", %{conn: conn} do
-      Config.put([:instance, :public], false)
+      clear_config([:instance, :public], false)
       user = insert(:user)
 
       {:ok, _} = CommonAPI.post(user, %{status: "test"})

test/pleroma/web/mastodon_api/controllers/account_controller_test.exs

@@ -1007,7 +1007,7 @@ test "registers and logs in without :account_activation_required / :account_appr
       assert %{"error" => "{\"email\":[\"Invalid email\"]}"} =
                json_response_and_validate_schema(conn, 400)
 
-      Pleroma.Config.put([User, :email_blacklist], [])
+      clear_config([User, :email_blacklist], [])
 
       conn =
         build_conn()

test/pleroma/web/mastodon_api/controllers/list_controller_test.exs

@@ -55,30 +55,39 @@ test "listing a user's lists" do
   test "adding users to a list" do
     %{user: user, conn: conn} = oauth_access(["write:lists"])
     other_user = insert(:user)
+    third_user = insert(:user)
     {:ok, list} = Pleroma.List.create("name", user)
 
     assert %{} ==
              conn
              |> put_req_header("content-type", "application/json")
-             |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
+             |> post("/api/v1/lists/#{list.id}/accounts", %{
+               "account_ids" => [other_user.id, third_user.id]
+             })
              |> json_response_and_validate_schema(:ok)
 
     %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
-    assert following == [other_user.follower_address]
+    assert length(following) == 2
+    assert other_user.follower_address in following
+    assert third_user.follower_address in following
   end
 
   test "removing users from a list, body params" do
     %{user: user, conn: conn} = oauth_access(["write:lists"])
     other_user = insert(:user)
     third_user = insert(:user)
+    fourth_user = insert(:user)
     {:ok, list} = Pleroma.List.create("name", user)
     {:ok, list} = Pleroma.List.follow(list, other_user)
     {:ok, list} = Pleroma.List.follow(list, third_user)
+    {:ok, list} = Pleroma.List.follow(list, fourth_user)
 
     assert %{} ==
              conn
              |> put_req_header("content-type", "application/json")
-             |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
+             |> delete("/api/v1/lists/#{list.id}/accounts", %{
+               "account_ids" => [other_user.id, fourth_user.id]
+             })
              |> json_response_and_validate_schema(:ok)
 
     %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)

test/pleroma/web/mastodon_api/controllers/poll_controller_test.exs

@@ -47,6 +47,78 @@ test "does not expose polls for private statuses", %{conn: conn} do
     end
   end
 
+  test "own_votes" do
+    %{conn: conn} = oauth_access(["write:statuses", "read:statuses"])
+
+    other_user = insert(:user)
+
+    {:ok, activity} =
+      CommonAPI.post(other_user, %{
+        status: "A very delicious sandwich",
+        poll: %{
+          options: ["Lettuce", "Grilled Bacon", "Tomato"],
+          expires_in: 20,
+          multiple: true
+        }
+      })
+
+    object = Object.normalize(activity, fetch: false)
+
+    conn
+    |> put_req_header("content-type", "application/json")
+    |> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 2]})
+    |> json_response_and_validate_schema(200)
+
+    object = Object.get_by_id(object.id)
+
+    assert [
+             %{
+               "name" => "Lettuce",
+               "replies" => %{"totalItems" => 1, "type" => "Collection"},
+               "type" => "Note"
+             },
+             %{
+               "name" => "Grilled Bacon",
+               "replies" => %{"totalItems" => 0, "type" => "Collection"},
+               "type" => "Note"
+             },
+             %{
+               "name" => "Tomato",
+               "replies" => %{"totalItems" => 1, "type" => "Collection"},
+               "type" => "Note"
+             }
+           ] == object.data["anyOf"]
+
+    assert %{"replies" => %{"totalItems" => 0}} =
+             Enum.find(object.data["anyOf"], fn %{"name" => name} -> name == "Grilled Bacon" end)
+
+    Enum.each(["Lettuce", "Tomato"], fn title ->
+      %{"replies" => %{"totalItems" => total_items}} =
+        Enum.find(object.data["anyOf"], fn %{"name" => name} -> name == title end)
+
+      assert total_items == 1
+    end)
+
+    assert %{
+             "own_votes" => own_votes,
+             "voted" => true
+           } =
+             conn
+             |> get("/api/v1/polls/#{object.id}")
+             |> json_response_and_validate_schema(200)
+
+    assert 0 in own_votes
+    assert 2 in own_votes
+    # for non authenticated user
+    response =
+      build_conn()
+      |> get("/api/v1/polls/#{object.id}")
+      |> json_response_and_validate_schema(200)
+
+    refute Map.has_key?(response, "own_votes")
+    refute Map.has_key?(response, "voted")
+  end
+
   describe "POST /api/v1/polls/:id/votes" do
     setup do: oauth_access(["write:statuses"])
 
@@ -65,12 +137,11 @@ test "votes are added to the poll", %{conn: conn} do
 
       object = Object.normalize(activity, fetch: false)
 
-      conn =
+      conn
-        conn
+      |> put_req_header("content-type", "application/json")
-        |> put_req_header("content-type", "application/json")
+      |> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1, 2]})
-        |> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1, 2]})
+      |> json_response_and_validate_schema(200)
 
-      assert json_response_and_validate_schema(conn, 200)
       object = Object.get_by_id(object.id)
 
       assert Enum.all?(object.data["anyOf"], fn %{"replies" => %{"totalItems" => total_items}} ->

test/pleroma/web/mastodon_api/controllers/scheduled_activity_controller_test.exs

@@ -55,7 +55,7 @@ test "shows a scheduled activity" do
   end
 
   test "updates a scheduled activity" do
-    Pleroma.Config.put([ScheduledActivity, :enabled], true)
+    clear_config([ScheduledActivity, :enabled], true)
     %{user: user, conn: conn} = oauth_access(["write:statuses"])
 
     scheduled_at = Timex.shift(NaiveDateTime.utc_now(), minutes: 60)
@@ -103,7 +103,7 @@ test "updates a scheduled activity" do
   end
 
   test "deletes a scheduled activity" do
-    Pleroma.Config.put([ScheduledActivity, :enabled], true)
+    clear_config([ScheduledActivity, :enabled], true)
     %{user: user, conn: conn} = oauth_access(["write:statuses"])
     scheduled_at = Timex.shift(NaiveDateTime.utc_now(), minutes: 60)
 

test/pleroma/web/mastodon_api/controllers/status_controller_test.exs

@@ -7,7 +7,6 @@ defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
   use Oban.Testing, repo: Pleroma.Repo
 
   alias Pleroma.Activity
-  alias Pleroma.Config
   alias Pleroma.Conversation.Participation
   alias Pleroma.Object
   alias Pleroma.Repo
@@ -29,7 +28,7 @@ defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
     setup do: oauth_access(["write:statuses"])
 
     test "posting a status does not increment reblog_count when relaying", %{conn: conn} do
-      Config.put([:instance, :federating], true)
+      clear_config([:instance, :federating], true)
       Config.get([:instance, :allow_relay], true)
 
       response =
@@ -151,8 +150,8 @@ test "it fails to create a status if `expires_in` is less or equal than an hour"
     end
 
     test "Get MRF reason when posting a status is rejected by one", %{conn: conn} do
-      Config.put([:mrf_keyword, :reject], ["GNO"])
+      clear_config([:mrf_keyword, :reject], ["GNO"])
-      Config.put([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])
+      clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])
 
       assert %{"error" => "[KeywordPolicy] Matches with rejected keyword"} =
                conn
@@ -1204,7 +1203,7 @@ test "on pin removes deletion job, on unpin reschedule deletion" do
 
   describe "cards" do
     setup do
-      Config.put([:rich_media, :enabled], true)
+      clear_config([:rich_media, :enabled], true)
 
       oauth_access(["read:statuses"])
     end

test/pleroma/web/mastodon_api/masto_fe_controller_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.Web.MastodonAPI.MastoFEControllerTest do
   use Pleroma.Web.ConnCase
 
-  alias Pleroma.Config
   alias Pleroma.User
 
   import Pleroma.Factory
@@ -55,7 +54,7 @@ test "redirects not logged-in users to the login page on private instances", %{
       conn: conn,
       path: path
     } do
-      Config.put([:instance, :public], false)
+      clear_config([:instance, :public], false)
 
       conn = get(conn, path)
 

test/pleroma/web/mastodon_api/views/account_view_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
   use Pleroma.DataCase
 
-  alias Pleroma.Config
   alias Pleroma.User
   alias Pleroma.UserRelationship
   alias Pleroma.Web.CommonAPI
@@ -556,7 +555,7 @@ test "uses mediaproxy urls when it's enabled (regardless of media preview proxy
       )
 
     with media_preview_enabled <- [false, true] do
-      Config.put([:media_preview_proxy, :enabled], media_preview_enabled)
+      clear_config([:media_preview_proxy, :enabled], media_preview_enabled)
 
       AccountView.render("show.json", %{user: user, skip_visibility_check: true})
       |> Enum.all?(fn

test/pleroma/web/mastodon_api/views/poll_view_test.exs

@@ -42,7 +42,6 @@ test "renders a poll" do
         %{title: "yes", votes_count: 0},
         %{title: "why are you even asking?", votes_count: 0}
       ],
-      voted: false,
       votes_count: 0,
       voters_count: 0
     }
@@ -124,6 +123,8 @@ test "detects vote status" do
     result = PollView.render("show.json", %{object: object, for: other_user})
 
     assert result[:voted] == true
+    assert 1 in result[:own_votes]
+    assert 2 in result[:own_votes]
     assert Enum.at(result[:options], 1)[:votes_count] == 1
     assert Enum.at(result[:options], 2)[:votes_count] == 1
   end

test/pleroma/web/media_proxy/invalidation/script_test.exs

@@ -8,7 +8,7 @@ defmodule Pleroma.Web.MediaProxy.Invalidation.ScriptTest do
 
   import ExUnit.CaptureLog
 
-  test "it logger error when script not found" do
+  test "it logs error when script is not found" do
     assert capture_log(fn ->
              assert Invalidation.Script.purge(
                       ["http://example.com/media/example.jpg"],
@@ -23,4 +23,30 @@ test "it logger error when script not found" do
              ) == {:error, "\"not found script path\""}
     end)
   end
+
+  describe "url formatting" do
+    setup do
+      urls = [
+        "https://bikeshed.party/media/foo.png",
+        "http://safe.millennial.space/proxy/wheeeee.gif",
+        "https://lain.com/proxy/mediafile.mp4?foo&bar=true",
+        "http://localhost:4000/media/upload.jpeg"
+      ]
+
+      [urls: urls]
+    end
+
+    test "with invalid formatter", %{urls: urls} do
+      assert urls == Invalidation.Script.maybe_format_urls(urls, nil)
+    end
+
+    test "with :htcacheclean formatter", %{urls: urls} do
+      assert [
+               "https://bikeshed.party:443/media/foo.png?",
+               "http://safe.millennial.space:80/proxy/wheeeee.gif?",
+               "https://lain.com:443/proxy/mediafile.mp4?foo&bar=true",
+               "http://localhost:4000/media/upload.jpeg?"
+             ] == Invalidation.Script.maybe_format_urls(urls, :htcacheclean)
+    end
+  end
 end

test/pleroma/web/media_proxy/invalidation_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.Web.MediaProxy.InvalidationTest do
   use Pleroma.DataCase
 
-  alias Pleroma.Config
   alias Pleroma.Web.MediaProxy.Invalidation
 
   import ExUnit.CaptureLog
@@ -16,11 +15,11 @@ defmodule Pleroma.Web.MediaProxy.InvalidationTest do
 
   describe "Invalidation.Http" do
     test "perform request to clear cache" do
-      Config.put([:media_proxy, :enabled], false)
+      clear_config([:media_proxy, :enabled], false)
-      Config.put([:media_proxy, :invalidation, :enabled], true)
+      clear_config([:media_proxy, :invalidation, :enabled], true)
-      Config.put([:media_proxy, :invalidation, :provider], Invalidation.Http)
+      clear_config([:media_proxy, :invalidation, :provider], Invalidation.Http)
 
-      Config.put([Invalidation.Http], method: :purge, headers: [{"x-refresh", 1}])
+      clear_config([Invalidation.Http], method: :purge, headers: [{"x-refresh", 1}])
       image_url = "http://example.com/media/example.jpg"
       Pleroma.Web.MediaProxy.put_in_banned_urls(image_url)
 
@@ -43,10 +42,10 @@ test "perform request to clear cache" do
 
   describe "Invalidation.Script" do
     test "run script to clear cache" do
-      Config.put([:media_proxy, :enabled], false)
+      clear_config([:media_proxy, :enabled], false)
-      Config.put([:media_proxy, :invalidation, :enabled], true)
+      clear_config([:media_proxy, :invalidation, :enabled], true)
-      Config.put([:media_proxy, :invalidation, :provider], Invalidation.Script)
+      clear_config([:media_proxy, :invalidation, :provider], Invalidation.Script)
-      Config.put([Invalidation.Script], script_path: "purge-nginx")
+      clear_config([Invalidation.Script], script_path: "purge-nginx")
 
       image_url = "http://example.com/media/example.jpg"
       Pleroma.Web.MediaProxy.put_in_banned_urls(image_url)

test/pleroma/web/media_proxy/media_proxy_controller_test.exs

@@ -33,7 +33,7 @@ test "it returns 404 when disabled", %{conn: conn} do
     end
 
     test "it returns 403 for invalid signature", %{conn: conn, url: url} do
-      Pleroma.Config.put([Pleroma.Web.Endpoint, :secret_key_base], "000")
+      clear_config([Pleroma.Web.Endpoint, :secret_key_base], "000")
       %{path: path} = URI.parse(url)
 
       assert %Conn{
@@ -128,7 +128,7 @@ test "returns 404 when disabled", %{conn: conn} do
     end
 
     test "it returns 403 for invalid signature", %{conn: conn, url: url} do
-      Pleroma.Config.put([Pleroma.Web.Endpoint, :secret_key_base], "000")
+      clear_config([Pleroma.Web.Endpoint, :secret_key_base], "000")
       %{path: path} = URI.parse(url)
 
       assert %Conn{

test/pleroma/web/metadata/providers/open_graph_test.exs

@@ -66,7 +66,7 @@ test "it renders all supported types of attachments and skips unknown types" do
   end
 
   test "it does not render attachments if post is nsfw" do
-    Pleroma.Config.put([Pleroma.Web.Metadata, :unfurl_nsfw], false)
+    clear_config([Pleroma.Web.Metadata, :unfurl_nsfw], false)
     user = insert(:user, avatar: %{"url" => [%{"href" => "https://pleroma.gov/tenshi.png"}]})
 
     note =

test/pleroma/web/metadata/providers/twitter_card_test.exs

@@ -54,7 +54,7 @@ test "it uses summary twittercard if post has no attachment" do
   end
 
   test "it renders avatar not attachment if post is nsfw and unfurl_nsfw is disabled" do
-    Pleroma.Config.put([Pleroma.Web.Metadata, :unfurl_nsfw], false)
+    clear_config([Pleroma.Web.Metadata, :unfurl_nsfw], false)
     user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994")
     {:ok, activity} = CommonAPI.post(user, %{status: "HI"})
 

test/pleroma/web/node_info_test.exs

@@ -7,8 +7,6 @@ defmodule Pleroma.Web.NodeInfoTest do
 
   import Pleroma.Factory
 
-  alias Pleroma.Config
-
   setup do: clear_config([:mrf_simple])
   setup do: clear_config(:instance)
 
@@ -93,7 +91,7 @@ test "it returns the safe_dm_mentions feature if enabled", %{conn: conn} do
 
     assert "safe_dm_mentions" in response["metadata"]["features"]
 
-    Config.put([:instance, :safe_dm_mentions], false)
+    clear_config([:instance, :safe_dm_mentions], false)
 
     response =
       conn
@@ -107,7 +105,7 @@ test "it returns the safe_dm_mentions feature if enabled", %{conn: conn} do
     setup do: clear_config([:instance, :federating])
 
     test "it shows if federation is enabled/disabled", %{conn: conn} do
-      Config.put([:instance, :federating], true)
+      clear_config([:instance, :federating], true)
 
       response =
         conn
@@ -116,7 +114,7 @@ test "it shows if federation is enabled/disabled", %{conn: conn} do
 
       assert response["metadata"]["federation"]["enabled"] == true
 
-      Config.put([:instance, :federating], false)
+      clear_config([:instance, :federating], false)
 
       response =
         conn

test/pleroma/web/o_auth/o_auth_controller_test.exs

@@ -923,7 +923,7 @@ test "rejects token exchange with invalid client credentials" do
     end
 
     test "rejects token exchange for valid credentials belonging to unconfirmed user and confirmation is required" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
       password = "testpassword"
 
       {:ok, user} =
@@ -1007,7 +1007,7 @@ test "rejects token exchange for user with password_reset_pending set to true" d
     end
 
     test "rejects token exchange for user with confirmation_pending set to true" do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)
       password = "testpassword"
 
       user =
@@ -1086,7 +1086,7 @@ test "rejects an invalid authorization code" do
     setup do: clear_config([:oauth2, :issue_new_refresh_token])
 
     test "issues a new access token with keep fresh token" do
-      Pleroma.Config.put([:oauth2, :issue_new_refresh_token], true)
+      clear_config([:oauth2, :issue_new_refresh_token], true)
       user = insert(:user)
       app = insert(:oauth_app, scopes: ["read", "write"])
 
@@ -1125,7 +1125,7 @@ test "issues a new access token with keep fresh token" do
     end
 
     test "issues a new access token with new fresh token" do
-      Pleroma.Config.put([:oauth2, :issue_new_refresh_token], false)
+      clear_config([:oauth2, :issue_new_refresh_token], false)
       user = insert(:user)
       app = insert(:oauth_app, scopes: ["read", "write"])
 

test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs

@@ -31,7 +31,7 @@ defmodule Pleroma.Web.PleromaAPI.EmojiPackControllerTest do
   end
 
   test "GET /api/pleroma/emoji/packs when :public: false", %{conn: conn} do
-    Config.put([:instance, :public], false)
+    clear_config([:instance, :public], false)
     conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
   end
 

test/pleroma/web/plugs/admin_secret_authentication_plug_test.exs

@@ -35,7 +35,7 @@ test "does nothing if a user is assigned", %{conn: conn} do
     end
 
     test "with `admin_token` query parameter", %{conn: conn} do
-      Pleroma.Config.put(:admin_token, "password123")
+      clear_config(:admin_token, "password123")
 
       conn =
         %{conn | params: %{"admin_token" => "wrong_password"}}
@@ -54,7 +54,7 @@ test "with `admin_token` query parameter", %{conn: conn} do
     end
 
     test "with `x-admin-token` HTTP header", %{conn: conn} do
-      Pleroma.Config.put(:admin_token, "☕️")
+      clear_config(:admin_token, "☕️")
 
       conn =
         conn

test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs

@@ -5,14 +5,13 @@
 defmodule Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlugTest do
   use Pleroma.Web.ConnCase
 
-  alias Pleroma.Config
   alias Pleroma.User
   alias Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlug
 
   setup do: clear_config([:instance, :public])
 
   test "it halts if not public and no user is assigned", %{conn: conn} do
-    Config.put([:instance, :public], false)
+    clear_config([:instance, :public], false)
 
     conn =
       conn
@@ -23,7 +22,7 @@ test "it halts if not public and no user is assigned", %{conn: conn} do
   end
 
   test "it continues if public", %{conn: conn} do
-    Config.put([:instance, :public], true)
+    clear_config([:instance, :public], true)
 
     ret_conn =
       conn
@@ -33,7 +32,7 @@ test "it continues if public", %{conn: conn} do
   end
 
   test "it continues if a user is assigned, even if not public", %{conn: conn} do
-    Config.put([:instance, :public], false)
+    clear_config([:instance, :public], false)
 
     conn =
       conn

test/pleroma/web/plugs/federating_plug_test.exs

@@ -8,7 +8,7 @@ defmodule Pleroma.Web.Plugs.FederatingPlugTest do
   setup do: clear_config([:instance, :federating])
 
   test "returns and halt the conn when federating is disabled" do
-    Pleroma.Config.put([:instance, :federating], false)
+    clear_config([:instance, :federating], false)
 
     conn =
       build_conn()
@@ -19,7 +19,7 @@ test "returns and halt the conn when federating is disabled" do
   end
 
   test "does nothing when federating is enabled" do
-    Pleroma.Config.put([:instance, :federating], true)
+    clear_config([:instance, :federating], true)
 
     conn =
       build_conn()

test/pleroma/web/plugs/http_security_plug_test.exs

@@ -72,6 +72,21 @@ test "default values for img-src and media-src with disabled media proxy", %{con
       assert csp =~ "media-src 'self' https:;"
       assert csp =~ "img-src 'self' data: blob: https:;"
     end
+
+    test "it sets the Service-Worker-Allowed header", %{conn: conn} do
+      clear_config([:http_security, :enabled], true)
+      clear_config([:frontends, :primary], %{"name" => "fedi-fe", "ref" => "develop"})
+
+      clear_config([:frontends, :available], %{
+        "fedi-fe" => %{
+          "name" => "fedi-fe",
+          "custom-http-headers" => [{"service-worker-allowed", "/"}]
+        }
+      })
+
+      conn = get(conn, "/api/v1/instance")
+      assert Conn.get_resp_header(conn, "service-worker-allowed") == ["/"]
+    end
   end
 
   describe "img-src and media-src" do

test/pleroma/web/plugs/http_signature_plug_test.exs

@@ -32,11 +32,7 @@ test "it call HTTPSignatures to check validity if the actor sighed it" do
 
   describe "requires a signature when `authorized_fetch_mode` is enabled" do
     setup do
-      Pleroma.Config.put([:activitypub, :authorized_fetch_mode], true)
+      clear_config([:activitypub, :authorized_fetch_mode], true)
-
-      on_exit(fn ->
-        Pleroma.Config.put([:activitypub, :authorized_fetch_mode], false)
-      end)
 
       params = %{"actor" => "http://mastodon.example.org/users/admin"}
       conn = build_conn(:get, "/doesntmattter", params) |> put_format("activity+json")

test/pleroma/web/plugs/o_auth_scopes_plug_test.exs

@@ -181,7 +181,7 @@ test "with :admin option, prefixes all requested scopes with `admin:` " <>
            "and [optionally] keeps only prefixed scopes, " <>
            "depending on `[:auth, :enforce_oauth_admin_scope_usage]` setting",
          %{f: f} do
-      Pleroma.Config.put([:auth, :enforce_oauth_admin_scope_usage], false)
+      clear_config([:auth, :enforce_oauth_admin_scope_usage], false)
 
       assert f.(["read"], %{admin: true}) == ["admin:read", "read"]
 
@@ -192,7 +192,7 @@ test "with :admin option, prefixes all requested scopes with `admin:` " <>
                "write"
              ]
 
-      Pleroma.Config.put([:auth, :enforce_oauth_admin_scope_usage], true)
+      clear_config([:auth, :enforce_oauth_admin_scope_usage], true)
 
       assert f.(["read:accounts"], %{admin: true}) == ["admin:read:accounts"]
 

test/pleroma/web/plugs/rate_limiter_test.exs

@@ -6,7 +6,6 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest do
   use Pleroma.Web.ConnCase
 
   alias Phoenix.ConnTest
-  alias Pleroma.Config
   alias Pleroma.Web.Plugs.RateLimiter
   alias Plug.Conn
 
@@ -22,8 +21,8 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest do
     setup do: clear_config([Pleroma.Web.Plugs.RemoteIp, :enabled])
 
     test "config is required for plug to work" do
-      Config.put([:rate_limit, @limiter_name], {1, 1})
+      clear_config([:rate_limit, @limiter_name], {1, 1})
-      Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
+      clear_config([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
 
       assert %{limits: {1, 1}, name: :test_init, opts: [name: :test_init]} ==
                [name: @limiter_name]
@@ -54,8 +53,8 @@ test "it restricts based on config values" do
     scale = 80
     limit = 5
 
-    Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
+    clear_config([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
-    Config.put([:rate_limit, limiter_name], {scale, limit})
+    clear_config([:rate_limit, limiter_name], {scale, limit})
 
     plug_opts = RateLimiter.init(name: limiter_name)
     conn = build_conn(:get, "/")
@@ -86,8 +85,8 @@ test "it restricts based on config values" do
     test "`bucket_name` option overrides default bucket name" do
       limiter_name = :test_bucket_name
 
-      Config.put([:rate_limit, limiter_name], {1000, 5})
+      clear_config([:rate_limit, limiter_name], {1000, 5})
-      Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
+      clear_config([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
 
       base_bucket_name = "#{limiter_name}:group1"
       plug_opts = RateLimiter.init(name: limiter_name, bucket_name: base_bucket_name)
@@ -101,8 +100,8 @@ test "`bucket_name` option overrides default bucket name" do
 
     test "`params` option allows different queries to be tracked independently" do
       limiter_name = :test_params
-      Config.put([:rate_limit, limiter_name], {1000, 5})
+      clear_config([:rate_limit, limiter_name], {1000, 5})
-      Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
+      clear_config([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
 
       plug_opts = RateLimiter.init(name: limiter_name, params: ["id"])
 
@@ -117,8 +116,8 @@ test "`params` option allows different queries to be tracked independently" do
 
     test "it supports combination of options modifying bucket name" do
       limiter_name = :test_options_combo
-      Config.put([:rate_limit, limiter_name], {1000, 5})
+      clear_config([:rate_limit, limiter_name], {1000, 5})
-      Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
+      clear_config([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
 
       base_bucket_name = "#{limiter_name}:group1"
 
@@ -140,8 +139,8 @@ test "it supports combination of options modifying bucket name" do
   describe "unauthenticated users" do
     test "are restricted based on remote IP" do
       limiter_name = :test_unauthenticated
-      Config.put([:rate_limit, limiter_name], [{1000, 5}, {1, 10}])
+      clear_config([:rate_limit, limiter_name], [{1000, 5}, {1, 10}])
-      Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
+      clear_config([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
 
       plug_opts = RateLimiter.init(name: limiter_name)
 
@@ -180,8 +179,8 @@ test "can have limits separate from unauthenticated connections" do
 
       scale = 50
       limit = 5
-      Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
+      clear_config([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
-      Config.put([:rate_limit, limiter_name], [{1000, 1}, {scale, limit}])
+      clear_config([:rate_limit, limiter_name], [{1000, 1}, {scale, limit}])
 
       plug_opts = RateLimiter.init(name: limiter_name)
 
@@ -202,8 +201,8 @@ test "can have limits separate from unauthenticated connections" do
 
     test "different users are counted independently" do
       limiter_name = :test_authenticated2
-      Config.put([:rate_limit, limiter_name], [{1, 10}, {1000, 5}])
+      clear_config([:rate_limit, limiter_name], [{1, 10}, {1000, 5}])
-      Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
+      clear_config([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
 
       plug_opts = RateLimiter.init(name: limiter_name)
 
@@ -232,8 +231,8 @@ test "different users are counted independently" do
 
   test "doesn't crash due to a race condition when multiple requests are made at the same time and the bucket is not yet initialized" do
     limiter_name = :test_race_condition
-    Pleroma.Config.put([:rate_limit, limiter_name], {1000, 5})
+    clear_config([:rate_limit, limiter_name], {1000, 5})
-    Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
+    clear_config([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
 
     opts = RateLimiter.init(name: limiter_name)
 

test/pleroma/web/plugs/remote_ip_test.exs

@@ -26,7 +26,7 @@ defmodule Pleroma.Web.Plugs.RemoteIpTest do
           )
 
   test "disabled" do
-    Pleroma.Config.put(RemoteIp, enabled: false)
+    clear_config(RemoteIp, enabled: false)
 
     %{remote_ip: remote_ip} = conn(:get, "/")
 
@@ -48,7 +48,7 @@ test "enabled" do
   end
 
   test "custom headers" do
-    Pleroma.Config.put(RemoteIp, enabled: true, headers: ["cf-connecting-ip"])
+    clear_config(RemoteIp, enabled: true, headers: ["cf-connecting-ip"])
 
     conn =
       conn(:get, "/")
@@ -73,7 +73,7 @@ test "custom proxies" do
 
     refute conn.remote_ip == {1, 1, 1, 1}
 
-    Pleroma.Config.put([RemoteIp, :proxies], ["173.245.48.0/20"])
+    clear_config([RemoteIp, :proxies], ["173.245.48.0/20"])
 
     conn =
       conn(:get, "/")
@@ -84,7 +84,7 @@ test "custom proxies" do
   end
 
   test "proxies set without CIDR format" do
-    Pleroma.Config.put([RemoteIp, :proxies], ["173.245.48.1"])
+    clear_config([RemoteIp, :proxies], ["173.245.48.1"])
 
     conn =
       conn(:get, "/")
@@ -95,8 +95,8 @@ test "proxies set without CIDR format" do
   end
 
   test "proxies set `nonsensical` CIDR" do
-    Pleroma.Config.put([RemoteIp, :reserved], ["127.0.0.0/8"])
+    clear_config([RemoteIp, :reserved], ["127.0.0.0/8"])
-    Pleroma.Config.put([RemoteIp, :proxies], ["10.0.0.3/24"])
+    clear_config([RemoteIp, :proxies], ["10.0.0.3/24"])
 
     conn =
       conn(:get, "/")

test/pleroma/web/plugs/user_enabled_plug_test.exs

@@ -20,7 +20,7 @@ test "doesn't do anything if the user isn't set", %{conn: conn} do
 
   test "with a user that's not confirmed and a config requiring confirmation, it removes that user",
        %{conn: conn} do
-    Pleroma.Config.put([:instance, :account_activation_required], true)
+    clear_config([:instance, :account_activation_required], true)
 
     user = insert(:user, is_confirmed: false)
 

test/pleroma/web/rich_media/helpers_test.exs

@@ -5,7 +5,6 @@
 defmodule Pleroma.Web.RichMedia.HelpersTest do
   use Pleroma.DataCase
 
-  alias Pleroma.Config
   alias Pleroma.Web.CommonAPI
   alias Pleroma.Web.RichMedia.Helpers
 
@@ -29,7 +28,7 @@ test "refuses to crawl incomplete URLs" do
         content_type: "text/markdown"
       })
 
-    Config.put([:rich_media, :enabled], true)
+    clear_config([:rich_media, :enabled], true)
 
     assert %{} == Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
   end
@@ -43,7 +42,7 @@ test "refuses to crawl malformed URLs" do
         content_type: "text/markdown"
       })
 
-    Config.put([:rich_media, :enabled], true)
+    clear_config([:rich_media, :enabled], true)
 
     assert %{} == Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
   end
@@ -57,7 +56,7 @@ test "crawls valid, complete URLs" do
         content_type: "text/markdown"
       })
 
-    Config.put([:rich_media, :enabled], true)
+    clear_config([:rich_media, :enabled], true)
 
     assert %{page_url: "https://example.com/ogp", rich_media: _} =
              Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
@@ -74,7 +73,7 @@ test "refuses to crawl URLs of private network from posts" do
     {:ok, activity4} = CommonAPI.post(user, %{status: "https://192.168.10.40/notice/9kCP7V"})
     {:ok, activity5} = CommonAPI.post(user, %{status: "https://pleroma.local/notice/9kCP7V"})
 
-    Config.put([:rich_media, :enabled], true)
+    clear_config([:rich_media, :enabled], true)
 
     assert %{} = Helpers.fetch_data_for_activity(activity)
     assert %{} = Helpers.fetch_data_for_activity(activity2)

test/pleroma/web/streamer_test.exs

@@ -510,7 +510,7 @@ test "handles deletions" do
 
   describe "thread_containment/2" do
     test "it filters to user if recipients invalid and thread containment is enabled" do
-      Pleroma.Config.put([:instance, :skip_thread_containment], false)
+      clear_config([:instance, :skip_thread_containment], false)
       author = insert(:user)
       %{user: user, token: oauth_token} = oauth_access(["read"])
       User.follow(user, author, :follow_accept)
@@ -531,7 +531,7 @@ test "it filters to user if recipients invalid and thread containment is enabled
     end
 
     test "it sends message if recipients invalid and thread containment is disabled" do
-      Pleroma.Config.put([:instance, :skip_thread_containment], true)
+      clear_config([:instance, :skip_thread_containment], true)
       author = insert(:user)
       %{user: user, token: oauth_token} = oauth_access(["read"])
       User.follow(user, author, :follow_accept)
@@ -553,7 +553,7 @@ test "it sends message if recipients invalid and thread containment is disabled"
     end
 
     test "it sends message if recipients invalid and thread containment is enabled but user's thread containment is disabled" do
-      Pleroma.Config.put([:instance, :skip_thread_containment], false)
+      clear_config([:instance, :skip_thread_containment], false)
       author = insert(:user)
       user = insert(:user, skip_thread_containment: true)
       %{token: oauth_token} = oauth_access(["read"], user: user)

test/pleroma/web/twitter_api/remote_follow_controller_test.exs

@@ -154,7 +154,7 @@ test "returns error when user is deactivated", %{conn: conn} do
     end
 
     test "returns error when user is blocked", %{conn: conn} do
-      Pleroma.Config.put([:user, :deny_follow_blocked], true)
+      clear_config([:user, :deny_follow_blocked], true)
       user = insert(:user)
       user2 = insert(:user)
 
@@ -365,7 +365,7 @@ test "returns error when password invalid", %{conn: conn} do
     end
 
     test "returns error when user is blocked", %{conn: conn} do
-      Pleroma.Config.put([:user, :deny_follow_blocked], true)
+      clear_config([:user, :deny_follow_blocked], true)
       user = insert(:user)
       user2 = insert(:user)
       {:ok, _user_block} = Pleroma.User.block(user2, user)

test/pleroma/web/twitter_api/twitter_api_test.exs

@@ -46,12 +46,7 @@ test "it registers a new user with empty string in bio and returns the user" do
   end
 
   test "it sends confirmation email if :account_activation_required is specified in instance config" do
-    setting = Pleroma.Config.get([:instance, :account_activation_required])
+    clear_config([:instance, :account_activation_required], true)
-
-    unless setting do
-      Pleroma.Config.put([:instance, :account_activation_required], true)
-      on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
-    end
 
     data = %{
       :username => "lain",

test/pleroma/web/twitter_api/util_controller_test.exs

@@ -6,7 +6,6 @@ defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
   use Pleroma.Web.ConnCase
   use Oban.Testing, repo: Pleroma.Repo
 
-  alias Pleroma.Config
   alias Pleroma.Tests.ObanHelpers
   alias Pleroma.User
 
@@ -66,7 +65,7 @@ test "returns everything in :pleroma, :frontend_configurations", %{conn: conn} d
         }
       ]
 
-      Config.put(:frontend_configurations, config)
+      clear_config(:frontend_configurations, config)
 
       response =
         conn
@@ -99,7 +98,7 @@ test "returns json with custom emoji with tags", %{conn: conn} do
     setup do: clear_config([:instance, :healthcheck])
 
     test "returns 503 when healthcheck disabled", %{conn: conn} do
-      Config.put([:instance, :healthcheck], false)
+      clear_config([:instance, :healthcheck], false)
 
       response =
         conn
@@ -110,7 +109,7 @@ test "returns 503 when healthcheck disabled", %{conn: conn} do
     end
 
     test "returns 200 when healthcheck enabled and all ok", %{conn: conn} do
-      Config.put([:instance, :healthcheck], true)
+      clear_config([:instance, :healthcheck], true)
 
       with_mock Pleroma.Healthcheck,
         system_info: fn -> %Pleroma.Healthcheck{healthy: true} end do
@@ -130,7 +129,7 @@ test "returns 200 when healthcheck enabled and all ok", %{conn: conn} do
     end
 
     test "returns 503 when healthcheck enabled and health is false", %{conn: conn} do
-      Config.put([:instance, :healthcheck], true)
+      clear_config([:instance, :healthcheck], true)
 
       with_mock Pleroma.Healthcheck,
         system_info: fn -> %Pleroma.Healthcheck{healthy: false} end do

test/pleroma/workers/cron/digest_emails_worker_test.exs

@@ -14,7 +14,7 @@ defmodule Pleroma.Workers.Cron.DigestEmailsWorkerTest do
   setup do: clear_config([:email_notifications, :digest])
 
   setup do
-    Pleroma.Config.put([:email_notifications, :digest], %{
+    clear_config([:email_notifications, :digest], %{
       active: true,
       inactivity_threshold: 7,
       interval: 7

test/pleroma/workers/scheduled_activity_worker_test.exs

@@ -14,7 +14,7 @@ defmodule Pleroma.Workers.ScheduledActivityWorkerTest do
   setup do: clear_config([ScheduledActivity, :enabled])
 
   test "creates a status from the scheduled activity" do
-    Pleroma.Config.put([ScheduledActivity, :enabled], true)
+    clear_config([ScheduledActivity, :enabled], true)
     user = insert(:user)
 
     naive_datetime =
@@ -40,7 +40,7 @@ test "creates a status from the scheduled activity" do
   end
 
   test "adds log message if ScheduledActivity isn't find" do
-    Pleroma.Config.put([ScheduledActivity, :enabled], true)
+    clear_config([ScheduledActivity, :enabled], true)
 
     assert capture_log([level: :error], fn ->
              ScheduledActivityWorker.perform(%Oban.Job{args: %{"activity_id" => 42}})