No OneTemporary
Actions

Size

103 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/bbs/handler_test.exs b/test/bbs/handler_test.exs
	index 7d5d68d11..934c9aa16 100644
	--- a/test/bbs/handler_test.exs
	+++ b/test/bbs/handler_test.exs
	@@ -1,83 +1,87 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.BBS.HandlerTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.BBS.Handler
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureIO
	import Pleroma.Factory
	import Ecto.Query

	test "getting the home timeline" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user} = User.follow(user, followed)

	{:ok, _first} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, _second} = CommonAPI.post(followed, %{"status" => "hello"})

	output =
	capture_io(fn ->
	Handler.handle_command(%{user: user}, "home")
	end)

	assert output =~ user.nickname
	assert output =~ followed.nickname

	assert output =~ "hey"
	assert output =~ "hello"
	end

	test "posting" do
	user = insert(:user)

	output =
	capture_io(fn ->
	Handler.handle_command(%{user: user}, "p this is a test post")
	end)

	assert output =~ "Posted"

	activity =
	Repo.one(
	from(a in Activity,
	where: fragment("?->>'type' = ?", a.data, "Create")
	)
	)

	assert activity.actor == user.ap_id
	object = Object.normalize(activity)
	assert object.data["content"] == "this is a test post"
	end

	test "replying" do
	user = insert(:user)
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(another_user, %{"status" => "this is a test post"})

	output =
	capture_io(fn ->
	Handler.handle_command(%{user: user}, "r #{activity.id} this is a reply")
	end)

	assert output =~ "Replied"

	reply =
	Repo.one(
	from(a in Activity,
	where: fragment("?->>'type' = ?", a.data, "Create"),
	where: a.actor == ^user.ap_id
	)
	)

	assert reply.actor == user.ap_id
	object = Object.normalize(reply)
	assert object.data["content"] == "this is a reply"
	assert object.data["inReplyTo"] == activity.data["object"]
	end
	end
	diff --git a/test/bookmark_test.exs b/test/bookmark_test.exs
	index b81c102ef..e54bd359c 100644
	--- a/test/bookmark_test.exs
	+++ b/test/bookmark_test.exs
	@@ -1,52 +1,56 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.BookmarkTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.Bookmark
	alias Pleroma.Web.CommonAPI

	describe "create/2" do
	test "with valid params" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "Some cool information"})
	{:ok, bookmark} = Bookmark.create(user.id, activity.id)
	assert bookmark.user_id == user.id
	assert bookmark.activity_id == activity.id
	end

	test "with invalid params" do
	{:error, changeset} = Bookmark.create(nil, "")
	refute changeset.valid?

	assert changeset.errors == [
	user_id: {"can't be blank", [validation: :required]},
	activity_id: {"can't be blank", [validation: :required]}
	]
	end
	end

	describe "destroy/2" do
	test "with valid params" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Some cool information"})
	{:ok, _bookmark} = Bookmark.create(user.id, activity.id)

	{:ok, _deleted_bookmark} = Bookmark.destroy(user.id, activity.id)
	end
	end

	describe "get/2" do
	test "gets a bookmark" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"Scientists Discover The Secret Behind Tenshi Eating A Corndog Being So Cute – Science Daily"
	})

	{:ok, bookmark} = Bookmark.create(user.id, activity.id)
	assert bookmark == Bookmark.get(user.id, activity.id)
	end
	end
	end
	diff --git a/test/config/transfer_task_test.exs b/test/config/transfer_task_test.exs
	index c0e433263..dbeadbe87 100644
	--- a/test/config/transfer_task_test.exs
	+++ b/test/config/transfer_task_test.exs
	@@ -1,53 +1,57 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Config.TransferTaskTest do
	use Pleroma.DataCase

	setup do
	dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])

	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
	refute Application.get_env(:pleroma, :test_key)
	refute Application.get_env(:idna, :test_key)

	Pleroma.Web.AdminAPI.Config.create(%{
	group: "pleroma",
	key: "test_key",
	value: [live: 2, com: 3]
	})

	Pleroma.Web.AdminAPI.Config.create(%{
	group: "idna",
	key: "test_key",
	value: [live: 15, com: 35]
	})

	Pleroma.Config.TransferTask.start_link()

	assert Application.get_env(:pleroma, :test_key) == [live: 2, com: 3]
	assert Application.get_env(:idna, :test_key) == [live: 15, com: 35]

	on_exit(fn ->
	Application.delete_env(:pleroma, :test_key)
	Application.delete_env(:idna, :test_key)
	end)
	end

	test "non existing atom" do
	Pleroma.Web.AdminAPI.Config.create(%{
	group: "pleroma",
	key: "undefined_atom_key",
	value: [live: 2, com: 3]
	})

	assert ExUnit.CaptureLog.capture_log(fn ->
	Pleroma.Config.TransferTask.start_link()
	end) =~
	"updating env causes error, key: \"undefined_atom_key\", error: %ArgumentError{message: \"argument error\"}"
	end
	end
	diff --git a/test/emoji_test.exs b/test/emoji_test.exs
	index 2eaa26be6..07ac6ff1d 100644
	--- a/test/emoji_test.exs
	+++ b/test/emoji_test.exs
	@@ -1,106 +1,110 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.EmojiTest do
	use ExUnit.Case, async: true
	alias Pleroma.Emoji

	describe "get_all/0" do
	setup do
	emoji_list = Emoji.get_all()
	{:ok, emoji_list: emoji_list}
	end

	test "first emoji", %{emoji_list: emoji_list} do
	[emoji \| _others] = emoji_list
	{code, path, tags} = emoji

	assert tuple_size(emoji) == 3
	assert is_binary(code)
	assert is_binary(path)
	assert is_list(tags)
	end

	test "random emoji", %{emoji_list: emoji_list} do
	emoji = Enum.random(emoji_list)
	{code, path, tags} = emoji

	assert tuple_size(emoji) == 3
	assert is_binary(code)
	assert is_binary(path)
	assert is_list(tags)
	end
	end

	describe "match_extra/2" do
	setup do
	groups = [
	"list of files": ["/emoji/custom/first_file.png", "/emoji/custom/second_file.png"],
	"wildcard folder": "/emoji/custom/*/file.png",
	"wildcard files": "/emoji/custom/folder/*.png",
	"special file": "/emoji/custom/special.png"
	]

	{:ok, groups: groups}
	end

	test "config for list of files", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/first_file.png")
	\|> to_string()

	assert group == "list of files"
	end

	test "config with wildcard folder", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/some_folder/file.png")
	\|> to_string()

	assert group == "wildcard folder"
	end

	test "config with wildcard folder and subfolders", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/some_folder/another_folder/file.png")
	\|> to_string()

	assert group == "wildcard folder"
	end

	test "config with wildcard files", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/folder/some_file.png")
	\|> to_string()

	assert group == "wildcard files"
	end

	test "config with wildcard files and subfolders", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/folder/another_folder/some_file.png")
	\|> to_string()

	assert group == "wildcard files"
	end

	test "config for special file", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/special.png")
	\|> to_string()

	assert group == "special file"
	end

	test "no mathing returns nil", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/some_undefined.png")

	refute group
	end
	end
	end
	diff --git a/test/healthcheck_test.exs b/test/healthcheck_test.exs
	index e05061220..6bb8d5b7f 100644
	--- a/test/healthcheck_test.exs
	+++ b/test/healthcheck_test.exs
	@@ -1,22 +1,26 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.HealthcheckTest do
	use Pleroma.DataCase
	alias Pleroma.Healthcheck

	test "system_info/0" do
	result = Healthcheck.system_info() \|> Map.from_struct()

	assert Map.keys(result) == [:active, :healthy, :idle, :memory_used, :pool_size]
	end

	describe "check_health/1" do
	test "pool size equals active connections" do
	result = Healthcheck.check_health(%Healthcheck{pool_size: 10, active: 10})
	refute result.healthy
	end

	test "chech_health/1" do
	result = Healthcheck.check_health(%Healthcheck{pool_size: 10, active: 9})
	assert result.healthy
	end
	end
	end
	diff --git a/test/http/request_builder_test.exs b/test/http/request_builder_test.exs
	index a368999ff..7febe84c5 100644
	--- a/test/http/request_builder_test.exs
	+++ b/test/http/request_builder_test.exs
	@@ -1,91 +1,95 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.HTTP.RequestBuilderTest do
	use ExUnit.Case, async: true
	alias Pleroma.HTTP.RequestBuilder

	describe "headers/2" do
	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
	end

	describe "add_optional_params/3" do
	test "don't add if keyword is empty" do
	assert RequestBuilder.add_optional_params(%{}, %{}, []) == %{}
	end

	test "add query parameter" do
	assert RequestBuilder.add_optional_params(
	%{},
	%{query: :query, body: :body, another: :val},
	[
	{:query, "param1=val1&param2=val2"},
	{:body, "some body"}
	]
	) == %{query: "param1=val1&param2=val2", body: "some body"}
	end
	end

	describe "add_param/4" do
	test "add file parameter" do
	%{
	body: %Tesla.Multipart{
	boundary: _,
	content_type_params: [],
	parts: [
	%Tesla.Multipart.Part{
	body: %File.Stream{
	line_or_bytes: 2048,
	modes: [:raw, :read_ahead, :read, :binary],
	path: "some-path/filename.png",
	raw: true
	},
	dispositions: [name: "filename.png", filename: "filename.png"],
	headers: []
	}
	]
	}
	} = RequestBuilder.add_param(%{}, :file, "filename.png", "some-path/filename.png")
	end

	test "add key to body" do
	%{
	body: %Tesla.Multipart{
	boundary: _,
	content_type_params: [],
	parts: [
	%Tesla.Multipart.Part{
	body: "\"someval\"",
	dispositions: [name: "somekey"],
	headers: ["Content-Type": "application/json"]
	}
	]
	}
	} = RequestBuilder.add_param(%{}, :body, "somekey", "someval")
	end

	test "add form parameter" do
	assert RequestBuilder.add_param(%{}, :form, "somename", "someval") == %{
	body: %{"somename" => "someval"}
	}
	end

	test "add for location" do
	assert RequestBuilder.add_param(%{}, :some_location, "somekey", "someval") == %{
	some_location: [{"somekey", "someval"}]
	}
	end
	end
	end
	diff --git a/test/keys_test.exs b/test/keys_test.exs
	index 776fdea6f..059f70b74 100644
	--- a/test/keys_test.exs
	+++ b/test/keys_test.exs
	@@ -1,20 +1,24 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.KeysTest do
	use Pleroma.DataCase

	alias Pleroma.Keys

	test "generates an RSA private key pem" do
	{:ok, key} = Keys.generate_rsa_pem()

	assert is_binary(key)
	assert Regex.match?(~r/RSA/, key)
	end

	test "returns a public and private key from a pem" do
	pem = File.read!("test/fixtures/private_key.pem")
	{:ok, private, public} = Keys.keys_from_pem(pem)

	assert elem(private, 0) == :RSAPrivateKey
	assert elem(public, 0) == :RSAPublicKey
	end
	end
	diff --git a/test/object/containment_test.exs b/test/object/containment_test.exs
	index a860355b8..1beed6236 100644
	--- a/test/object/containment_test.exs
	+++ b/test/object/containment_test.exs
	@@ -1,67 +1,71 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Object.ContainmentTest do
	use Pleroma.DataCase

	alias Pleroma.Object.Containment
	alias Pleroma.User

	import Pleroma.Factory
	import ExUnit.CaptureLog

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

	describe "general origin containment" do
	test "contain_origin_from_id() catches obvious spoofing attempts" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:error =
	Containment.contain_origin_from_id(
	"http://example.org/~alyssa/activities/1234.json",
	data
	)
	end

	test "contain_origin_from_id() allows alternate IDs within the same origin domain" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:ok =
	Containment.contain_origin_from_id(
	"http://example.com/~alyssa/activities/1234",
	data
	)
	end

	test "contain_origin_from_id() allows matching IDs" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:ok =
	Containment.contain_origin_from_id(
	"http://example.com/~alyssa/activities/1234.json",
	data
	)
	end

	test "users cannot be collided through fake direction spoofing attempts" do
	_user =
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	assert capture_log(fn ->
	{:error, _} = User.get_or_fetch_by_ap_id("https://n1u.moe/users/rye")
	end) =~
	"[error] Could not decode user at fetch https://n1u.moe/users/rye, {:error, :error}"
	end
	end
	end
	diff --git a/test/object/fetcher_test.exs b/test/object/fetcher_test.exs
	index 26dc9496d..3b666e0d1 100644
	--- a/test/object/fetcher_test.exs
	+++ b/test/object/fetcher_test.exs
	@@ -1,133 +1,137 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Object.FetcherTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	import Tesla.Mock

	setup do
	mock(fn
	%{method: :get, url: "https://mastodon.example.org/users/userisgone"} ->
	%Tesla.Env{status: 410}

	%{method: :get, url: "https://mastodon.example.org/users/userisgone404"} ->
	%Tesla.Env{status: 404}

	env ->
	apply(HttpRequestMock, :request, [env])
	end)

	:ok
	end

	describe "actor origin containment" do
	test "it rejects objects with a bogus origin" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity.json")
	end

	test "it rejects objects when attributedTo is wrong (variant 1)" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity2.json")
	end

	test "it rejects objects when attributedTo is wrong (variant 2)" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity3.json")
	end
	end

	describe "fetching an object" do
	test "it fetches an object" do
	{:ok, object} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
	assert activity.data["id"]

	{:ok, object_again} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert [attachment] = object.data["attachment"]
	assert is_list(attachment["url"])

	assert object == object_again
	end

	test "it works with objects only available via Ostatus" do
	{:ok, object} = Fetcher.fetch_object_from_id("https://shitposter.club/notice/2827873")
	assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
	assert activity.data["id"]

	{:ok, object_again} = Fetcher.fetch_object_from_id("https://shitposter.club/notice/2827873")

	assert object == object_again
	end

	test "it correctly stitches up conversations between ostatus and ap" do
	last = "https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	{:ok, object} = Fetcher.fetch_object_from_id(last)

	object = Object.get_by_ap_id(object.data["inReplyTo"])
	assert object
	end
	end

	describe "implementation quirks" do
	test "it can fetch plume articles" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/"
	)

	assert object
	end

	test "it can fetch peertube videos" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	assert object
	end

	test "all objects with fake directions are rejected by the object fetcher" do
	assert {:error, _} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://info.pleroma.site/activity4.json"
	)
	end

	test "handle HTTP 410 Gone response" do
	assert {:error, "Object has been deleted"} ==
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://mastodon.example.org/users/userisgone"
	)
	end

	test "handle HTTP 404 response" do
	assert {:error, "Object has been deleted"} ==
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://mastodon.example.org/users/userisgone404"
	)
	end
	end

	describe "pruning" do
	test "it can refetch pruned objects" do
	object_id = "http://mastodon.example.org/@admin/99541947525187367"

	{:ok, object} = Fetcher.fetch_object_from_id(object_id)

	assert object

	{:ok, _object} = Object.prune(object)

	refute Object.get_by_ap_id(object_id)

	{:ok, %Object{} = object_two} = Fetcher.fetch_object_from_id(object_id)

	assert object.data["id"] == object_two.data["id"]
	assert object.id != object_two.id
	end
	end
	end
	diff --git a/test/plugs/rate_limiter_test.exs b/test/plugs/rate_limiter_test.exs
	index b8d6aff89..f8251b5c7 100644
	--- a/test/plugs/rate_limiter_test.exs
	+++ b/test/plugs/rate_limiter_test.exs
	@@ -1,108 +1,112 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Plugs.RateLimiterTest do
	use ExUnit.Case, async: true
	use Plug.Test

	alias Pleroma.Plugs.RateLimiter

	import Pleroma.Factory

	@limiter_name :testing

	test "init/1" do
	Pleroma.Config.put([:rate_limit, @limiter_name], {1, 1})

	assert {@limiter_name, {1, 1}} == RateLimiter.init(@limiter_name)
	assert nil == RateLimiter.init(:foo)
	end

	test "ip/1" do
	assert "127.0.0.1" == RateLimiter.ip(%{remote_ip: {127, 0, 0, 1}})
	end

	test "it restricts by opts" do
	scale = 1000
	limit = 5

	Pleroma.Config.put([:rate_limit, @limiter_name], {scale, limit})

	opts = RateLimiter.init(@limiter_name)
	conn = conn(:get, "/")
	bucket_name = "#{@limiter_name}:#{RateLimiter.ip(conn)}"

	conn = RateLimiter.call(conn, opts)
	assert {1, 4, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)
	assert {2, 3, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)
	assert {3, 2, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)
	assert {4, 1, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)
	assert {5, 0, to_reset, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)

	assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
	assert conn.halted

	Process.sleep(to_reset)

	conn = conn(:get, "/")

	conn = RateLimiter.call(conn, opts)
	assert {1, 4, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	refute conn.status == Plug.Conn.Status.code(:too_many_requests)
	refute conn.resp_body
	refute conn.halted
	end

	test "optional limits for authenticated users" do
	Ecto.Adapters.SQL.Sandbox.checkout(Pleroma.Repo)

	scale = 1000
	limit = 5
	Pleroma.Config.put([:rate_limit, @limiter_name], [{1, 10}, {scale, limit}])

	opts = RateLimiter.init(@limiter_name)

	user = insert(:user)
	conn = conn(:get, "/") \|> assign(:user, user)
	bucket_name = "#{@limiter_name}:#{user.id}"

	conn = RateLimiter.call(conn, opts)
	assert {1, 4, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)
	assert {2, 3, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)
	assert {3, 2, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)
	assert {4, 1, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)
	assert {5, 0, to_reset, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	conn = RateLimiter.call(conn, opts)

	assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
	assert conn.halted

	Process.sleep(to_reset)

	conn = conn(:get, "/") \|> assign(:user, user)

	conn = RateLimiter.call(conn, opts)
	assert {1, 4, _, _, _} = ExRated.inspect_bucket(bucket_name, scale, limit)

	refute conn.status == Plug.Conn.Status.code(:too_many_requests)
	refute conn.resp_body
	refute conn.halted
	end
	end
	diff --git a/test/repo_test.exs b/test/repo_test.exs
	index 85085a1fa..85b64d4d1 100644
	--- a/test/repo_test.exs
	+++ b/test/repo_test.exs
	@@ -1,45 +1,49 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.RepoTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.User

	describe "find_resource/1" do
	test "returns user" do
	user = insert(:user)
	query = from(t in User, where: t.id == ^user.id)
	assert Repo.find_resource(query) == {:ok, user}
	end

	test "returns not_found" do
	query = from(t in User, where: t.id == ^"9gBuXNpD2NyDmmxxdw")
	assert Repo.find_resource(query) == {:error, :not_found}
	end
	end

	describe "get_assoc/2" do
	test "get assoc from preloaded data" do
	user = %User{name: "Agent Smith"}
	token = %Pleroma.Web.OAuth.Token{insert(:oauth_token) \| user: user}
	assert Repo.get_assoc(token, :user) == {:ok, user}
	end

	test "get one-to-one assoc from repo" do
	user = insert(:user, name: "Jimi Hendrix")
	token = refresh_record(insert(:oauth_token, user: user))

	assert Repo.get_assoc(token, :user) == {:ok, user}
	end

	test "get one-to-many assoc from repo" do
	user = insert(:user)
	notification = refresh_record(insert(:notification, user: user))

	assert Repo.get_assoc(user, :notifications) == {:ok, [notification]}
	end

	test "return error if has not assoc " do
	token = insert(:oauth_token, user: nil)
	assert Repo.get_assoc(token, :user) == {:error, :not_found}
	end
	end
	end
	diff --git a/test/reverse_proxy_test.exs b/test/reverse_proxy_test.exs
	index 75a61445a..f542de97c 100644
	--- a/test/reverse_proxy_test.exs
	+++ b/test/reverse_proxy_test.exs
	@@ -1,297 +1,301 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.ReverseProxyTest do
	use Pleroma.Web.ConnCase, async: true
	import ExUnit.CaptureLog
	import ExUnit.CaptureLog
	import Mox
	alias Pleroma.ReverseProxy
	alias Pleroma.ReverseProxy.ClientMock

	setup_all do
	{:ok, _} = Registry.start_link(keys: :unique, name: Pleroma.ReverseProxy.ClientMock)
	:ok
	end

	setup :verify_on_exit!

	defp user_agent_mock(user_agent, invokes) do
	json = Jason.encode!(%{"user-agent": user_agent})

	ClientMock
	\|> expect(:request, fn :get, url, _, _, _ ->
	Registry.register(Pleroma.ReverseProxy.ClientMock, url, 0)

	{:ok, 200,
	[
	{"content-type", "application/json"},
	{"content-length", byte_size(json) \|> to_string()}
	], %{url: url}}
	end)
	\|> expect(:stream_body, invokes, fn %{url: url} ->
	case Registry.lookup(Pleroma.ReverseProxy.ClientMock, url) do
	[{_, 0}] ->
	Registry.update_value(Pleroma.ReverseProxy.ClientMock, url, &(&1 + 1))
	{:ok, json}

	[{_, 1}] ->
	Registry.unregister(Pleroma.ReverseProxy.ClientMock, url)
	:done
	end
	end)
	end

	describe "user-agent" do
	test "don't keep", %{conn: conn} do
	user_agent_mock("hackney/1.15.1", 2)
	conn = ReverseProxy.call(conn, "/user-agent")
	assert json_response(conn, 200) == %{"user-agent" => "hackney/1.15.1"}
	end

	test "keep", %{conn: conn} do
	user_agent_mock(Pleroma.Application.user_agent(), 2)
	conn = ReverseProxy.call(conn, "/user-agent-keep", keep_user_agent: true)
	assert json_response(conn, 200) == %{"user-agent" => Pleroma.Application.user_agent()}
	end
	end

	test "closed connection", %{conn: conn} do
	ClientMock
	\|> expect(:request, fn :get, "/closed", _, _, _ -> {:ok, 200, [], %{}} end)
	\|> expect(:stream_body, fn _ -> {:error, :closed} end)
	\|> expect(:close, fn _ -> :ok end)

	conn = ReverseProxy.call(conn, "/closed")
	assert conn.halted
	end

	describe "max_body " do
	test "length returns error if content-length more than option", %{conn: conn} do
	user_agent_mock("hackney/1.15.1", 0)

	assert capture_log(fn ->
	ReverseProxy.call(conn, "/user-agent", max_body_length: 4)
	end) =~
	"[error] Elixir.Pleroma.ReverseProxy: request to \"/user-agent\" failed: :body_too_large"
	end

	defp stream_mock(invokes, with_close? \\ false) do
	ClientMock
	\|> expect(:request, fn :get, "/stream-bytes/" <> length, _, _, _ ->
	Registry.register(Pleroma.ReverseProxy.ClientMock, "/stream-bytes/" <> length, 0)

	{:ok, 200, [{"content-type", "application/octet-stream"}],
	%{url: "/stream-bytes/" <> length}}
	end)
	\|> expect(:stream_body, invokes, fn %{url: "/stream-bytes/" <> length} ->
	max = String.to_integer(length)

	case Registry.lookup(Pleroma.ReverseProxy.ClientMock, "/stream-bytes/" <> length) do
	[{_, current}] when current < max ->
	Registry.update_value(
	Pleroma.ReverseProxy.ClientMock,
	"/stream-bytes/" <> length,
	&(&1 + 10)
	)

	{:ok, "0123456789"}

	[{_, ^max}] ->
	Registry.unregister(Pleroma.ReverseProxy.ClientMock, "/stream-bytes/" <> length)
	:done
	end
	end)

	if with_close? do
	expect(ClientMock, :close, fn _ -> :ok end)
	end
	end

	test "max_body_size returns error if streaming body more than that option", %{conn: conn} do
	stream_mock(3, true)

	assert capture_log(fn ->
	ReverseProxy.call(conn, "/stream-bytes/50", max_body_size: 30)
	end) =~
	"[warn] Elixir.Pleroma.ReverseProxy request to /stream-bytes/50 failed while reading/chunking: :body_too_large"
	end
	end

	describe "HEAD requests" do
	test "common", %{conn: conn} do
	ClientMock
	\|> expect(:request, fn :head, "/head", _, _, _ ->
	{:ok, 200, [{"content-type", "text/html; charset=utf-8"}]}
	end)

	conn = ReverseProxy.call(Map.put(conn, :method, "HEAD"), "/head")
	assert html_response(conn, 200) == ""
	end
	end

	defp error_mock(status) when is_integer(status) do
	ClientMock
	\|> expect(:request, fn :get, "/status/" <> _, _, _, _ ->
	{:error, status}
	end)
	end

	describe "returns error on" do
	test "500", %{conn: conn} do
	error_mock(500)

	capture_log(fn -> ReverseProxy.call(conn, "/status/500") end) =~
	"[error] Elixir.Pleroma.ReverseProxy: request to /status/500 failed with HTTP status 500"
	end

	test "400", %{conn: conn} do
	error_mock(400)

	capture_log(fn -> ReverseProxy.call(conn, "/status/400") end) =~
	"[error] Elixir.Pleroma.ReverseProxy: request to /status/400 failed with HTTP status 400"
	end

	test "204", %{conn: conn} do
	ClientMock
	\|> expect(:request, fn :get, "/status/204", _, _, _ -> {:ok, 204, [], %{}} end)

	capture_log(fn ->
	conn = ReverseProxy.call(conn, "/status/204")
	assert conn.resp_body == "Request failed: No Content"
	assert conn.halted
	end) =~
	"[error] Elixir.Pleroma.ReverseProxy: request to \"/status/204\" failed with HTTP status 204"
	end
	end

	test "streaming", %{conn: conn} do
	stream_mock(21)
	conn = ReverseProxy.call(conn, "/stream-bytes/200")
	assert conn.state == :chunked
	assert byte_size(conn.resp_body) == 200
	assert Plug.Conn.get_resp_header(conn, "content-type") == ["application/octet-stream"]
	end

	defp headers_mock(_) do
	ClientMock
	\|> expect(:request, fn :get, "/headers", headers, _, _ ->
	Registry.register(Pleroma.ReverseProxy.ClientMock, "/headers", 0)
	{:ok, 200, [{"content-type", "application/json"}], %{url: "/headers", headers: headers}}
	end)
	\|> expect(:stream_body, 2, fn %{url: url, headers: headers} ->
	case Registry.lookup(Pleroma.ReverseProxy.ClientMock, url) do
	[{_, 0}] ->
	Registry.update_value(Pleroma.ReverseProxy.ClientMock, url, &(&1 + 1))
	headers = for {k, v} <- headers, into: %{}, do: {String.capitalize(k), v}
	{:ok, Jason.encode!(%{headers: headers})}

	[{_, 1}] ->
	Registry.unregister(Pleroma.ReverseProxy.ClientMock, url)
	:done
	end
	end)

	:ok
	end

	describe "keep request headers" do
	setup [:headers_mock]

	test "header passes", %{conn: conn} do
	conn =
	Plug.Conn.put_req_header(
	conn,
	"accept",
	"text/html"
	)
	\|> ReverseProxy.call("/headers")

	%{"headers" => headers} = json_response(conn, 200)
	assert headers["Accept"] == "text/html"
	end

	test "header is filtered", %{conn: conn} do
	conn =
	Plug.Conn.put_req_header(
	conn,
	"accept-language",
	"en-US"
	)
	\|> ReverseProxy.call("/headers")

	%{"headers" => headers} = json_response(conn, 200)
	refute headers["Accept-Language"]
	end
	end

	test "returns 400 on non GET, HEAD requests", %{conn: conn} do
	conn = ReverseProxy.call(Map.put(conn, :method, "POST"), "/ip")
	assert conn.status == 400
	end

	describe "cache resp headers" do
	test "returns headers", %{conn: conn} do
	ClientMock
	\|> expect(:request, fn :get, "/cache/" <> ttl, _, _, _ ->
	{:ok, 200, [{"cache-control", "public, max-age=" <> ttl}], %{}}
	end)
	\|> expect(:stream_body, fn _ -> :done end)

	conn = ReverseProxy.call(conn, "/cache/10")
	assert {"cache-control", "public, max-age=10"} in conn.resp_headers
	end

	test "add cache-control", %{conn: conn} do
	ClientMock
	\|> expect(:request, fn :get, "/cache", _, _, _ ->
	{:ok, 200, [{"ETag", "some ETag"}], %{}}
	end)
	\|> expect(:stream_body, fn _ -> :done end)

	conn = ReverseProxy.call(conn, "/cache")
	assert {"cache-control", "public"} in conn.resp_headers
	end
	end

	defp disposition_headers_mock(headers) do
	ClientMock
	\|> expect(:request, fn :get, "/disposition", _, _, _ ->
	Registry.register(Pleroma.ReverseProxy.ClientMock, "/disposition", 0)

	{:ok, 200, headers, %{url: "/disposition"}}
	end)
	\|> expect(:stream_body, 2, fn %{url: "/disposition"} ->
	case Registry.lookup(Pleroma.ReverseProxy.ClientMock, "/disposition") do
	[{_, 0}] ->
	Registry.update_value(Pleroma.ReverseProxy.ClientMock, "/disposition", &(&1 + 1))
	{:ok, ""}

	[{_, 1}] ->
	Registry.unregister(Pleroma.ReverseProxy.ClientMock, "/disposition")
	:done
	end
	end)
	end

	describe "response content disposition header" do
	test "not atachment", %{conn: conn} do
	disposition_headers_mock([
	{"content-type", "image/gif"},
	{"content-length", 0}
	])

	conn = ReverseProxy.call(conn, "/disposition")

	assert {"content-type", "image/gif"} in conn.resp_headers
	end

	test "with content-disposition header", %{conn: conn} do
	disposition_headers_mock([
	{"content-disposition", "attachment; filename=\"filename.jpg\""},
	{"content-length", 0}
	])

	conn = ReverseProxy.call(conn, "/disposition")

	assert {"content-disposition", "attachment; filename=\"filename.jpg\""} in conn.resp_headers
	end
	end
	end
	diff --git a/test/tasks/config_test.exs b/test/tasks/config_test.exs
	index 83a363356..bbcc57217 100644
	--- a/test/tasks/config_test.exs
	+++ b/test/tasks/config_test.exs
	@@ -1,63 +1,67 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Mix.Tasks.Pleroma.ConfigTest do
	use Pleroma.DataCase
	alias Pleroma.Repo
	alias Pleroma.Web.AdminAPI.Config

	setup_all do
	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

	test "settings are migrated to db" do
	assert Repo.all(Config) == []

	Application.put_env(:pleroma, :first_setting, key: "value", key2: [Pleroma.Repo])
	Application.put_env(:pleroma, :second_setting, key: "value2", key2: [Pleroma.Activity])

	Mix.Tasks.Pleroma.Config.run(["migrate_to_db"])

	first_db = Config.get_by_params(%{group: "pleroma", key: "first_setting"})
	second_db = Config.get_by_params(%{group: "pleroma", key: "second_setting"})
	refute Config.get_by_params(%{group: "pleroma", key: "Pleroma.Repo"})

	assert Config.from_binary(first_db.value) == [key: "value", key2: [Pleroma.Repo]]
	assert Config.from_binary(second_db.value) == [key: "value2", key2: [Pleroma.Activity]]
	end

	test "settings are migrated to file and deleted from db", %{temp_file: temp_file} do
	Config.create(%{
	group: "pleroma",
	key: "setting_first",
	value: [key: "value", key2: [Pleroma.Activity]]
	})

	Config.create(%{
	group: "pleroma",
	key: "setting_second",
	value: [key: "valu2", key2: [Pleroma.Repo]]
	})

	Mix.Tasks.Pleroma.Config.run(["migrate_from_db", "temp", "true"])

	assert Repo.all(Config) == []
	assert File.exists?(temp_file)
	{:ok, file} = File.read(temp_file)

	assert file =~ "config :pleroma, setting_first:"
	assert file =~ "config :pleroma, setting_second:"
	end
	end
	diff --git a/test/tasks/ecto/ecto_test.exs b/test/tasks/ecto/ecto_test.exs
	index b48662c88..a1b9ca174 100644
	--- a/test/tasks/ecto/ecto_test.exs
	+++ b/test/tasks/ecto/ecto_test.exs
	@@ -1,11 +1,15 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Mix.Tasks.Pleroma.EctoTest do
	use ExUnit.Case, async: true

	test "raise on bad path" do
	assert_raise RuntimeError, ~r/Could not find migrations directory/, fn ->
	Mix.Tasks.Pleroma.Ecto.ensure_migrations_path(Pleroma.Repo,
	migrations_path: "some-path"
	)
	end
	end
	end
	diff --git a/test/tasks/ecto/rollback_test.exs b/test/tasks/ecto/rollback_test.exs
	index 33d093fca..c33c4e940 100644
	--- a/test/tasks/ecto/rollback_test.exs
	+++ b/test/tasks/ecto/rollback_test.exs
	@@ -1,16 +1,20 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Mix.Tasks.Pleroma.Ecto.RollbackTest do
	use Pleroma.DataCase
	import ExUnit.CaptureLog
	require Logger

	test "ecto.rollback info message" do
	level = Logger.level()
	Logger.configure(level: :warn)

	assert capture_log(fn ->
	Mix.Tasks.Pleroma.Ecto.Rollback.run()
	end) =~ "[info] Rollback succesfully"

	Logger.configure(level: level)
	end
	end
	diff --git a/test/tasks/instance.exs b/test/tasks/instance.exs
	index 1875f52a3..bf3359b6f 100644
	--- a/test/tasks/instance.exs
	+++ b/test/tasks/instance.exs
	@@ -1,65 +1,69 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.InstanceTest do
	use ExUnit.Case, async: true

	setup do
	File.mkdir_p!(tmp_path())
	on_exit(fn -> File.rm_rf(tmp_path()) end)
	:ok
	end

	defp tmp_path do
	"/tmp/generated_files/"
	end

	test "running gen" do
	mix_task = fn ->
	Mix.Tasks.Pleroma.Instance.run([
	"gen",
	"--output",
	tmp_path() <> "generated_config.exs",
	"--output-psql",
	tmp_path() <> "setup.psql",
	"--domain",
	"test.pleroma.social",
	"--instance-name",
	"Pleroma",
	"--admin-email",
	"admin@example.com",
	"--notify-email",
	"notify@example.com",
	"--dbhost",
	"dbhost",
	"--dbname",
	"dbname",
	"--dbuser",
	"dbuser",
	"--dbpass",
	"dbpass",
	"--indexable",
	"y",
	"--db-configurable",
	"y"
	])
	end

	ExUnit.CaptureIO.capture_io(fn ->
	mix_task.()
	end)

	generated_config = File.read!(tmp_path() <> "generated_config.exs")
	assert generated_config =~ "host: \"test.pleroma.social\""
	assert generated_config =~ "name: \"Pleroma\""
	assert generated_config =~ "email: \"admin@example.com\""
	assert generated_config =~ "notify_email: \"notify@example.com\""
	assert generated_config =~ "hostname: \"dbhost\""
	assert generated_config =~ "database: \"dbname\""
	assert generated_config =~ "username: \"dbuser\""
	assert generated_config =~ "password: \"dbpass\""
	assert generated_config =~ "dynamic_configuration: true"
	assert File.read!(tmp_path() <> "setup.psql") == generated_setup_psql()
	end

	defp generated_setup_psql do
	~s(CREATE USER dbuser WITH ENCRYPTED PASSWORD 'dbpass';\nCREATE DATABASE dbname OWNER dbuser;\n\\c dbname;\n--Extensions made by ecto.migrate that need superuser access\nCREATE EXTENSION IF NOT EXISTS citext;\nCREATE EXTENSION IF NOT EXISTS pg_trgm;\nCREATE EXTENSION IF NOT EXISTS \"uuid-ossp\";\n)
	end
	end
	diff --git a/test/tasks/pleroma_test.exs b/test/tasks/pleroma_test.exs
	index e236ccbbb..a20bd9cf2 100644
	--- a/test/tasks/pleroma_test.exs
	+++ b/test/tasks/pleroma_test.exs
	@@ -1,46 +1,50 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Mix.PleromaTest do
	use ExUnit.Case, async: true
	import Mix.Pleroma

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "shell_prompt/1" do
	test "input" do
	send(self(), {:mix_shell_input, :prompt, "Yes"})

	answer = shell_prompt("Do you want this?")
	assert_received {:mix_shell, :prompt, [message]}
	assert message =~ "Do you want this?"
	assert answer == "Yes"
	end

	test "with defval" do
	send(self(), {:mix_shell_input, :prompt, "\n"})

	answer = shell_prompt("Do you want this?", "defval")

	assert_received {:mix_shell, :prompt, [message]}
	assert message =~ "Do you want this? [defval]"
	assert answer == "defval"
	end
	end

	describe "get_option/3" do
	test "get from options" do
	assert get_option([domain: "some-domain.com"], :domain, "Promt") == "some-domain.com"
	end

	test "get from prompt" do
	send(self(), {:mix_shell_input, :prompt, "another-domain.com"})
	assert get_option([], :domain, "Prompt") == "another-domain.com"
	end
	end
	end
	diff --git a/test/tasks/robots_txt_test.exs b/test/tasks/robots_txt_test.exs
	index 539193f73..97147a919 100644
	--- a/test/tasks/robots_txt_test.exs
	+++ b/test/tasks/robots_txt_test.exs
	@@ -1,43 +1,47 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Mix.Tasks.Pleroma.RobotsTxtTest do
	use ExUnit.Case, async: true
	alias Mix.Tasks.Pleroma.RobotsTxt

	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)

	RobotsTxt.run(["disallow_all"])

	assert File.exists?(file_path)
	{:ok, file} = File.read(file_path)

	assert file == "User-Agent: *\nDisallow: /\n"
	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)

	RobotsTxt.run(["disallow_all"])

	assert File.exists?(file_path)
	{:ok, file} = File.read(file_path)

	assert file == "User-Agent: *\nDisallow: /\n"
	end
	end
	diff --git a/test/upload/filter/anonymize_filename_test.exs b/test/upload/filter/anonymize_filename_test.exs
	index 02241cfa4..a31b38ab1 100644
	--- a/test/upload/filter/anonymize_filename_test.exs
	+++ b/test/upload/filter/anonymize_filename_test.exs
	@@ -1,40 +1,44 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Upload.Filter.AnonymizeFilenameTest do
	use Pleroma.DataCase

	alias Pleroma.Config
	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",
	path: Path.absname("test/fixtures/image_tmp.jpg")
	}

	%{upload_file: upload_file}
	end

	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)
	assert name == "custom-file.png"
	end

	test "it replaces filename on pre-defined text expression", %{upload_file: upload_file} do
	Config.put([Upload.Filter.AnonymizeFilename, :text], "custom-file.{extension}")
	{:ok, %Upload{name: name}} = Upload.Filter.AnonymizeFilename.filter(upload_file)
	assert name == "custom-file.jpg"
	end

	test "it replaces filename on random text", %{upload_file: upload_file} do
	{:ok, %Upload{name: name}} = Upload.Filter.AnonymizeFilename.filter(upload_file)
	assert <<_::bytes-size(14)>> <> ".jpg" = name
	refute name == "an… image.jpg"
	end
	end
	diff --git a/test/user_invite_token_test.exs b/test/user_invite_token_test.exs
	index 276788254..111e40361 100644
	--- a/test/user_invite_token_test.exs
	+++ b/test/user_invite_token_test.exs
	@@ -1,96 +1,100 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.UserInviteTokenTest do
	use ExUnit.Case, async: true
	use Pleroma.DataCase
	alias Pleroma.UserInviteToken

	describe "valid_invite?/1 one time invites" do
	setup do
	invite = %UserInviteToken{invite_type: "one_time"}

	{:ok, invite: invite}
	end

	test "not used returns true", %{invite: invite} do
	invite = %{invite \| used: false}
	assert UserInviteToken.valid_invite?(invite)
	end

	test "used returns false", %{invite: invite} do
	invite = %{invite \| used: true}
	refute UserInviteToken.valid_invite?(invite)
	end
	end

	describe "valid_invite?/1 reusable invites" do
	setup do
	invite = %UserInviteToken{
	invite_type: "reusable",
	max_use: 5
	}

	{:ok, invite: invite}
	end

	test "with less uses then max use returns true", %{invite: invite} do
	invite = %{invite \| uses: 4}
	assert UserInviteToken.valid_invite?(invite)
	end

	test "with equal or more uses then max use returns false", %{invite: invite} do
	invite = %{invite \| uses: 5}

	refute UserInviteToken.valid_invite?(invite)

	invite = %{invite \| uses: 6}

	refute UserInviteToken.valid_invite?(invite)
	end
	end

	describe "valid_token?/1 date limited invites" do
	setup do
	invite = %UserInviteToken{invite_type: "date_limited"}
	{:ok, invite: invite}
	end

	test "expires today returns true", %{invite: invite} do
	invite = %{invite \| expires_at: Date.utc_today()}
	assert UserInviteToken.valid_invite?(invite)
	end

	test "expires yesterday returns false", %{invite: invite} do
	invite = %{invite \| expires_at: Date.add(Date.utc_today(), -1)}
	invite = Repo.insert!(invite)
	refute UserInviteToken.valid_invite?(invite)
	end
	end

	describe "valid_token?/1 reusable date limited invites" do
	setup do
	invite = %UserInviteToken{invite_type: "reusable_date_limited", max_use: 5}
	{:ok, invite: invite}
	end

	test "not overdue date and less uses returns true", %{invite: invite} do
	invite = %{invite \| expires_at: Date.utc_today(), uses: 4}
	assert UserInviteToken.valid_invite?(invite)
	end

	test "overdue date and less uses returns false", %{invite: invite} do
	invite = %{invite \| expires_at: Date.add(Date.utc_today(), -1)}
	invite = Repo.insert!(invite)
	refute UserInviteToken.valid_invite?(invite)
	end

	test "not overdue date with more uses returns false", %{invite: invite} do
	invite = %{invite \| expires_at: Date.utc_today(), uses: 5}
	refute UserInviteToken.valid_invite?(invite)
	end

	test "overdue date with more uses returns false", %{invite: invite} do
	invite = %{invite \| expires_at: Date.add(Date.utc_today(), -1), uses: 5}
	invite = Repo.insert!(invite)
	refute UserInviteToken.valid_invite?(invite)
	end
	end
	end
	diff --git a/test/web/activity_pub/utils_test.exs b/test/web/activity_pub/utils_test.exs
	index 932d5f5e7..ca5f057a7 100644
	--- a/test/web/activity_pub/utils_test.exs
	+++ b/test/web/activity_pub/utils_test.exs
	@@ -1,298 +1,302 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.ActivityPub.UtilsTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = User.get_cached_by_ap_id(activity.data["actor"])
	followed = User.get_cached_by_ap_id(activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "fetch the latest Block" do
	test "fetches the latest Block activity" do
	blocker = insert(:user)
	blocked = insert(:user)
	{:ok, activity} = ActivityPub.block(blocker, blocked)

	assert activity == Utils.fetch_latest_block(blocker, blocked)
	end
	end

	describe "determine_explicit_mentions()" do
	test "works with an object that has mentions" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that does not have mentions" do
	object = %{
	"tag" => [
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has mentions and other tags" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	},
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that has no tags" do
	object = %{}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has only IR tags" do
	object = %{"tag" => ["2hu"]}

	assert Utils.determine_explicit_mentions(object) == []
	end
	end

	describe "make_like_data" do
	setup do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	[user: user, other_user: other_user, third_user: third_user]
	end

	test "addresses actor's follower address if the activity is public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id, other_user.follower_address])
	expected_cc = Enum.sort(["https://www.w3.org/ns/activitystreams#Public", third_user.ap_id])

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end

	test "does not adress actor's follower address if the activity is not public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id])
	expected_cc = [third_user.ap_id]

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
	"visibility" => "private"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end
	end

	describe "fetch_ordered_collection" do
	import Tesla.Mock

	test "fetches the first OrderedCollectionPage when an OrderedCollection is encountered" do
	mock(fn
	%{method: :get, url: "http://mastodon.com/outbox"} ->
	json(%{"type" => "OrderedCollection", "first" => "http://mastodon.com/outbox?page=true"})

	%{method: :get, url: "http://mastodon.com/outbox?page=true"} ->
	json(%{"type" => "OrderedCollectionPage", "orderedItems" => ["ok"]})
	end)

	assert Utils.fetch_ordered_collection("http://mastodon.com/outbox", 1) == ["ok"]
	end

	test "fetches several pages in the right order one after another, but only the specified amount" do
	mock(fn
	%{method: :get, url: "http://example.com/outbox"} ->
	json(%{
	"type" => "OrderedCollectionPage",
	"orderedItems" => [0],
	"next" => "http://example.com/outbox?page=1"
	})

	%{method: :get, url: "http://example.com/outbox?page=1"} ->
	json(%{
	"type" => "OrderedCollectionPage",
	"orderedItems" => [1],
	"next" => "http://example.com/outbox?page=2"
	})

	%{method: :get, url: "http://example.com/outbox?page=2"} ->
	json(%{"type" => "OrderedCollectionPage", "orderedItems" => [2]})
	end)

	assert Utils.fetch_ordered_collection("http://example.com/outbox", 0) == [0]
	assert Utils.fetch_ordered_collection("http://example.com/outbox", 1) == [0, 1]
	end

	test "returns an error if the url doesn't have an OrderedCollection/Page" do
	mock(fn
	%{method: :get, url: "http://example.com/not-an-outbox"} ->
	json(%{"type" => "NotAnOutbox"})
	end)

	assert {:error, _} = Utils.fetch_ordered_collection("http://example.com/not-an-outbox", 1)
	end

	test "returns the what was collected if there are less pages than specified" do
	mock(fn
	%{method: :get, url: "http://example.com/outbox"} ->
	json(%{
	"type" => "OrderedCollectionPage",
	"orderedItems" => [0],
	"next" => "http://example.com/outbox?page=1"
	})

	%{method: :get, url: "http://example.com/outbox?page=1"} ->
	json(%{"type" => "OrderedCollectionPage", "orderedItems" => [1]})
	end)

	assert Utils.fetch_ordered_collection("http://example.com/outbox", 5) == [0, 1]
	end
	end

	test "make_json_ld_header/0" do
	assert Utils.make_json_ld_header() == %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	]
	}
	end

	describe "get_existing_votes" do
	test "fetches existing votes" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "How do I pronounce LaTeX?",
	"poll" => %{
	"options" => ["laytekh", "lahtekh", "latex"],
	"expires_in" => 20,
	"multiple" => true
	}
	})

	object = Object.normalize(activity)
	{:ok, votes, object} = CommonAPI.vote(other_user, object, [0, 1])
	assert Enum.sort(Utils.get_existing_votes(other_user.ap_id, object)) == Enum.sort(votes)
	end

	test "fetches only Create activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "Are we living in a society?",
	"poll" => %{
	"options" => ["yes", "no"],
	"expires_in" => 20
	}
	})

	object = Object.normalize(activity)
	{:ok, [vote], object} = CommonAPI.vote(other_user, object, [0])
	vote_object = Object.normalize(vote)
	{:ok, _activity, _object} = ActivityPub.like(user, vote_object)
	[fetched_vote] = Utils.get_existing_votes(other_user.ap_id, object)
	assert fetched_vote.id == vote.id
	end
	end

	describe "update_follow_state_for_all/2" do
	test "updates the state of all Follow activities with the same actor and object" do
	user = insert(:user, info: %{locked: true})
	follower = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "accept")

	assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
	end
	end

	describe "update_follow_state/2" do
	test "updates the state of the given follow activity" do
	user = insert(:user, info: %{locked: true})
	follower = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} = Utils.update_follow_state(follow_activity_two, "reject")

	assert Repo.get(Activity, follow_activity.id).data["state"] == "pending"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
	end
	end
	end
	diff --git a/test/web/activity_pub/views/object_view_test.exs b/test/web/activity_pub/views/object_view_test.exs
	index d939fc5a7..ac624dfa4 100644
	--- a/test/web/activity_pub/views/object_view_test.exs
	+++ b/test/web/activity_pub/views/object_view_test.exs
	@@ -1,58 +1,62 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.ActivityPub.ObjectViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory

	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.CommonAPI

	test "renders a note object" do
	note = insert(:note)

	result = ObjectView.render("object.json", %{object: note})

	assert result["id"] == note.data["id"]
	assert result["to"] == note.data["to"]
	assert result["content"] == note.data["content"]
	assert result["type"] == "Note"
	assert result["@context"]
	end

	test "renders a note activity" do
	note = insert(:note_activity)

	result = ObjectView.render("object.json", %{object: note})

	assert result["id"] == note.data["id"]
	assert result["to"] == note.data["to"]
	assert result["object"]["type"] == "Note"
	assert result["object"]["content"] == note.data["object"]["content"]
	assert result["type"] == "Create"
	assert result["@context"]
	end

	test "renders a like activity" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, like_activity, _} = CommonAPI.favorite(note.id, user)

	result = ObjectView.render("object.json", %{object: like_activity})

	assert result["id"] == like_activity.data["id"]
	assert result["object"] == note.data["object"]["id"]
	assert result["type"] == "Like"
	end

	test "renders an announce activity" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, announce_activity, _} = CommonAPI.repeat(note.id, user)

	result = ObjectView.render("object.json", %{object: announce_activity})

	assert result["id"] == announce_activity.data["id"]
	assert result["object"] == note.data["object"]["id"]
	assert result["type"] == "Announce"
	end
	end
	diff --git a/test/web/activity_pub/views/user_view_test.exs b/test/web/activity_pub/views/user_view_test.exs
	index e6483db8b..969860c4c 100644
	--- a/test/web/activity_pub/views/user_view_test.exs
	+++ b/test/web/activity_pub/views/user_view_test.exs
	@@ -1,81 +1,85 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.ActivityPub.UserViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.UserView

	test "Renders a user, including the public key" do
	user = insert(:user)
	{:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["preferredUsername"] == user.nickname

	assert String.contains?(result["publicKey"]["publicKeyPem"], "BEGIN PUBLIC KEY")
	end

	test "Does not add an avatar image if the user hasn't set one" do
	user = insert(:user)
	{:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})
	refute result["icon"]
	refute result["image"]

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://someurl"}]},
	info: %{
	banner: %{"url" => [%{"href" => "https://somebanner"}]}
	}
	)

	{:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})
	assert result["icon"]["url"] == "https://someurl"
	assert result["image"]["url"] == "https://somebanner"
	end

	describe "endpoints" do
	test "local users have a usable endpoints structure" do
	user = insert(:user)
	{:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id

	%{
	"sharedInbox" => _,
	"oauthAuthorizationEndpoint" => _,
	"oauthRegistrationEndpoint" => _,
	"oauthTokenEndpoint" => _
	} = result["endpoints"]
	end

	test "remote users have an empty endpoints structure" do
	user = insert(:user, local: false)
	{:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["endpoints"] == %{}
	end

	test "instance users do not expose oAuth endpoints" do
	user = insert(:user, nickname: nil, local: true)
	{:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})

	refute result["endpoints"]["oauthAuthorizationEndpoint"]
	refute result["endpoints"]["oauthRegistrationEndpoint"]
	refute result["endpoints"]["oauthTokenEndpoint"]
	end
	end
	end
	diff --git a/test/web/activity_pub/visibilty_test.exs b/test/web/activity_pub/visibilty_test.exs
	index e24df3cab..4d5c07da4 100644
	--- a/test/web/activity_pub/visibilty_test.exs
	+++ b/test/web/activity_pub/visibilty_test.exs
	@@ -1,167 +1,171 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.ActivityPub.VisibilityTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory

	setup do
	user = insert(:user)
	mentioned = insert(:user)
	following = insert(:user)
	unrelated = insert(:user)
	{:ok, following} = Pleroma.User.follow(following, user)

	{:ok, public} =
	CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "public"})

	{:ok, private} =
	CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "private"})

	{:ok, direct} =
	CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "direct"})

	{:ok, unlisted} =
	CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "unlisted"})

	%{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	user: user,
	mentioned: mentioned,
	following: following,
	unrelated: unrelated
	}
	end

	test "is_direct?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
	assert Visibility.is_direct?(direct)
	refute Visibility.is_direct?(public)
	refute Visibility.is_direct?(private)
	refute Visibility.is_direct?(unlisted)
	end

	test "is_public?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
	refute Visibility.is_public?(direct)
	assert Visibility.is_public?(public)
	refute Visibility.is_public?(private)
	assert Visibility.is_public?(unlisted)
	end

	test "is_private?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
	refute Visibility.is_private?(direct)
	refute Visibility.is_private?(public)
	assert Visibility.is_private?(private)
	refute Visibility.is_private?(unlisted)
	end

	test "visible_for_user?", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	user: user,
	mentioned: mentioned,
	following: following,
	unrelated: unrelated
	} do
	# All visible to author

	assert Visibility.visible_for_user?(public, user)
	assert Visibility.visible_for_user?(private, user)
	assert Visibility.visible_for_user?(unlisted, user)
	assert Visibility.visible_for_user?(direct, user)

	# All visible to a mentioned user

	assert Visibility.visible_for_user?(public, mentioned)
	assert Visibility.visible_for_user?(private, mentioned)
	assert Visibility.visible_for_user?(unlisted, mentioned)
	assert Visibility.visible_for_user?(direct, mentioned)

	# DM not visible for just follower

	assert Visibility.visible_for_user?(public, following)
	assert Visibility.visible_for_user?(private, following)
	assert Visibility.visible_for_user?(unlisted, following)
	refute Visibility.visible_for_user?(direct, following)

	# Public and unlisted visible for unrelated user

	assert Visibility.visible_for_user?(public, unrelated)
	assert Visibility.visible_for_user?(unlisted, unrelated)
	refute Visibility.visible_for_user?(private, unrelated)
	refute Visibility.visible_for_user?(direct, unrelated)
	end

	test "doesn't die when the user doesn't exist",
	%{
	direct: direct,
	user: user
	} do
	Repo.delete(user)
	Cachex.clear(:user_cache)
	refute Visibility.is_private?(direct)
	end

	test "get_visibility", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted
	} do
	assert Visibility.get_visibility(public) == "public"
	assert Visibility.get_visibility(private) == "private"
	assert Visibility.get_visibility(direct) == "direct"
	assert Visibility.get_visibility(unlisted) == "unlisted"
	end

	test "get_visibility with directMessage flag" do
	assert Visibility.get_visibility(%{data: %{"directMessage" => true}}) == "direct"
	end

	describe "entire_thread_visible_for_user?/2" do
	test "returns false if not found activity", %{user: user} do
	refute Visibility.entire_thread_visible_for_user?(%Activity{}, user)
	end

	test "returns true if activity hasn't 'Create' type", %{user: user} do
	activity = insert(:like_activity)
	assert Visibility.entire_thread_visible_for_user?(activity, user)
	end

	test "returns false when invalid recipients", %{user: user} do
	author = insert(:user)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["test-user"]}
	)
	)

	refute Visibility.entire_thread_visible_for_user?(activity, user)
	end

	test "returns true if user following to author" do
	author = insert(:user)
	user = insert(:user, following: [author.ap_id])

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => [user.ap_id]}
	)
	)

	assert Visibility.entire_thread_visible_for_user?(activity, user)
	end
	end
	end
	diff --git a/test/web/admin_api/config_test.exs b/test/web/admin_api/config_test.exs
	index 10cb3b68a..b281831e3 100644
	--- a/test/web/admin_api/config_test.exs
	+++ b/test/web/admin_api/config_test.exs
	@@ -1,258 +1,262 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.AdminAPI.ConfigTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Web.AdminAPI.Config

	test "get_by_key/1" do
	config = insert(:config)
	insert(:config)

	assert config == Config.get_by_params(%{group: config.group, key: config.key})
	end

	test "create/1" do
	{:ok, config} = Config.create(%{group: "pleroma", key: "some_key", value: "some_value"})
	assert config == Config.get_by_params(%{group: "pleroma", key: "some_key"})
	end

	test "update/1" do
	config = insert(:config)
	{:ok, updated} = Config.update(config, %{value: "some_value"})
	loaded = Config.get_by_params(%{group: config.group, key: config.key})
	assert loaded == updated
	end

	test "update_or_create/1" do
	config = insert(:config)
	key2 = "another_key"

	params = [
	%{group: "pleroma", key: key2, value: "another_value"},
	%{group: config.group, key: config.key, value: "new_value"}
	]

	assert Repo.all(Config) \|> length() == 1

	Enum.each(params, &Config.update_or_create(&1))

	assert Repo.all(Config) \|> length() == 2

	config1 = Config.get_by_params(%{group: config.group, key: config.key})
	config2 = Config.get_by_params(%{group: "pleroma", key: key2})

	assert config1.value == Config.transform("new_value")
	assert config2.value == Config.transform("another_value")
	end

	test "delete/1" do
	config = insert(:config)
	{:ok, _} = Config.delete(%{key: config.key, group: config.group})
	refute Config.get_by_params(%{key: config.key, group: config.group})
	end

	describe "transform/1" do
	test "string" do
	binary = Config.transform("value as string")
	assert binary == :erlang.term_to_binary("value as string")
	assert Config.from_binary(binary) == "value as string"
	end

	test "list of modules" do
	binary = Config.transform(["Pleroma.Repo", "Pleroma.Activity"])
	assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
	assert Config.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
	end

	test "list of strings" do
	binary = Config.transform(["string1", "string2"])
	assert binary == :erlang.term_to_binary(["string1", "string2"])
	assert Config.from_binary(binary) == ["string1", "string2"]
	end

	test "map" do
	binary =
	Config.transform(%{
	"types" => "Pleroma.PostgresTypes",
	"telemetry_event" => ["Pleroma.Repo.Instrumenter"],
	"migration_lock" => ""
	})

	assert binary ==
	:erlang.term_to_binary(
	telemetry_event: [Pleroma.Repo.Instrumenter],
	types: Pleroma.PostgresTypes
	)

	assert Config.from_binary(binary) == [
	telemetry_event: [Pleroma.Repo.Instrumenter],
	types: Pleroma.PostgresTypes
	]
	end

	test "complex map with nested integers, lists and atoms" do
	binary =
	Config.transform(%{
	"uploader" => "Pleroma.Uploaders.Local",
	"filters" => ["Pleroma.Upload.Filter.Dedupe"],
	"link_name" => ":true",
	"proxy_remote" => ":false",
	"proxy_opts" => %{
	"redirect_on_failure" => ":false",
	"max_body_length" => "i:1048576",
	"http" => %{
	"follow_redirect" => ":true",
	"pool" => ":upload"
	}
	}
	})

	assert binary ==
	:erlang.term_to_binary(
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	proxy_opts: [
	http: [
	follow_redirect: true,
	pool: :upload
	],
	max_body_length: 1_048_576,
	redirect_on_failure: false
	],
	proxy_remote: false,
	uploader: Pleroma.Uploaders.Local
	)

	assert Config.from_binary(binary) ==
	[
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	proxy_opts: [
	http: [
	follow_redirect: true,
	pool: :upload
	],
	max_body_length: 1_048_576,
	redirect_on_failure: false
	],
	proxy_remote: false,
	uploader: Pleroma.Uploaders.Local
	]
	end

	test "keyword" do
	binary =
	Config.transform(%{
	"level" => ":warn",
	"meta" => [":all"],
	"webhook_url" => "https://hooks.slack.com/services/YOUR-KEY-HERE"
	})

	assert binary ==
	:erlang.term_to_binary(
	level: :warn,
	meta: [:all],
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	)

	assert Config.from_binary(binary) == [
	level: :warn,
	meta: [:all],
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	]
	end

	test "complex map with sigil" do
	binary =
	Config.transform(%{
	federated_timeline_removal: [],
	reject: [~r/comp[lL][aA][iI][nN]er/],
	replace: []
	})

	assert binary ==
	:erlang.term_to_binary(
	federated_timeline_removal: [],
	reject: [~r/comp[lL][aA][iI][nN]er/],
	replace: []
	)

	assert Config.from_binary(binary) ==
	[federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
	end

	test "complex map with tuples with more than 2 values" do
	binary =
	Config.transform(%{
	"http" => %{
	"dispatch" => [
	%{
	"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 binary ==
	:erlang.term_to_binary(
	http: [
	dispatch: [
	_: [
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]
	]
	]
	)

	assert Config.from_binary(binary) == [
	http: [
	dispatch: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	]
	]
	]
	end
	end
	end
	diff --git a/test/web/metadata/rel_me_test.exs b/test/web/metadata/rel_me_test.exs
	index f66bf7834..3874e077b 100644
	--- a/test/web/metadata/rel_me_test.exs
	+++ b/test/web/metadata/rel_me_test.exs
	@@ -1,18 +1,22 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.Metadata.Providers.RelMeTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.Web.Metadata.Providers.RelMe

	test "it renders all links with rel='me' from user bio" do
	bio =
	~s(<a href="https://some-link.com">https://some-link.com</a> <a rel="me" href="https://another-link.com">https://another-link.com</a>
	<link href="http://some.com"> <link rel="me" href="http://some3.com>")

	user = insert(:user, %{bio: bio})

	assert RelMe.build_tags(%{user: user}) == [
	{:link, [rel: "me", href: "http://some3.com>"], []},
	{:link, [rel: "me", href: "https://another-link.com"], []}
	]
	end
	end
	diff --git a/test/web/ostatus/incoming_documents/delete_handling_test.exs b/test/web/ostatus/incoming_documents/delete_handling_test.exs
	index ca6e61339..36d688d22 100644
	--- a/test/web/ostatus/incoming_documents/delete_handling_test.exs
	+++ b/test/web/ostatus/incoming_documents/delete_handling_test.exs
	@@ -1,43 +1,47 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.OStatus.DeleteHandlingTest do
	use Pleroma.DataCase

	import Pleroma.Factory
	import Tesla.Mock

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.OStatus

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "deletions" do
	test "it removes the mentioned activity" do
	note = insert(:note_activity)
	second_note = insert(:note_activity)
	user = insert(:user)
	object = Object.get_by_ap_id(note.data["object"]["id"])

	{:ok, like, _object} = Pleroma.Web.ActivityPub.ActivityPub.like(user, object)

	incoming =
	File.read!("test/fixtures/delete.xml")
	\|> String.replace(
	"tag:mastodon.sdf.org,2017-06-10:objectId=310513:objectType=Status",
	note.data["object"]["id"]
	)

	{:ok, [delete]} = OStatus.handle_incoming(incoming)

	refute Activity.get_by_id(note.id)
	refute Activity.get_by_id(like.id)
	assert Object.get_by_ap_id(note.data["object"]["id"]).data["type"] == "Tombstone"
	assert Activity.get_by_id(second_note.id)
	assert Object.get_by_ap_id(second_note.data["object"]["id"])

	assert delete.data["type"] == "Delete"
	end
	end
	end
	diff --git a/test/web/rel_me_test.exs b/test/web/rel_me_test.exs
	index 5188f4de1..85515c432 100644
	--- a/test/web/rel_me_test.exs
	+++ b/test/web/rel_me_test.exs
	@@ -1,67 +1,71 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.RelMeTest do
	use ExUnit.Case, async: true

	setup do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "http://example.com/rel_me/anchor"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rel_me_anchor.html")}

	%{
	method: :get,
	url: "http://example.com/rel_me/anchor_nofollow"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rel_me_anchor_nofollow.html")}

	%{
	method: :get,
	url: "http://example.com/rel_me/link"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rel_me_link.html")}

	%{
	method: :get,
	url: "http://example.com/rel_me/null"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rel_me_null.html")}
	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 {:error, _} = 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/web/rich_media/helpers_test.exs b/test/web/rich_media/helpers_test.exs
	index c8f442b05..92198f3d9 100644
	--- a/test/web/rich_media/helpers_test.exs
	+++ b/test/web/rich_media/helpers_test.exs
	@@ -1,117 +1,121 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.RichMedia.HelpersTest do
	use Pleroma.DataCase

	alias Pleroma.Config
	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.RichMedia.Helpers

	import Pleroma.Factory
	import Tesla.Mock

	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

	test "refuses to crawl incomplete URLs" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "[test](example.com/ogp)",
	"content_type" => "text/markdown"
	})

	Config.put([:rich_media, :enabled], true)

	assert %{} == Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end

	test "refuses to crawl malformed URLs" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "[test](example.com[]/ogp)",
	"content_type" => "text/markdown"
	})

	Config.put([:rich_media, :enabled], true)

	assert %{} == Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end

	test "crawls valid, complete URLs" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "[test](https://example.com/ogp)",
	"content_type" => "text/markdown"
	})

	Config.put([:rich_media, :enabled], true)

	assert %{page_url: "https://example.com/ogp", rich_media: _} =
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end

	test "refuses to crawl URLs from posts marked sensitive" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "http://example.com/ogp",
	"sensitive" => true
	})

	%Object{} = object = Object.normalize(activity)

	assert object.data["sensitive"]

	Config.put([:rich_media, :enabled], true)

	assert %{} = Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end

	test "refuses to crawl URLs from posts tagged NSFW" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "http://example.com/ogp #nsfw"
	})

	%Object{} = object = Object.normalize(activity)

	assert object.data["sensitive"]

	Config.put([:rich_media, :enabled], true)

	assert %{} = Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end

	test "refuses to crawl URLs of private network from posts" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "http://127.0.0.1:4000/notice/9kCP7VNyPJXFOXDrgO"})

	{:ok, activity2} = CommonAPI.post(user, %{"status" => "https://10.111.10.1/notice/9kCP7V"})
	{:ok, activity3} = CommonAPI.post(user, %{"status" => "https://172.16.32.40/notice/9kCP7V"})
	{:ok, activity4} = CommonAPI.post(user, %{"status" => "https://192.168.10.40/notice/9kCP7V"})
	{:ok, activity5} = CommonAPI.post(user, %{"status" => "https://pleroma.local/notice/9kCP7V"})

	Config.put([:rich_media, :enabled], true)

	assert %{} = Helpers.fetch_data_for_activity(activity)
	assert %{} = Helpers.fetch_data_for_activity(activity2)
	assert %{} = Helpers.fetch_data_for_activity(activity3)
	assert %{} = Helpers.fetch_data_for_activity(activity4)
	assert %{} = Helpers.fetch_data_for_activity(activity5)
	end
	end
	diff --git a/test/web/rich_media/parser_test.exs b/test/web/rich_media/parser_test.exs
	index bc48341ca..19c19e895 100644
	--- a/test/web/rich_media/parser_test.exs
	+++ b/test/web/rich_media/parser_test.exs
	@@ -1,130 +1,134 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.RichMedia.ParserTest do
	use ExUnit.Case, async: true

	setup do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "http://example.com/ogp"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/ogp.html")}

	%{
	method: :get,
	url: "http://example.com/non-ogp"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/non_ogp_embed.html")}

	%{
	method: :get,
	url: "http://example.com/ogp-missing-title"
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/rich_media/ogp-missing-title.html")
	}

	%{
	method: :get,
	url: "http://example.com/twitter-card"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/twitter_card.html")}

	%{
	method: :get,
	url: "http://example.com/oembed"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/oembed.html")}

	%{
	method: :get,
	url: "http://example.com/oembed.json"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/oembed.json")}

	%{method: :get, url: "http://example.com/empty"} ->
	%Tesla.Env{status: 200, body: "hello"}
	end)

	:ok
	end

	test "returns error when no metadata present" do
	assert {:error, _} = Pleroma.Web.RichMedia.Parser.parse("http://example.com/empty")
	end

	test "doesn't just add a title" do
	assert Pleroma.Web.RichMedia.Parser.parse("http://example.com/non-ogp") ==
	{:error, "Found metadata was invalid or incomplete: %{}"}
	end

	test "parses ogp" do
	assert Pleroma.Web.RichMedia.Parser.parse("http://example.com/ogp") ==
	{:ok,
	%{
	image: "http://ia.media-imdb.com/images/rock.jpg",
	title: "The Rock",
	description:
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
	type: "video.movie",
	url: "http://www.imdb.com/title/tt0117500/"
	}}
	end

	test "falls back to <title> when ogp:title is missing" do
	assert Pleroma.Web.RichMedia.Parser.parse("http://example.com/ogp-missing-title") ==
	{:ok,
	%{
	image: "http://ia.media-imdb.com/images/rock.jpg",
	title: "The Rock (1996)",
	description:
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
	type: "video.movie",
	url: "http://www.imdb.com/title/tt0117500/"
	}}
	end

	test "parses twitter card" do
	assert Pleroma.Web.RichMedia.Parser.parse("http://example.com/twitter-card") ==
	{:ok,
	%{
	card: "summary",
	site: "@flickr",
	image: "https://farm6.staticflickr.com/5510/14338202952_93595258ff_z.jpg",
	title: "Small Island Developing States Photo Submission",
	description: "View the album on Flickr."
	}}
	end

	test "parses OEmbed" do
	assert Pleroma.Web.RichMedia.Parser.parse("http://example.com/oembed") ==
	{:ok,
	%{
	author_name: "‮‭‬bees‬",
	author_url: "https://www.flickr.com/photos/bees/",
	cache_age: 3600,
	flickr_type: "photo",
	height: "768",
	html:
	"<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/bees/2362225867/\" title=\"Bacon Lollys by ‮‭‬bees‬, on Flickr\"><img src=\"https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_b.jpg\" width=\"1024\" height=\"768\" alt=\"Bacon Lollys\"></a><script async src=\"https://embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>",
	license: "All Rights Reserved",
	license_id: 0,
	provider_name: "Flickr",
	provider_url: "https://www.flickr.com/",
	thumbnail_height: 150,
	thumbnail_url: "https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_q.jpg",
	thumbnail_width: 150,
	title: "Bacon Lollys",
	type: "photo",
	url: "https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_b.jpg",
	version: "1.0",
	web_page: "https://www.flickr.com/photos/bees/2362225867/",
	web_page_short_url: "https://flic.kr/p/4AK2sc",
	width: "1024"
	}}
	end

	test "rejects invalid OGP data" do
	assert {:error, _} = Pleroma.Web.RichMedia.Parser.parse("http://example.com/malformed")
	end
	end
	diff --git a/test/web/twitter_api/password_controller_test.exs b/test/web/twitter_api/password_controller_test.exs
	index 6b9da8204..3a7246ea8 100644
	--- a/test/web/twitter_api/password_controller_test.exs
	+++ b/test/web/twitter_api/password_controller_test.exs
	@@ -1,56 +1,60 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.TwitterAPI.PasswordControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.PasswordResetToken
	alias Pleroma.Web.OAuth.Token
	import Pleroma.Factory

	describe "GET /api/pleroma/password_reset/token" do
	test "it returns error when token invalid", %{conn: conn} do
	response =
	conn
	\|> get("/api/pleroma/password_reset/token")
	\|> html_response(:ok)

	assert response =~ "<h2>Invalid Token</h2>"
	end

	test "it shows password reset form", %{conn: conn} do
	user = insert(:user)
	{:ok, token} = PasswordResetToken.create_token(user)

	response =
	conn
	\|> get("/api/pleroma/password_reset/#{token.token}")
	\|> html_response(:ok)

	assert response =~ "<h2>Password Reset for #{user.nickname}</h2>"
	end
	end

	describe "POST /api/pleroma/password_reset" do
	test "it returns HTTP 200", %{conn: conn} do
	user = insert(:user)
	{:ok, token} = PasswordResetToken.create_token(user)
	{:ok, _access_token} = Token.create_token(insert(:oauth_app), user, %{})

	params = %{
	"password" => "test",
	password_confirmation: "test",
	token: token.token
	}

	response =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/password_reset", %{data: params})
	\|> html_response(:ok)

	assert response =~ "<h2>Password changed!</h2>"

	user = refresh_record(user)
	assert Comeonin.Pbkdf2.checkpw("test", user.password_hash)
	assert length(Token.get_user_tokens(user)) == 0
	end
	end
	end
	diff --git a/test/web/twitter_api/util_controller_test.exs b/test/web/twitter_api/util_controller_test.exs
	index cab9e5d90..21324399f 100644
	--- a/test/web/twitter_api/util_controller_test.exs
	+++ b/test/web/twitter_api/util_controller_test.exs
	@@ -1,253 +1,257 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory

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

	describe "POST /api/pleroma/follow_import" do
	test "it returns HTTP 200", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/follow_import", %{"list" => "#{user2.ap_id}"})
	\|> json_response(:ok)

	assert response == "job started"
	end

	test "it imports new-style mastodon follow lists", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/follow_import", %{
	"list" => "Account address,Show boosts\n#{user2.ap_id},true"
	})
	\|> json_response(:ok)

	assert response == "job started"
	end

	test "requires 'follow' permission", %{conn: conn} do
	token1 = insert(:oauth_token, scopes: ["read", "write"])
	token2 = insert(:oauth_token, scopes: ["follow"])
	another_user = insert(:user)

	for token <- [token1, token2] do
	conn =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> post("/api/pleroma/follow_import", %{"list" => "#{another_user.ap_id}"})

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

	describe "POST /api/pleroma/blocks_import" do
	test "it returns HTTP 200", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/blocks_import", %{"list" => "#{user2.ap_id}"})
	\|> json_response(:ok)

	assert response == "job started"
	end
	end

	describe "POST /api/pleroma/notifications/read" do
	test "it marks a single notification as read", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, activity1} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"})
	{:ok, activity2} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"})
	{:ok, [notification1]} = Notification.create_notifications(activity1)
	{:ok, [notification2]} = Notification.create_notifications(activity2)

	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/notifications/read", %{"id" => "#{notification1.id}"})
	\|> json_response(:ok)

	assert Repo.get(Notification, notification1.id).seen
	refute Repo.get(Notification, notification2.id).seen
	end
	end

	describe "PUT /api/pleroma/notification_settings" do
	test "it updates notification settings", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> put("/api/pleroma/notification_settings", %{
	"followers" => false,
	"bar" => 1
	})
	\|> json_response(:ok)

	user = Repo.get(User, user.id)

	assert %{
	"followers" => false,
	"follows" => true,
	"non_follows" => true,
	"non_followers" => true
	} == user.info.notification_settings
	end
	end

	describe "GET /api/statusnet/config.json" do
	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 =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["safeDMMentionsEnabled"] == "1"

	Pleroma.Config.put([:instance, :safe_dm_mentions], false)

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> 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
	Pleroma.Config.put([:instance, :managed_config], false)
	Pleroma.Config.put([:frontend_configurations, :pleroma_fe], %{theme: "asuka-hospital"})

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	refute response["site"]["pleromafe"]

	Pleroma.Config.put([:instance, :managed_config], true)

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["pleromafe"] == %{"theme" => "asuka-hospital"}
	end
	end

	describe "GET /api/pleroma/frontend_configurations" do
	test "returns everything in :pleroma, :frontend_configurations", %{conn: conn} do
	config = [
	frontend_a: %{
	x: 1,
	y: 2
	},
	frontend_b: %{
	z: 3
	}
	]

	Pleroma.Config.put(:frontend_configurations, config)

	response =
	conn
	\|> get("/api/pleroma/frontend_configurations")
	\|> json_response(:ok)

	assert response == Jason.encode!(config \|> Enum.into(%{})) \|> Jason.decode!()
	end
	end

	describe "/api/pleroma/emoji" do
	test "returns json with custom emoji with tags", %{conn: conn} do
	emoji =
	conn
	\|> get("/api/pleroma/emoji")
	\|> json_response(200)

	assert Enum.all?(emoji, fn
	{_key,
	%{
	"image_url" => url,
	"tags" => tags
	}} ->
	is_binary(url) and is_list(tags)
	end)
	end
	end

	describe "GET /ostatus_subscribe?acct=...." do
	test "adds status to pleroma instance if the `acct` is a status", %{conn: conn} do
	conn =
	get(
	conn,
	"/ostatus_subscribe?acct=https://mastodon.social/users/emelie/statuses/101849165031453009"
	)

	assert redirected_to(conn) =~ "/notice/"
	end

	test "show follow account page if the `acct` is a account link", %{conn: conn} do
	response =
	get(
	conn,
	"/ostatus_subscribe?acct=https://mastodon.social/users/emelie"
	)

	assert html_response(response, 200) =~ "Log in to follow"
	end
	end

	test "GET /api/pleroma/healthcheck", %{conn: conn} do
	conn = get(conn, "/api/pleroma/healthcheck")

	assert conn.status in [200, 503]
	end

	describe "POST /api/pleroma/disable_account" do
	test "it returns HTTP 200", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/disable_account", %{"password" => "test"})
	\|> json_response(:ok)

	assert response == %{"status" => "success"}

	user = User.get_cached_by_id(user.id)

	assert user.info.deactivated == true
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 10, 5:40 PM (1 d, 9 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1785376
Default Alt Text: (103 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions