nrd.li/akkoma
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Convert tests to all use clear_config instead of Pleroma.Config.put

Browse source
This commit is contained in:
Mark Felder 2021-01-26 11:58:43 -06:00
parent e1eac4faac
commit e854c35e65
69 changed files with 325 additions and 368 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
test/mix/tasks/pleroma/robots_txt_test.exs
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)

4
test/pleroma/activity_test.exs
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)

27
test/pleroma/application_requirements_test.exs
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

6
test/pleroma/captcha_test.exs
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()

36
test/pleroma/config_test.exs
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}

3
test/pleroma/gun/connection_pool_test.exs
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)

13
test/pleroma/http/adapter_helper/gun_test.exs
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)

11
test/pleroma/object/fetcher_test.exs
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")

2
test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
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, []} =

2
test/pleroma/repo/migrations/fix_malformed_formatter_config_test.exs
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, []} =

4
test/pleroma/scheduled_activity_test.exs
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 =

5
test/pleroma/upload/filter/anonymize_filename_test.exs
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

3
test/pleroma/upload/filter_test.exs
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",

7
test/pleroma/uploaders/s3_test.exs
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"
) )

8
test/pleroma/user/backup_test.exs
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)

7
test/pleroma/user/welcome_chat_message_test.exs
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!"
) )

10
test/pleroma/user/welcome_email_test.exs
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)

7
test/pleroma/user/welcome_message_test.exs
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"
) )

6
test/pleroma/user_search_test.exs
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})

76
test/pleroma/user_test.exs
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

19
test/pleroma/web/activity_pub/activity_pub_controller_test.exs
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

6
test/pleroma/web/activity_pub/activity_pub_test.exs
View file

@ -1079,15 +1079,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

12
test/pleroma/web/activity_pub/mrf/hellthread_policy_test.exs
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

26
test/pleroma/web/activity_pub/mrf/keyword_policy_test.exs
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"}
]) ])

12
test/pleroma/web/activity_pub/mrf/mention_policy_test.exs
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",

19
test/pleroma/web/activity_pub/mrf/object_age_policy_test.exs
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()

8
test/pleroma/web/activity_pub/mrf/reject_non_public_test.exs
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

81
test/pleroma/web/activity_pub/mrf/simple_policy_test.exs
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()

4
test/pleroma/web/activity_pub/mrf/subchain_policy_test.exs
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]
}) })

4
test/pleroma/web/activity_pub/mrf/user_allow_list_policy_test.exs
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

14
test/pleroma/web/activity_pub/mrf/vocabulary_policy_test.exs
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",

2
test/pleroma/web/activity_pub/object_validators/chat_validation_test.exs
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

2
test/pleroma/web/activity_pub/transmogrifier/follow_handling_test.exs
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")

12
test/pleroma/web/activity_pub/transmogrifier/note_handling_test.exs
View file

@ -415,7 +415,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)
@ -427,7 +427,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)
@ -464,7 +464,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)
@ -476,7 +476,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)
@ -551,7 +551,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")
@ -585,7 +585,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"] ==

9
test/pleroma/web/admin_api/controllers/config_controller_test.exs
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")

9
test/pleroma/web/admin_api/controllers/invite_controller_test.exs
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

6
test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs
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

2
test/pleroma/web/chat_channel_test.exs
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

8
test/pleroma/web/common_api_test.exs
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!!!"})

6
test/pleroma/web/federator_test.exs
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
) )

5
test/pleroma/web/feed/tag_controller_test.exs
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: "..."}
) )

5
test/pleroma/web/feed/user_controller_test.exs
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"})

2
test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
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()

4
test/pleroma/web/mastodon_api/controllers/scheduled_activity_controller_test.exs
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)

9
test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
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

3
test/pleroma/web/mastodon_api/masto_fe_controller_test.exs
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)

3
test/pleroma/web/mastodon_api/views/account_view_test.exs
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

17
test/pleroma/web/media_proxy/invalidation_test.exs
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)

4
test/pleroma/web/media_proxy/media_proxy_controller_test.exs
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{

2
test/pleroma/web/metadata/providers/open_graph_test.exs
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 =

2
test/pleroma/web/metadata/providers/twitter_card_test.exs
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"})

8
test/pleroma/web/node_info_test.exs
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

8
test/pleroma/web/o_auth/o_auth_controller_test.exs
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"])

2
test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs
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

4
test/pleroma/web/plugs/admin_secret_authentication_plug_test.exs
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

7
test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs
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

4
test/pleroma/web/plugs/federating_plug_test.exs
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()

6
test/pleroma/web/plugs/http_signature_plug_test.exs
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")

4
test/pleroma/web/plugs/o_auth_scopes_plug_test.exs
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"]

37
test/pleroma/web/plugs/rate_limiter_test.exs
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)

12
test/pleroma/web/plugs/remote_ip_test.exs
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, "/")

2
test/pleroma/web/plugs/user_enabled_plug_test.exs
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)

9
test/pleroma/web/rich_media/helpers_test.exs
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)

6
test/pleroma/web/streamer_test.exs
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)

4
test/pleroma/web/twitter_api/remote_follow_controller_test.exs
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)

7
test/pleroma/web/twitter_api/twitter_api_test.exs
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",

9
test/pleroma/web/twitter_api/util_controller_test.exs
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

2
test/pleroma/workers/cron/digest_emails_worker_test.exs
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

4
test/pleroma/workers/scheduled_activity_worker_test.exs
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}})