limepotato/akkoma
1
0
Fork 0
Code Pull requests 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 @@ defmodule Mix.Tasks.Pleroma.RobotsTxtTest 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 @@ defmodule Pleroma.ActivityTest do
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 @@ defmodule Pleroma.ActivityTest do
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 @@ defmodule Pleroma.ApplicationRequirementsTest do
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 @@ defmodule Pleroma.ApplicationRequirementsTest 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 @@ defmodule Pleroma.ApplicationRequirementsTest 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 @@ defmodule Pleroma.ApplicationRequirementsTest do
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 @@ defmodule Pleroma.ApplicationRequirementsTest 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 @@ defmodule Pleroma.ApplicationRequirementsTest 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 @@ defmodule Pleroma.ApplicationRequirementsTest 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 @@ defmodule Pleroma.ApplicationRequirementsTest 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 @@ defmodule Pleroma.CaptchaTest 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 @@ defmodule Pleroma.CaptchaTest 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 @@ defmodule Pleroma.CaptchaTest 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 @@ defmodule Pleroma.ConfigTest 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 @@ defmodule Pleroma.ConfigTest 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 @@ defmodule Pleroma.ConfigTest 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 @@ defmodule Pleroma.ConfigTest 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 @@ defmodule Pleroma.Gun.ConnectionPoolTest 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 @@ defmodule Pleroma.HTTP.AdapterHelper.GunTest 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 @@ defmodule Pleroma.HTTP.AdapterHelper.GunTest 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 @@ defmodule Pleroma.HTTP.AdapterHelper.GunTest 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 @@ defmodule Pleroma.Object.FetcherTest 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 @@ defmodule Pleroma.Object.FetcherTest 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 @@ defmodule Pleroma.Object.FetcherTest 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 @@ defmodule Pleroma.Repo.Migrations.AutolinkerToLinkifyTest 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, []} =

2
test/pleroma/repo/migrations/fix_malformed_formatter_config_test.exs
View file

