No OneTemporary
Actions

Authored By

Unknown

Size

105 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/pleroma/config_test.exs b/test/pleroma/config_test.exs
	index ac7c8bba9..f524d90dd 100644
	--- a/test/pleroma/config_test.exs
	+++ b/test/pleroma/config_test.exs
	@@ -1,139 +1,139 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConfigTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase

	test "get/1 with an atom" do
	assert Pleroma.Config.get(:instance) == Application.get_env(:pleroma, :instance)
	assert Pleroma.Config.get(:azertyuiop) == nil
	assert Pleroma.Config.get(:azertyuiop, true) == true
	end

	test "get/1 with a list of keys" do
	assert Pleroma.Config.get([:instance, :public]) ==
	Keyword.get(Application.get_env(:pleroma, :instance), :public)

	assert Pleroma.Config.get([Pleroma.Web.Endpoint, :render_errors, :view]) ==
	get_in(
	Application.get_env(
	:pleroma,
	Pleroma.Web.Endpoint
	),
	[:render_errors, :view]
	)

	assert Pleroma.Config.get([:azerty, :uiop]) == nil
	assert Pleroma.Config.get([:azerty, :uiop], true) == true
	end

	describe "nil values" do
	setup do
	Pleroma.Config.put(:lorem, nil)
	Pleroma.Config.put(:ipsum, %{dolor: [sit: nil]})
	Pleroma.Config.put(:dolor, sit: %{amet: nil})

	on_exit(fn -> Enum.each(~w(lorem ipsum dolor)a, &Pleroma.Config.delete/1) end)
	end

	test "get/1 with an atom for nil value" do
	assert Pleroma.Config.get(:lorem) == nil
	end

	test "get/2 with an atom for nil value" do
	assert Pleroma.Config.get(:lorem, true) == nil
	end

	test "get/1 with a list of keys for nil value" do
	assert Pleroma.Config.get([:ipsum, :dolor, :sit]) == nil
	assert Pleroma.Config.get([:dolor, :sit, :amet]) == nil
	end

	test "get/2 with a list of keys for nil value" do
	assert Pleroma.Config.get([:ipsum, :dolor, :sit], true) == nil
	assert Pleroma.Config.get([:dolor, :sit, :amet], true) == nil
	end
	end

	test "get/1 when value is false" do
	Pleroma.Config.put([:instance, :false_test], false)
	Pleroma.Config.put([:instance, :nested], [])
	Pleroma.Config.put([:instance, :nested, :false_test], false)

	assert Pleroma.Config.get([:instance, :false_test]) == false
	assert Pleroma.Config.get([:instance, :nested, :false_test]) == false
	end

	test "get!/1" do
	assert Pleroma.Config.get!(:instance) == Application.get_env(:pleroma, :instance)

	assert Pleroma.Config.get!([:instance, :public]) ==
	Keyword.get(Application.get_env(:pleroma, :instance), :public)

	assert_raise(Pleroma.Config.Error, fn ->
	Pleroma.Config.get!(:azertyuiop)
	end)

	assert_raise(Pleroma.Config.Error, fn ->
	Pleroma.Config.get!([:azerty, :uiop])
	end)
	end

	test "get!/1 when value is false" do
	Pleroma.Config.put([:instance, :false_test], false)
	Pleroma.Config.put([:instance, :nested], [])
	Pleroma.Config.put([:instance, :nested, :false_test], false)

	assert Pleroma.Config.get!([:instance, :false_test]) == false
	assert Pleroma.Config.get!([:instance, :nested, :false_test]) == false
	end

	test "put/2 with a key" do
	Pleroma.Config.put(:config_test, true)

	assert Pleroma.Config.get(:config_test) == true
	end

	test "put/2 with a list of keys" do
	Pleroma.Config.put([:instance, :config_test], true)
	Pleroma.Config.put([:instance, :config_nested_test], [])
	Pleroma.Config.put([:instance, :config_nested_test, :x], true)

	assert Pleroma.Config.get([:instance, :config_test]) == true
	assert Pleroma.Config.get([:instance, :config_nested_test, :x]) == true
	end

	test "delete/1 with a key" do
	Pleroma.Config.put([:delete_me], :delete_me)
	Pleroma.Config.delete([:delete_me])
	assert Pleroma.Config.get([:delete_me]) == nil
	end

	test "delete/2 with a list of keys" do
	Pleroma.Config.put([:delete_me], hello: "world", world: "Hello")
	Pleroma.Config.delete([:delete_me, :world])
	assert Pleroma.Config.get([:delete_me]) == [hello: "world"]
	Pleroma.Config.put([:delete_me, :delete_me], hello: "world", world: "Hello")
	Pleroma.Config.delete([:delete_me, :delete_me, :world])
	assert Pleroma.Config.get([:delete_me, :delete_me]) == [hello: "world"]

	assert Pleroma.Config.delete([:this_key_does_not_exist])
	assert Pleroma.Config.delete([:non, :existing, :key])
	end

	test "fetch/1" do
	Pleroma.Config.put([:lorem], :ipsum)
	Pleroma.Config.put([:ipsum], dolor: :sit)

	assert Pleroma.Config.fetch([:lorem]) == {:ok, :ipsum}
	assert Pleroma.Config.fetch(:lorem) == {:ok, :ipsum}
	assert Pleroma.Config.fetch([:ipsum, :dolor]) == {:ok, :sit}
	assert Pleroma.Config.fetch([:lorem, :ipsum]) == :error
	assert Pleroma.Config.fetch([:loremipsum]) == :error
	assert Pleroma.Config.fetch(:loremipsum) == :error

	Pleroma.Config.delete([:lorem])
	Pleroma.Config.delete([:ipsum])
	end
	end
	diff --git a/test/pleroma/http/adapter_helper/gun_test.exs b/test/pleroma/http/adapter_helper/gun_test.exs
	index 80589c73d..487d2e7c1 100644
	--- a/test/pleroma/http/adapter_helper/gun_test.exs
	+++ b/test/pleroma/http/adapter_helper/gun_test.exs
	@@ -1,84 +1,84 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTP.AdapterHelper.GunTest do
	- use ExUnit.Case, async: true
	+ use ExUnit.Case
	use Pleroma.Tests.Helpers

	import Mox

	alias Pleroma.Config
	alias Pleroma.HTTP.AdapterHelper.Gun

	setup :verify_on_exit!

	describe "options/1" do
	setup do: clear_config([:http, :adapter], a: 1, b: 2)

	test "https url with default port" do
	uri = URI.parse("https://example.com")

	opts = Gun.options([receive_conn: false], uri)
	assert opts[:certificates_verification]
	end

	test "https ipv4 with default port" do
	uri = URI.parse("https://127.0.0.1")

	opts = Gun.options([receive_conn: false], uri)
	assert opts[:certificates_verification]
	end

	test "https ipv6 with default port" do
	uri = URI.parse("https://[2a03:2880:f10c:83:face:b00c:0:25de]")

	opts = Gun.options([receive_conn: false], uri)
	assert opts[:certificates_verification]
	end

	test "https url with non standart port" do
	uri = URI.parse("https://example.com:115")

	opts = Gun.options([receive_conn: false], uri)

	assert opts[:certificates_verification]
	end

	test "merges with defaul http adapter config" do
	defaults = Gun.options([receive_conn: false], URI.parse("https://example.com"))
	assert Keyword.has_key?(defaults, :a)
	assert Keyword.has_key?(defaults, :b)
	end

	test "parses string proxy host & port" do
	proxy = Config.get([:http, :proxy_url])
	Config.put([:http, :proxy_url], "localhost:8123")
	on_exit(fn -> Config.put([:http, :proxy_url], proxy) end)

	uri = URI.parse("https://some-domain.com")
	opts = Gun.options([receive_conn: false], uri)
	assert opts[:proxy] == {'localhost', 8123}
	end

	test "parses tuple proxy scheme host and port" do
	proxy = Config.get([:http, :proxy_url])
	Config.put([:http, :proxy_url], {:socks, 'localhost', 1234})
	on_exit(fn -> Config.put([:http, :proxy_url], proxy) end)

	uri = URI.parse("https://some-domain.com")
	opts = Gun.options([receive_conn: false], uri)
	assert opts[:proxy] == {:socks, 'localhost', 1234}
	end

	test "passed opts have more weight than defaults" do
	proxy = Config.get([:http, :proxy_url])
	Config.put([:http, :proxy_url], {:socks5, 'localhost', 1234})
	on_exit(fn -> Config.put([:http, :proxy_url], proxy) end)
	uri = URI.parse("https://some-domain.com")
	opts = Gun.options([receive_conn: false, proxy: {'example.com', 4321}], uri)

	assert opts[:proxy] == {'example.com', 4321}
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	index 326466f7f..8ed5e5e90 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	@@ -1,159 +1,159 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.UserUpdateHandlingTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Pleroma.Factory

	test "it works for incoming update activities" do
	user = insert(:user, local: false)

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	assert data["id"] == update_data["id"]

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.name == "gargle"

	assert user.avatar["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]

	assert user.banner["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]

	assert user.bio == "<p>Some bio</p>"
	end

	test "it works with alsoKnownAs" do
	%{ap_id: actor} = insert(:user, local: false)

	assert User.get_cached_by_ap_id(actor).also_known_as == []

	{:ok, _activity} =
	"test/fixtures/mastodon-update.json"
	\|> File.read!()
	\|> Jason.decode!()
	\|> Map.put("actor", actor)
	\|> Map.update!("object", fn object ->
	object
	\|> Map.put("actor", actor)
	\|> Map.put("id", actor)
	\|> Map.put("alsoKnownAs", [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	])
	end)
	\|> Transmogrifier.handle_incoming()

	assert User.get_cached_by_ap_id(actor).also_known_as == [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	]
	end

	test "it works with custom profile fields" do
	user = insert(:user, local: false)

	assert user.fields == []

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, _update_activity} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	- Pleroma.Config.put([:instance, :max_remote_account_fields], 2)
	+ clear_config([:instance, :max_remote_account_fields], 2)

	update_data =
	update_data
	\|> put_in(["object", "attachment"], [
	%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"},
	%{"name" => "foo11", "type" => "PropertyValue", "value" => "bar11"},
	%{"name" => "foo22", "type" => "PropertyValue", "value" => "bar22"}
	])
	\|> Map.put("id", update_data["id"] <> ".")

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	update_data =
	update_data
	\|> put_in(["object", "attachment"], [])
	\|> Map.put("id", update_data["id"] <> ".")

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == []
	end

	test "it works for incoming update activities which lock the account" do
	user = insert(:user, local: false)

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)
	\|> Map.put("manuallyApprovesFollowers", true)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)
	assert user.is_locked == true
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/config_controller_test.exs b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	index e6b203e74..df5d74d45 100644
	--- a/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	@@ -1,1459 +1,1459 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
	- use Pleroma.Web.ConnCase, async: true
	+ use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.Config
	alias Pleroma.ConfigDB

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "GET /api/pleroma/admin/config" do
	setup do: clear_config(:configurable_from_database, true)

	test "when configuration from database is off", %{conn: conn} do
	Config.put(:configurable_from_database, false)
	conn = get(conn, "/api/pleroma/admin/config")

	assert json_response_and_validate_schema(conn, 400) ==
	%{
	"error" => "To use this endpoint you need to enable configuration from database."
	}
	end

	test "with settings only in db", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	conn = get(conn, "/api/pleroma/admin/config?only_db=true")

	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => key1,
	"value" => _
	},
	%{
	"group" => ":pleroma",
	"key" => key2,
	"value" => _
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert key1 == inspect(config1.key)
	assert key2 == inspect(config2.key)
	end

	test "db is added to settings that are in db", %{conn: conn} do
	_config = insert(:config, key: ":instance", value: [name: "Some name"])

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	[instance_config] =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key == ":instance"
	end)

	assert instance_config["db"] == [":name"]
	end

	test "merged default setting with db settings", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	config3 =
	insert(:config,
	value: [k1: :v1, k2: :v2]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert length(configs) > 3

	saved_configs = [config1, config2, config3]
	keys = Enum.map(saved_configs, &inspect(&1.key))

	received_configs =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in keys
	end)

	assert length(received_configs) == 3

	db_keys =
	config3.value
	\|> Keyword.keys()
	\|> ConfigDB.to_json_types()

	keys = Enum.map(saved_configs -- [config3], &inspect(&1.key))

	values = Enum.map(saved_configs, &ConfigDB.to_json_types(&1.value))

	mapset_keys = MapSet.new(keys ++ db_keys)

	Enum.each(received_configs, fn %{"value" => value, "db" => db} ->
	db = MapSet.new(db)
	assert MapSet.subset?(db, mapset_keys)

	assert value in values
	end)
	end

	test "subkeys with full update right merge", %{conn: conn} do
	insert(:config,
	key: ":emoji",
	value: [groups: [a: 1, b: 2], key: [a: 1]]
	)

	insert(:config,
	key: ":assets",
	value: [mascots: [a: 1, b: 2], key: [a: 1]]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	vals =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in [":emoji", ":assets"]
	end)

	emoji = Enum.find(vals, fn %{"key" => key} -> key == ":emoji" end)
	assets = Enum.find(vals, fn %{"key" => key} -> key == ":assets" end)

	emoji_val = ConfigDB.to_elixir_types(emoji["value"])
	assets_val = ConfigDB.to_elixir_types(assets["value"])

	assert emoji_val[:groups] == [a: 1, b: 2]
	assert assets_val[:mascots] == [a: 1, b: 2]
	end

	test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	clear_config([:admin_token], "password123")

	build_conn()
	\|> get("/api/pleroma/admin/config?admin_token=password123")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "POST /api/pleroma/admin/config with configdb disabled", %{conn: conn} do
	clear_config(:configurable_from_database, false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => []})

	assert json_response_and_validate_schema(conn, 400) ==
	%{"error" => "To use this endpoint you need to enable configuration from database."}
	end

	describe "POST /api/pleroma/admin/config" do
	setup do
	http = Application.get_env(:pleroma, :http)

	on_exit(fn ->
	Application.delete_env(:pleroma, :key1)
	Application.delete_env(:pleroma, :key2)
	Application.delete_env(:pleroma, :key3)
	Application.delete_env(:pleroma, :key4)
	Application.delete_env(:pleroma, :keyaa1)
	Application.delete_env(:pleroma, :keyaa2)
	Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
	Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
	Application.put_env(:pleroma, :http, http)
	Application.put_env(:tesla, :adapter, Tesla.Mock)
	Restarter.Pleroma.refresh()
	end)
	end

	setup do: clear_config(:configurable_from_database, true)

	@tag capture_log: true
	test "create new config setting in db", %{conn: conn} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	on_exit(fn -> Application.put_env(:ueberauth, Ueberauth, ueberauth) end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
	},
	%{
	group: ":pleroma",
	key: ":key2",
	value: %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	}
	},
	%{
	group: ":pleroma",
	key: ":key3",
	value: [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]
	},
	%{
	group: ":pleroma",
	key: ":key4",
	value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
	},
	%{
	group: ":idna",
	key: ":key5",
	value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => "value1",
	"db" => [":key1"]
	},
	%{
	"group" => ":ueberauth",
	"key" => "Ueberauth",
	"value" => [%{"tuple" => [":consumer_secret", "aaaa"]}],
	"db" => [":consumer_secret"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key2",
	"value" => %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	},
	"db" => [":key2"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key3",
	"value" => [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	],
	"db" => [":key3"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key4",
	"value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"},
	"db" => [":key4"]
	},
	%{
	"group" => ":idna",
	"key" => ":key5",
	"value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]},
	"db" => [":key5"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == "value1"

	assert Application.get_env(:pleroma, :key2) == %{
	nested_1: "nested_value1",
	nested_2: [
	%{nested_22: "nested_value222"},
	%{nested_33: %{nested_44: "nested_444"}}
	]
	}

	assert Application.get_env(:pleroma, :key3) == [
	%{"nested_3" => :nested_3, "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]

	assert Application.get_env(:pleroma, :key4) == %{
	"endpoint" => "https://example.com",
	nested_5: :upload
	}

	assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
	end

	test "save configs setting without explicit key", %{conn: conn} do
	level = Application.get_env(:quack, :level)
	meta = Application.get_env(:quack, :meta)
	webhook_url = Application.get_env(:quack, :webhook_url)

	on_exit(fn ->
	Application.put_env(:quack, :level, level)
	Application.put_env(:quack, :meta, meta)
	Application.put_env(:quack, :webhook_url, webhook_url)
	end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":quack",
	key: ":level",
	value: ":info"
	},
	%{
	group: ":quack",
	key: ":meta",
	value: [":none"]
	},
	%{
	group: ":quack",
	key: ":webhook_url",
	value: "https://hooks.slack.com/services/KEY"
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":quack",
	"key" => ":level",
	"value" => ":info",
	"db" => [":level"]
	},
	%{
	"group" => ":quack",
	"key" => ":meta",
	"value" => [":none"],
	"db" => [":meta"]
	},
	%{
	"group" => ":quack",
	"key" => ":webhook_url",
	"value" => "https://hooks.slack.com/services/KEY",
	"db" => [":webhook_url"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:quack, :level) == :info
	assert Application.get_env(:quack, :meta) == [:none]
	assert Application.get_env(:quack, :webhook_url) == "https://hooks.slack.com/services/KEY"
	end

	test "saving config with partial update", %{conn: conn} do
	insert(:config, key: ":key1", value: :erlang.term_to_binary(key1: 1, key2: 2))

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key2", 2]},
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key1", ":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving config which need pleroma reboot", %{conn: conn} do
	chat = Config.get(:chat)
	on_exit(fn -> Config.put(:chat, chat) end)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":chat", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":chat",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"]

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "update setting which need reboot, don't change reboot flag until reboot", %{conn: conn} do
	chat = Config.get(:chat)
	on_exit(fn -> Config.put(:chat, chat) end)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":chat", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":chat",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key3"]
	}
	],
	"need_reboot" => true
	}

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "saving config with nested merge", %{conn: conn} do
	insert(:config, key: :key1, value: [key1: 1, key2: [k1: 1, k2: 2]])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":key1",
	value: [
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k1", 1]},
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	],
	"db" => [":key1", ":key3", ":key2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving special atoms", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	],
	"db" => [":ssl_options"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == [
	ssl_options: [versions: [:tlsv1, :"tlsv1.1", :"tlsv1.2"]]
	]
	end

	test "saving full setting if value is in full_key_update list", %{conn: conn} do
	backends = Application.get_env(:logger, :backends)
	on_exit(fn -> Application.put_env(:logger, :backends, backends) end)

	insert(:config,
	group: :logger,
	key: :backends,
	value: []
	)

	Pleroma.Config.TransferTask.load_and_update_env([], false)

	assert Application.get_env(:logger, :backends) == []

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":logger",
	key: ":backends",
	value: [":console"]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":logger",
	"key" => ":backends",
	"value" => [
	":console"
	],
	"db" => [":backends"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:logger, :backends) == [
	:console
	]
	end

	test "saving full setting if value is not keyword", %{conn: conn} do
	insert(:config,
	group: :tesla,
	key: :adapter,
	value: Tesla.Adapter.Hackey
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":tesla", key: ":adapter", value: "Tesla.Adapter.Httpc"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":tesla",
	"key" => ":adapter",
	"value" => "Tesla.Adapter.Httpc",
	"db" => [":adapter"]
	}
	],
	"need_reboot" => false
	}
	end

	test "update config setting & delete with fallback to default value", %{
	conn: conn,
	admin: admin,
	token: token
	} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	insert(:config, key: :keyaa1)
	insert(:config, key: :keyaa2)

	config3 =
	insert(:config,
	group: :ueberauth,
	key: Ueberauth
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa1", value: "another_value"},
	%{group: ":pleroma", key: ":keyaa2", value: "another_value"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => "another_value",
	"db" => [":keyaa1"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":keyaa2",
	"value" => "another_value",
	"db" => [":keyaa2"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	assert Application.get_env(:pleroma, :keyaa2) == "another_value"
	assert Application.get_env(:ueberauth, Ueberauth) == config3.value

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa2", delete: true},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [],
	"need_reboot" => false
	}

	assert Application.get_env(:ueberauth, Ueberauth) == ueberauth
	refute Keyword.has_key?(Application.get_all_env(:pleroma), :keyaa2)
	end

	test "common config example", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	]
	}
	]
	})

	assert Config.get([Pleroma.Captcha.NotReal, :name]) == "Pleroma"

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	],
	"db" => [
	":enabled",
	":method",
	":seconds_valid",
	":path",
	":key1",
	":partial_chain",
	":regex1",
	":regex2",
	":regex3",
	":regex4",
	":name"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "tuples with more than two values", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	],
	"db" => [":http"]
	}
	],
	"need_reboot" => false
	}
	end

	test "settings with nesting map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000,
	"nested" => %{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000
	}
	}
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0,
	"nested" => %{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0
	}
	}
	]
	}
	],
	"db" => [":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "value as map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"},
	"db" => [":key1"]
	}
	],
	"need_reboot" => false
	}
	end

	test "queues key as atom", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	],
	"db" => [
	":federator_incoming",
	":federator_outgoing",
	":web_push",
	":mailer",
	":transmogrifier",
	":scheduled_activities",
	":background"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "delete part of settings by atom subkeys", %{conn: conn} do
	insert(:config,
	key: :keyaa1,
	value: [subkey1: "val1", subkey2: "val2", subkey3: "val3"]
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":keyaa1",
	subkeys: [":subkey1", ":subkey3"],
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => [%{"tuple" => [":subkey2", "val2"]}],
	"db" => [":subkey2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "proxy tuple localhost", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple domain", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple ip", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]} in value
	assert ":proxy_url" in db
	end

	@tag capture_log: true
	test "doesn't set keys not in the whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :key1},
	{:pleroma, :key2},
	{:pleroma, Pleroma.Captcha.NotReal},
	{:not_real}
	])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{group: ":pleroma", key: ":key2", value: "value2"},
	%{group: ":pleroma", key: ":key3", value: "value3"},
	%{group: ":pleroma", key: "Pleroma.Web.Endpoint.NotReal", value: "value4"},
	%{group: ":pleroma", key: "Pleroma.Captcha.NotReal", value: "value5"},
	%{group: ":not_real", key: ":anything", value: "value6"}
	]
	})

	assert Application.get_env(:pleroma, :key1) == "value1"
	assert Application.get_env(:pleroma, :key2) == "value2"
	assert Application.get_env(:pleroma, :key3) == nil
	assert Application.get_env(:pleroma, Pleroma.Web.Endpoint.NotReal) == nil
	assert Application.get_env(:pleroma, Pleroma.Captcha.NotReal) == "value5"
	assert Application.get_env(:not_real, :anything) == "value6"
	end

	test "args for Pleroma.Upload.Filter.Mogrify with custom tuples", %{conn: conn} do
	clear_config(Pleroma.Upload.Filter.Mogrify)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	]
	}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	assert Config.get(Pleroma.Upload.Filter.Mogrify) == [args: ["auto-orient", "strip"]]

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	]
	}
	]
	})
	\|> json_response(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	assert Config.get(Pleroma.Upload.Filter.Mogrify) == [
	args: ["auto-orient", "strip", {"implode", "1"}, {"resize", "3840x1080>"}]
	]
	end

	test "enables the welcome messages", %{conn: conn} do
	clear_config([:welcome])

	params = %{
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => [
	%{
	"tuple" => [
	":direct_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":chat_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":email",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":sender", %{"tuple" => ["pleroma@dev.dev", "Pleroma"]}]},
	%{"tuple" => [":subject", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":html", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":text", "Welcome to <%= instance_name %>!"]}
	]
	]
	}
	]
	}

	refute Pleroma.User.WelcomeEmail.enabled?()
	refute Pleroma.User.WelcomeMessage.enabled?()
	refute Pleroma.User.WelcomeChatMessage.enabled?()

	res =
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200)

	assert Pleroma.User.WelcomeEmail.enabled?()
	assert Pleroma.User.WelcomeMessage.enabled?()
	assert Pleroma.User.WelcomeChatMessage.enabled?()

	assert res == %{
	"configs" => [
	%{
	"db" => [":direct_message", ":chat_message", ":email"],
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => params["value"]
	}
	],
	"need_reboot" => false
	}
	end
	end

	describe "GET /api/pleroma/admin/config/descriptions" do
	test "structure", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	assert [child \| _others] = json_response_and_validate_schema(conn, 200)

	assert child["children"]
	assert child["key"]
	assert String.starts_with?(child["group"], ":")
	assert child["description"]
	end

	test "filters by database configuration whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :instance},
	{:pleroma, :activitypub},
	{:pleroma, Pleroma.Upload},
	{:esshd}
	])

	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	children = json_response_and_validate_schema(conn, 200)

	assert length(children) == 4

	assert Enum.count(children, fn c -> c["group"] == ":pleroma" end) == 3

	instance = Enum.find(children, fn c -> c["key"] == ":instance" end)
	assert instance["children"]

	activitypub = Enum.find(children, fn c -> c["key"] == ":activitypub" end)
	assert activitypub["children"]

	web_endpoint = Enum.find(children, fn c -> c["key"] == "Pleroma.Upload" end)
	assert web_endpoint["children"]

	esshd = Enum.find(children, fn c -> c["group"] == ":esshd" end)
	assert esshd["children"]
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/domain_block_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/domain_block_controller_test.exs
	index 664654500..b10aa6966 100644
	--- a/test/pleroma/web/mastodon_api/controllers/domain_block_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/domain_block_controller_test.exs
	@@ -1,79 +1,80 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.DomainBlockControllerTest do
	+ # TODO: Should not need Cachex
	use Pleroma.Web.ConnCase

	alias Pleroma.User

	import Pleroma.Factory

	test "blocking / unblocking a domain" do
	%{user: user, conn: conn} = oauth_access(["write:blocks"])
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} == json_response_and_validate_schema(ret_conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	assert User.blocks?(user, other_user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} == json_response_and_validate_schema(ret_conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

	test "blocking a domain via query params" do
	%{user: user, conn: conn} = oauth_access(["write:blocks"])
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/domain_blocks?domain=dogwhistle.zone")

	assert %{} == json_response_and_validate_schema(ret_conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	assert User.blocks?(user, other_user)
	end

	test "unblocking a domain via query params" do
	%{user: user, conn: conn} = oauth_access(["write:blocks"])
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	User.block_domain(user, "dogwhistle.zone")
	user = refresh_record(user)
	assert User.blocks?(user, other_user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/v1/domain_blocks?domain=dogwhistle.zone")

	assert %{} == json_response_and_validate_schema(ret_conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

	test "getting a list of domain blocks" do
	%{user: user, conn: conn} = oauth_access(["read:blocks"])

	{:ok, user} = User.block_domain(user, "bad.site")
	{:ok, user} = User.block_domain(user, "even.worse.site")

	assert ["even.worse.site", "bad.site"] ==
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/domain_blocks")
	\|> json_response_and_validate_schema(200)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	index 605df6ed6..71a170240 100644
	--- a/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	@@ -1,92 +1,93 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.InstanceControllerTest do
	+ # TODO: Should not need Cachex
	use Pleroma.Web.ConnCase

	alias Pleroma.User
	import Pleroma.Factory

	test "get instance information", %{conn: conn} do
	conn = get(conn, "/api/v1/instance")
	assert result = json_response_and_validate_schema(conn, 200)

	email = Pleroma.Config.get([:instance, :email])
	thumbnail = Pleroma.Web.base_url() <> Pleroma.Config.get([:instance, :instance_thumbnail])
	background = Pleroma.Web.base_url() <> Pleroma.Config.get([:instance, :background_image])

	# Note: not checking for "max_toot_chars" since it's optional
	assert %{
	"uri" => _,
	"title" => _,
	"description" => _,
	"version" => _,
	"email" => from_config_email,
	"urls" => %{
	"streaming_api" => _
	},
	"stats" => _,
	"thumbnail" => from_config_thumbnail,
	"languages" => _,
	"registrations" => _,
	"approval_required" => _,
	"poll_limits" => _,
	"upload_limit" => _,
	"avatar_upload_limit" => _,
	"background_upload_limit" => _,
	"banner_upload_limit" => _,
	"background_image" => from_config_background,
	"chat_limit" => _,
	"description_limit" => _
	} = result

	assert result["pleroma"]["metadata"]["account_activation_required"] != nil
	assert result["pleroma"]["metadata"]["features"]
	assert result["pleroma"]["metadata"]["federation"]
	assert result["pleroma"]["metadata"]["fields_limits"]
	assert result["pleroma"]["vapid_public_key"]

	assert email == from_config_email
	assert thumbnail == from_config_thumbnail
	assert background == from_config_background
	end

	test "get instance stats", %{conn: conn} do
	user = insert(:user, %{local: true})

	user2 = insert(:user, %{local: true})
	{:ok, _user2} = User.deactivate(user2, !user2.deactivated)

	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	{:ok, _} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})

	Pleroma.Stats.force_update()

	conn = get(conn, "/api/v1/instance")

	assert result = json_response_and_validate_schema(conn, 200)

	stats = result["stats"]

	assert stats
	assert stats["user_count"] == 1
	assert stats["status_count"] == 1
	assert stats["domain_count"] == 2
	end

	test "get peers", %{conn: conn} do
	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	Pleroma.Stats.force_update()

	conn = get(conn, "/api/v1/instance/peers")

	assert result = json_response_and_validate_schema(conn, 200)

	assert ["peer1.com", "peer2.com"] == Enum.sort(result)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/update_credentials_test.exs b/test/pleroma/web/mastodon_api/update_credentials_test.exs
	index ed1921c91..023726468 100644
	--- a/test/pleroma/web/mastodon_api/update_credentials_test.exs
	+++ b/test/pleroma/web/mastodon_api/update_credentials_test.exs
	@@ -1,529 +1,527 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.UpdateCredentialsTest do
	alias Pleroma.Repo
	alias Pleroma.User

	use Pleroma.Web.ConnCase

	import Mock
	import Pleroma.Factory

	- setup do: clear_config([:instance, :max_account_fields])
	-
	describe "updating credentials" do
	setup do: oauth_access(["write:accounts"])
	setup :request_content_type

	test "sets user settings in a generic way", %{conn: conn} do
	res_conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	pleroma_fe: %{
	theme: "bla"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)
	assert user_data["pleroma"]["settings_store"] == %{"pleroma_fe" => %{"theme" => "bla"}}

	user = Repo.get(User, user_data["id"])

	res_conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	masto_fe: %{
	theme: "bla"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)

	assert user_data["pleroma"]["settings_store"] ==
	%{
	"pleroma_fe" => %{"theme" => "bla"},
	"masto_fe" => %{"theme" => "bla"}
	}

	user = Repo.get(User, user_data["id"])

	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _activity -> :ok end do
	res_conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	masto_fe: %{
	theme: "blub"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)

	assert user_data["pleroma"]["settings_store"] ==
	%{
	"pleroma_fe" => %{"theme" => "bla"},
	"masto_fe" => %{"theme" => "blub"}
	}

	assert_called(Pleroma.Web.Federator.publish(:_))
	end
	end

	test "updates the user's bio", %{conn: conn} do
	user2 = insert(:user)

	raw_bio = "I drink #cofe with @#{user2.nickname}\n\nsuya.."

	conn = patch(conn, "/api/v1/accounts/update_credentials", %{"note" => raw_bio})

	assert user_data = json_response_and_validate_schema(conn, 200)

	assert user_data["note"] ==
	~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe">#cofe</a> with <span class="h-card"><a class="u-url mention" data-user="#{
	user2.id
	}" href="#{user2.ap_id}" rel="ugc">@<span>#{user2.nickname}</span></a></span><br/><br/>suya..)

	assert user_data["source"]["note"] == raw_bio

	user = Repo.get(User, user_data["id"])

	assert user.raw_bio == raw_bio
	end

	test "updates the user's locking status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{locked: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["locked"] == true
	end

	test "updates the user's chat acceptance status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{accepts_chat_messages: "false"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["accepts_chat_messages"] == false
	end

	test "updates the user's allow_following_move", %{user: user, conn: conn} do
	assert user.allow_following_move == true

	conn = patch(conn, "/api/v1/accounts/update_credentials", %{allow_following_move: "false"})

	assert refresh_record(user).allow_following_move == false
	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["allow_following_move"] == false
	end

	test "updates the user's default scope", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{default_scope: "unlisted"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["privacy"] == "unlisted"
	end

	test "updates the user's privacy", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{source: %{privacy: "unlisted"}})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["privacy"] == "unlisted"
	end

	test "updates the user's hide_followers status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_followers: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_followers"] == true
	end

	test "updates the user's discoverable status", %{conn: conn} do
	assert %{"source" => %{"pleroma" => %{"discoverable" => true}}} =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{discoverable: "true"})
	\|> json_response_and_validate_schema(:ok)

	assert %{"source" => %{"pleroma" => %{"discoverable" => false}}} =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{discoverable: "false"})
	\|> json_response_and_validate_schema(:ok)
	end

	test "updates the user's hide_followers_count and hide_follows_count", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	hide_followers_count: "true",
	hide_follows_count: "true"
	})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_followers_count"] == true
	assert user_data["pleroma"]["hide_follows_count"] == true
	end

	test "updates the user's skip_thread_containment option", %{user: user, conn: conn} do
	response =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{skip_thread_containment: "true"})
	\|> json_response_and_validate_schema(200)

	assert response["pleroma"]["skip_thread_containment"] == true
	assert refresh_record(user).skip_thread_containment
	end

	test "updates the user's hide_follows status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_follows: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_follows"] == true
	end

	test "updates the user's hide_favorites status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_favorites: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_favorites"] == true
	end

	test "updates the user's show_role status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{show_role: "false"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["pleroma"]["show_role"] == false
	end

	test "updates the user's no_rich_text status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{no_rich_text: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["pleroma"]["no_rich_text"] == true
	end

	test "updates the user's name", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["display_name"] == "markorepairs"

	update_activity = Repo.one(Pleroma.Activity)
	assert update_activity.data["type"] == "Update"
	assert update_activity.data["object"]["name"] == "markorepairs"
	end

	test "updates the user's avatar", %{user: user, conn: conn} do
	new_avatar = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	assert user.avatar == %{}

	res = patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["avatar"] != User.avatar_url(user)

	user = User.get_by_id(user.id)
	refute user.avatar == %{}

	# Also resets it
	_res = patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => ""})

	user = User.get_by_id(user.id)
	assert user.avatar == nil
	end

	test "updates the user's banner", %{user: user, conn: conn} do
	new_header = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => new_header})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["header"] != User.banner_url(user)

	# Also resets it
	_res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => ""})

	user = User.get_by_id(user.id)
	assert user.banner == nil
	end

	test "updates the user's background", %{conn: conn, user: user} do
	new_header = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	res =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"pleroma_background_image" => new_header
	})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["pleroma"]["background_image"]
	#
	# Also resets it
	_res =
	patch(conn, "/api/v1/accounts/update_credentials", %{"pleroma_background_image" => ""})

	user = User.get_by_id(user.id)
	assert user.background == nil
	end

	test "requires 'write:accounts' permission" do
	token1 = insert(:oauth_token, scopes: ["read"])
	token2 = insert(:oauth_token, scopes: ["write", "follow"])

	for token <- [token1, token2] do
	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> patch("/api/v1/accounts/update_credentials", %{})

	if token == token1 do
	assert %{"error" => "Insufficient permissions: write:accounts."} ==
	json_response_and_validate_schema(conn, 403)
	else
	assert json_response_and_validate_schema(conn, 200)
	end
	end
	end

	test "updates profile emojos", %{user: user, conn: conn} do
	note = "sips :blank:"
	name = "I am :firefox:"

	ret_conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"note" => note,
	"display_name" => name
	})

	assert json_response_and_validate_schema(ret_conn, 200)

	conn = get(conn, "/api/v1/accounts/#{user.id}")

	assert user_data = json_response_and_validate_schema(conn, 200)

	assert user_data["note"] == note
	assert user_data["display_name"] == name
	assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user_data["emojis"]
	end

	test "update fields", %{conn: conn} do
	fields = [
	%{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "<script>bar</script>"},
	%{"name" => "link.io", "value" => "cofe.io"}
	]

	account_data =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(200)

	assert account_data["fields"] == [
	%{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "bar"},
	%{
	"name" => "link.io",
	"value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)
	}
	]

	assert account_data["source"]["fields"] == [
	%{
	"name" => "<a href=\"http://google.com\">foo</a>",
	"value" => "<script>bar</script>"
	},
	%{"name" => "link.io", "value" => "cofe.io"}
	]
	end

	test "emojis in fields labels", %{conn: conn} do
	fields = [
	%{"name" => ":firefox:", "value" => "is best 2hu"},
	%{"name" => "they wins", "value" => ":blank:"}
	]

	account_data =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(200)

	assert account_data["fields"] == [
	%{"name" => ":firefox:", "value" => "is best 2hu"},
	%{"name" => "they wins", "value" => ":blank:"}
	]

	assert account_data["source"]["fields"] == [
	%{"name" => ":firefox:", "value" => "is best 2hu"},
	%{"name" => "they wins", "value" => ":blank:"}
	]

	assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = account_data["emojis"]
	end

	test "update fields via x-www-form-urlencoded", %{conn: conn} do
	fields =
	[
	"fields_attributes[1][name]=link",
	"fields_attributes[1][value]=http://cofe.io",
	"fields_attributes[0][name]=foo",
	"fields_attributes[0][value]=bar"
	]
	\|> Enum.join("&")

	account =
	conn
	\|> put_req_header("content-type", "application/x-www-form-urlencoded")
	\|> patch("/api/v1/accounts/update_credentials", fields)
	\|> json_response_and_validate_schema(200)

	assert account["fields"] == [
	%{"name" => "foo", "value" => "bar"},
	%{
	"name" => "link",
	"value" => ~S(<a href="http://cofe.io" rel="ugc">http://cofe.io</a>)
	}
	]

	assert account["source"]["fields"] == [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "link", "value" => "http://cofe.io"}
	]
	end

	test "update fields with empty name", %{conn: conn} do
	fields = [
	%{"name" => "foo", "value" => ""},
	%{"name" => "", "value" => "bar"}
	]

	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(200)

	assert account["fields"] == [
	%{"name" => "foo", "value" => ""}
	]
	end

	test "update fields when invalid request", %{conn: conn} do
	name_limit = Pleroma.Config.get([:instance, :account_field_name_length])
	value_limit = Pleroma.Config.get([:instance, :account_field_value_length])

	long_name = Enum.map(0..name_limit, fn _ -> "x" end) \|> Enum.join()
	long_value = Enum.map(0..value_limit, fn _ -> "x" end) \|> Enum.join()

	fields = [%{"name" => "foo", "value" => long_value}]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(403)

	fields = [%{"name" => long_name, "value" => "bar"}]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(403)

	- Pleroma.Config.put([:instance, :max_account_fields], 1)
	+ clear_config([:instance, :max_account_fields], 1)

	fields = [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "link", "value" => "cofe.io"}
	]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(403)
	end
	end

	describe "Mark account as bot" do
	setup do: oauth_access(["write:accounts"])
	setup :request_content_type

	test "changing actor_type to Service makes account a bot", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{actor_type: "Service"})
	\|> json_response_and_validate_schema(200)

	assert account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Service"
	end

	test "changing actor_type to Person makes account a human", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{actor_type: "Person"})
	\|> json_response_and_validate_schema(200)

	refute account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Person"
	end

	test "changing actor_type to Application causes error", %{conn: conn} do
	response =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{actor_type: "Application"})
	\|> json_response_and_validate_schema(403)

	assert %{"error" => "Invalid request"} == response
	end

	test "changing bot field to true changes actor_type to Service", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{bot: "true"})
	\|> json_response_and_validate_schema(200)

	assert account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Service"
	end

	test "changing bot field to false changes actor_type to Person", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{bot: "false"})
	\|> json_response_and_validate_schema(200)

	refute account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Person"
	end

	test "actor_type field has a higher priority than bot", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{
	actor_type: "Person",
	bot: "true"
	})
	\|> json_response_and_validate_schema(200)

	refute account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Person"
	end
	end
	end
	diff --git a/test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs b/test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs
	index 211443a55..9f15f5c93 100644
	--- a/test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs
	+++ b/test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs
	@@ -1,48 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlugTest do
	- use Pleroma.Web.ConnCase, async: true
	+ use Pleroma.Web.ConnCase

	alias Pleroma.Config
	alias Pleroma.User
	alias Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlug

	setup do: clear_config([:instance, :public])

	test "it halts if not public and no user is assigned", %{conn: conn} do
	Config.put([:instance, :public], false)

	conn =
	conn
	\|> EnsurePublicOrAuthenticatedPlug.call(%{})

	assert conn.status == 403
	assert conn.halted == true
	end

	test "it continues if public", %{conn: conn} do
	Config.put([:instance, :public], true)

	ret_conn =
	conn
	\|> EnsurePublicOrAuthenticatedPlug.call(%{})

	refute ret_conn.halted
	end

	test "it continues if a user is assigned, even if not public", %{conn: conn} do
	Config.put([:instance, :public], false)

	conn =
	conn
	\|> assign(:user, %User{})

	ret_conn =
	conn
	\|> EnsurePublicOrAuthenticatedPlug.call(%{})

	refute ret_conn.halted
	end
	end
	diff --git a/test/pleroma/web/plugs/user_enabled_plug_test.exs b/test/pleroma/web/plugs/user_enabled_plug_test.exs
	index 71c56f03a..e9c9e5f3e 100644
	--- a/test/pleroma/web/plugs/user_enabled_plug_test.exs
	+++ b/test/pleroma/web/plugs/user_enabled_plug_test.exs
	@@ -1,59 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.UserEnabledPlugTest do
	- use Pleroma.Web.ConnCase, async: true
	+ use Pleroma.Web.ConnCase

	alias Pleroma.Web.Plugs.UserEnabledPlug
	import Pleroma.Factory

	setup do: clear_config([:instance, :account_activation_required])

	test "doesn't do anything if the user isn't set", %{conn: conn} do
	ret_conn =
	conn
	\|> UserEnabledPlug.call(%{})

	assert ret_conn == conn
	end

	test "with a user that's not confirmed and a config requiring confirmation, it removes that user",
	%{conn: conn} do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, confirmation_pending: true)

	conn =
	conn
	\|> assign(:user, user)
	\|> UserEnabledPlug.call(%{})

	assert conn.assigns.user == nil
	end

	test "with a user that is deactivated, it removes that user", %{conn: conn} do
	user = insert(:user, deactivated: true)

	conn =
	conn
	\|> assign(:user, user)
	\|> UserEnabledPlug.call(%{})

	assert conn.assigns.user == nil
	end

	test "with a user that is not deactivated, it does nothing", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)

	ret_conn =
	conn
	\|> UserEnabledPlug.call(%{})

	assert conn == ret_conn
	end
	end
	diff --git a/test/pleroma/web/rel_me_test.exs b/test/pleroma/web/rel_me_test.exs
	index 40c4e4801..811cb0893 100644
	--- a/test/pleroma/web/rel_me_test.exs
	+++ b/test/pleroma/web/rel_me_test.exs
	@@ -1,48 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RelMeTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "parse/1" do
	hrefs = ["https://social.example.org/users/lain"]

	assert Pleroma.Web.RelMe.parse("http://example.com/rel_me/null") == {:ok, []}

	assert {:ok, %Tesla.Env{status: 404}} =
	Pleroma.Web.RelMe.parse("http://example.com/rel_me/error")

	assert Pleroma.Web.RelMe.parse("http://example.com/rel_me/link") == {:ok, hrefs}
	assert Pleroma.Web.RelMe.parse("http://example.com/rel_me/anchor") == {:ok, hrefs}
	assert Pleroma.Web.RelMe.parse("http://example.com/rel_me/anchor_nofollow") == {:ok, hrefs}
	end

	test "maybe_put_rel_me/2" do
	profile_urls = ["https://social.example.org/users/lain"]
	attr = "me"
	fallback = nil

	assert Pleroma.Web.RelMe.maybe_put_rel_me("http://example.com/rel_me/null", profile_urls) ==
	fallback

	assert Pleroma.Web.RelMe.maybe_put_rel_me("http://example.com/rel_me/error", profile_urls) ==
	fallback

	assert Pleroma.Web.RelMe.maybe_put_rel_me("http://example.com/rel_me/anchor", profile_urls) ==
	attr

	assert Pleroma.Web.RelMe.maybe_put_rel_me(
	"http://example.com/rel_me/anchor_nofollow",
	profile_urls
	) == attr

	assert Pleroma.Web.RelMe.maybe_put_rel_me("http://example.com/rel_me/link", profile_urls) ==
	attr
	end
	end
	diff --git a/test/pleroma/web/twitter_api/remote_follow_controller_test.exs b/test/pleroma/web/twitter_api/remote_follow_controller_test.exs
	index a3e784d13..dfe5b02be 100644
	--- a/test/pleroma/web/twitter_api/remote_follow_controller_test.exs
	+++ b/test/pleroma/web/twitter_api/remote_follow_controller_test.exs
	@@ -1,349 +1,383 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.RemoteFollowControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.MFA
	alias Pleroma.MFA.TOTP
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Ecto.Query

	- setup do
	- Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	- :ok
	- end
	-
	setup_all do: clear_config([:instance, :federating], true)
	- setup do: clear_config([:instance])
	- setup do: clear_config([:frontend_configurations, :pleroma_fe])
	setup do: clear_config([:user, :deny_follow_blocked])

	describe "GET /ostatus_subscribe - remote_follow/2" do
	test "adds status to pleroma instance if the `acct` is a status", %{conn: conn} do
	+ Tesla.Mock.mock(fn
	+ %{method: :get, url: "https://mastodon.social/users/emelie/statuses/101849165031453009"} ->
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-type", "application/activity+json"}],
	+ body: File.read!("test/fixtures/tesla_mock/status.emelie.json")
	+ }
	+
	+ %{method: :get, url: "https://mastodon.social/users/emelie"} ->
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-type", "application/activity+json"}],
	+ body: File.read!("test/fixtures/tesla_mock/emelie.json")
	+ }
	+ end)
	+
	assert conn
	\|> get(
	remote_follow_path(conn, :follow, %{
	acct: "https://mastodon.social/users/emelie/statuses/101849165031453009"
	})
	)
	\|> redirected_to() =~ "/notice/"
	end

	test "show follow account page if the `acct` is a account link", %{conn: conn} do
	+ Tesla.Mock.mock(fn
	+ %{method: :get, url: "https://mastodon.social/users/emelie"} ->
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-type", "application/activity+json"}],
	+ body: File.read!("test/fixtures/tesla_mock/emelie.json")
	+ }
	+ end)
	+
	response =
	conn
	\|> get(remote_follow_path(conn, :follow, %{acct: "https://mastodon.social/users/emelie"}))
	\|> html_response(200)

	assert response =~ "Log in to follow"
	end

	test "show follow page if the `acct` is a account link", %{conn: conn} do
	+ Tesla.Mock.mock(fn
	+ %{method: :get, url: "https://mastodon.social/users/emelie"} ->
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-type", "application/activity+json"}],
	+ body: File.read!("test/fixtures/tesla_mock/emelie.json")
	+ }
	+ end)
	+
	user = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> get(remote_follow_path(conn, :follow, %{acct: "https://mastodon.social/users/emelie"}))
	\|> html_response(200)

	assert response =~ "Remote follow"
	end

	- test "show follow page with error when user cannot fecth by `acct` link", %{conn: conn} do
	+ test "show follow page with error when user can not be fetched by `acct` link", %{conn: conn} do
	+ Tesla.Mock.mock(fn
	+ %{method: :get, url: "https://mastodon.social/users/not_found"} ->
	+ %Tesla.Env{
	+ status: 404
	+ }
	+ end)
	+
	user = insert(:user)

	assert capture_log(fn ->
	response =
	conn
	\|> assign(:user, user)
	\|> get(
	remote_follow_path(conn, :follow, %{
	acct: "https://mastodon.social/users/not_found"
	})
	)
	\|> html_response(200)

	assert response =~ "Error fetching user"
	end) =~ "Object has been deleted"
	end
	end

	describe "POST /ostatus_subscribe - do_follow/2 with assigned user " do
	test "required `follow \| write:follows` scope", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)
	read_token = insert(:oauth_token, user: user, scopes: ["read"])

	assert capture_log(fn ->
	response =
	conn
	\|> assign(:user, user)
	\|> assign(:token, read_token)
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Error following account"
	end) =~ "Insufficient permissions: follow \| write:follows."
	end

	test "follows user", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:follows"]))
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})

	assert redirected_to(conn) == "/users/#{user2.id}"
	end

	test "returns error when user is deactivated", %{conn: conn} do
	user = insert(:user, deactivated: true)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns error when user is blocked", %{conn: conn} do
	Pleroma.Config.put([:user, :deny_follow_blocked], true)
	user = insert(:user)
	user2 = insert(:user)

	{:ok, _user_block} = Pleroma.User.block(user2, user)

	response =
	conn
	\|> assign(:user, user)
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns error when followee not found", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => "jimm"}})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns success result when user already in followers", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)
	{:ok, _, _, _} = CommonAPI.follow(user, user2)

	conn =
	conn
	\|> assign(:user, refresh_record(user))
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:follows"]))
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})

	assert redirected_to(conn) == "/users/#{user2.id}"
	end
	end

	describe "POST /ostatus_subscribe - follow/2 with enabled Two-Factor Auth " do
	test "render the MFA login form", %{conn: conn} do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	user2 = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
	})
	\|> response(200)

	mfa_token = Pleroma.Repo.one(from(q in Pleroma.MFA.Token, where: q.user_id == ^user.id))

	assert response =~ "Two-factor authentication"
	assert response =~ "Authentication code"
	assert response =~ mfa_token.token
	refute user2.follower_address in User.following(user)
	end

	test "returns error when password is incorrect", %{conn: conn} do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	user2 = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test1", "id" => user2.id}
	})
	\|> response(200)

	assert response =~ "Wrong username or password"
	refute user2.follower_address in User.following(user)
	end

	test "follows", %{conn: conn} do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	{:ok, %{token: token}} = MFA.Token.create(user)

	user2 = insert(:user)
	otp_token = TOTP.generate_token(otp_secret)

	conn =
	conn
	\|> post(
	remote_follow_path(conn, :do_follow),
	%{
	"mfa" => %{"code" => otp_token, "token" => token, "id" => user2.id}
	}
	)

	assert redirected_to(conn) == "/users/#{user2.id}"
	assert user2.follower_address in User.following(user)
	end

	test "returns error when auth code is incorrect", %{conn: conn} do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	{:ok, %{token: token}} = MFA.Token.create(user)

	user2 = insert(:user)
	otp_token = TOTP.generate_token(TOTP.generate_secret())

	response =
	conn
	\|> post(
	remote_follow_path(conn, :do_follow),
	%{
	"mfa" => %{"code" => otp_token, "token" => token, "id" => user2.id}
	}
	)
	\|> response(200)

	assert response =~ "Wrong authentication code"
	refute user2.follower_address in User.following(user)
	end
	end

	describe "POST /ostatus_subscribe - follow/2 without assigned user " do
	test "follows", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
	})

	assert redirected_to(conn) == "/users/#{user2.id}"
	assert user2.follower_address in User.following(user)
	end

	test "returns error when followee not found", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => "jimm"}
	})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns error when login invalid", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => "jimm", "password" => "test", "id" => user.id}
	})
	\|> response(200)

	assert response =~ "Wrong username or password"
	end

	test "returns error when password invalid", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "42", "id" => user2.id}
	})
	\|> response(200)

	assert response =~ "Wrong username or password"
	end

	test "returns error when user is blocked", %{conn: conn} do
	Pleroma.Config.put([:user, :deny_follow_blocked], true)
	user = insert(:user)
	user2 = insert(:user)
	{:ok, _user_block} = Pleroma.User.block(user2, user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
	})
	\|> response(200)

	assert response =~ "Error following account"
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 7:04 PM (10 h, 30 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803266
Default Alt Text: (105 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions