defmodule Pleroma.Config.TransferTaskTest do
use Pleroma.DataCase
- setup do
- dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
-
+ clear_config([:instance, :dynamic_configuration]) do
Pleroma.Config.put([:instance, :dynamic_configuration], true)
-
- on_exit(fn ->
- Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
- end)
end
test "transfer config values from db to env" do
import Pleroma.Factory
- setup_all do
- config_path = [:instance, :federating]
- initial_setting = Pleroma.Config.get(config_path)
-
- Pleroma.Config.put(config_path, true)
- on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
-
- :ok
+ clear_config_all([:instance, :federating]) do
+ Pleroma.Config.put([:instance, :federating], true)
end
test "it goes through old direct conversations" do
to: [{"Test User", "user1@example.com"}]
}
- setup do
- value = Pleroma.Config.get([Pleroma.Emails.Mailer, :enabled])
- on_exit(fn -> Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], value) end)
- :ok
- end
+ clear_config([Pleroma.Emails.Mailer, :enabled])
test "not send email when mailer is disabled" do
Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)
defmodule Pleroma.HTTP.RequestBuilderTest do
use ExUnit.Case, async: true
+ use Pleroma.Tests.Helpers
alias Pleroma.HTTP.RequestBuilder
describe "headers/2" do
+ clear_config([:http, :send_user_agent])
+
test "don't send pleroma user agent" do
assert RequestBuilder.headers(%{}, []) == %{headers: []}
end
test "send pleroma user agent" do
- send = Pleroma.Config.get([:http, :send_user_agent])
Pleroma.Config.put([:http, :send_user_agent], true)
- on_exit(fn ->
- Pleroma.Config.put([:http, :send_user_agent], send)
- end)
-
assert RequestBuilder.headers(%{}, []) == %{
headers: [{"User-Agent", Pleroma.Application.user_agent()}]
}
end
describe "signed fetches" do
+ clear_config([:activitypub, :sign_object_fetches])
+
test_with_mock "it signs fetches when configured to do so",
Pleroma.Signature,
[:passthrough],
[] do
- option = Pleroma.Config.get([:activitypub, :sign_object_fetches])
Pleroma.Config.put([:activitypub, :sign_object_fetches], true)
Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
assert called(Pleroma.Signature.sign(:_, :_))
-
- Pleroma.Config.put([:activitypub, :sign_object_fetches], option)
end
test_with_mock "it doesn't sign fetches when not configured to do so",
Pleroma.Signature,
[:passthrough],
[] do
- option = Pleroma.Config.get([:activitypub, :sign_object_fetches])
Pleroma.Config.put([:activitypub, :sign_object_fetches], false)
Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
refute called(Pleroma.Signature.sign(:_, :_))
-
- Pleroma.Config.put([:activitypub, :sign_object_fetches], option)
end
end
end
alias Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug
alias Pleroma.User
+ clear_config([:instance, :public])
+
test "it halts if not public and no user is assigned", %{conn: conn} do
- set_public_to(false)
+ Config.put([:instance, :public], false)
conn =
conn
end
test "it continues if public", %{conn: conn} do
- set_public_to(true)
+ Config.put([:instance, :public], true)
ret_conn =
conn
end
test "it continues if a user is assigned, even if not public", %{conn: conn} do
- set_public_to(false)
+ Config.put([:instance, :public], false)
conn =
conn
assert ret_conn == conn
end
-
- defp set_public_to(value) do
- orig = Config.get!([:instance, :public])
- Config.put([:instance, :public], value)
-
- on_exit(fn ->
- Config.put([:instance, :public], orig)
- end)
- end
end
alias Pleroma.Config
alias Plug.Conn
+ clear_config([:http_securiy, :enabled])
+ clear_config([:http_security, :sts])
+
describe "http security enabled" do
setup do
- enabled = Config.get([:http_securiy, :enabled])
-
Config.put([:http_security, :enabled], true)
-
- on_exit(fn ->
- Config.put([:http_security, :enabled], enabled)
- end)
-
- :ok
end
test "it sends CSP headers when enabled", %{conn: conn} do
end
test "it does not send CSP headers when disabled", %{conn: conn} do
- enabled = Config.get([:http_securiy, :enabled])
-
Config.put([:http_security, :enabled], false)
- on_exit(fn ->
- Config.put([:http_security, :enabled], enabled)
- end)
-
conn = get(conn, "/api/v1/instance")
assert Conn.get_resp_header(conn, "x-xss-protection") == []
@dir "test/tmp/instance_static"
setup do
- static_dir = Pleroma.Config.get([:instance, :static_dir])
- Pleroma.Config.put([:instance, :static_dir], @dir)
File.mkdir_p!(@dir)
+ on_exit(fn -> File.rm_rf(@dir) end)
+ end
- on_exit(fn ->
- Pleroma.Config.put([:instance, :static_dir], static_dir)
- File.rm_rf(@dir)
- end)
+ clear_config([:instance, :static_dir]) do
+ Pleroma.Config.put([:instance, :static_dir], @dir)
end
test "overrides index" do
Helpers for use in tests.
"""
+ defmacro clear_config(config_path) do
+ quote do
+ clear_config(unquote(config_path)) do
+ end
+ end
+ end
+
+ defmacro clear_config(config_path, do: yield) do
+ quote do
+ setup do
+ initial_setting = Pleroma.Config.get(unquote(config_path))
+ unquote(yield)
+ on_exit(fn -> Pleroma.Config.put(unquote(config_path), initial_setting) end)
+ :ok
+ end
+ end
+ end
+
+ defmacro clear_config_all(config_path) do
+ quote do
+ clear_config_all(unquote(config_path)) do
+ end
+ end
+ end
+
+ defmacro clear_config_all(config_path, do: yield) do
+ quote do
+ setup_all do
+ initial_setting = Pleroma.Config.get(unquote(config_path))
+ unquote(yield)
+ on_exit(fn -> Pleroma.Config.put(unquote(config_path), initial_setting) end)
+ :ok
+ end
+ end
+ end
+
defmacro __using__(_opts) do
quote do
+ import Pleroma.Tests.Helpers,
+ only: [
+ clear_config: 1,
+ clear_config: 2,
+ clear_config_all: 1,
+ clear_config_all: 2
+ ]
+
def collect_ids(collection) do
collection
|> Enum.map(& &1.id)
|> Poison.encode!()
|> Poison.decode!()
end
+
+ defmacro guards_config(config_path) do
+ quote do
+ initial_setting = Pleroma.Config.get(config_path)
+
+ Pleroma.Config.put(config_path, true)
+ on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
+ end
+ end
end
end
end
Mix.shell(Mix.Shell.Process)
temp_file = "config/temp.exported_from_db.secret.exs"
- dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
-
- Pleroma.Config.put([:instance, :dynamic_configuration], true)
-
on_exit(fn ->
Mix.shell(Mix.Shell.IO)
Application.delete_env(:pleroma, :first_setting)
Application.delete_env(:pleroma, :second_setting)
- Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
:ok = File.rm(temp_file)
end)
{:ok, temp_file: temp_file}
end
+ clear_config_all([:instance, :dynamic_configuration]) do
+ Pleroma.Config.put([:instance, :dynamic_configuration], true)
+ end
+
test "settings are migrated to db" do
assert Repo.all(Config) == []
defmodule Mix.Tasks.Pleroma.RobotsTxtTest do
use ExUnit.Case
+ use Pleroma.Tests.Helpers
alias Mix.Tasks.Pleroma.RobotsTxt
+ clear_config([:instance, :static_dir])
+
test "creates new dir" do
path = "test/fixtures/new_dir/"
file_path = path <> "robots.txt"
-
- static_dir = Pleroma.Config.get([:instance, :static_dir])
Pleroma.Config.put([:instance, :static_dir], path)
on_exit(fn ->
- Pleroma.Config.put([:instance, :static_dir], static_dir)
{:ok, ["test/fixtures/new_dir/", "test/fixtures/new_dir/robots.txt"]} = File.rm_rf(path)
end)
test "to existance folder" do
path = "test/fixtures/"
file_path = path <> "robots.txt"
- static_dir = Pleroma.Config.get([:instance, :static_dir])
Pleroma.Config.put([:instance, :static_dir], path)
on_exit(fn ->
- Pleroma.Config.put([:instance, :static_dir], static_dir)
:ok = File.rm(file_path)
end)
alias Pleroma.Upload
setup do
- custom_filename = Config.get([Upload.Filter.AnonymizeFilename, :text])
-
- on_exit(fn ->
- Config.put([Upload.Filter.AnonymizeFilename, :text], custom_filename)
- end)
-
upload_file = %Upload{
name: "an… image.jpg",
content_type: "image/jpg",
%{upload_file: upload_file}
end
+ clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text])
+
test "it replaces filename on pre-defined text", %{upload_file: upload_file} do
Config.put([Upload.Filter.AnonymizeFilename, :text], "custom-file.png")
{:ok, %Upload{name: name}} = Upload.Filter.AnonymizeFilename.filter(upload_file)
alias Pleroma.Upload
alias Pleroma.Upload.Filter
- setup do
- filter = Config.get([Filter.Mogrify, :args])
-
- on_exit(fn ->
- Config.put([Filter.Mogrify, :args], filter)
- end)
- end
+ clear_config([Filter.Mogrify, :args])
test "apply mogrify filter" do
Config.put([Filter.Mogrify, :args], [{"tint", "40"}])
alias Pleroma.Config
alias Pleroma.Upload.Filter
- setup do
- custom_filename = Config.get([Pleroma.Upload.Filter.AnonymizeFilename, :text])
-
- on_exit(fn ->
- Config.put([Pleroma.Upload.Filter.AnonymizeFilename, :text], custom_filename)
- end)
- end
+ clear_config([Pleroma.Upload.Filter.AnonymizeFilename, :text])
test "applies filters" do
Config.put([Pleroma.Upload.Filter.AnonymizeFilename, :text], "custom-file.png")
end
describe "Setting a custom base_url for uploaded media" do
- setup do
+ clear_config([Pleroma.Upload, :base_url]) do
Pleroma.Config.put([Pleroma.Upload, :base_url], "https://cache.pleroma.social")
-
- on_exit(fn ->
- Pleroma.Config.put([Pleroma.Upload, :base_url], nil)
- end)
end
test "returns a media url with configured base_url" do
import Mock
import ExUnit.CaptureLog
- setup do
- config = Config.get([Pleroma.Uploaders.S3])
-
+ clear_config([Pleroma.Uploaders.S3]) do
Config.put([Pleroma.Uploaders.S3],
bucket: "test_bucket",
public_endpoint: "https://s3.amazonaws.com"
)
-
- on_exit(fn ->
- Config.put([Pleroma.Uploaders.S3], config)
- end)
-
- :ok
end
describe "get_file/1" do
:ok
end
+ clear_config([:instance, :account_activation_required])
+
describe "when tags are nil" do
test "tagging a user" do
user = insert(:user, %{tags: nil})
password_confirmation: "test",
email: "email@example.com"
}
+ clear_config([:instance, :autofollowed_nicknames])
+ clear_config([:instance, :welcome_message])
+ clear_config([:instance, :welcome_user_nickname])
test "it autofollows accounts that are set for it" do
user = insert(:user)
assert User.following?(registered_user, user)
refute User.following?(registered_user, remote_user)
-
- Pleroma.Config.put([:instance, :autofollowed_nicknames], [])
end
test "it sends a welcome message if it is set" do
assert registered_user.ap_id in activity.recipients
assert Object.normalize(activity).data["content"] =~ "cool site"
assert activity.actor == welcome_user.ap_id
-
- Pleroma.Config.put([:instance, :welcome_user_nickname], nil)
- Pleroma.Config.put([:instance, :welcome_message], nil)
end
test "it requires an email, name, nickname and password, bio is optional" do
email: "email@example.com"
}
- setup do
- setting = Pleroma.Config.get([:instance, :account_activation_required])
-
- unless setting do
- Pleroma.Config.put([:instance, :account_activation_required], true)
- on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
- end
-
- :ok
+ clear_config([:instance, :account_activation_required]) do
+ Pleroma.Config.put([:instance, :account_activation_required], true)
end
test "it creates unconfirmed user" do
[user: user]
end
+ clear_config([:instance, :federating])
+
test ".delete_user_activities deletes all create activities", %{user: user} do
{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
Pleroma.Web.ActivityPub.Publisher,
[:passthrough],
[] do
- config_path = [:instance, :federating]
- initial_setting = Pleroma.Config.get(config_path)
- Pleroma.Config.put(config_path, true)
+ Pleroma.Config.put([:instance, :federating], true)
{:ok, follower} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
{:ok, _} = User.follow(follower, user)
inbox: "http://mastodon.example.org/inbox"
})
)
-
- Pleroma.Config.put(config_path, initial_setting)
end
end
refute User.auth_active?(local_user)
assert User.auth_active?(confirmed_user)
assert User.auth_active?(remote_user)
-
- Pleroma.Config.put([:instance, :account_activation_required], false)
end
describe "superuser?/1" do
other_user = insert(:user, local: true)
refute User.visible_for?(user, other_user)
-
- Pleroma.Config.put([:instance, :account_activation_required], false)
end
test "returns true when the account is unauthenticated and auth is not required" do
other_user = insert(:user, local: true, info: %{is_admin: true})
assert User.visible_for?(user, other_user)
-
- Pleroma.Config.put([:instance, :account_activation_required], false)
end
end
end
describe "following/followers synchronization" do
- setup do
- sync = Pleroma.Config.get([:instance, :external_user_synchronization])
- on_exit(fn -> Pleroma.Config.put([:instance, :external_user_synchronization], sync) end)
- end
+ clear_config([:instance, :external_user_synchronization])
test "updates the counters normally on following/getting a follow when disabled" do
Pleroma.Config.put([:instance, :external_user_synchronization], false)
setup_all do
Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
-
- config_path = [:instance, :federating]
- initial_setting = Pleroma.Config.get(config_path)
-
- Pleroma.Config.put(config_path, true)
- on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
-
:ok
end
+ clear_config_all([:instance, :federating],
+ do: Pleroma.Config.put([:instance, :federating], true)
+ )
+
describe "/relay" do
+ clear_config([:instance, :allow_relay])
+
test "with the relay active, it returns the relay user", %{conn: conn} do
res =
conn
|> get(activity_pub_path(conn, :relay))
|> json_response(404)
|> assert
-
- Pleroma.Config.put([:instance, :allow_relay], true)
end
end
defmodule Pleroma.Web.ActivityPub.MRFTest do
use ExUnit.Case, async: true
+ use Pleroma.Tests.Helpers
alias Pleroma.Web.ActivityPub.MRF
test "subdomains_regex/1" do
end
describe "describe/0" do
+ clear_config([:instance, :rewrite_policy])
+
test "it works as expected with noop policy" do
expected = %{
mrf_policies: ["NoOpPolicy"],
end
test "it works as expected with mock policy" do
- config = Pleroma.Config.get([:instance, :rewrite_policy])
Pleroma.Config.put([:instance, :rewrite_policy], [MRFModuleMock])
expected = %{
}
{:ok, ^expected} = MRF.describe()
-
- Pleroma.Config.put([:instance, :rewrite_policy], config)
end
end
end
alias Pleroma.Web.ActivityPub.MRF.RejectNonPublic
- setup do
- policy = Pleroma.Config.get([:mrf_rejectnonpublic])
- on_exit(fn -> Pleroma.Config.put([:mrf_rejectnonpublic], policy) end)
-
- :ok
- end
+ clear_config([:mrf_rejectnonpublic])
describe "public message" do
test "it's allowed when address is public" do
alias Pleroma.Config
alias Pleroma.Web.ActivityPub.MRF.SimplePolicy
- setup do
- orig = Config.get!(:mrf_simple)
-
+ clear_config([:mrf_simple]) do
Config.put(:mrf_simple,
media_removal: [],
media_nsfw: [],
avatar_removal: [],
banner_removal: []
)
-
- on_exit(fn ->
- Config.put(:mrf_simple, orig)
- end)
end
describe "when :media_removal" do
alias Pleroma.Web.ActivityPub.MRF.UserAllowListPolicy
- setup do
- policy = Pleroma.Config.get([:mrf_user_allowlist]) || []
- on_exit(fn -> Pleroma.Config.put([:mrf_user_allowlist], policy) end)
-
- :ok
- end
+ clear_config([:mrf_user_allowlist, :localhost])
test "pass filter if allow list is empty" do
actor = insert(:user)
alias Pleroma.Web.ActivityPub.MRF.VocabularyPolicy
describe "accept" do
+ clear_config([:mrf_vocabulary, :accept])
+
test "it accepts based on parent activity type" do
- config = Pleroma.Config.get([:mrf_vocabulary, :accept])
Pleroma.Config.put([:mrf_vocabulary, :accept], ["Like"])
message = %{
}
{:ok, ^message} = VocabularyPolicy.filter(message)
-
- Pleroma.Config.put([:mrf_vocabulary, :accept], config)
end
test "it accepts based on child object type" do
- config = Pleroma.Config.get([:mrf_vocabulary, :accept])
Pleroma.Config.put([:mrf_vocabulary, :accept], ["Create", "Note"])
message = %{
}
{:ok, ^message} = VocabularyPolicy.filter(message)
-
- Pleroma.Config.put([:mrf_vocabulary, :accept], config)
end
test "it does not accept disallowed child objects" do
- config = Pleroma.Config.get([:mrf_vocabulary, :accept])
Pleroma.Config.put([:mrf_vocabulary, :accept], ["Create", "Note"])
message = %{
}
{:reject, nil} = VocabularyPolicy.filter(message)
-
- Pleroma.Config.put([:mrf_vocabulary, :accept], config)
end
test "it does not accept disallowed parent types" do
- config = Pleroma.Config.get([:mrf_vocabulary, :accept])
Pleroma.Config.put([:mrf_vocabulary, :accept], ["Announce", "Note"])
message = %{
}
{:reject, nil} = VocabularyPolicy.filter(message)
-
- Pleroma.Config.put([:mrf_vocabulary, :accept], config)
end
end
describe "reject" do
+ clear_config([:mrf_vocabulary, :reject])
+
test "it rejects based on parent activity type" do
- config = Pleroma.Config.get([:mrf_vocabulary, :reject])
Pleroma.Config.put([:mrf_vocabulary, :reject], ["Like"])
message = %{
}
{:reject, nil} = VocabularyPolicy.filter(message)
-
- Pleroma.Config.put([:mrf_vocabulary, :reject], config)
end
test "it rejects based on child object type" do
- config = Pleroma.Config.get([:mrf_vocabulary, :reject])
Pleroma.Config.put([:mrf_vocabulary, :reject], ["Note"])
message = %{
}
{:reject, nil} = VocabularyPolicy.filter(message)
-
- Pleroma.Config.put([:mrf_vocabulary, :reject], config)
end
test "it passes through objects that aren't disallowed" do
- config = Pleroma.Config.get([:mrf_vocabulary, :reject])
Pleroma.Config.put([:mrf_vocabulary, :reject], ["Like"])
message = %{
}
{:ok, ^message} = VocabularyPolicy.filter(message)
-
- Pleroma.Config.put([:mrf_vocabulary, :reject], config)
end
end
end
describe "POST /api/pleroma/admin/email_invite, with valid config" do
setup do
- registrations_open = Pleroma.Config.get([:instance, :registrations_open])
- invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
- Pleroma.Config.put([:instance, :registrations_open], false)
- Pleroma.Config.put([:instance, :invites_enabled], true)
+ [user: insert(:user, info: %{is_admin: true})]
+ end
- on_exit(fn ->
- Pleroma.Config.put([:instance, :registrations_open], registrations_open)
- Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
- :ok
- end)
+ clear_config([:instance, :registrations_open]) do
+ Pleroma.Config.put([:instance, :registrations_open], false)
+ end
- [user: insert(:user, info: %{is_admin: true})]
+ clear_config([:instance, :invites_enabled]) do
+ Pleroma.Config.put([:instance, :invites_enabled], true)
end
test "sends invitation and returns 204", %{conn: conn, user: user} do
[user: insert(:user, info: %{is_admin: true})]
end
+ clear_config([:instance, :registrations_open])
+ clear_config([:instance, :invites_enabled])
+
test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
- registrations_open = Pleroma.Config.get([:instance, :registrations_open])
- invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
Pleroma.Config.put([:instance, :registrations_open], false)
Pleroma.Config.put([:instance, :invites_enabled], false)
- on_exit(fn ->
- Pleroma.Config.put([:instance, :registrations_open], registrations_open)
- Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
- :ok
- end)
-
conn =
conn
|> assign(:user, user)
end
test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
- registrations_open = Pleroma.Config.get([:instance, :registrations_open])
- invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
Pleroma.Config.put([:instance, :registrations_open], true)
Pleroma.Config.put([:instance, :invites_enabled], true)
- on_exit(fn ->
- Pleroma.Config.put([:instance, :registrations_open], registrations_open)
- Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
- :ok
- end)
-
conn =
conn
|> assign(:user, user)
:ok = File.rm(temp_file)
end)
- dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
+ %{conn: assign(conn, :user, admin)}
+ end
+ clear_config([:instance, :dynamic_configuration]) do
Pleroma.Config.put([:instance, :dynamic_configuration], true)
-
- on_exit(fn ->
- Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
- end)
-
- %{conn: assign(conn, :user, admin)}
end
test "create new config setting in db", %{conn: conn} do
:ok = File.rm(temp_file)
end)
- dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
+ %{conn: assign(conn, :user, admin), admin: admin}
+ end
+ clear_config([:instance, :dynamic_configuration]) do
Pleroma.Config.put([:instance, :dynamic_configuration], true)
-
- on_exit(fn ->
- Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
- end)
-
- %{conn: assign(conn, :user, admin), admin: admin}
end
test "transfer settings to DB and to file", %{conn: conn, admin: admin} do
import Pleroma.Factory
+ clear_config([:instance, :safe_dm_mentions])
+ clear_config([:instance, :limit])
+ clear_config([:instance, :max_pinned_statuses])
+
test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
har = insert(:user)
jafnhar = insert(:user)
tridi = insert(:user)
- option = Pleroma.Config.get([:instance, :safe_dm_mentions])
Pleroma.Config.put([:instance, :safe_dm_mentions], true)
{:ok, activity} =
refute tridi.ap_id in activity.recipients
assert jafnhar.ap_id in activity.recipients
- Pleroma.Config.put([:instance, :safe_dm_mentions], option)
end
test "it de-duplicates tags" do
end
test "it returns error when character limit is exceeded" do
- limit = Pleroma.Config.get([:instance, :limit])
Pleroma.Config.put([:instance, :limit], 5)
user = insert(:user)
assert {:error, "The status is over the character limit"} =
CommonAPI.post(user, %{"status" => "foobar"})
-
- Pleroma.Config.put([:instance, :limit], limit)
end
end
setup_all do
Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
- config_path = [:instance, :federating]
- initial_setting = Pleroma.Config.get(config_path)
-
- Pleroma.Config.put(config_path, true)
- on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
-
:ok
end
+ clear_config_all([:instance, :federating]) do
+ Pleroma.Config.put([:instance, :federating], true)
+ end
+
+ clear_config([:instance, :allow_relay])
+ clear_config([:instance, :rewrite_policy])
+ clear_config([:mrf_keyword])
+
describe "Publisher.perform" do
test "call `perform` with unknown task" do
assert {
end
refute_received :relay_publish
-
- Pleroma.Config.put([:instance, :allow_relay], true)
end
end
end
test "it does not crash if MRF rejects the post" do
- policies = Pleroma.Config.get([:instance, :rewrite_policy])
- mrf_keyword_policy = Pleroma.Config.get(:mrf_keyword)
Pleroma.Config.put([:mrf_keyword, :reject], ["lain"])
- Pleroma.Config.put([:instance, :rewrite_policy], Pleroma.Web.ActivityPub.MRF.KeywordPolicy)
+
+ Pleroma.Config.put(
+ [:instance, :rewrite_policy],
+ Pleroma.Web.ActivityPub.MRF.KeywordPolicy
+ )
params =
File.read!("test/fixtures/mastodon-post-activity.json")
|> Poison.decode!()
assert Federator.incoming_ap_doc(params) == :error
-
- Pleroma.Config.put([:instance, :rewrite_policy], policies)
- Pleroma.Config.put(:mrf_keyword, mrf_keyword_policy)
end
end
end
import Pleroma.Factory
- setup_all do
- config_path = [:instance, :federation_reachability_timeout_days]
- initial_setting = Pleroma.Config.get(config_path)
-
- Pleroma.Config.put(config_path, 1)
- on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
-
- :ok
+ clear_config_all([:instance, :federation_reachability_timeout_days]) do
+ Pleroma.Config.put([:instance, :federation_reachability_timeout_days], 1)
end
describe "set_reachable/1" do
use Pleroma.DataCase
- setup_all do
- config_path = [:instance, :federation_reachability_timeout_days]
- initial_setting = Pleroma.Config.get(config_path)
-
- Pleroma.Config.put(config_path, 1)
- on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
-
- :ok
+ clear_config_all([:instance, :federation_reachability_timeout_days]) do
+ Pleroma.Config.put([:instance, :federation_reachability_timeout_days], 1)
end
describe "reachable?/1" do
:ok
end
+ clear_config([:instance, :public])
+ clear_config([:rich_media, :enabled])
+
test "the home timeline", %{conn: conn} do
user = insert(:user)
following = insert(:user)
end
test "the public timeline when public is set to false", %{conn: conn} do
- public = Config.get([:instance, :public])
Config.put([:instance, :public], false)
- on_exit(fn ->
- Config.put([:instance, :public], public)
- end)
-
assert conn
|> get("/api/v1/timelines/public", %{"local" => "False"})
|> json_response(403) == %{"error" => "This resource requires authentication."}
assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
assert Activity.get_by_id(id)
- Config.put([:rich_media, :enabled], false)
end
test "posting a direct status", %{conn: conn} do
describe "media upload" do
setup do
- upload_config = Config.get([Pleroma.Upload])
- proxy_config = Config.get([:media_proxy])
-
- on_exit(fn ->
- Config.put([Pleroma.Upload], upload_config)
- Config.put([:media_proxy], proxy_config)
- end)
-
user = insert(:user)
conn =
[conn: conn, image: image]
end
+ clear_config([:media_proxy])
+ clear_config([Pleroma.Upload])
+
test "returns uploaded image", %{conn: conn, image: image} do
desc = "Description of the image"
describe "pinned statuses" do
setup do
- Config.put([:instance, :max_pinned_statuses], 1)
-
user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
[user: user, activity: activity]
end
+ clear_config([:instance, :max_pinned_statuses]) do
+ Config.put([:instance, :max_pinned_statuses], 1)
+ end
+
test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
{:ok, _} = CommonAPI.pin(activity.id, user)
setup do
Config.put([:rich_media, :enabled], true)
- on_exit(fn ->
- Config.put([:rich_media, :enabled], false)
- end)
-
user = insert(:user)
%{user: user}
end
conn: conn,
path: path
} do
- is_public = Config.get([:instance, :public])
Config.put([:instance, :public], false)
conn = get(conn, path)
assert conn.status == 302
assert redirected_to(conn) == "/web/login"
-
- Config.put([:instance, :public], is_public)
end
test "does not redirect logged in users to the login page", %{conn: conn, path: path} do
describe "POST /api/v1/pleroma/accounts/confirmation_resend" do
setup do
- setting = Config.get([:instance, :account_activation_required])
-
- unless setting do
- Config.put([:instance, :account_activation_required], true)
- on_exit(fn -> Config.put([:instance, :account_activation_required], setting) end)
- end
-
user = insert(:user)
info_change = User.Info.confirmation_changeset(user.info, need_confirmation: true)
[user: user]
end
+ clear_config([:instance, :account_activation_required]) do
+ Config.put([:instance, :account_activation_required], true)
+ end
+
test "resend account confirmation email", %{conn: conn, user: user} do
conn
|> assign(:user, user)
setup do
user = insert(:user)
other_user = insert(:user)
- config = Config.get(:suggestions)
- on_exit(fn -> Config.put(:suggestions, config) end)
-
host = Config.get([Pleroma.Web.Endpoint, :url, :host])
url500 = "http://test500?#{host}&#{user.nickname}"
url200 = "http://test200?#{host}&#{user.nickname}"
[user: user, other_user: other_user]
end
+ clear_config(:suggestions)
+
test "returns empty result when suggestions disabled", %{conn: conn, user: user} do
Config.put([:suggestions, :enabled], false)
defmodule Pleroma.Web.MediaProxyTest do
use ExUnit.Case
+ use Pleroma.Tests.Helpers
import Pleroma.Web.MediaProxy
alias Pleroma.Web.MediaProxy.MediaProxyController
- setup do
- enabled = Pleroma.Config.get([:media_proxy, :enabled])
- on_exit(fn -> Pleroma.Config.put([:media_proxy, :enabled], enabled) end)
- :ok
- end
+ clear_config([:media_proxy, :enabled])
describe "when enabled" do
setup do
@skip if !Code.ensure_loaded?(:eldap), do: :skip
- setup_all do
- ldap_authenticator =
- Pleroma.Config.get(Pleroma.Web.Auth.Authenticator, Pleroma.Web.Auth.PleromaAuthenticator)
-
- ldap_enabled = Pleroma.Config.get([:ldap, :enabled])
-
- on_exit(fn ->
- Pleroma.Config.put(Pleroma.Web.Auth.Authenticator, ldap_authenticator)
- Pleroma.Config.put([:ldap, :enabled], ldap_enabled)
- end)
-
- Pleroma.Config.put(Pleroma.Web.Auth.Authenticator, Pleroma.Web.Auth.LDAPAuthenticator)
+ clear_config_all([:ldap, :enabled]) do
Pleroma.Config.put([:ldap, :enabled], true)
+ end
- :ok
+ clear_config_all(Pleroma.Web.Auth.Authenticator) do
+ Pleroma.Config.put(Pleroma.Web.Auth.Authenticator, Pleroma.Web.Auth.LDAPAuthenticator)
end
@tag @skip
alias Pleroma.Web.OAuth.OAuthController
alias Pleroma.Web.OAuth.Token
- @oauth_config_path [:oauth2, :issue_new_refresh_token]
@session_opts [
store: :cookie,
key: "_test",
signing_salt: "cooldude"
]
+ clear_config_all([:instance, :account_activation_required])
describe "in OAuth consumer mode, " do
setup do
- oauth_consumer_strategies_path = [:auth, :oauth_consumer_strategies]
- oauth_consumer_strategies = Pleroma.Config.get(oauth_consumer_strategies_path)
- Pleroma.Config.put(oauth_consumer_strategies_path, ~w(twitter facebook))
-
- on_exit(fn ->
- Pleroma.Config.put(oauth_consumer_strategies_path, oauth_consumer_strategies)
- end)
-
[
app: insert(:oauth_app),
conn:
]
end
+ clear_config([:auth, :oauth_consumer_strategies]) do
+ Pleroma.Config.put(
+ [:auth, :oauth_consumer_strategies],
+ ~w(twitter facebook)
+ )
+ end
+
test "GET /oauth/authorize renders auth forms, including OAuth consumer form", %{
app: app,
conn: conn
end
test "rejects token exchange for valid credentials belonging to unconfirmed user and confirmation is required" do
- setting = Pleroma.Config.get([:instance, :account_activation_required])
-
- unless setting do
- Pleroma.Config.put([:instance, :account_activation_required], true)
- on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
- end
+ Pleroma.Config.put([:instance, :account_activation_required], true)
password = "testpassword"
user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
end
describe "POST /oauth/token - refresh token" do
- setup do
- oauth_token_config = Pleroma.Config.get(@oauth_config_path)
-
- on_exit(fn ->
- Pleroma.Config.get(@oauth_config_path, oauth_token_config)
- end)
- end
+ clear_config([:oauth2, :issue_new_refresh_token])
test "issues a new access token with keep fresh token" do
- Pleroma.Config.put(@oauth_config_path, true)
+ Pleroma.Config.put([:oauth2, :issue_new_refresh_token], true)
user = insert(:user)
app = insert(:oauth_app, scopes: ["read", "write"])
end
test "issues a new access token with new fresh token" do
- Pleroma.Config.put(@oauth_config_path, false)
+ Pleroma.Config.put([:oauth2, :issue_new_refresh_token], false)
user = insert(:user)
app = insert(:oauth_app, scopes: ["read", "write"])
setup_all do
Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
-
- config_path = [:instance, :federating]
- initial_setting = Pleroma.Config.get(config_path)
-
- Pleroma.Config.put(config_path, true)
- on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
-
:ok
end
+ clear_config_all([:instance, :federating]) do
+ Pleroma.Config.put([:instance, :federating], true)
+ end
+
describe "salmon_incoming" do
test "decodes a salmon", %{conn: conn} do
user = insert(:user)
defmodule Pleroma.Web.FederatingPlugTest do
use Pleroma.Web.ConnCase
-
- setup_all do
- config_path = [:instance, :federating]
- initial_setting = Pleroma.Config.get(config_path)
-
- on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
-
- :ok
- end
+ clear_config_all([:instance, :federating])
test "returns and halt the conn when federating is disabled" do
Pleroma.Config.put([:instance, :federating], false)
setup do
mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
- rich_media = Config.get([:rich_media, :enabled])
- on_exit(fn -> Config.put([:rich_media, :enabled], rich_media) end)
:ok
end
+ clear_config([:rich_media, :enabled])
+
test "refuses to crawl incomplete URLs" do
user = insert(:user)
alias Pleroma.Web.Streamer
import Pleroma.Factory
- setup do
- skip_thread_containment = Pleroma.Config.get([:instance, :skip_thread_containment])
-
- on_exit(fn ->
- Pleroma.Config.put([:instance, :skip_thread_containment], skip_thread_containment)
- end)
-
- :ok
- end
+ clear_config_all([:instance, :skip_thread_containment])
describe "user streams" do
setup do
describe "GET /statuses/public_timeline.json" do
setup [:valid_user]
+ clear_config([:instance, :public])
test "returns statuses", %{conn: conn} do
user = insert(:user)
conn
|> get("/api/statuses/public_timeline.json")
|> json_response(403)
-
- Pleroma.Config.put([:instance, :public], true)
end
test "returns 200 to authenticated request when the instance is not public",
|> with_credentials(user.nickname, "test")
|> get("/api/statuses/public_timeline.json")
|> json_response(200)
-
- Pleroma.Config.put([:instance, :public], true)
end
test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
describe "GET /statuses/public_and_external_timeline.json" do
setup [:valid_user]
+ clear_config([:instance, :public])
test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
Pleroma.Config.put([:instance, :public], false)
conn
|> get("/api/statuses/public_and_external_timeline.json")
|> json_response(403)
-
- Pleroma.Config.put([:instance, :public], true)
end
test "returns 200 to authenticated request when the instance is not public",
|> with_credentials(user.nickname, "test")
|> get("/api/statuses/public_and_external_timeline.json")
|> json_response(200)
-
- Pleroma.Config.put([:instance, :public], true)
end
test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
describe "POST /api/account/resend_confirmation_email" do
setup do
- setting = Pleroma.Config.get([:instance, :account_activation_required])
-
- unless setting do
- Pleroma.Config.put([:instance, :account_activation_required], true)
- on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
- end
-
user = insert(:user)
info_change = User.Info.confirmation_changeset(user.info, need_confirmation: true)
[user: user]
end
+ clear_config([:instance, :account_activation_required]) do
+ Pleroma.Config.put([:instance, :account_activation_required], true)
+ end
+
test "it returns 204 No Content", %{conn: conn, user: user} do
conn
|> assign(:user, user)
setup do
Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
-
- instance_config = Pleroma.Config.get([:instance])
- pleroma_fe = Pleroma.Config.get([:frontend_configurations, :pleroma_fe])
- deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
-
- on_exit(fn ->
- Pleroma.Config.put([:instance], instance_config)
- Pleroma.Config.put([:frontend_configurations, :pleroma_fe], pleroma_fe)
- Pleroma.Config.put([:user, :deny_follow_blocked], deny_follow_blocked)
- end)
-
:ok
end
+ clear_config([:instance])
+ clear_config([:frontend_configurations, :pleroma_fe])
+ clear_config([:user, :deny_follow_blocked])
+
describe "POST /api/pleroma/follow_import" do
test "it returns HTTP 200", %{conn: conn} do
user1 = insert(:user)
end
test "returns the state of safe_dm_mentions flag", %{conn: conn} do
- option = Pleroma.Config.get([:instance, :safe_dm_mentions])
Pleroma.Config.put([:instance, :safe_dm_mentions], true)
response =
|> json_response(:ok)
assert response["site"]["safeDMMentionsEnabled"] == "0"
-
- Pleroma.Config.put([:instance, :safe_dm_mentions], option)
end
test "it returns the managed config", %{conn: conn} do
end
describe "GET /api/pleroma/healthcheck" do
- setup do
- config_healthcheck = Pleroma.Config.get([:instance, :healthcheck])
-
- on_exit(fn ->
- Pleroma.Config.put([:instance, :healthcheck], config_healthcheck)
- end)
-
- :ok
- end
+ clear_config([:instance, :healthcheck])
test "returns 503 when healthcheck disabled", %{conn: conn} do
Pleroma.Config.put([:instance, :healthcheck], false)
setup do
mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
-
- config_path = [:instance, :federating]
- initial_setting = Pleroma.Config.get(config_path)
-
- Pleroma.Config.put(config_path, true)
- on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
:ok
end
+ clear_config_all([:instance, :federating]) do
+ Pleroma.Config.put([:instance, :federating], true)
+ end
+
test "GET host-meta" do
response =
build_conn()
alias Pleroma.Web.Websub
alias Pleroma.Web.Websub.WebsubClientSubscription
- setup_all do
- config_path = [:instance, :federating]
- initial_setting = Pleroma.Config.get(config_path)
-
- Pleroma.Config.put(config_path, true)
- on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
-
- :ok
+ clear_config_all([:instance, :federating]) do
+ Pleroma.Config.put([:instance, :federating], true)
end
test "websub subscription request", %{conn: conn} do
projects / akkoma / commitdiff