No OneTemporary
Actions

Authored By

Unknown

Size

87 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/support/http_request_mock.ex b/test/support/http_request_mock.ex
	index 4a4566e84..f44e9a1c6 100644
	--- a/test/support/http_request_mock.ex
	+++ b/test/support/http_request_mock.ex
	@@ -1,538 +1,567 @@
	defmodule HttpRequestMock do
	require Logger

	def request(
	%Tesla.Env{
	url: url,
	method: method,
	headers: headers,
	query: query,
	body: body
	} = _env
	) do
	with {:ok, res} <- apply(__MODULE__, method, [url, query, body, headers]) do
	res
	else
	{_, r} = error ->
	Logger.warn(r)
	error
	end
	end

	# GET Requests
	#
	def get(url, query \\ [], body \\ [], headers \\ [])

	+ def get("http://gs.example.org:4040/index.php/user/1", _, _, Accept: "application/activity+json") do
	+ {:ok,
	+ %Tesla.Env{
	+ status: 200,
	+ body: "{\"id\": 1}"
	+ }}
	+ end
	+
	+ def get("https://squeet.me/xrd/?uri=lain@squeet.me", _, _,
	+ Accept: "application/xrd+xml,application/jrd+json"
	+ ) do
	+ {:ok,
	+ %Tesla.Env{
	+ status: 200,
	+ body: File.read!("test/fixtures/httpoison_mock/lain_squeet.me_webfinger.xml")
	+ }}
	+ end
	+
	+ def get("https://mst3k.interlinked.me/users/luciferMysticus", _, _,
	+ Accept: "application/activity+json"
	+ ) do
	+ {:ok,
	+ %Tesla.Env{
	+ status: 200,
	+ body: File.read!("test/fixtures/httpoison_mock/lucifermysticus.json")
	+ }}
	+ end
	+
	def get("https://prismo.news/@mxb", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___prismo.news__mxb.json")
	}}
	end

	- def get("https://hubzilla.example.org/channel/kaniini",
	- _, _, [Accept: "application/activity+json"]) do
	+ def get("https://hubzilla.example.org/channel/kaniini", _, _,
	+ Accept: "application/activity+json"
	+ ) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/kaniini@hubzilla.example.org.json")
	}}
	end

	- def get("https://niu.moe/users/rye", _, _, [Accept: "application/activity+json"]) do
	+ def get("https://niu.moe/users/rye", _, _, Accept: "application/activity+json") do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/rye.json")
	}}
	end

	def get("http://mastodon.example.org/users/admin/statuses/100787282858396771", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	- body: File.read!(
	- "test/fixtures/httpoison_mock/http___mastodon.example.org_users_admin_status_1234.json"
	- )
	+ body:
	+ File.read!(
	+ "test/fixtures/httpoison_mock/http___mastodon.example.org_users_admin_status_1234.json"
	+ )
	}}
	end

	- def get("https://puckipedia.com/", _, _, [Accept: "application/activity+json"]) do
	+ def get("https://puckipedia.com/", _, _, Accept: "application/activity+json") do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/puckipedia.com.json")
	}}
	end

	-
	def get("https://peertube.moe/accounts/7even", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/7even.json")
	}}
	end

	def get("https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/peertube.moe-vid.json")
	}}
	end

	def get("https://baptiste.gelez.xyz/@/BaptisteGelez", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/baptiste.gelex.xyz-user.json")
	}}
	end

	def get("https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/baptiste.gelex.xyz-article.json")
	}}
	end

	-
	- def get("http://mastodon.example.org/users/admin", _, _, [Accept: "application/activity+json"]) do
	+ def get("http://mastodon.example.org/users/admin", _, _, Accept: "application/activity+json") do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/admin@mastdon.example.org.json")
	}}
	end

	- def get("http://mastodon.example.org/@admin/99541947525187367",
	- _, _, [Accept: "application/activity+json"]) do
	+ def get("http://mastodon.example.org/@admin/99541947525187367", _, _,
	+ Accept: "application/activity+json"
	+ ) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/mastodon-note-object.json")
	}}
	end

	def get("https://shitposter.club/notice/7369654", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/7369654.html")
	}}
	end

	- def get("https://mstdn.io/users/mayuutann", _, _, [Accept: "application/activity+json"]) do
	+ def get("https://mstdn.io/users/mayuutann", _, _, Accept: "application/activity+json") do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/mayumayu.json")
	}}
	end

	- def get("https://mstdn.io/users/mayuutann/statuses/99568293732299394",
	- _, _, [Accept: "application/activity+json"]) do
	+ def get("https://mstdn.io/users/mayuutann/statuses/99568293732299394", _, _,
	+ Accept: "application/activity+json"
	+ ) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/mayumayupost.json")
	}}
	end

	-
	def get("https://pleroma.soykaf.com/users/lain/feed.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___pleroma.soykaf.com_users_lain_feed.atom.xml"
	)
	}}
	end

	def get(url, _, _, Accept: "application/xrd+xml,application/jrd+json")
	when url in [
	"https://pleroma.soykaf.com/.well-known/webfinger?resource=acct:https://pleroma.soykaf.com/users/lain",
	"https://pleroma.soykaf.com/.well-known/webfinger?resource=https://pleroma.soykaf.com/users/lain"
	] do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___pleroma.soykaf.com_users_lain.xml")
	}}
	end

	def get("https://shitposter.club/api/statuses/user_timeline/1.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___shitposter.club_api_statuses_user_timeline_1.atom.xml"
	)
	}}
	end

	def get(
	"https://shitposter.club/.well-known/webfinger?resource=https://shitposter.club/user/1",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___shitposter.club_user_1.xml")
	}}
	end

	def get("https://shitposter.club/notice/2827873", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/httpoison_mock/https___shitposter.club_notice_2827873.html")
	}}
	end

	def get("https://shitposter.club/api/statuses/show/2827873.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___shitposter.club_api_statuses_show_2827873.atom.xml"
	)
	}}
	end

	def get("https://testing.pleroma.lol/objects/b319022a-4946-44c5-9de9-34801f95507b", _, _, _) do
	{:ok, %Tesla.Env{status: 200}}
	end

	def get("https://shitposter.club/api/statuses/user_timeline/5381.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/spc_5381.atom")
	}}
	end

	def get(
	"https://shitposter.club/.well-known/webfinger?resource=https://shitposter.club/user/5381",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/spc_5381_xrd.xml")
	}}
	end

	def get("http://shitposter.club/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/shitposter.club_host_meta")
	}}
	end

	def get("https://shitposter.club/api/statuses/show/7369654.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/7369654.atom")
	}}
	end

	def get("https://shitposter.club/notice/4027863", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/7369654.html")
	}}
	end

	def get("https://social.sakamoto.gq/users/eal/feed.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/sakamoto_eal_feed.atom")
	}}
	end

	def get("http://social.sakamoto.gq/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/social.sakamoto.gq_host_meta")
	}}
	end

	def get(
	"https://social.sakamoto.gq/.well-known/webfinger?resource=https://social.sakamoto.gq/users/eal",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/eal_sakamoto.xml")
	}}
	end

	def get("https://social.sakamoto.gq/objects/0ccc1a2c-66b0-4305-b23a-7f7f2b040056", _, _,
	Accept: "application/atom+xml"
	) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/httpoison_mock/sakamoto.atom")}}
	end

	def get("http://mastodon.social/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/mastodon.social_host_meta")
	}}
	end

	def get(
	"https://mastodon.social/.well-known/webfinger?resource=https://mastodon.social/users/lambadalambda",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___mastodon.social_users_lambadalambda.xml"
	)
	}}
	end

	def get("http://gs.example.org/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/gs.example.org_host_meta")
	}}
	end

	def get(
	"http://gs.example.org/.well-known/webfinger?resource=http://gs.example.org:4040/index.php/user/1",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/http___gs.example.org_4040_index.php_user_1.xml"
	)
	}}
	end

	def get("http://gs.example.org/index.php/api/statuses/user_timeline/1.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/http__gs.example.org_index.php_api_statuses_user_timeline_1.atom.xml"
	)
	}}
	end

	def get("https://social.heldscal.la/api/statuses/user_timeline/29191.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___social.heldscal.la_api_statuses_user_timeline_29191.atom.xml"
	)
	}}
	end

	def get("http://squeet.me/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/httpoison_mock/squeet.me_host_meta")}}
	end

	def get("https://squeet.me/xrd?uri=lain@squeet.me", _, _,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/lain_squeet.me_webfinger.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=shp@social.heldscal.la",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/shp@social.heldscal.la.xml")
	}}
	end

	def get("http://framatube.org/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/framatube.org_host_meta")
	}}
	end

	def get("http://framatube.org/main/xrd?uri=framasoft@framatube.org", _, _,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/json"}],
	body: File.read!("test/fixtures/httpoison_mock/framasoft@framatube.org.json")
	}}
	end

	def get("http://gnusocial.de/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/gnusocial.de_host_meta")
	}}
	end

	def get("http://gnusocial.de/main/xrd?uri=winterdienst@gnusocial.de", _, _,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/winterdienst_webfinger.json")
	}}
	end

	def get("http://status.alpicola.com/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/status.alpicola.com_host_meta")
	}}
	end

	def get("http://macgirvin.com/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/macgirvin.com_host_meta")
	}}
	end

	def get("http://gerzilla.de/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/gerzilla.de_host_meta")
	}}
	end

	def get("https://gerzilla.de/xrd/?uri=kaniini@gerzilla.de", _, _,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/json"}],
	body: File.read!("test/fixtures/httpoison_mock/kaniini@gerzilla.de.json")
	}}
	end

	def get("https://social.heldscal.la/api/statuses/user_timeline/23211.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___social.heldscal.la_api_statuses_user_timeline_23211.atom.xml"
	)
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=https://social.heldscal.la/user/23211",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___social.heldscal.la_user_23211.xml")
	}}
	end

	def get("http://social.heldscal.la/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/social.heldscal.la_host_meta")
	}}
	end

	def get("https://social.heldscal.la/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/social.heldscal.la_host_meta")
	}}
	end

	def get("https://mastodon.social/users/lambadalambda.atom", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/lambadalambda.atom")}}
	end

	def get("https://social.heldscal.la/user/23211", _, _, Accept: "application/activity+json") do
	{:ok, Tesla.Mock.json(%{"id" => "https://social.heldscal.la/user/23211"}, status: 200)}
	end

	def get(url, query, body, headers) do
	{:error,
	"Not implemented the mock response for get #{inspect(url)}, #{query}, #{inspect(body)}, #{
	inspect(headers)
	}"}
	end

	# POST Requests
	#

	def post(url, query \\ [], body \\ [], headers \\ [])

	def post("http://example.org/needs_refresh", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: ""
	}}
	end

	def post(url, _query, _body, _headers) do
	{:error, "Not implemented the mock response for post #{inspect(url)}"}
	end
	end
	diff --git a/test/web/http_sigs/http_sig_test.exs b/test/web/http_sigs/http_sig_test.exs
	index b2bf8d61b..2e189d583 100644
	--- a/test/web/http_sigs/http_sig_test.exs
	+++ b/test/web/http_sigs/http_sig_test.exs
	@@ -1,189 +1,195 @@
	# http signatures
	# Test data from https://tools.ietf.org/html/draft-cavage-http-signatures-08#appendix-C
	defmodule Pleroma.Web.HTTPSignaturesTest do
	use Pleroma.DataCase
	alias Pleroma.Web.HTTPSignatures
	import Pleroma.Factory
	+ import Tesla.Mock
	+
	+ setup do
	+ mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end

	@private_key hd(:public_key.pem_decode(File.read!("test/web/http_sigs/priv.key")))
	\|> :public_key.pem_entry_decode()

	@public_key hd(:public_key.pem_decode(File.read!("test/web/http_sigs/pub.key")))
	\|> :public_key.pem_entry_decode()

	@headers %{
	"(request-target)" => "post /foo?param=value&pet=dog",
	"host" => "example.com",
	"date" => "Thu, 05 Jan 2014 21:31:40 GMT",
	"content-type" => "application/json",
	"digest" => "SHA-256=X48E9qOokqqrvdts8nOJRJN3OWDUoyWxBf7kbu9DBPE=",
	"content-length" => "18"
	}

	@body "{\"hello\": \"world\"}"

	@default_signature """
	keyId="Test",algorithm="rsa-sha256",signature="jKyvPcxB4JbmYY4mByyBY7cZfNl4OW9HpFQlG7N4YcJPteKTu4MWCLyk+gIr0wDgqtLWf9NLpMAMimdfsH7FSWGfbMFSrsVTHNTk0rK3usrfFnti1dxsM4jl0kYJCKTGI/UWkqiaxwNiKqGcdlEDrTcUhhsFsOIo8VhddmZTZ8w="
	"""

	@basic_signature """
	keyId="Test",algorithm="rsa-sha256",headers="(request-target) host date",signature="HUxc9BS3P/kPhSmJo+0pQ4IsCo007vkv6bUm4Qehrx+B1Eo4Mq5/6KylET72ZpMUS80XvjlOPjKzxfeTQj4DiKbAzwJAb4HX3qX6obQTa00/qPDXlMepD2JtTw33yNnm/0xV7fQuvILN/ys+378Ysi082+4xBQFwvhNvSoVsGv4="
	"""

	@all_headers_signature """
	keyId="Test",algorithm="rsa-sha256",headers="(request-target) host date content-type digest content-length",signature="Ef7MlxLXoBovhil3AlyjtBwAL9g4TN3tibLj7uuNB3CROat/9KaeQ4hW2NiJ+pZ6HQEOx9vYZAyi+7cmIkmJszJCut5kQLAwuX+Ms/mUFvpKlSo9StS2bMXDBNjOh4Auj774GFj4gwjS+3NhFeoqyr/MuN6HsEnkvn6zdgfE2i0="
	"""

	test "split up a signature" do
	expected = %{
	"keyId" => "Test",
	"algorithm" => "rsa-sha256",
	"signature" =>
	"jKyvPcxB4JbmYY4mByyBY7cZfNl4OW9HpFQlG7N4YcJPteKTu4MWCLyk+gIr0wDgqtLWf9NLpMAMimdfsH7FSWGfbMFSrsVTHNTk0rK3usrfFnti1dxsM4jl0kYJCKTGI/UWkqiaxwNiKqGcdlEDrTcUhhsFsOIo8VhddmZTZ8w=",
	"headers" => ["date"]
	}

	assert HTTPSignatures.split_signature(@default_signature) == expected
	end

	test "validates the default case" do
	signature = HTTPSignatures.split_signature(@default_signature)
	assert HTTPSignatures.validate(@headers, signature, @public_key)
	end

	test "validates the basic case" do
	signature = HTTPSignatures.split_signature(@basic_signature)
	assert HTTPSignatures.validate(@headers, signature, @public_key)
	end

	test "validates the all-headers case" do
	signature = HTTPSignatures.split_signature(@all_headers_signature)
	assert HTTPSignatures.validate(@headers, signature, @public_key)
	end

	test "it contructs a signing string" do
	expected = "date: Thu, 05 Jan 2014 21:31:40 GMT\ncontent-length: 18"
	assert expected == HTTPSignatures.build_signing_string(@headers, ["date", "content-length"])
	end

	test "it validates a conn" do
	public_key_pem =
	"-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnGb42rPZIapY4Hfhxrgn\nxKVJczBkfDviCrrYaYjfGxawSw93dWTUlenCVTymJo8meBlFgIQ70ar4rUbzl6GX\nMYvRdku072d1WpglNHXkjKPkXQgngFDrh2sGKtNB/cEtJcAPRO8OiCgPFqRtMiNM\nc8VdPfPdZuHEIZsJ/aUM38EnqHi9YnVDQik2xxDe3wPghOhqjxUM6eLC9jrjI+7i\naIaEygUdyst9qVg8e2FGQlwAeS2Eh8ygCxn+bBlT5OyV59jSzbYfbhtF2qnWHtZy\nkL7KOOwhIfGs7O9SoR2ZVpTEQ4HthNzainIe/6iCR5HGrao/T8dygweXFYRv+k5A\nPQIDAQAB\n-----END PUBLIC KEY-----\n"

	[public_key] = :public_key.pem_decode(public_key_pem)

	public_key =
	public_key
	\|> :public_key.pem_entry_decode()

	conn = %{
	req_headers: [
	{"host", "localtesting.pleroma.lol"},
	{"connection", "close"},
	{"content-length", "2316"},
	{"user-agent", "http.rb/2.2.2 (Mastodon/2.1.0.rc3; +http://mastodon.example.org/)"},
	{"date", "Sun, 10 Dec 2017 14:23:49 GMT"},
	{"digest", "SHA-256=x/bHADMW8qRrq2NdPb5P9fl0lYpKXXpe5h5maCIL0nM="},
	{"content-type", "application/activity+json"},
	{"(request-target)", "post /users/demiurge/inbox"},
	{"signature",
	"keyId=\"http://mastodon.example.org/users/admin#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) user-agent host date digest content-type\",signature=\"i0FQvr51sj9BoWAKydySUAO1RDxZmNY6g7M62IA7VesbRSdFZZj9/fZapLp6YSuvxUF0h80ZcBEq9GzUDY3Chi9lx6yjpUAS2eKb+Am/hY3aswhnAfYd6FmIdEHzsMrpdKIRqO+rpQ2tR05LwiGEHJPGS0p528NvyVxrxMT5H5yZS5RnxY5X2HmTKEgKYYcvujdv7JWvsfH88xeRS7Jlq5aDZkmXvqoR4wFyfgnwJMPLel8P/BUbn8BcXglH/cunR0LUP7sflTxEz+Rv5qg+9yB8zgBsB4C0233WpcJxjeD6Dkq0EcoJObBR56F8dcb7NQtUDu7x6xxzcgSd7dHm5w==\""}
	]
	}

	assert HTTPSignatures.validate_conn(conn, public_key)
	end

	test "it validates a conn and fetches the key" do
	conn = %{
	params: %{"actor" => "http://mastodon.example.org/users/admin"},
	req_headers: [
	{"host", "localtesting.pleroma.lol"},
	{"x-forwarded-for", "127.0.0.1"},
	{"connection", "close"},
	{"content-length", "2307"},
	{"user-agent", "http.rb/2.2.2 (Mastodon/2.1.0.rc3; +http://mastodon.example.org/)"},
	{"date", "Sun, 11 Feb 2018 17:12:01 GMT"},
	{"digest", "SHA-256=UXsAnMtR9c7mi1FOf6HRMtPgGI1yi2e9nqB/j4rZ99I="},
	{"content-type", "application/activity+json"},
	{"signature",
	"keyId=\"http://mastodon.example.org/users/admin#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) user-agent host date digest content-type\",signature=\"qXKqpQXUpC3d9bZi2ioEeAqP8nRMD021CzH1h6/w+LRk4Hj31ARJHDwQM+QwHltwaLDUepshMfz2WHSXAoLmzWtvv7xRwY+mRqe+NGk1GhxVZ/LSrO/Vp7rYfDpfdVtkn36LU7/Bzwxvvaa4ZWYltbFsRBL0oUrqsfmJFswNCQIG01BB52BAhGSCORHKtQyzo1IZHdxl8y80pzp/+FOK2SmHkqWkP9QbaU1qTZzckL01+7M5btMW48xs9zurEqC2sM5gdWMQSZyL6isTV5tmkTZrY8gUFPBJQZgihK44v3qgfWojYaOwM8ATpiv7NG8wKN/IX7clDLRMA8xqKRCOKw==\""},
	{"(request-target)", "post /users/demiurge/inbox"}
	]
	}

	assert HTTPSignatures.validate_conn(conn)
	end

	test "validate this" do
	conn = %{
	params: %{"actor" => "https://niu.moe/users/rye"},
	req_headers: [
	{"x-forwarded-for", "149.202.73.191"},
	{"host", "testing.pleroma.lol"},
	{"x-cluster-client-ip", "149.202.73.191"},
	{"connection", "upgrade"},
	{"content-length", "2396"},
	{"user-agent", "http.rb/3.0.0 (Mastodon/2.2.0; +https://niu.moe/)"},
	{"date", "Sun, 18 Feb 2018 20:31:51 GMT"},
	{"digest", "SHA-256=dzH+vLyhxxALoe9RJdMl4hbEV9bGAZnSfddHQzeidTU="},
	{"content-type", "application/activity+json"},
	{"signature",
	"keyId=\"https://niu.moe/users/rye#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) user-agent host date digest content-type\",signature=\"wtxDg4kIpW7nsnUcVJhBk6SgJeDZOocr8yjsnpDRqE52lR47SH6X7G16r7L1AUJdlnbfx7oqcvomoIJoHB3ghP6kRnZW6MyTMZ2jPoi3g0iC5RDqv6oAmDSO14iw6U+cqZbb3P/odS5LkbThF0UNXcfenVNfsKosIJycFjhNQc54IPCDXYq/7SArEKJp8XwEgzmiC2MdxlkVIUSTQYfjM4EG533cwlZocw1mw72e5mm/owTa80BUZAr0OOuhoWARJV9btMb02ZyAF6SCSoGPTA37wHyfM1Dk88NHf7Z0Aov/Fl65dpRM+XyoxdkpkrhDfH9qAx4iuV2VEWddQDiXHA==\""},
	{"(request-target)", "post /inbox"}
	]
	}

	assert HTTPSignatures.validate_conn(conn)
	end

	test "validate this too" do
	conn = %{
	params: %{"actor" => "https://niu.moe/users/rye"},
	req_headers: [
	{"x-forwarded-for", "149.202.73.191"},
	{"host", "testing.pleroma.lol"},
	{"x-cluster-client-ip", "149.202.73.191"},
	{"connection", "upgrade"},
	{"content-length", "2342"},
	{"user-agent", "http.rb/3.0.0 (Mastodon/2.2.0; +https://niu.moe/)"},
	{"date", "Sun, 18 Feb 2018 21:44:46 GMT"},
	{"digest", "SHA-256=vS8uDOJlyAu78cF3k5EzrvaU9iilHCX3chP37gs5sS8="},
	{"content-type", "application/activity+json"},
	{"signature",
	"keyId=\"https://niu.moe/users/rye#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) user-agent host date digest content-type\",signature=\"IN6fHD8pLiDEf35dOaRHzJKc1wBYh3/Yq0ItaNGxUSbJTd2xMjigZbcsVKzvgYYjglDDN+disGNeD+OBKwMqkXWaWe/lyMc9wHvCH5NMhpn/A7qGLY8yToSt4vh8ytSkZKO6B97yC+Nvy6Fz/yMbvKtFycIvSXCq417cMmY6f/aG+rtMUlTbKO5gXzC7SUgGJCtBPCh1xZzu5/w0pdqdjO46ePNeR6JyJSLLV4hfo3+p2n7SRraxM4ePVCUZqhwS9LPt3Zdhy3ut+IXCZgMVIZggQFM+zXLtcXY5HgFCsFQr5WQDu+YkhWciNWtKFnWfAsnsg5sC330lZ/0Z8Z91yA==\""},
	{"(request-target)", "post /inbox"}
	]
	}

	assert HTTPSignatures.validate_conn(conn)
	end

	test "it generates a signature" do
	user = insert(:user)
	assert HTTPSignatures.sign(user, %{host: "mastodon.example.org"}) =~ "keyId=\""
	end

	test "this too" do
	conn = %{
	params: %{"actor" => "https://mst3k.interlinked.me/users/luciferMysticus"},
	req_headers: [
	{"host", "soc.canned-death.us"},
	{"user-agent", "http.rb/3.0.0 (Mastodon/2.2.0; +https://mst3k.interlinked.me/)"},
	{"date", "Sun, 11 Mar 2018 12:19:36 GMT"},
	{"digest", "SHA-256=V7Hl6qDK2m8WzNsjzNYSBISi9VoIXLFlyjF/a5o1SOc="},
	{"content-type", "application/activity+json"},
	{"signature",
	"keyId=\"https://mst3k.interlinked.me/users/luciferMysticus#main-key\",algorithm=\"rsa-sha256\",headers=\"(request-target) user-agent host date digest content-type\",signature=\"CTYdK5a6lYMxzmqjLOpvRRASoxo2Rqib2VrAvbR5HaTn80kiImj15pCpAyx8IZp53s0Fn/y8MjCTzp+absw8kxx0k2sQAXYs2iy6xhdDUe7iGzz+XLAEqLyZIZfecynaU2nb3Z2XnFDjhGjR1vj/JP7wiXpwp6o1dpDZj+KT2vxHtXuB9585V+sOHLwSB1cGDbAgTy0jx/2az2EGIKK2zkw1KJuAZm0DDMSZalp/30P8dl3qz7DV2EHdDNfaVtrs5BfbDOZ7t1hCcASllzAzgVGFl0BsrkzBfRMeUMRucr111ZG+c0BNOEtJYOHSyZsSSdNknElggCJekONYMYk5ZA==\""},
	{"x-forwarded-for", "2607:5300:203:2899::31:1337"},
	{"x-forwarded-host", "soc.canned-death.us"},
	{"x-forwarded-server", "soc.canned-death.us"},
	{"connection", "Keep-Alive"},
	{"content-length", "2006"},
	{"(request-target)", "post /inbox"}
	]
	}

	assert HTTPSignatures.validate_conn(conn)
	end
	end
	diff --git a/test/web/mastodon_api/mastodon_api_controller_test.exs b/test/web/mastodon_api/mastodon_api_controller_test.exs
	index 098acb59f..7cd98cde8 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,1352 +1,1358 @@
	defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.{Repo, User, Activity, Notification}
	alias Pleroma.Web.{OStatus, CommonAPI}
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Pleroma.Factory
	import ExUnit.CaptureLog
	+ import Tesla.Mock
	+
	+ setup do
	+ mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end

	test "the home timeline", %{conn: conn} do
	user = insert(:user)
	following = insert(:user)

	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert length(json_response(conn, 200)) == 0

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end

	test "the public timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	conn =
	conn
	\|> get("/api/v1/timelines/public", %{"local" => "False"})

	assert length(json_response(conn, 200)) == 2

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "True"})

	assert [%{"content" => "test"}] = json_response(conn, 200)

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "1"})

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end)
	end

	test "posting a status", %{conn: conn} do
	user = insert(:user)

	idempotency_key = "Pikachu rocks!"

	conn_one =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	{:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
	# Six hours
	assert ttl > :timer.seconds(6 * 60 * 60 - 1)

	assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
	json_response(conn_one, 200)

	assert Repo.get(Activity, id)

	conn_two =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => second_id} = json_response(conn_two, 200)

	assert id == second_id

	conn_three =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => third_id} = json_response(conn_three, 200)

	refute id == third_id
	end

	test "posting a sensitive status", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})

	assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
	assert Repo.get(Activity, id)
	end

	test "posting a direct status", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	content = "direct cofe @#{user2.nickname}"

	conn =
	conn
	\|> assign(:user, user1)
	\|> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})

	assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
	assert activity = Repo.get(Activity, id)
	assert activity.recipients == [user2.ap_id]
	assert activity.data["to"] == [user2.ap_id]
	assert activity.data["cc"] == []
	end

	test "direct timeline", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	{:ok, user_two} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "private"
	})

	# Only direct should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status
	assert status["url"] != direct.data["id"]

	# Both should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/home")

	[_s1, _s2] = json_response(res_conn, 200)

	# Test pagination
	Enum.each(1..20, fn _ ->
	{:ok, _} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})
	end)

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	statuses = json_response(res_conn, 200)
	assert length(statuses) == 20

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})

	[status] = json_response(res_conn, 200)

	assert status["url"] != direct.data["id"]
	end

	test "replying to a status", %{conn: conn} do
	user = insert(:user)

	{:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Repo.get(Activity, id)

	assert activity.data["context"] == replied_to.data["context"]
	assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
	end

	test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Repo.get(Activity, id)

	assert activity
	end

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "get a status", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(activity.id)
	end

	describe "deleting a status" do
	test "when you created it", %{conn: conn} do
	activity = insert(:note_activity)
	author = User.get_by_ap_id(activity.data["actor"])

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response(conn, 200)

	assert Repo.get(Activity, activity.id) == nil
	end

	test "when you didn't create it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{"error" => _} = json_response(conn, 403)

	assert Repo.get(Activity, activity.id) == activity
	end
	end

	describe "filters" do
	test "creating a filter", %{conn: conn} do
	user = insert(:user)

	filter = %Pleroma.Filter{
	phrase: "knights",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})

	assert response = json_response(conn, 200)
	assert response["phrase"] == filter.phrase
	assert response["context"] == filter.context
	assert response["id"] != nil
	assert response["id"] != ""
	end

	test "fetching a list of filters", %{conn: conn} do
	user = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 1,
	phrase: "knights",
	context: ["home"]
	}

	query_two = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "who",
	context: ["home"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	{:ok, filter_two} = Pleroma.Filter.create(query_two)

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

	assert response = json_response(conn, 200)
	end

	test "get a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters/#{filter.filter_id}")

	assert response = json_response(conn, 200)
	end

	test "update a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	new = %Pleroma.Filter{
	phrase: "nii",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/filters/#{query.filter_id}", %{
	phrase: new.phrase,
	context: new.context
	})

	assert response = json_response(conn, 200)
	assert response["phrase"] == new.phrase
	assert response["context"] == new.context
	end

	test "delete a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/filters/#{filter.filter_id}")

	assert response = json_response(conn, 200)
	assert response == %{}
	end
	end

	describe "lists" do
	test "creating a list", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists", %{"title" => "cuties"})

	assert %{"title" => title} = json_response(conn, 200)
	assert title == "cuties"
	end

	test "adding users to a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [other_user.follower_address]
	end

	test "removing users from a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)
	{:ok, list} = Pleroma.List.follow(list, third_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [third_user.follower_address]
	end

	test "listing users in a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "retrieving a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(list.id)
	end

	test "renaming a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})

	assert %{"title" => name} = json_response(conn, 200)
	assert name == "newname"
	end

	test "deleting a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}")

	assert %{} = json_response(conn, 200)
	assert is_nil(Repo.get(Pleroma.List, list.id))
	end

	test "list timeline", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
	{:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_two.id)
	end

	test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})

	{:ok, activity_two} =
	TwitterAPI.create_status(other_user, %{
	"status" => "Marisa is cute.",
	"visibility" => "private"
	})

	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_one.id)
	end
	end

	describe "notifications" do
	test "list of notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

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

	expected_response =
	"hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"

	assert [%{"status" => %{"content" => response}} \| _rest] = json_response(conn, 200)
	assert response == expected_response
	end

	test "getting a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications/#{notification.id}")

	expected_response =
	"hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"

	assert %{"status" => %{"content" => response}} = json_response(conn, 200)
	assert response == expected_response
	end

	test "dismissing a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/dismiss", %{"id" => notification.id})

	assert %{} = json_response(conn, 200)
	end

	test "clearing all notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/clear")

	assert %{} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	assert all = json_response(conn, 200)
	assert all == []
	end
	end

	describe "reblogging" do
	test "reblogs and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "unreblogging" do
	test "unreblogs and returns the unreblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unreblog")

	assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "favoriting" do
	test "favs a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

	assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 500 for a wrong id", %{conn: conn} do
	user = insert(:user)

	resp =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/1/favourite")
	\|> json_response(500)

	assert resp == "Something went wrong"
	end
	end

	describe "unfavoriting" do
	test "unfavorites a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")

	assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "user timelines" do
	test "gets a users statuses", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, user_three} = User.follow(user_three, user_one)

	{:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})

	{:ok, direct_activity} =
	CommonAPI.post(user_one, %{
	"status" => "Hi, @#{user_two.nickname}.",
	"visibility" => "direct"
	})

	{:ok, private_activity} =
	CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})

	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id}] = json_response(resp, 200)
	assert id == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_two)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(direct_activity.id)
	assert id_two == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_three)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(private_activity.id)
	assert id_two == to_string(activity.id)
	end

	test "unimplemented pinned statuses feature", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_by_ap_id(note.data["actor"])

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")

	assert json_response(conn, 200) == []
	end

	test "gets an users media", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_by_ap_id(note.data["actor"])

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	media =
	TwitterAPI.upload(file, "json")
	\|> Poison.decode!()

	{:ok, image_post} =
	TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)
	end
	end

	describe "user relationships" do
	test "returns the relationships for the current user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})

	assert [relationship] = json_response(conn, 200)

	assert to_string(other_user.id) == relationship["id"]
	end
	end

	describe "locked accounts" do
	test "/api/v1/follow_requests works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, activity} = ActivityPub.follow(other_user, user)

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

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/follow_requests")

	assert [relationship] = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]
	end

	test "/api/v1/follow_requests/:id/authorize works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, activity} = ActivityPub.follow(other_user, user)

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

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/authorize")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

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

	assert User.following?(other_user, user) == true
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "/api/v1/follow_requests/:id/reject works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, activity} = ActivityPub.follow(other_user, user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/reject")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

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

	assert User.following?(other_user, user) == false
	end
	end

	test "account fetching", %{conn: conn} do
	user = insert(:user)

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

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(user.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/-1")

	assert %{"error" => "Can't find user"} = json_response(conn, 404)
	end

	test "media upload", %{conn: conn} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	desc = "Description of the image"

	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/media", %{"file" => file, "description" => desc})

	assert media = json_response(conn, 200)

	assert media["type"] == "image"
	assert media["description"] == desc
	end

	test "hashtag timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2hu")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)

	# works for different capitalization too
	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2HU")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)
	end)
	end

	test "getting followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "getting following", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "following / unfollowing a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/follow")

	assert %{"id" => _id, "following" => true} = json_response(conn, 200)

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unfollow")

	assert %{"id" => _id, "following" => false} = json_response(conn, 200)

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follows", %{"uri" => other_user.nickname})

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "blocking / unblocking a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
	end

	test "getting a list of blocks", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.block(user, other_user)

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

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(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", %{conn: conn} do
	user = insert(:user)

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

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

	domain_blocks = json_response(conn, 200)

	assert "bad.site" in domain_blocks
	assert "even.worse.site" in domain_blocks
	end

	test "unimplemented mute endpoints" do
	user = insert(:user)
	other_user = insert(:user)

	["mute", "unmute"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end)
	end

	test "unimplemented mutes, follow_requests, blocks, domain blocks" do
	user = insert(:user)

	["blocks", "domain_blocks", "mutes", "follow_requests"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/#{endpoint}")

	assert [] = json_response(conn, 200)
	end)
	end

	test "account search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "shp"})
	\|> json_response(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_two.nickname in result_ids
	assert user_three.nickname in result_ids

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "2hu"})
	\|> json_response(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_three.nickname in result_ids
	end

	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	"status" => "This is about 2hu, but private",
	"visibility" => "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "2hu"})

	assert results = json_response(conn, 200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == []

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search fetches remote statuses", %{conn: conn} do
	capture_log(fn ->
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})

	assert results = json_response(conn, 200)

	[status] = results["statuses"]
	assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end)
	end

	test "search fetches remote accounts", %{conn: conn} do
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})

	assert results = json_response(conn, 200)
	[account] = results["accounts"]
	assert account["acct"] == "shp@social.heldscal.la"
	end

	test "returns the favorites of a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})

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

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

	assert [status] = json_response(conn, 200)
	assert status["id"] == to_string(activity.id)
	end

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

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"note" => "I drink #cofe with @#{user2.nickname}"
	})

	assert user = json_response(conn, 200)

	assert user["note"] ==
	"I drink <a href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span><a href=\"#{
	user2.ap_id
	}\">@<span>#{user2.nickname}</span></a></span>"
	end

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

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{locked: "true"})

	assert user = json_response(conn, 200)
	assert user["locked"] == true
	end

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

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})

	assert user = json_response(conn, 200)
	assert user["display_name"] == "markorepairs"
	end

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

	new_avatar = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})

	assert user_response = json_response(conn, 200)
	assert user_response["avatar"] != User.avatar_url(user)
	end

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

	new_header = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})

	assert user_response = json_response(conn, 200)
	assert user_response["header"] != User.banner_url(user)
	end
	end

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

	{:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	Pleroma.Stats.update_stats()

	conn =
	conn
	\|> get("/api/v1/instance")

	assert result = json_response(conn, 200)

	assert result["stats"]["user_count"] == 2
	assert result["stats"]["status_count"] == 1
	end
	end
	diff --git a/test/web/mastodon_api/status_view_test.exs b/test/web/mastodon_api/status_view_test.exs
	index 31554a07d..9e69b3189 100644
	--- a/test/web/mastodon_api/status_view_test.exs
	+++ b/test/web/mastodon_api/status_view_test.exs
	@@ -1,148 +1,154 @@
	defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
	use Pleroma.DataCase

	alias Pleroma.Web.MastodonAPI.{StatusView, AccountView}
	alias Pleroma.User
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory
	+ import Tesla.Mock
	+
	+ setup do
	+ mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end

	test "a note with null content" do
	note = insert(:note_activity)

	data =
	note.data
	\|> put_in(["object", "content"], nil)

	note =
	note
	\|> Map.put(:data, data)

	user = User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("status.json", %{activity: note})

	assert status.content == ""
	end

	test "a note activity" do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("status.json", %{activity: note})

	created_at =
	(note.data["object"]["published"] \|\| "")
	\|> String.replace(~r/\.\d+Z/, ".000Z")

	expected = %{
	id: to_string(note.id),
	uri: note.data["object"]["id"],
	url: note.data["object"]["id"],
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: nil,
	content: HtmlSanitizeEx.basic_html(note.data["object"]["content"]),
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	favourited: false,
	muted: false,
	sensitive: false,
	spoiler_text: note.data["object"]["summary"],
	visibility: "public",
	media_attachments: [],
	mentions: [],
	tags: [],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [
	%{
	shortcode: "2hu",
	url: "corndog.png",
	static_url: "corndog.png",
	visible_in_picker: false
	}
	]
	}

	assert status == expected
	end

	test "a reply" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "he", "in_reply_to_status_id" => note.id})

	status = StatusView.render("status.json", %{activity: activity})

	assert status.in_reply_to_id == to_string(note.id)

	[status] = StatusView.render("index.json", %{activities: [activity], as: :activity})

	assert status.in_reply_to_id == to_string(note.id)
	end

	test "contains mentions" do
	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	# a user with this ap id might be in the cache.
	recipient = "https://pleroma.soykaf.com/users/lain"
	user = insert(:user, %{ap_id: recipient})

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

	status = StatusView.render("status.json", %{activity: activity})

	assert status.mentions == [AccountView.render("mention.json", %{user: user})]
	end

	test "attachments" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl"
	}
	],
	"uuid" => 6
	}

	expected = %{
	id: "1638338801",
	type: "image",
	url: "someurl",
	remote_url: "someurl",
	preview_url: "someurl",
	text_url: "someurl",
	description: nil
	}

	assert expected == StatusView.render("attachment.json", %{attachment: object})

	# If theres a "id", use that instead of the generated one
	object = Map.put(object, "id", 2)
	assert %{id: "2"} = StatusView.render("attachment.json", %{attachment: object})
	end

	test "a reblog" do
	user = insert(:user)
	activity = insert(:note_activity)

	{:ok, reblog, _} = CommonAPI.repeat(activity.id, user)

	represented = StatusView.render("status.json", %{for: user, activity: reblog})

	assert represented[:id] == to_string(reblog.id)
	assert represented[:reblog][:id] == to_string(activity.id)
	assert represented[:emojis] == []
	end
	end
	diff --git a/test/web/ostatus/activity_representer_test.exs b/test/web/ostatus/activity_representer_test.exs
	index 8bf3bc775..a351510d8 100644
	--- a/test/web/ostatus/activity_representer_test.exs
	+++ b/test/web/ostatus/activity_representer_test.exs
	@@ -1,293 +1,299 @@
	defmodule Pleroma.Web.OStatus.ActivityRepresenterTest do
	use Pleroma.DataCase

	alias Pleroma.Web.OStatus.ActivityRepresenter
	alias Pleroma.{User, Activity, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.OStatus

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

	test "an external note activity" do
	incoming = File.read!("test/fixtures/mastodon-note-cw.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	user = User.get_cached_by_ap_id(activity.data["actor"])

	tuple = ActivityRepresenter.to_simple_form(activity, user)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	assert String.contains?(
	res,
	~s{<link type="text/html" href="https://mastodon.social/users/lambadalambda/updates/2314748" rel="alternate"/>}
	)
	end

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

	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/post</activity:verb>
	<id>#{note_activity.data["object"]["id"]}</id>
	<title>New note by #{user.nickname}</title>
	<content type="html">#{note_activity.data["object"]["content"]}</content>
	<published>#{note_activity.data["object"]["published"]}</published>
	<updated>#{note_activity.data["object"]["published"]}</updated>
	<ostatus:conversation ref="#{note_activity.data["context"]}">#{note_activity.data["context"]}</ostatus:conversation>
	<link ref="#{note_activity.data["context"]}" rel="ostatus:conversation" />
	<summary>#{note_activity.data["object"]["summary"]}</summary>
	<link type="application/atom+xml" href="#{note_activity.data["object"]["id"]}" rel="self" />
	<link type="text/html" href="#{note_activity.data["object"]["id"]}" rel="alternate" />
	<category term="2hu"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	<link name="2hu" rel="emoji" href="corndog.png" />
	"""

	tuple = ActivityRepresenter.to_simple_form(note_activity, user)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	assert clean(res) == clean(expected)
	end

	test "a reply note" do
	note = insert(:note_activity)
	answer = insert(:note_activity)
	object = answer.data["object"]
	object = Map.put(object, "inReplyTo", note.data["object"]["id"])

	data = %{answer.data \| "object" => object}
	answer = %{answer \| data: data}

	note_object = Object.get_by_ap_id(note.data["object"]["id"])

	Repo.update!(
	Object.change(note_object, %{data: Map.put(note_object.data, "external_url", "someurl")})
	)

	user = User.get_cached_by_ap_id(answer.data["actor"])

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/post</activity:verb>
	<id>#{answer.data["object"]["id"]}</id>
	<title>New note by #{user.nickname}</title>
	<content type="html">#{answer.data["object"]["content"]}</content>
	<published>#{answer.data["object"]["published"]}</published>
	<updated>#{answer.data["object"]["published"]}</updated>
	<ostatus:conversation ref="#{answer.data["context"]}">#{answer.data["context"]}</ostatus:conversation>
	<link ref="#{answer.data["context"]}" rel="ostatus:conversation" />
	<summary>2hu</summary>
	<link type="application/atom+xml" href="#{answer.data["object"]["id"]}" rel="self" />
	<link type="text/html" href="#{answer.data["object"]["id"]}" rel="alternate" />
	<category term="2hu"/>
	<thr:in-reply-to ref="#{note.data["object"]["id"]}" href="someurl" />
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	<link name="2hu" rel="emoji" href="corndog.png" />
	"""

	tuple = ActivityRepresenter.to_simple_form(answer, user)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	assert clean(res) == clean(expected)
	end

	test "an announce activity" do
	note = insert(:note_activity)
	user = insert(:user)
	object = Object.get_cached_by_ap_id(note.data["object"]["id"])

	{:ok, announce, _object} = ActivityPub.announce(user, object)

	announce = Repo.get(Activity, announce.id)

	note_user = User.get_cached_by_ap_id(note.data["actor"])
	note = Repo.get(Activity, note.id)

	note_xml =
	ActivityRepresenter.to_simple_form(note, note_user, true)
	\|> :xmerl.export_simple_content(:xmerl_xml)
	\|> to_string

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/activity</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/share</activity:verb>
	<id>#{announce.data["id"]}</id>
	<title>#{user.nickname} repeated a notice</title>
	<content type="html">RT #{note.data["object"]["content"]}</content>
	<published>#{announce.data["published"]}</published>
	<updated>#{announce.data["published"]}</updated>
	<ostatus:conversation ref="#{announce.data["context"]}">#{announce.data["context"]}</ostatus:conversation>
	<link ref="#{announce.data["context"]}" rel="ostatus:conversation" />
	<link rel="self" type="application/atom+xml" href="#{announce.data["id"]}"/>
	<activity:object>
	#{note_xml}
	</activity:object>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person" href="#{
	note.data["actor"]
	}"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	"""

	announce_xml =
	ActivityRepresenter.to_simple_form(announce, user)
	\|> :xmerl.export_simple_content(:xmerl_xml)
	\|> to_string

	assert clean(expected) == clean(announce_xml)
	end

	test "a like activity" do
	note = insert(:note)
	user = insert(:user)
	{:ok, like, _note} = ActivityPub.like(user, note)

	tuple = ActivityRepresenter.to_simple_form(like, user)
	refute is_nil(tuple)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	expected = """
	<activity:verb>http://activitystrea.ms/schema/1.0/favorite</activity:verb>
	<id>#{like.data["id"]}</id>
	<title>New favorite by #{user.nickname}</title>
	<content type="html">#{user.nickname} favorited something</content>
	<published>#{like.data["published"]}</published>
	<updated>#{like.data["published"]}</updated>
	<activity:object>
	<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	<id>#{note.data["id"]}</id>
	</activity:object>
	<ostatus:conversation ref="#{like.data["context"]}">#{like.data["context"]}</ostatus:conversation>
	<link ref="#{like.data["context"]}" rel="ostatus:conversation" />
	<link rel="self" type="application/atom+xml" href="#{like.data["id"]}"/>
	<thr:in-reply-to ref="#{note.data["id"]}" />
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person" href="#{
	note.data["actor"]
	}"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	"""

	assert clean(res) == clean(expected)
	end

	test "a follow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, activity} =
	ActivityPub.insert(%{
	"type" => "Follow",
	"actor" => follower.ap_id,
	"object" => followed.ap_id,
	"to" => [followed.ap_id]
	})

	tuple = ActivityRepresenter.to_simple_form(activity, follower)

	refute is_nil(tuple)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/activity</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/follow</activity:verb>
	<id>#{activity.data["id"]}</id>
	<title>#{follower.nickname} started following #{activity.data["object"]}</title>
	<content type="html"> #{follower.nickname} started following #{activity.data["object"]}</content>
	<published>#{activity.data["published"]}</published>
	<updated>#{activity.data["published"]}</updated>
	<activity:object>
	<activity:object-type>http://activitystrea.ms/schema/1.0/person</activity:object-type>
	<id>#{activity.data["object"]}</id>
	<uri>#{activity.data["object"]}</uri>
	</activity:object>
	<link rel="self" type="application/atom+xml" href="#{activity.data["id"]}"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person" href="#{
	activity.data["object"]
	}"/>
	"""

	assert clean(res) == clean(expected)
	end

	test "an unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)
	{:ok, _activity} = ActivityPub.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	tuple = ActivityRepresenter.to_simple_form(activity, follower)

	refute is_nil(tuple)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/activity</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/unfollow</activity:verb>
	<id>#{activity.data["id"]}</id>
	<title>#{follower.nickname} stopped following #{followed.ap_id}</title>
	<content type="html"> #{follower.nickname} stopped following #{followed.ap_id}</content>
	<published>#{activity.data["published"]}</published>
	<updated>#{activity.data["published"]}</updated>
	<activity:object>
	<activity:object-type>http://activitystrea.ms/schema/1.0/person</activity:object-type>
	<id>#{followed.ap_id}</id>
	<uri>#{followed.ap_id}</uri>
	</activity:object>
	<link rel="self" type="application/atom+xml" href="#{activity.data["id"]}"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person" href="#{
	followed.ap_id
	}"/>
	"""

	assert clean(res) == clean(expected)
	end

	test "a delete" do
	user = insert(:user)

	activity = %Activity{
	data: %{
	"id" => "ap_id",
	"type" => "Delete",
	"actor" => user.ap_id,
	"object" => "some_id",
	"published" => "2017-06-18T12:00:18+00:00"
	}
	}

	tuple = ActivityRepresenter.to_simple_form(activity, nil)

	refute is_nil(tuple)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/activity</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/delete</activity:verb>
	<id>#{activity.data["object"]}</id>
	<title>An object was deleted</title>
	<content type="html">An object was deleted</content>
	<published>#{activity.data["published"]}</published>
	<updated>#{activity.data["published"]}</updated>
	"""

	assert clean(res) == clean(expected)
	end

	test "an unknown activity" do
	tuple = ActivityRepresenter.to_simple_form(%Activity{}, nil)
	assert is_nil(tuple)
	end

	defp clean(string) do
	String.replace(string, ~r/\s/, "")
	end
	end
	diff --git a/test/web/ostatus/ostatus_controller_test.exs b/test/web/ostatus/ostatus_controller_test.exs
	index e81adde68..6327a524e 100644
	--- a/test/web/ostatus/ostatus_controller_test.exs
	+++ b/test/web/ostatus/ostatus_controller_test.exs
	@@ -1,232 +1,238 @@
	defmodule Pleroma.Web.OStatus.OStatusControllerTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory
	alias Pleroma.{User, Repo}
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OStatus.ActivityRepresenter
	+ import Tesla.Mock
	+
	+ setup do
	+ mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end

	test "decodes a salmon", %{conn: conn} do
	user = insert(:user)
	salmon = File.read!("test/fixtures/salmon.xml")

	conn =
	conn
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/users/#{user.nickname}/salmon", salmon)

	assert response(conn, 200)
	end

	test "decodes a salmon with a changed magic key", %{conn: conn} do
	user = insert(:user)
	salmon = File.read!("test/fixtures/salmon.xml")

	conn =
	conn
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/users/#{user.nickname}/salmon", salmon)

	assert response(conn, 200)

	# Set a wrong magic-key for a user so it has to refetch
	salmon_user = User.get_by_ap_id("http://gs.example.org:4040/index.php/user/1")
	# Wrong key
	info_cng =
	User.Info.remote_user_creation(salmon_user.info, %{
	magic_key:
	"RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwrong1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAB"
	})

	cng =
	Ecto.Changeset.change(salmon_user)
	\|> Ecto.Changeset.put_embed(:info, info_cng)
	\|> Repo.update()

	conn =
	build_conn()
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/users/#{user.nickname}/salmon", salmon)

	assert response(conn, 200)
	end

	test "gets a feed", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> put_req_header("content-type", "application/atom+xml")
	\|> get("/users/#{user.nickname}/feed.atom")

	assert response(conn, 200) =~ note_activity.data["object"]["content"]
	end

	test "returns 404 for a missing feed", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/atom+xml")
	\|> get("/users/nonexisting/feed.atom")

	assert response(conn, 404)
	end

	test "gets an object", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_by_ap_id(note_activity.data["actor"])
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["object"]["id"]))
	url = "/objects/#{uuid}"

	conn =
	conn
	\|> get(url)

	expected =
	ActivityRepresenter.to_simple_form(note_activity, user, true)
	\|> ActivityRepresenter.wrap_with_entry()
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	assert response(conn, 200) == expected
	end

	test "404s on private objects", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	user = User.get_by_ap_id(note_activity.data["actor"])
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["object"]["id"]))
	url = "/objects/#{uuid}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "404s on nonexisting objects", %{conn: conn} do
	url = "/objects/123"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "gets an activity", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))
	url = "/activities/#{uuid}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 200)
	end

	test "404s on private activities", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))
	url = "/activities/#{uuid}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "404s on nonexistent activities", %{conn: conn} do
	url = "/activities/123"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "gets a notice", %{conn: conn} do
	note_activity = insert(:note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 200)
	end

	test "gets a notice in AS2 format", %{conn: conn} do
	note_activity = insert(:note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(url)

	assert json_response(conn, 200)
	end

	test "only gets a notice in AS2 format for Create messages", %{conn: conn} do
	note_activity = insert(:note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(url)

	assert json_response(conn, 200)

	user = insert(:user)

	{:ok, like_activity, _} = CommonAPI.favorite(note_activity.id, user)
	url = "/notice/#{like_activity.id}"

	assert like_activity.data["type"] == "Like"

	conn =
	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> get(url)

	assert response(conn, 404)
	end

	test "gets an activity in AS2 format", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))
	url = "/activities/#{uuid}"

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(url)

	assert json_response(conn, 200)
	end

	test "404s a private notice", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "404s a nonexisting notice", %{conn: conn} do
	url = "/notice/123"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 2:08 AM (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799181
Default Alt Text: (87 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions