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

# Conflicts:
#	CHANGELOG.md
This commit is contained in:
Ivan Tashkinov 2021-01-31 20:38:58 +03:00
commit 1b49b8efe5
85 changed files with 672 additions and 435 deletions

View File

@ -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. - Emoji: Support the full Unicode 13.1 set of Emoji for reactions, plus regional indicators.
- Admin API: Reports now ordered by newest - 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. - 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`). - Extracted object hashtags into separate table in order to improve hashtag timeline performance (via background migration in `Pleroma.Migrators.HashtagsTableMigrator`).
### Added ### 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. - 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. - Ability to set ActivityPub aliases for follower migration.
- Configurable background job limits for RichMedia (link previews) and MediaProxyWarmingPolicy - Configurable background job limits for RichMedia (link previews) and MediaProxyWarmingPolicy
- Ability to define custom HTTP headers per each frontend
<details> <details>
<summary>API Changes</summary> <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> <summary>API Changes</summary>
- Mastodon API: Current user is now included in conversation if it's the only participant. - 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: 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> </details>
## Unreleased (Patch) ## Unreleased (Patch)

View File

@ -438,7 +438,9 @@
headers: [], headers: [],
options: [] 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 # Note: media preview proxy depends on media proxy to be enabled
config :pleroma, :media_preview_proxy, config :pleroma, :media_preview_proxy,
@ -725,7 +727,10 @@
"git" => "https://git.pleroma.social/pleroma/fedi-fe", "git" => "https://git.pleroma.social/pleroma/fedi-fe",
"build_url" => "build_url" =>
"https://git.pleroma.social/pleroma/fedi-fe/-/jobs/artifacts/${ref}/download?job=build", "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" => %{ "admin-fe" => %{
"name" => "admin-fe", "name" => "admin-fe",

View File

@ -60,6 +60,12 @@
label: "Build directory", label: "Build directory",
type: :string, type: :string,
description: "The directory inside the zip file " 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, group: :pleroma,
key: Pleroma.Web.MediaProxy.Invalidation.Script, key: Pleroma.Web.MediaProxy.Invalidation.Script,
type: :group, type: :group,
description: "Script invalidate settings", description: "Invalidation script settings",
children: [ children: [
%{ %{
key: :script_path, key: :script_path,
type: :string, 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"] 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, type: :string,
description: "S3 host", description: "S3 host",
suggestions: ["s3.eu-central-1.amazonaws.com"] suggestions: ["s3.eu-central-1.amazonaws.com"]
},
%{
key: :region,
type: :string,
description: "S3 region (for AWS)",
suggestions: ["us-east-1"]
} }
] ]
}, },

View File

@ -321,9 +321,10 @@ This section describe PWA manifest instance-specific values. Currently this opti
#### Pleroma.Web.MediaProxy.Invalidation.Script #### Pleroma.Web.MediaProxy.Invalidation.Script
This strategy allow perform external shell script to purge cache. 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: Example:

View File

@ -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 $@

View File

@ -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: # 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 # Optional: enable disk-based caching for the media proxy
# For details, see https://git.pleroma.social/pleroma/pleroma/wikis/How%20to%20activate%20mediaproxy # 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. # the Apache user can write to it.
# 2. Configure Apache's htcacheclean to clean the directory periodically. # 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 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} ServerName ${servername}
ServerTokens Prod 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> <VirtualHost *:80>
Redirect permanent / https://${servername} RewriteEngine on
RewriteCond %{SERVER_NAME} =${servername}
RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost> </VirtualHost>
<VirtualHost *:443> <VirtualHost *:443>
SSLEngine on SSLEngine on
SSLCertificateFile /etc/letsencrypt/live/${servername}/fullchain.pem SSLCertificateFile /etc/letsencrypt/live/${servername}/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/${servername}/privkey.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 RewriteEngine On
RewriteCond %{HTTP:Connection} Upgrade [NC] RewriteCond %{HTTP:Connection} Upgrade [NC]
RewriteCond %{HTTP:Upgrade} websocket [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 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/ ProxyPass / http://127.0.0.1:4000/
ProxyPassReverse / http://127.0.0.1:4000/ ProxyPassReverse / http://127.0.0.1:4000/
RequestHeader set Host ${servername}
ProxyPreserveHost On ProxyPreserveHost On
</VirtualHost> </VirtualHost>
# OCSP Stapling, only in httpd 2.3.3 and later
SSLUseStapling on
SSLStaplingResponderTimeout 5
SSLStaplingReturnResponderErrors off
SSLStaplingCache shmcb:/var/run/ocsp(128000)

View File

@ -113,11 +113,15 @@ def create(title, %User{} = creator) do
end end
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])}) update_follows(list, %{following: Enum.uniq([followed.follower_address | following])})
end 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)}) update_follows(list, %{following: List.delete(following, unfollowed.follower_address)})
end end

View File

@ -23,6 +23,18 @@ defmodule Pleroma.Web.Endpoint do
# InstanceStatic needs to be before Plug.Static to be able to override shipped-static files # 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 # 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 # 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, plug(Pleroma.Web.Plugs.InstanceStatic,
at: "/", at: "/",
gzip: true, gzip: true,

View File

@ -11,7 +11,7 @@ def render("show.json", %{object: object, multiple: multiple, options: options}
{end_time, expired} = end_time_and_expired(object) {end_time, expired} = end_time_and_expired(object)
{options, votes_count} = options_and_votes_count(options) {options, votes_count} = options_and_votes_count(options)
%{ poll = %{
# Mastodon uses separate ids for polls, but an object can't have # Mastodon uses separate ids for polls, but an object can't have
# more than one poll embedded so object id is fine # more than one poll embedded so object id is fine
id: to_string(object.id), id: to_string(object.id),
@ -21,9 +21,16 @@ def render("show.json", %{object: object, multiple: multiple, options: options}
votes_count: votes_count, votes_count: votes_count,
voters_count: voters_count(object), voters_count: voters_count(object),
options: options, options: options,
voted: voted?(params),
emojis: Pleroma.Web.MastodonAPI.StatusView.build_emojis(object.data["emoji"]) 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 end
def render("show.json", %{object: object} = params) do 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 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 else
false {false, []}
end end
end end
end end

View File

@ -13,6 +13,7 @@ defmodule Pleroma.Web.MediaProxy.Invalidation.Script do
def purge(urls, opts \\ []) do def purge(urls, opts \\ []) do
args = args =
urls urls
|> maybe_format_urls(Keyword.get(opts, :url_format))
|> List.wrap() |> List.wrap()
|> Enum.uniq() |> Enum.uniq()
|> Enum.join(" ") |> Enum.join(" ")
@ -40,4 +41,22 @@ defp handle_result(error, _) do
Logger.error("Error while cache purge: #{inspect(error)}") Logger.error("Error while cache purge: #{inspect(error)}")
{:error, inspect(error)} {:error, inspect(error)}
end 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 end

View File

@ -20,9 +20,26 @@ def call(conn, _options) do
end end
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]) referrer_policy = Config.get([:http_security, :referrer_policy])
report_uri = Config.get([:http_security, :report_uri]) report_uri = Config.get([:http_security, :report_uri])
custom_http_frontend_headers = custom_http_frontend_headers()
headers = [ headers = [
{"x-xss-protection", "1; mode=block"}, {"x-xss-protection", "1; mode=block"},
@ -34,6 +51,13 @@ defp headers do
{"content-security-policy", csp_string()} {"content-security-policy", csp_string()}
] ]
headers =
if custom_http_frontend_headers do
custom_http_frontend_headers ++ headers
else
headers
end
if report_uri do if report_uri do
report_group = %{ report_group = %{
"group" => "csp-endpoint", "group" => "csp-endpoint",

View File

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

View File

@ -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`", test "find only local statuses for unauthenticated users when `limit_to_local_content` is `:all`",
%{local_activity: local_activity} do %{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") assert [^local_activity] = Activity.search(nil, "find me")
end end
@ -177,7 +177,7 @@ test "find all statuses for unauthenticated users when `limit_to_local_content`
local_activity: local_activity, local_activity: local_activity,
remote_activity: remote_activity remote_activity: remote_activity
} do } 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) activities = Enum.sort_by(Activity.search(nil, "find me"), & &1.id)

View File

@ -9,7 +9,6 @@ defmodule Pleroma.ApplicationRequirementsTest do
import Mock import Mock
alias Pleroma.ApplicationRequirements alias Pleroma.ApplicationRequirements
alias Pleroma.Config
alias Pleroma.Repo alias Pleroma.Repo
describe "check_repo_pool_size!/1" do 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]) setup do: clear_config([Pleroma.Emails.Mailer])
test "raises if welcome email enabled but mail disabled" do 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 -> assert_raise Pleroma.ApplicationRequirements.VerifyError, "The mail disabled.", fn ->
capture_log(&Pleroma.ApplicationRequirements.verify!/0) 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]) setup do: clear_config([:instance, :account_activation_required])
test "raises if account confirmation is required but mailer isn't enable" do 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, assert_raise Pleroma.ApplicationRequirements.VerifyError,
"Account activation enabled, but Mailer is disabled. Cannot send confirmation emails.", "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 end
test "doesn't do anything if account confirmation is disabled" do 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 assert Pleroma.ApplicationRequirements.verify!() == :ok
end end
test "doesn't do anything if account confirmation is required and mailer is enabled" do 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 assert Pleroma.ApplicationRequirements.verify!() == :ok
end end
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]) setup do: clear_config([:database, :rum_enabled])
test "raises if rum is enabled and detects unapplied rum migrations" do 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 with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
assert_raise ApplicationRequirements.VerifyError, assert_raise ApplicationRequirements.VerifyError,
@ -105,7 +104,7 @@ test "raises if rum is enabled and detects unapplied rum migrations" do
end end
test "raises if rum is disabled and detects rum migrations" do 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 with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
assert_raise ApplicationRequirements.VerifyError, assert_raise ApplicationRequirements.VerifyError,
@ -117,7 +116,7 @@ test "raises if rum is disabled and detects rum migrations" do
end end
test "doesn't do anything if rum enabled and applied migrations" do 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 with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
assert ApplicationRequirements.verify!() == :ok assert ApplicationRequirements.verify!() == :ok
@ -125,7 +124,7 @@ test "doesn't do anything if rum enabled and applied migrations" do
end end
test "doesn't do anything if rum disabled" do 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 with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
assert ApplicationRequirements.verify!() == :ok assert ApplicationRequirements.verify!() == :ok
@ -161,7 +160,7 @@ test "raises if it detects unapplied migrations" do
end end
test "doesn't do anything if disabled" do 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!() assert :ok == ApplicationRequirements.verify!()
end end