@ -34,7 +34,7 @@ defmodule Pleroma.Repo.Migrations.FixMalformedFormatterConfigTest 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 @@ defmodule Pleroma.ScheduledActivityTest 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 @@ defmodule Pleroma.Uploaders.S3Test 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 @@ defmodule Pleroma.Uploaders.S3Test 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 @@ defmodule Pleroma.User.BackupTest 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 @@ defmodule Pleroma.User.BackupTest 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 @@ defmodule Pleroma.User.WelcomeChatMessageTest 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 @@ defmodule Pleroma.User.WelcomeEmailTest 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 @@ defmodule Pleroma.User.WelcomeMessageTest 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 @@ defmodule Pleroma.UserSearchTest 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 @@ defmodule Pleroma.UserSearchTest do
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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest do
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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest do
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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest do
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 @@ defmodule Pleroma.UserTest do
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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.UserTest do
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 @@ defmodule Pleroma.UserTest do
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 @@ defmodule Pleroma.UserTest do
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 @@ defmodule Pleroma.UserTest 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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest 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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest 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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest 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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest 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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
|> 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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest 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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest 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 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicyTest do
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 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicyTest do
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 @@ defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicyTest do
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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.MentionPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.MentionPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.MentionPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.MentionPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.MentionPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.MentionPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.ObjectAgePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.RejectNonPublicTest do
"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 @@ defmodule Pleroma.Web.ActivityPub.MRF.RejectNonPublicTest do
"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 @@ defmodule Pleroma.Web.ActivityPub.MRF.RejectNonPublicTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.RejectNonPublicTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.SubchainPolicyTest do
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 @@ defmodule Pleroma.Web.ActivityPub.MRF.UserAllowListPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicyTest 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 @@ defmodule Pleroma.Web.ActivityPub.ObjectValidators.ChatValidationTest do
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 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.FollowHandlingTest do
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 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.NoteHandlingTest do
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 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.NoteHandlingTest do
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 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.NoteHandlingTest do
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 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.NoteHandlingTest do
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 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.NoteHandlingTest do
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 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier.NoteHandlingTest 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 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest 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 @@ defmodule Pleroma.Web.AdminAPI.ConfigControllerTest 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 @@ defmodule Pleroma.Web.AdminAPI.InviteControllerTest 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 @@ defmodule Pleroma.Web.AdminAPI.InviteControllerTest 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 @@ defmodule Pleroma.Web.ChatChannelTest 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 @@ defmodule Pleroma.Web.CommonAPITest 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 @@ defmodule Pleroma.Web.CommonAPITest do
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 @@ defmodule Pleroma.Web.CommonAPITest 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 @@ defmodule Pleroma.Web.CommonAPITest 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 @@ defmodule Pleroma.Web.FederatorTest do
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 @@ defmodule Pleroma.Web.FederatorTest 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 @@ defmodule Pleroma.Web.Feed.TagControllerTest 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 @@ defmodule Pleroma.Web.Feed.UserControllerTest do
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 @@ defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
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 @@ defmodule Pleroma.Web.MastodonAPI.ScheduledActivityControllerTest 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 @@ defmodule Pleroma.Web.MastodonAPI.ScheduledActivityControllerTest 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 @@ defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
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 @@ defmodule Pleroma.Web.MastodonAPI.StatusControllerTest 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 @@ defmodule Pleroma.Web.MastodonAPI.MastoFEControllerTest do
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 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
) )
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 @@ defmodule Pleroma.Web.MediaProxy.InvalidationTest 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 @@ defmodule Pleroma.Web.MediaProxy.MediaProxyControllerTest 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 @@ defmodule Pleroma.Web.MediaProxy.MediaProxyControllerTest 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 @@ defmodule Pleroma.Web.Metadata.Providers.OpenGraphTest 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 @@ defmodule Pleroma.Web.Metadata.Providers.TwitterCardTest 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 @@ defmodule Pleroma.Web.NodeInfoTest 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 @@ defmodule Pleroma.Web.NodeInfoTest 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 @@ defmodule Pleroma.Web.NodeInfoTest 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 @@ defmodule Pleroma.Web.OAuth.OAuthControllerTest 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 @@ defmodule Pleroma.Web.OAuth.OAuthControllerTest do
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 @@ defmodule Pleroma.Web.OAuth.OAuthControllerTest 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 @@ defmodule Pleroma.Web.OAuth.OAuthControllerTest 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 @@ defmodule Pleroma.Web.Plugs.AdminSecretAuthenticationPlugTest 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 @@ defmodule Pleroma.Web.Plugs.AdminSecretAuthenticationPlugTest 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 @@ defmodule Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlugTest 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 @@ defmodule Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlugTest 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 @@ defmodule Pleroma.Web.Plugs.FederatingPlugTest 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 @@ defmodule Pleroma.Web.Plugs.HTTPSignaturePlugTest 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 @@ defmodule Pleroma.Web.Plugs.OAuthScopesPlugTest do
"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 @@ defmodule Pleroma.Web.Plugs.OAuthScopesPlugTest do
"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 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest 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 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest 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 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest 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 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest 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 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest 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 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest 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 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest 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 @@ defmodule Pleroma.Web.Plugs.RateLimiterTest 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 @@ defmodule Pleroma.Web.Plugs.RemoteIpTest 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 @@ defmodule Pleroma.Web.Plugs.RemoteIpTest 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 @@ defmodule Pleroma.Web.Plugs.RemoteIpTest 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 @@ defmodule Pleroma.Web.Plugs.RemoteIpTest 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 @@ defmodule Pleroma.Web.Plugs.UserEnabledPlugTest 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 @@ defmodule Pleroma.Web.RichMedia.HelpersTest 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 @@ defmodule Pleroma.Web.RichMedia.HelpersTest 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 @@ defmodule Pleroma.Web.RichMedia.HelpersTest 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 @@ defmodule Pleroma.Web.RichMedia.HelpersTest 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 @@ defmodule Pleroma.Web.StreamerTest 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 @@ defmodule Pleroma.Web.StreamerTest do
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 @@ defmodule Pleroma.Web.StreamerTest do
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 @@ defmodule Pleroma.Web.TwitterAPI.RemoteFollowControllerTest 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 @@ defmodule Pleroma.Web.TwitterAPI.RemoteFollowControllerTest 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 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPITest 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 @@ defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
} }
] ]
Config.put(:frontend_configurations, config) clear_config(:frontend_configurations, config)
response = response =
conn conn
@ -99,7 +98,7 @@ defmodule Pleroma.Web.TwitterAPI.UtilControllerTest 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 @@ defmodule Pleroma.Web.TwitterAPI.UtilControllerTest 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 @@ defmodule Pleroma.Web.TwitterAPI.UtilControllerTest 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 @@ defmodule Pleroma.Workers.ScheduledActivityWorkerTest 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}})