View File

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

View File

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

View File

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

View File

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

View File

@ -6,7 +6,6 @@ defmodule Pleroma.Object.FetcherTest do
use Pleroma.DataCase use Pleroma.DataCase
alias Pleroma.Activity alias Pleroma.Activity
alias Pleroma.Config
alias Pleroma.Object alias Pleroma.Object
alias Pleroma.Object.Fetcher 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]) setup do: clear_config([:instance, :federation_incoming_replies_max_depth])
test "it returns thread depth exceeded error if thread depth is exceeded" do 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."} = assert {:error, "Max thread distance exceeded."} =
Fetcher.fetch_object_from_id(@ap_id, depth: 1) Fetcher.fetch_object_from_id(@ap_id, depth: 1)
end end
test "it fetches object if max thread depth is restricted to 0 and depth is not specified" do 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) assert {:ok, _} = Fetcher.fetch_object_from_id(@ap_id)
end end
test "it fetches object if requested depth does not exceed max thread depth" do 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) assert {:ok, _} = Fetcher.fetch_object_from_id(@ap_id, depth: 10)
end end
@ -245,7 +244,7 @@ test "it can refetch pruned objects" do
Pleroma.Signature, Pleroma.Signature,
[:passthrough], [:passthrough],
[] do [] 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") Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
@ -256,7 +255,7 @@ test "it can refetch pruned objects" do
Pleroma.Signature, Pleroma.Signature,
[:passthrough], [:passthrough],
[] do [] 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") Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

View File

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

View File

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

View File

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

View File

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

View File

@ -5,13 +5,12 @@
defmodule Pleroma.Upload.FilterTest do defmodule Pleroma.Upload.FilterTest do
use Pleroma.DataCase use Pleroma.DataCase
alias Pleroma.Config
alias Pleroma.Upload.Filter alias Pleroma.Upload.Filter
setup do: clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text]) setup do: clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text])
test "applies filters" do 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!( File.cp!(
"test/fixtures/image.jpg", "test/fixtures/image.jpg",

View File

@ -5,7 +5,6 @@
defmodule Pleroma.Uploaders.S3Test do defmodule Pleroma.Uploaders.S3Test do
use Pleroma.DataCase use Pleroma.DataCase
alias Pleroma.Config
alias Pleroma.Uploaders.S3 alias Pleroma.Uploaders.S3
import Mock import Mock
@ -27,13 +26,13 @@ test "it returns path to local folder for files" do
end end
test "it returns path without bucket when truncated_namespace set to ''" do 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: "test_bucket",
bucket_namespace: "myaccount", bucket_namespace: "myaccount",
truncated_namespace: "" 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") == { assert S3.get_file("test_image.jpg") == {
:ok, :ok,
@ -42,7 +41,7 @@ test "it returns path without bucket when truncated_namespace set to ''" do
end end
test "it returns path with bucket namespace when namespace is set" do 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: "test_bucket",
bucket_namespace: "family" bucket_namespace: "family"
) )

View File

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

View File

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

View File

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

View File

@ -5,7 +5,6 @@
defmodule Pleroma.User.WelcomeMessageTest do defmodule Pleroma.User.WelcomeMessageTest do
use Pleroma.DataCase use Pleroma.DataCase
alias Pleroma.Config
alias Pleroma.User.WelcomeMessage alias Pleroma.User.WelcomeMessage
import Pleroma.Factory import Pleroma.Factory
@ -17,10 +16,10 @@ test "send a direct welcome message" do
welcome_user = insert(:user) welcome_user = insert(:user)
user = insert(:user, name: "Jimm") 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], [:welcome, :direct_message, :message],
"Hello. Welcome to Pleroma" "Hello. Welcome to Pleroma"
) )

View File

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

View File

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

View File

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

View File

@ -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 test "it sets the default description depending on the configuration", %{test_file: file} do
clear_config([Pleroma.Upload, :default_description]) 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) {:ok, %Object{} = object} = ActivityPub.upload(file)
assert object.data["name"] == "" 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) {:ok, %Object{} = object} = ActivityPub.upload(file)
assert object.data["name"] == "an_image.jpg" 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) {:ok, %Object{} = object} = ActivityPub.upload(file)
assert object.data["name"] == "unnamed attachment" assert object.data["name"] == "unnamed attachment"
end end

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -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 test "pass filter if allow list isn't empty and user in allow list" do
actor = insert(:user) 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} message = %{"actor" => actor.ap_id}
assert UserAllowListPolicy.filter(message) == {:ok, message} assert UserAllowListPolicy.filter(message) == {:ok, message}
end end
test "rejected if allow list isn't empty and user not in allow list" do test "rejected if allow list isn't empty and user not in allow list" do
actor = insert(:user) 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} message = %{"actor" => actor.ap_id}
assert {:reject, _} = UserAllowListPolicy.filter(message) assert {:reject, _} = UserAllowListPolicy.filter(message)
end end

View File

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

View File

@ -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", %{ test "does not validate if the message is longer than the remote_limit", %{
valid_chat_message: valid_chat_message valid_chat_message: valid_chat_message
} do } do
Pleroma.Config.put([:instance, :remote_limit], 2) clear_config([:instance, :remote_limit], 2)
refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, [])) refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
end end

View File

@ -133,7 +133,7 @@ test "it works for follow requests when you are already followed, creating a new
end end
test "it rejects incoming follow requests from blocked users when deny_follow_blocked is enabled" do 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) user = insert(:user)
{:ok, target} = User.get_or_fetch("http://mastodon.example.org/users/admin") {:ok, target} = User.get_or_fetch("http://mastodon.example.org/users/admin")

View File

@ -417,7 +417,7 @@ test "schedules background fetching of `replies` items if max thread depth limit
data: data, data: data,
items: items items: items
} do } 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) {: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", test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
%{data: data} do %{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) {: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, federation_output: federation_output,
replies_uris: replies_uris replies_uris: replies_uris
} do } 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) {: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", test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
%{federation_output: federation_output} do %{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) {:ok, _activity} = Transmogrifier.handle_incoming(federation_output)
@ -553,7 +553,7 @@ test "returns not modified object when hasn't containts inReplyTo field", %{data
end end
test "returns object with inReplyTo when denied incoming reply", %{data: data} do 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 = object_with_reply =
Map.put(data["object"], "inReplyTo", "https://shitposter.club/notice/2827873") 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" "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) modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
assert modified_object["inReplyTo"] == assert modified_object["inReplyTo"] ==

View File

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

View File

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

View File

@ -21,9 +21,9 @@ defmodule Pleroma.Web.AdminAPI.MediaProxyCacheControllerTest do
|> assign(:user, admin) |> assign(:user, admin)
|> assign(:token, token) |> 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}} {:ok, %{admin: admin, token: token, conn: conn}}
end end

View File

@ -33,7 +33,7 @@ test "it ignores messages of length zero", %{socket: socket} do
end end
test "it ignores messages above a certain length", %{socket: socket} do 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"}) push(socket, "new_msg", %{"text" => "123"})
refute_broadcast("new_msg", %{text: "123"}) refute_broadcast("new_msg", %{text: "123"})
end end

View File

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

View File

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

View File

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

View File

@ -8,7 +8,6 @@ defmodule Pleroma.Web.Feed.UserControllerTest do
import Pleroma.Factory import Pleroma.Factory
import SweetXml import SweetXml
alias Pleroma.Config
alias Pleroma.Object alias Pleroma.Object
alias Pleroma.User alias Pleroma.User
alias Pleroma.Web.CommonAPI alias Pleroma.Web.CommonAPI
@ -20,7 +19,7 @@ defmodule Pleroma.Web.Feed.UserControllerTest do
setup do: clear_config([:feed]) setup do: clear_config([:feed])
setup do setup do
Config.put( clear_config(
[:feed, :post_title], [:feed, :post_title],
%{max_length: 15, omission: "..."} %{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]) setup do: clear_config([:instance, :public])
test "returns 404 for user feed", %{conn: conn} do test "returns 404 for user feed", %{conn: conn} do
Config.put([:instance, :public], false) clear_config([:instance, :public], false)
user = insert(:user) user = insert(:user)
{:ok, _} = CommonAPI.post(user, %{status: "test"}) {:ok, _} = CommonAPI.post(user, %{status: "test"})

View File

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

View File

@ -55,30 +55,39 @@ test "listing a user's lists" do
test "adding users to a list" do test "adding users to a list" do
%{user: user, conn: conn} = oauth_access(["write:lists"]) %{user: user, conn: conn} = oauth_access(["write:lists"])
other_user = insert(:user) other_user = insert(:user)
third_user = insert(:user)
{:ok, list} = Pleroma.List.create("name", user) {:ok, list} = Pleroma.List.create("name", user)
assert %{} == assert %{} ==
conn conn
|> put_req_header("content-type", "application/json") |> 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) |> json_response_and_validate_schema(:ok)
%Pleroma.List{following: following} = Pleroma.List.get(list.id, user) %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 end
test "removing users from a list, body params" do test "removing users from a list, body params" do
%{user: user, conn: conn} = oauth_access(["write:lists"]) %{user: user, conn: conn} = oauth_access(["write:lists"])
other_user = insert(:user) other_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
fourth_user = insert(:user)
{:ok, list} = Pleroma.List.create("name", user) {:ok, list} = Pleroma.List.create("name", user)
{:ok, list} = Pleroma.List.follow(list, other_user) {:ok, list} = Pleroma.List.follow(list, other_user)
{:ok, list} = Pleroma.List.follow(list, third_user) {:ok, list} = Pleroma.List.follow(list, third_user)
{:ok, list} = Pleroma.List.follow(list, fourth_user)
assert %{} == assert %{} ==
conn conn
|> put_req_header("content-type", "application/json") |> 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) |> json_response_and_validate_schema(:ok)
%Pleroma.List{following: following} = Pleroma.List.get(list.id, user) %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)

View File

@ -47,6 +47,78 @@ test "does not expose polls for private statuses", %{conn: conn} do
end end
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 describe "POST /api/v1/polls/:id/votes" do
setup do: oauth_access(["write:statuses"]) 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) 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) object = Object.get_by_id(object.id)
assert Enum.all?(object.data["anyOf"], fn %{"replies" => %{"totalItems" => total_items}} -> assert Enum.all?(object.data["anyOf"], fn %{"replies" => %{"totalItems" => total_items}} ->

View File

@ -55,7 +55,7 @@ test "shows a scheduled activity" do
end end
test "updates a scheduled activity" do 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"]) %{user: user, conn: conn} = oauth_access(["write:statuses"])
scheduled_at = Timex.shift(NaiveDateTime.utc_now(), minutes: 60) scheduled_at = Timex.shift(NaiveDateTime.utc_now(), minutes: 60)
@ -103,7 +103,7 @@ test "updates a scheduled activity" do
end end
test "deletes a scheduled activity" do 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"]) %{user: user, conn: conn} = oauth_access(["write:statuses"])
scheduled_at = Timex.shift(NaiveDateTime.utc_now(), minutes: 60) scheduled_at = Timex.shift(NaiveDateTime.utc_now(), minutes: 60)

View File

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

View File

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

View File

@ -5,7 +5,6 @@
defmodule Pleroma.Web.MastodonAPI.AccountViewTest do defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
use Pleroma.DataCase use Pleroma.DataCase
alias Pleroma.Config
alias Pleroma.User alias Pleroma.User
alias Pleroma.UserRelationship alias Pleroma.UserRelationship
alias Pleroma.Web.CommonAPI 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 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}) AccountView.render("show.json", %{user: user, skip_visibility_check: true})
|> Enum.all?(fn |> Enum.all?(fn

View File

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

View File

@ -8,7 +8,7 @@ defmodule Pleroma.Web.MediaProxy.Invalidation.ScriptTest do
import ExUnit.CaptureLog 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 capture_log(fn ->
assert Invalidation.Script.purge( assert Invalidation.Script.purge(
["http://example.com/media/example.jpg"], ["http://example.com/media/example.jpg"],
@ -23,4 +23,30 @@ test "it logger error when script not found" do
) == {:error, "\"not found script path\""} ) == {:error, "\"not found script path\""}
end) end)
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 end

View File

@ -5,7 +5,6 @@
defmodule Pleroma.Web.MediaProxy.InvalidationTest do defmodule Pleroma.Web.MediaProxy.InvalidationTest do
use Pleroma.DataCase use Pleroma.DataCase
alias Pleroma.Config
alias Pleroma.Web.MediaProxy.Invalidation alias Pleroma.Web.MediaProxy.Invalidation
import ExUnit.CaptureLog import ExUnit.CaptureLog
@ -16,11 +15,11 @@ defmodule Pleroma.Web.MediaProxy.InvalidationTest do
describe "Invalidation.Http" do describe "Invalidation.Http" do
test "perform request to clear cache" 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" image_url = "http://example.com/media/example.jpg"
Pleroma.Web.MediaProxy.put_in_banned_urls(image_url) Pleroma.Web.MediaProxy.put_in_banned_urls(image_url)
@ -43,10 +42,10 @@ test "perform request to clear cache" do
describe "Invalidation.Script" do describe "Invalidation.Script" do
test "run script to clear cache" 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" image_url = "http://example.com/media/example.jpg"
Pleroma.Web.MediaProxy.put_in_banned_urls(image_url) Pleroma.Web.MediaProxy.put_in_banned_urls(image_url)

View File

@ -33,7 +33,7 @@ test "it returns 404 when disabled", %{conn: conn} do
end end
test "it returns 403 for invalid signature", %{conn: conn, url: url} do 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) %{path: path} = URI.parse(url)
assert %Conn{ assert %Conn{
@ -128,7 +128,7 @@ test "returns 404 when disabled", %{conn: conn} do
end end
test "it returns 403 for invalid signature", %{conn: conn, url: url} do 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) %{path: path} = URI.parse(url)
assert %Conn{ assert %Conn{

View File

@ -66,7 +66,7 @@ test "it renders all supported types of attachments and skips unknown types" do
end end
test "it does not render attachments if post is nsfw" do 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"}]}) user = insert(:user, avatar: %{"url" => [%{"href" => "https://pleroma.gov/tenshi.png"}]})
note = note =

View File

@ -54,7 +54,7 @@ test "it uses summary twittercard if post has no attachment" do
end end
test "it renders avatar not attachment if post is nsfw and unfurl_nsfw is disabled" do 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") user = insert(:user, name: "Jimmy Hendriks", bio: "born 19 March 1994")
{:ok, activity} = CommonAPI.post(user, %{status: "HI"}) {:ok, activity} = CommonAPI.post(user, %{status: "HI"})

View File

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

View File

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

View File

@ -31,7 +31,7 @@ defmodule Pleroma.Web.PleromaAPI.EmojiPackControllerTest do
end end
test "GET /api/pleroma/emoji/packs when :public: false", %{conn: conn} do 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) conn |> get("/api/pleroma/emoji/packs") |> json_response_and_validate_schema(200)
end end

View File

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

View File

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

View File

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

View File

@ -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 =~ "media-src 'self' https:;"
assert csp =~ "img-src 'self' data: blob: https:;" assert csp =~ "img-src 'self' data: blob: https:;"
end 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 end
describe "img-src and media-src" do describe "img-src and media-src" do

View File

@ -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 describe "requires a signature when `authorized_fetch_mode` is enabled" do
setup 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"} params = %{"actor" => "http://mastodon.example.org/users/admin"}
conn = build_conn(:get, "/doesntmattter", params) |> put_format("activity+json") conn = build_conn(:get, "/doesntmattter", params) |> put_format("activity+json")

View File

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

View File

@ -6,7 +6,6 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest do
use Pleroma.Web.ConnCase use Pleroma.Web.ConnCase
alias Phoenix.ConnTest alias Phoenix.ConnTest
alias Pleroma.Config
alias Pleroma.Web.Plugs.RateLimiter alias Pleroma.Web.Plugs.RateLimiter
alias Plug.Conn alias Plug.Conn
@ -22,8 +21,8 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest do
setup do: clear_config([Pleroma.Web.Plugs.RemoteIp, :enabled]) setup do: clear_config([Pleroma.Web.Plugs.RemoteIp, :enabled])
test "config is required for plug to work" do 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]} == assert %{limits: {1, 1}, name: :test_init, opts: [name: :test_init]} ==
[name: @limiter_name] [name: @limiter_name]
@ -54,8 +53,8 @@ test "it restricts based on config values" do
scale = 80 scale = 80
limit = 5 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) plug_opts = RateLimiter.init(name: limiter_name)
conn = build_conn(:get, "/") 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 test "`bucket_name` option overrides default bucket name" do
limiter_name = :test_bucket_name 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" base_bucket_name = "#{limiter_name}:group1"
plug_opts = RateLimiter.init(name: limiter_name, bucket_name: base_bucket_name) 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 test "`params` option allows different queries to be tracked independently" do
limiter_name = :test_params 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"]) 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 test "it supports combination of options modifying bucket name" do
limiter_name = :test_options_combo 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" base_bucket_name = "#{limiter_name}:group1"
@ -140,8 +139,8 @@ test "it supports combination of options modifying bucket name" do
describe "unauthenticated users" do describe "unauthenticated users" do
test "are restricted based on remote IP" do test "are restricted based on remote IP" do
limiter_name = :test_unauthenticated 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) plug_opts = RateLimiter.init(name: limiter_name)
@ -180,8 +179,8 @@ test "can have limits separate from unauthenticated connections" do
scale = 50 scale = 50
limit = 5 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) 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 test "different users are counted independently" do
limiter_name = :test_authenticated2 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) 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 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 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) opts = RateLimiter.init(name: limiter_name)

View File

@ -26,7 +26,7 @@ defmodule Pleroma.Web.Plugs.RemoteIpTest do
) )
test "disabled" do test "disabled" do
Pleroma.Config.put(RemoteIp, enabled: false) clear_config(RemoteIp, enabled: false)
%{remote_ip: remote_ip} = conn(:get, "/") %{remote_ip: remote_ip} = conn(:get, "/")
@ -48,7 +48,7 @@ test "enabled" do
end end
test "custom headers" do 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 =
conn(:get, "/") conn(:get, "/")
@ -73,7 +73,7 @@ test "custom proxies" do
refute conn.remote_ip == {1, 1, 1, 1} 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 =
conn(:get, "/") conn(:get, "/")
@ -84,7 +84,7 @@ test "custom proxies" do
end end
test "proxies set without CIDR format" do 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 =
conn(:get, "/") conn(:get, "/")
@ -95,8 +95,8 @@ test "proxies set without CIDR format" do
end end
test "proxies set `nonsensical` CIDR" do 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 =
conn(:get, "/") conn(:get, "/")

View File

@ -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", test "with a user that's not confirmed and a config requiring confirmation, it removes that user",
%{conn: conn} do %{conn: conn} do
Pleroma.Config.put([:instance, :account_activation_required], true) clear_config([:instance, :account_activation_required], true)
user = insert(:user, is_confirmed: false) user = insert(:user, is_confirmed: false)

View File

@ -5,7 +5,6 @@
defmodule Pleroma.Web.RichMedia.HelpersTest do defmodule Pleroma.Web.RichMedia.HelpersTest do
use Pleroma.DataCase use Pleroma.DataCase
alias Pleroma.Config
alias Pleroma.Web.CommonAPI alias Pleroma.Web.CommonAPI
alias Pleroma.Web.RichMedia.Helpers alias Pleroma.Web.RichMedia.Helpers
@ -29,7 +28,7 @@ test "refuses to crawl incomplete URLs" do
content_type: "text/markdown" 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) assert %{} == Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
end end
@ -43,7 +42,7 @@ test "refuses to crawl malformed URLs" do
content_type: "text/markdown" 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) assert %{} == Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
end end
@ -57,7 +56,7 @@ test "crawls valid, complete URLs" do
content_type: "text/markdown" 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: _} = assert %{page_url: "https://example.com/ogp", rich_media: _} =
Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity) 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, activity4} = CommonAPI.post(user, %{status: "https://192.168.10.40/notice/9kCP7V"})
{:ok, activity5} = CommonAPI.post(user, %{status: "https://pleroma.local/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(activity)
assert %{} = Helpers.fetch_data_for_activity(activity2) assert %{} = Helpers.fetch_data_for_activity(activity2)

View File

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

View File

@ -154,7 +154,7 @@ test "returns error when user is deactivated", %{conn: conn} do
end end
test "returns error when user is blocked", %{conn: conn} do 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) user = insert(:user)
user2 = insert(:user) user2 = insert(:user)
@ -365,7 +365,7 @@ test "returns error when password invalid", %{conn: conn} do
end end
test "returns error when user is blocked", %{conn: conn} do 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) user = insert(:user)
user2 = insert(:user) user2 = insert(:user)
{:ok, _user_block} = Pleroma.User.block(user2, user) {:ok, _user_block} = Pleroma.User.block(user2, user)

View File

@ -46,12 +46,7 @@ test "it registers a new user with empty string in bio and returns the user" do
end end
test "it sends confirmation email if :account_activation_required is specified in instance config" do 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 = %{ data = %{
:username => "lain", :username => "lain",

View File

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

View File

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

View File

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